pax_global_header00006660000000000000000000000064146404373050014520gustar00rootroot0000000000000052 comment=d322427bc5451090993b1a4a3f183650617f5820 hyprutils-0.1.5/000077500000000000000000000000001464043730500135665ustar00rootroot00000000000000hyprutils-0.1.5/.clang-format000066400000000000000000000034161464043730500161450ustar00rootroot00000000000000--- 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 hyprutils-0.1.5/.github/000077500000000000000000000000001464043730500151265ustar00rootroot00000000000000hyprutils-0.1.5/.github/workflows/000077500000000000000000000000001464043730500171635ustar00rootroot00000000000000hyprutils-0.1.5/.github/workflows/arch.yml000066400000000000000000000042001464043730500206170ustar00rootroot00000000000000name: Build & Test (Arch) on: [push, pull_request, workflow_dispatch] jobs: gcc: name: "Arch: Build and Test (gcc)" runs-on: ubuntu-latest container: image: archlinux steps: - name: Checkout repository actions uses: actions/checkout@v4 with: sparse-checkout: .github/actions - name: Get required pkgs run: | sed -i 's/SigLevel = Required DatabaseOptional/SigLevel = Optional TrustAll/' /etc/pacman.conf pacman --noconfirm --noprogressbar -Syyu pacman --noconfirm --noprogressbar -Sy gcc base-devel cmake clang libc++ pixman - name: Build hyprutils with gcc run: | CC="/usr/bin/gcc" CXX="/usr/bin/g++" cmake --no-warn-unused-cli -DCMAKE_BUILD_TYPE:STRING=Release -DCMAKE_INSTALL_PREFIX:PATH=/usr -S . -B ./build CC="/usr/bin/gcc" CXX="/usr/bin/g++" cmake --build ./build --config Release --target all -j`nproc 2>/dev/null || getconf NPROCESSORS_CONF` cmake --install ./build - name: Run tests run: | cd ./build && ctest --output-on-failure clang: name: "Arch: Build and Test (clang)" runs-on: ubuntu-latest container: image: archlinux steps: - name: Checkout repository actions uses: actions/checkout@v4 with: sparse-checkout: .github/actions - name: Get required pkgs run: | sed -i 's/SigLevel = Required DatabaseOptional/SigLevel = Optional TrustAll/' /etc/pacman.conf pacman --noconfirm --noprogressbar -Syyu pacman --noconfirm --noprogressbar -Sy gcc base-devel cmake clang libc++ pixman - name: Build hyprutils with clang run: | CC="/usr/bin/clang" CXX="/usr/bin/clang++" cmake --no-warn-unused-cli -DCMAKE_BUILD_TYPE:STRING=Release -DCMAKE_INSTALL_PREFIX:PATH=/usr -S . -B ./build CC="/usr/bin/clang" CXX="/usr/bin/clang++" cmake --build ./build --config Release --target all -j`nproc 2>/dev/null || getconf NPROCESSORS_CONF` cmake --install ./build - name: Run tests run: | cd ./build && ctest --output-on-failure hyprutils-0.1.5/.github/workflows/nix.yml000066400000000000000000000011271464043730500205050ustar00rootroot00000000000000name: Build & Test on: [push, pull_request, workflow_dispatch] jobs: nix: strategy: matrix: package: - hyprutils - hyprutils-with-tests runs-on: ubuntu-latest steps: - uses: actions/checkout@v3 - uses: cachix/install-nix-action@v26 - uses: DeterminateSystems/magic-nix-cache-action@main # not needed (yet) # - uses: cachix/cachix-action@v12 # with: # name: hyprland # authToken: '${{ secrets.CACHIX_AUTH_TOKEN }}' - name: Build & Test run: nix build .#${{ matrix.package }} --print-build-logs hyprutils-0.1.5/.gitignore000066400000000000000000000004471464043730500155630ustar00rootroot00000000000000# Prerequisites *.d # Compiled Object files *.slo *.lo *.o *.obj # Precompiled Headers *.gch *.pch # Compiled Dynamic libraries *.so *.dylib *.dll # Fortran module files *.mod *.smod # Compiled Static libraries *.lai *.la *.a *.lib # Executables *.exe *.out *.app build/ .vscode/ .cache/ hyprutils-0.1.5/CMakeLists.txt000066400000000000000000000050511464043730500163270ustar00rootroot00000000000000cmake_minimum_required(VERSION 3.19) set(HYPRUTILS_VERSION "0.1.5") add_compile_definitions(HYPRUTILS_VERSION="${HYPRUTILS_VERSION}") project(hyprutils VERSION ${HYPRUTILS_VERSION} DESCRIPTION "Small C++ library for utilities used across the Hypr* ecosystem" ) include(CTest) include(GNUInstallDirs) set(PREFIX ${CMAKE_INSTALL_PREFIX}) set(INCLUDE ${CMAKE_INSTALL_FULL_INCLUDEDIR}) set(LIBDIR ${CMAKE_INSTALL_FULL_LIBDIR}) configure_file(hyprutils.pc.in hyprutils.pc @ONLY) set(CMAKE_CXX_STANDARD 23) if(CMAKE_BUILD_TYPE MATCHES Debug OR CMAKE_BUILD_TYPE MATCHES DEBUG) message(STATUS "Configuring hyprutils in Debug") add_compile_definitions(HYPRLAND_DEBUG) else() add_compile_options(-O3) message(STATUS "Configuring hyprutils in Release") endif() file(GLOB_RECURSE SRCFILES CONFIGURE_DEPENDS "src/*.cpp" "include/*.hpp") file(GLOB_RECURSE PUBLIC_HEADERS CONFIGURE_DEPENDS "include/*.hpp") find_package(PkgConfig REQUIRED) pkg_check_modules(deps REQUIRED IMPORTED_TARGET pixman-1) add_library(hyprutils SHARED ${SRCFILES}) target_include_directories( hyprutils PUBLIC "./include" PRIVATE "./src" ) set_target_properties(hyprutils PROPERTIES VERSION ${hyprutils_VERSION} SOVERSION 0 ) target_link_libraries(hyprutils PkgConfig::deps) # tests add_custom_target(tests) add_executable(hyprutils_memory "tests/memory.cpp") target_link_libraries(hyprutils_memory PRIVATE hyprutils PkgConfig::deps) add_test(NAME "Memory" WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}/tests COMMAND hyprutils_memory "memory") add_dependencies(tests hyprutils_memory) add_executable(hyprutils_string "tests/string.cpp") target_link_libraries(hyprutils_string PRIVATE hyprutils PkgConfig::deps) add_test(NAME "String" WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}/tests COMMAND hyprutils_string "string") add_dependencies(tests hyprutils_string) add_executable(hyprutils_signal "tests/signal.cpp") target_link_libraries(hyprutils_signal PRIVATE hyprutils PkgConfig::deps) add_test(NAME "Signal" WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}/tests COMMAND hyprutils_signal "signal") add_dependencies(tests hyprutils_signal) add_executable(hyprutils_math "tests/math.cpp") target_link_libraries(hyprutils_math PRIVATE hyprutils PkgConfig::deps) add_test(NAME "Math" WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}/tests COMMAND hyprutils_math "math") add_dependencies(tests hyprutils_math) # Installation install(TARGETS hyprutils) install(DIRECTORY "include/hyprutils" DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}) install(FILES ${CMAKE_BINARY_DIR}/hyprutils.pc DESTINATION ${CMAKE_INSTALL_LIBDIR}/pkgconfig) hyprutils-0.1.5/LICENSE000066400000000000000000000027371464043730500146040ustar00rootroot00000000000000BSD 3-Clause License Copyright (c) 2024, Hypr Development 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. hyprutils-0.1.5/README.md000066400000000000000000000011161464043730500150440ustar00rootroot00000000000000# hyprutils Hyprutils is a small C++ library for utilities used across the Hypr* ecosystem. ## Stability Hyprutils depends on the ABI stability of the stdlib implementation of your compiler. Sover bumps will be done only for hyprutils ABI breaks, not stdlib. ## Building ```sh git clone https://github.com/hyprwm/hyprutils.git cd hyprutils/ cmake --no-warn-unused-cli -DCMAKE_BUILD_TYPE:STRING=Release -DCMAKE_INSTALL_PREFIX:PATH=/usr -S . -B ./build cmake --build ./build --config Release --target all -j`nproc 2>/dev/null || getconf _NPROCESSORS_CONF` sudo cmake --install build ``` hyprutils-0.1.5/flake.lock000066400000000000000000000020011464043730500155130ustar00rootroot00000000000000{ "nodes": { "nixpkgs": { "locked": { "lastModified": 1717602782, "narHash": "sha256-pL9jeus5QpX5R+9rsp3hhZ+uplVHscNJh8n8VpqscM0=", "owner": "NixOS", "repo": "nixpkgs", "rev": "e8057b67ebf307f01bdcc8fba94d94f75039d1f6", "type": "github" }, "original": { "owner": "NixOS", "ref": "nixos-unstable", "repo": "nixpkgs", "type": "github" } }, "root": { "inputs": { "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 } hyprutils-0.1.5/flake.nix000066400000000000000000000024761464043730500154010ustar00rootroot00000000000000{ description = "Small C++ library for utilities used across the Hypr* ecosystem"; inputs = { nixpkgs.url = "github:NixOS/nixpkgs/nixos-unstable"; systems.url = "github:nix-systems/default-linux"; }; outputs = { self, nixpkgs, systems, }: let inherit (nixpkgs) lib; eachSystem = lib.genAttrs (import systems); pkgsFor = eachSystem (system: import nixpkgs { localSystem.system = system; overlays = with self.overlays; [hyprutils]; }); mkDate = longDate: (lib.concatStringsSep "-" [ (builtins.substring 0 4 longDate) (builtins.substring 4 2 longDate) (builtins.substring 6 2 longDate) ]); in { overlays = { default = self.overlays.hyprutils; hyprutils = final: prev: { hyprutils = final.callPackage ./nix/default.nix { stdenv = final.gcc13Stdenv; version = "0.pre" + "+date=" + (mkDate (self.lastModifiedDate or "19700101")) + "_" + (self.shortRev or "dirty"); }; hyprutils-with-tests = final.hyprutils.override {doCheck = true;}; }; }; packages = eachSystem (system: { default = self.packages.${system}.hyprutils; inherit (pkgsFor.${system}) hyprutils hyprutils-with-tests; }); formatter = eachSystem (system: pkgsFor.${system}.alejandra); }; } hyprutils-0.1.5/hyprutils.pc.in000066400000000000000000000004051464043730500165610ustar00rootroot00000000000000prefix=@PREFIX@ includedir=@INCLUDE@ libdir=@LIBDIR@ Name: hyprutils URL: https://github.com/hyprwm/hyprutils Description: Hyprland utilities library used across the ecosystem Version: @HYPRUTILS_VERSION@ Cflags: -I${includedir} Libs: -L${libdir} -lhyprutils hyprutils-0.1.5/include/000077500000000000000000000000001464043730500152115ustar00rootroot00000000000000hyprutils-0.1.5/include/hyprutils/000077500000000000000000000000001464043730500172545ustar00rootroot00000000000000hyprutils-0.1.5/include/hyprutils/math/000077500000000000000000000000001464043730500202055ustar00rootroot00000000000000hyprutils-0.1.5/include/hyprutils/math/Box.hpp000066400000000000000000000136051464043730500214530ustar00rootroot00000000000000#pragma once #include "./Vector2D.hpp" #include "./Misc.hpp" namespace Hyprutils::Math { /** * @brief Represents the extents of a bounding box. */ struct SBoxExtents { Vector2D topLeft; Vector2D bottomRight; /** * @brief Scales the extents by a given factor. * @param scale The scaling factor. * @return Scaled SBoxExtents. */ SBoxExtents operator*(const double& scale) const { return SBoxExtents{topLeft * scale, bottomRight * scale}; } /** * @brief Rounds the coordinates of the extents. * @return Rounded SBoxExtents. */ SBoxExtents round() { return {topLeft.round(), bottomRight.round()}; } /** * @brief Checks equality between two SBoxExtents objects. * @param other Another SBoxExtents object to compare. * @return True if both SBoxExtents are equal, false otherwise. */ bool operator==(const SBoxExtents& other) const { return topLeft == other.topLeft && bottomRight == other.bottomRight; } /** * @brief Adjusts the extents to encompass another SBoxExtents. * @param other Another SBoxExtents to add to this one. */ void addExtents(const SBoxExtents& other) { topLeft = topLeft.getComponentMax(other.topLeft); bottomRight = bottomRight.getComponentMax(other.bottomRight); } }; /** * @brief Represents a 2D bounding box. */ class CBox { public: /** * @brief Constructs a CBox with specified position and dimensions. * @param x_ X-coordinate of the top-left corner. * @param y_ Y-coordinate of the top-left corner. * @param w_ Width of the box. * @param h_ Height of the box. */ CBox(double x_, double y_, double w_, double h_) { x = x_; y = y_; w = w_; h = h_; } /** * @brief Default constructor. Initializes an empty box (0 width, 0 height). */ CBox() { w = 0; h = 0; } /** * @brief Constructs a CBox with uniform dimensions. * @param d Dimensions to apply uniformly (x, y, width, height). */ CBox(const double d) { x = d; y = d; w = d; h = d; } /** * @brief Constructs a CBox from a position and size vector. * @param pos Position vector representing the top-left corner. * @param size Size vector representing width and height. */ CBox(const Vector2D& pos, const Vector2D& size) { x = pos.x; y = pos.y; w = size.x; h = size.y; } // Geometric operations CBox& applyFromWlr(); CBox& scale(double scale); CBox& scaleFromCenter(double scale); CBox& scale(const Vector2D& scale); CBox& translate(const Vector2D& vec); CBox& round(); CBox& transform(const eTransform t, double w, double h); CBox& addExtents(const SBoxExtents& e); CBox& expand(const double& value); CBox& noNegativeSize(); CBox copy() const; CBox intersection(const CBox& other) const; bool overlaps(const CBox& other) const; bool inside(const CBox& bound) const; /** * @brief Computes the extents of the box relative to another box. * @param small Another CBox to compare against. * @return SBoxExtents representing the extents of the box relative to 'small'. */ SBoxExtents extentsFrom(const CBox&); // this is the big box /** * @brief Calculates the middle point of the box. * @return Vector2D representing the middle point. */ Vector2D middle() const; /** * @brief Retrieves the position of the top-left corner of the box. * @return Vector2D representing the position. */ Vector2D pos() const; /** * @brief Retrieves the size (width and height) of the box. * @return Vector2D representing the size. */ Vector2D size() const; /** * @brief Finds the closest point within the box to a given vector. * @param vec Vector from which to find the closest point. * @return Vector2D representing the closest point within the box. */ Vector2D closestPoint(const Vector2D& vec) const; /** * @brief Checks if a given point is inside the box. * @param vec Vector representing the point to check. * @return True if the point is inside the box, false otherwise. */ bool containsPoint(const Vector2D& vec) const; /** * @brief Checks if the box is empty (zero width or height). * @return True if the box is empty, false otherwise. */ bool empty() const; double x = 0, y = 0; // Position of the top-left corner of the box. union { double w; double width; }; union { double h; double height; }; double rot = 0; //< Rotation angle of the box in radians (counterclockwise). /** * @brief Checks equality between two CBox objects. * @param rhs Another CBox object to compare. * @return True if both CBox objects are equal, false otherwise. */ bool operator==(const CBox& rhs) const { return x == rhs.x && y == rhs.y && w == rhs.w && h == rhs.h; } private: CBox roundInternal(); }; }hyprutils-0.1.5/include/hyprutils/math/Misc.hpp000066400000000000000000000007551464043730500216200ustar00rootroot00000000000000#pragma once namespace Hyprutils { namespace Math { enum eTransform { HYPRUTILS_TRANSFORM_NORMAL = 0, HYPRUTILS_TRANSFORM_90 = 1, HYPRUTILS_TRANSFORM_180 = 2, HYPRUTILS_TRANSFORM_270 = 3, HYPRUTILS_TRANSFORM_FLIPPED = 4, HYPRUTILS_TRANSFORM_FLIPPED_90 = 5, HYPRUTILS_TRANSFORM_FLIPPED_180 = 6, HYPRUTILS_TRANSFORM_FLIPPED_270 = 7, }; } }hyprutils-0.1.5/include/hyprutils/math/Region.hpp000066400000000000000000000051531464043730500221450ustar00rootroot00000000000000#pragma once #include #include #include "Vector2D.hpp" #include "Box.hpp" namespace Hyprutils { namespace Math { class CRegion { public: /* Create an empty region */ CRegion(); /* Create from a reference. Copies, does not own. */ CRegion(const pixman_region32_t* const ref); /* Create from a box */ CRegion(double x, double y, double w, double h); /* Create from a CBox */ CRegion(const CBox& box); /* Create from a pixman_box32_t */ CRegion(pixman_box32_t* box); CRegion(const CRegion&); CRegion(CRegion&&); ~CRegion(); CRegion& operator=(CRegion&& other) { pixman_region32_copy(&m_rRegion, other.pixman()); return *this; } CRegion& operator=(CRegion& other) { pixman_region32_copy(&m_rRegion, other.pixman()); return *this; } CRegion& clear(); CRegion& set(const CRegion& other); CRegion& add(const CRegion& other); CRegion& add(double x, double y, double w, double h); CRegion& add(const CBox& other); CRegion& subtract(const CRegion& other); CRegion& intersect(const CRegion& other); CRegion& intersect(double x, double y, double w, double h); CRegion& translate(const Vector2D& vec); CRegion& transform(const eTransform t, double w, double h); CRegion& invert(pixman_box32_t* box); CRegion& invert(const CBox& box); CRegion& scale(float scale); CRegion& scale(const Vector2D& scale); CRegion& rationalize(); CBox getExtents(); bool containsPoint(const Vector2D& vec) const; bool empty() const; Vector2D closestPoint(const Vector2D& vec) const; CRegion copy() const; std::vector getRects() const; // pixman_region32_t* pixman() { return &m_rRegion; } private: pixman_region32_t m_rRegion; }; } } hyprutils-0.1.5/include/hyprutils/math/Vector2D.hpp000066400000000000000000000176351464043730500223620ustar00rootroot00000000000000#pragma once #include #include namespace Hyprutils { namespace Math { class Vector2D { public: Vector2D(double, double); Vector2D(int, int); Vector2D(); ~Vector2D(); double x = 0; double y = 0; // returns the scale double normalize(); Vector2D operator+(const Vector2D& a) const { return Vector2D(this->x + a.x, this->y + a.y); } Vector2D operator-(const Vector2D& a) const { return Vector2D(this->x - a.x, this->y - a.y); } Vector2D operator-() const { return Vector2D(-this->x, -this->y); } Vector2D operator*(const double& a) const { return Vector2D(this->x * a, this->y * a); } Vector2D operator/(const double& a) const { return Vector2D(this->x / a, this->y / a); } bool operator==(const Vector2D& a) const { return a.x == x && a.y == y; } bool operator!=(const Vector2D& a) const { return a.x != x || a.y != y; } Vector2D operator*(const Vector2D& a) const { return Vector2D(this->x * a.x, this->y * a.y); } Vector2D operator/(const Vector2D& a) const { return Vector2D(this->x / a.x, this->y / a.y); } bool operator>(const Vector2D& a) const { return this->x > a.x && this->y > a.y; } bool operator<(const Vector2D& a) const { return this->x < a.x && this->y < a.y; } Vector2D& operator+=(const Vector2D& a) { this->x += a.x; this->y += a.y; return *this; } Vector2D& operator-=(const Vector2D& a) { this->x -= a.x; this->y -= a.y; return *this; } Vector2D& operator*=(const Vector2D& a) { this->x *= a.x; this->y *= a.y; return *this; } Vector2D& operator/=(const Vector2D& a) { this->x /= a.x; this->y /= a.y; return *this; } Vector2D& operator*=(const double& a) { this->x *= a; this->y *= a; return *this; } Vector2D& operator/=(const double& a) { this->x /= a; this->y /= a; return *this; } double distance(const Vector2D& other) const; double distanceSq(const Vector2D& other) const; double size() const; Vector2D clamp(const Vector2D& min, const Vector2D& max = Vector2D{-1, -1}) const; Vector2D floor() const; Vector2D round() const; Vector2D getComponentMax(const Vector2D& other) const; }; } } // absolutely ridiculous formatter spec parsing #define AQ_FORMAT_PARSE(specs__, type__) \ template \ constexpr auto parse(FormatContext& ctx) { \ auto it = ctx.begin(); \ for (; it != ctx.end() && *it != '}'; it++) { \ switch (*it) { specs__ default : throw std::format_error("invalid format specification"); } \ } \ return it; \ } #define AQ_FORMAT_FLAG(spec__, flag__) \ case spec__: (flag__) = true; break; #define AQ_FORMAT_NUMBER(buf__) \ case '0': \ case '1': \ case '2': \ case '3': \ case '4': \ case '5': \ case '6': \ case '7': \ case '8': \ case '9': (buf__).push_back(*it); break; /** format specification - 'j', as json array - 'X', same as std::format("{}x{}", vec.x, vec.y) - number, floating point precision, use `0` to format as integer */ template struct std::formatter : std::formatter { bool formatJson = false; bool formatX = false; std::string precision = ""; AQ_FORMAT_PARSE(AQ_FORMAT_FLAG('j', formatJson) // AQ_FORMAT_FLAG('X', formatX) // AQ_FORMAT_NUMBER(precision), Hyprutils::Math::Vector2D) template auto format(const Hyprutils::Math::Vector2D& vec, FormatContext& ctx) const { std::string formatString = precision.empty() ? "{}" : std::format("{{:.{}f}}", precision); if (formatJson) formatString = std::format("[{0}, {0}]", formatString); else if (formatX) formatString = std::format("{0}x{0}", formatString); else formatString = std::format("[Vector2D: x: {0}, y: {0}]", formatString); try { string buf = std::vformat(formatString, std::make_format_args(vec.x, vec.y)); return std::format_to(ctx.out(), "{}", buf); } catch (std::format_error& e) { return std::format_to(ctx.out(), "[{}, {}]", vec.x, vec.y); } } }; hyprutils-0.1.5/include/hyprutils/memory/000077500000000000000000000000001464043730500205645ustar00rootroot00000000000000hyprutils-0.1.5/include/hyprutils/memory/SharedPtr.hpp000066400000000000000000000221061464043730500231720ustar00rootroot00000000000000#pragma once #include #include #include /* This is a custom impl of std::shared_ptr. It is not thread-safe like the STL one, but Hyprland is single-threaded anyways. It differs a bit from how the STL one works, namely in the fact that it keeps the T* inside the control block, and that you can still make a CWeakPtr or deref an existing one inside the destructor. */ namespace Hyprutils { namespace Memory { namespace CSharedPointer_ { class impl_base { public: virtual ~impl_base(){}; virtual void inc() noexcept = 0; virtual void dec() noexcept = 0; virtual void incWeak() noexcept = 0; virtual void decWeak() noexcept = 0; virtual unsigned int ref() noexcept = 0; virtual unsigned int wref() noexcept = 0; virtual void destroy() noexcept = 0; virtual bool destroying() noexcept = 0; virtual bool dataNonNull() noexcept = 0; }; template class impl : public impl_base { public: impl(T* data) noexcept : _data(data) { ; } /* strong refcount */ unsigned int _ref = 0; /* weak refcount */ unsigned int _weak = 0; T* _data = nullptr; friend void swap(impl*& a, impl*& b) { impl* tmp = a; a = b; b = tmp; } /* if the destructor was called, creating shared_ptrs is no longer valid */ bool _destroying = false; void _destroy() { if (!_data || _destroying) return; // first, we destroy the data, but keep the pointer. // this way, weak pointers will still be able to // reference and use, but no longer create shared ones. _destroying = true; __deleter(_data); // now, we can reset the data and call it a day. _data = nullptr; _destroying = false; } std::default_delete __deleter{}; // virtual void inc() noexcept { _ref++; } virtual void dec() noexcept { _ref--; } virtual void incWeak() noexcept { _weak++; } virtual void decWeak() noexcept { _weak--; } virtual unsigned int ref() noexcept { return _ref; } virtual unsigned int wref() noexcept { return _weak; } virtual void destroy() noexcept { _destroy(); } virtual bool destroying() noexcept { return _destroying; } virtual bool dataNonNull() noexcept { return _data; } virtual ~impl() { destroy(); } }; }; template class CSharedPointer { public: template using validHierarchy = typename std::enable_if&, X>::value, CSharedPointer&>::type; template using isConstructible = typename std::enable_if::value>::type; /* creates a new shared pointer managing a resource avoid calling. Could duplicate ownership. Prefer makeShared */ explicit CSharedPointer(T* object) noexcept { impl_ = new CSharedPointer_::impl(object); increment(); } /* creates a shared pointer from a reference */ template > CSharedPointer(const CSharedPointer& ref) noexcept { impl_ = ref.impl_; increment(); } CSharedPointer(const CSharedPointer& ref) noexcept { impl_ = ref.impl_; increment(); } template > CSharedPointer(CSharedPointer&& ref) noexcept { std::swap(impl_, ref.impl_); } CSharedPointer(CSharedPointer&& ref) noexcept { std::swap(impl_, ref.impl_); } /* allows weakPointer to create from an impl */ CSharedPointer(CSharedPointer_::impl_base* implementation) noexcept { impl_ = implementation; increment(); } /* creates an empty shared pointer with no implementation */ CSharedPointer() noexcept { ; // empty } /* creates an empty shared pointer with no implementation */ CSharedPointer(std::nullptr_t) noexcept { ; // empty } ~CSharedPointer() { decrement(); } template validHierarchy&> operator=(const CSharedPointer& rhs) { if (impl_ == rhs.impl_) return *this; decrement(); impl_ = rhs.impl_; increment(); return *this; } CSharedPointer& operator=(const CSharedPointer& rhs) { if (impl_ == rhs.impl_) return *this; decrement(); impl_ = rhs.impl_; increment(); return *this; } template validHierarchy&> operator=(CSharedPointer&& rhs) { std::swap(impl_, rhs.impl_); return *this; } CSharedPointer& operator=(CSharedPointer&& rhs) { std::swap(impl_, rhs.impl_); return *this; } operator bool() const { return impl_ && impl_->dataNonNull(); } bool operator==(const CSharedPointer& rhs) const { return impl_ == rhs.impl_; } bool operator()(const CSharedPointer& lhs, const CSharedPointer& rhs) const { return (uintptr_t)lhs.impl_ < (uintptr_t)rhs.impl_; } bool operator<(const CSharedPointer& rhs) const { return (uintptr_t)impl_ < (uintptr_t)rhs.impl_; } T* operator->() const { return get(); } T& operator*() const { return *get(); } void reset() { decrement(); impl_ = nullptr; } T* get() const { return (T*)(impl_ ? static_cast*>(impl_)->_data : nullptr); } unsigned int strongRef() const { return impl_ ? impl_->ref() : 0; } CSharedPointer_::impl_base* impl_ = nullptr; private: /* no-op if there is no impl_ may delete the stored object if ref == 0 may delete and reset impl_ if ref == 0 and weak == 0 */ void decrement() { if (!impl_) return; impl_->dec(); // if ref == 0, we can destroy impl if (impl_->ref() == 0) destroyImpl(); } /* no-op if there is no impl_ */ void increment() { if (!impl_) return; impl_->inc(); } /* destroy the pointed-to object if able, will also destroy impl */ void destroyImpl() { // destroy the impl contents impl_->destroy(); // check for weak refs, if zero, we can also delete impl_ if (impl_->wref() == 0) { delete impl_; impl_ = nullptr; } } }; template static CSharedPointer makeShared(Args&&... args) { return CSharedPointer(new U(std::forward(args)...)); } } } template struct std::hash> { std::size_t operator()(const Hyprutils::Memory::CSharedPointer& p) const noexcept { return std::hash{}(p.impl_); } };hyprutils-0.1.5/include/hyprutils/memory/WeakPtr.hpp000066400000000000000000000140001464043730500226450ustar00rootroot00000000000000#pragma once #include "./SharedPtr.hpp" /* This is a Hyprland implementation of std::weak_ptr. See SharedPtr.hpp for more info on how it's different. */ namespace Hyprutils { namespace Memory { template class CWeakPointer { public: template using validHierarchy = typename std::enable_if&, X>::value, CWeakPointer&>::type; template using isConstructible = typename std::enable_if::value>::type; /* create a weak ptr from a reference */ template > CWeakPointer(const CSharedPointer& ref) noexcept { if (!ref.impl_) return; impl_ = ref.impl_; incrementWeak(); } /* create a weak ptr from another weak ptr */ template > CWeakPointer(const CWeakPointer& ref) noexcept { if (!ref.impl_) return; impl_ = ref.impl_; incrementWeak(); } CWeakPointer(const CWeakPointer& ref) noexcept { if (!ref.impl_) return; impl_ = ref.impl_; incrementWeak(); } template > CWeakPointer(CWeakPointer&& ref) noexcept { std::swap(impl_, ref.impl_); } CWeakPointer(CWeakPointer&& ref) noexcept { std::swap(impl_, ref.impl_); } /* create a weak ptr from another weak ptr with assignment */ template validHierarchy&> operator=(const CWeakPointer& rhs) { if (impl_ == rhs.impl_) return *this; decrementWeak(); impl_ = rhs.impl_; incrementWeak(); return *this; } CWeakPointer& operator=(const CWeakPointer& rhs) { if (impl_ == rhs.impl_) return *this; decrementWeak(); impl_ = rhs.impl_; incrementWeak(); return *this; } /* create a weak ptr from a shared ptr with assignment */ template validHierarchy&> operator=(const CSharedPointer& rhs) { if ((uintptr_t)impl_ == (uintptr_t)rhs.impl_) return *this; decrementWeak(); impl_ = rhs.impl_; incrementWeak(); return *this; } /* create an empty weak ptr */ CWeakPointer() { ; } ~CWeakPointer() { decrementWeak(); } /* expired MAY return true even if the pointer is still stored. the situation would be e.g. self-weak pointer in a destructor. for pointer validity, use valid() */ bool expired() const { return !impl_ || !impl_->dataNonNull() || impl_->destroying(); } /* this means the pointed-to object is not yet deleted and can still be referenced, but it might be in the process of being deleted. check !expired() if you want to check whether it's valid and assignable to a SP. */ bool valid() const { return impl_ && impl_->dataNonNull(); } void reset() { decrementWeak(); impl_ = nullptr; } CSharedPointer lock() const { if (!impl_ || !impl_->dataNonNull() || impl_->destroying()) return {}; return CSharedPointer(impl_); } /* this returns valid() */ operator bool() const { return valid(); } bool operator==(const CWeakPointer& rhs) const { return impl_ == rhs.impl_; } bool operator==(const CSharedPointer& rhs) const { return impl_ == rhs.impl_; } bool operator()(const CWeakPointer& lhs, const CWeakPointer& rhs) const { return (uintptr_t)lhs.impl_ < (uintptr_t)rhs.impl_; } bool operator<(const CWeakPointer& rhs) const { return (uintptr_t)impl_ < (uintptr_t)rhs.impl_; } T* get() const { return (T*)(impl_ ? static_cast*>(impl_)->_data : nullptr); } T* operator->() const { return get(); } CSharedPointer_::impl_base* impl_ = nullptr; private: /* no-op if there is no impl_ */ void decrementWeak() { if (!impl_) return; impl_->decWeak(); // we need to check for ->destroying, // because otherwise we could destroy here // and have a shared_ptr destroy the same thing // later (in situations where we have a weak_ptr to self) if (impl_->wref() == 0 && impl_->ref() == 0 && !impl_->destroying()) { delete impl_; impl_ = nullptr; } } /* no-op if there is no impl_ */ void incrementWeak() { if (!impl_) return; impl_->incWeak(); } }; } } template struct std::hash> { std::size_t operator()(const Hyprutils::Memory::CWeakPointer& p) const noexcept { return std::hash{}(p.impl_); } }; hyprutils-0.1.5/include/hyprutils/signal/000077500000000000000000000000001464043730500205315ustar00rootroot00000000000000hyprutils-0.1.5/include/hyprutils/signal/Listener.hpp000066400000000000000000000025771464043730500230420ustar00rootroot00000000000000#pragma once #include #include #include namespace Hyprutils { namespace Signal { class CSignal; class CSignalListener { public: CSignalListener(std::function handler); CSignalListener(CSignalListener&&) = delete; CSignalListener(CSignalListener&) = delete; CSignalListener(const CSignalListener&) = delete; CSignalListener(const CSignalListener&&) = delete; void emit(std::any data); private: std::function m_fHandler; }; typedef Hyprutils::Memory::CSharedPointer CHyprSignalListener; class CStaticSignalListener { public: CStaticSignalListener(std::function handler, void* owner); CStaticSignalListener(CStaticSignalListener&&) = delete; CStaticSignalListener(CStaticSignalListener&) = delete; CStaticSignalListener(const CStaticSignalListener&) = delete; CStaticSignalListener(const CStaticSignalListener&&) = delete; void emit(std::any data); private: void* m_pOwner = nullptr; std::function m_fHandler; }; } } hyprutils-0.1.5/include/hyprutils/signal/Signal.hpp000066400000000000000000000016421464043730500224620ustar00rootroot00000000000000#pragma once #include #include #include #include #include #include "./Listener.hpp" namespace Hyprutils { namespace Signal { class CSignal { public: void emit(std::any data = {}); // [[nodiscard("Listener is unregistered when the ptr is lost")]] CHyprSignalListener registerListener(std::function handler); // this is for static listeners. They die with this signal. // TODO: can we somehow rid of the void* data and make it a custom this? void registerStaticListener(std::function handler, void* owner); private: std::vector> m_vListeners; std::vector> m_vStaticListeners; }; } }hyprutils-0.1.5/include/hyprutils/string/000077500000000000000000000000001464043730500205625ustar00rootroot00000000000000hyprutils-0.1.5/include/hyprutils/string/String.hpp000066400000000000000000000005561464043730500225470ustar00rootroot00000000000000#pragma once #include namespace Hyprutils { namespace String { // trims beginning and end of whitespace characters std::string trim(const std::string& in); bool isNumber(const std::string& str, bool allowfloat = false); void replaceInString(std::string& string, const std::string& what, const std::string& to); }; };hyprutils-0.1.5/include/hyprutils/string/VarList.hpp000066400000000000000000000040361464043730500226620ustar00rootroot00000000000000#pragma once #include #include #include namespace Hyprutils { namespace String { class CVarList { public: /** Split string into arg list @param lastArgNo stop splitting after argv reaches maximum size, last arg will contain rest of unsplit args @param delim if delimiter is 's', use std::isspace @param removeEmpty remove empty args from argv */ CVarList(const std::string& in, const size_t maxSize = 0, const char delim = ',', const bool removeEmpty = false); ~CVarList() = default; size_t size() const { return m_vArgs.size(); } std::string join(const std::string& joiner, size_t from = 0, size_t to = 0) const; void map(std::function func) { for (auto& s : m_vArgs) func(s); } void append(const std::string arg) { m_vArgs.emplace_back(arg); } std::string operator[](const size_t& idx) const { if (idx >= m_vArgs.size()) return ""; return m_vArgs[idx]; } // for range-based loops std::vector::iterator begin() { return m_vArgs.begin(); } std::vector::const_iterator begin() const { return m_vArgs.begin(); } std::vector::iterator end() { return m_vArgs.end(); } std::vector::const_iterator end() const { return m_vArgs.end(); } bool contains(const std::string& el) { for (auto& a : m_vArgs) { if (a == el) return true; } return false; } private: std::vector m_vArgs; }; } } hyprutils-0.1.5/nix/000077500000000000000000000000001464043730500143645ustar00rootroot00000000000000hyprutils-0.1.5/nix/default.nix000066400000000000000000000011121464043730500165230ustar00rootroot00000000000000{ lib, stdenv, cmake, pkg-config, pixman, version ? "git", doCheck ? false, }: stdenv.mkDerivation { pname = "hyprutils"; inherit version doCheck; src = ../.; nativeBuildInputs = [ cmake pkg-config ]; buildInputs = [ pixman ]; outputs = ["out" "dev"]; cmakeBuildType = "RelWithDebInfo"; dontStrip = true; meta = with lib; { homepage = "https://github.com/hyprwm/hyprutils"; description = "Small C++ library for utilities used across the Hypr* ecosystem"; license = licenses.bsd3; platforms = platforms.linux; }; } hyprutils-0.1.5/src/000077500000000000000000000000001464043730500143555ustar00rootroot00000000000000hyprutils-0.1.5/src/math/000077500000000000000000000000001464043730500153065ustar00rootroot00000000000000hyprutils-0.1.5/src/math/Box.cpp000066400000000000000000000127431464043730500165510ustar00rootroot00000000000000#include #include #include #include #define VECINRECT(vec, x1, y1, x2, y2) ((vec).x >= (x1) && (vec).x < (x2) && (vec).y >= (y1) && (vec).y < (y2)) using namespace Hyprutils::Math; constexpr double HALF = 0.5; constexpr double DOUBLE = 2.0; constexpr double EPSILON = 1e-9; CBox& Hyprutils::Math::CBox::scale(double scale) { x *= scale; y *= scale; w *= scale; h *= scale; return *this; } CBox& Hyprutils::Math::CBox::scale(const Vector2D& scale) { x *= scale.x; y *= scale.y; w *= scale.x; h *= scale.y; return *this; } CBox& Hyprutils::Math::CBox::translate(const Vector2D& vec) { x += vec.x; y += vec.y; return *this; } Vector2D Hyprutils::Math::CBox::middle() const { return Vector2D{x + w * HALF, y + h * HALF}; } bool Hyprutils::Math::CBox::containsPoint(const Vector2D& vec) const { return VECINRECT(vec, x, y, x + w, y + h); } bool Hyprutils::Math::CBox::empty() const { return std::fabs(w) < EPSILON || std::fabs(h) < EPSILON; } CBox& Hyprutils::Math::CBox::round() { double roundedX = std::round(x); double roundedY = std::round(y); double newW = x + w - roundedX; double newH = y + h - roundedY; x = roundedX; y = roundedY; w = std::round(newW); h = std::round(newH); return *this; } CBox& Hyprutils::Math::CBox::transform(const eTransform t, double w, double h) { CBox temp = *this; if (t % 2 == 0) { width = temp.width; height = temp.height; } else { width = temp.height; height = temp.width; } switch (t) { case HYPRUTILS_TRANSFORM_NORMAL: x = temp.x; y = temp.y; break; case HYPRUTILS_TRANSFORM_90: x = h - temp.y - temp.height; y = temp.x; break; case HYPRUTILS_TRANSFORM_180: x = w - temp.x - temp.width; y = h - temp.y - temp.height; break; case HYPRUTILS_TRANSFORM_270: x = temp.y; y = w - temp.x - temp.width; break; case HYPRUTILS_TRANSFORM_FLIPPED: x = w - temp.x - temp.width; y = temp.y; break; case HYPRUTILS_TRANSFORM_FLIPPED_90: x = temp.y; y = temp.x; break; case HYPRUTILS_TRANSFORM_FLIPPED_180: x = temp.x; y = h - temp.y - temp.height; break; case HYPRUTILS_TRANSFORM_FLIPPED_270: x = h - temp.y - temp.height; y = w - temp.x - temp.width; break; } return *this; } CBox& Hyprutils::Math::CBox::addExtents(const SBoxExtents& e) { x -= e.topLeft.x; y -= e.topLeft.y; w += e.topLeft.x + e.bottomRight.x; h += e.topLeft.y + e.bottomRight.y; return *this; } CBox& Hyprutils::Math::CBox::scaleFromCenter(double scale) { double oldW = w, oldH = h; w *= scale; h *= scale; x -= (w - oldW) * HALF; y -= (h - oldH) * HALF; return *this; } CBox& Hyprutils::Math::CBox::expand(const double& value) { x -= value; y -= value; w += value * DOUBLE; h += value * DOUBLE; if (w <= EPSILON || h <= EPSILON) { w = 0; h = 0; } return *this; } CBox& Hyprutils::Math::CBox::noNegativeSize() { w = std::clamp(w, 0.0, std::numeric_limits::infinity()); h = std::clamp(h, 0.0, std::numeric_limits::infinity()); return *this; } CBox Hyprutils::Math::CBox::intersection(const CBox& other) const { const double newX = std::max(x, other.x); const double newY = std::max(y, other.y); const double newBottom = std::min(y + h, other.y + other.h); const double newRight = std::min(x + w, other.x + other.w); double newW = newRight - newX; double newH = newBottom - newY; if (newW <= EPSILON || newH <= EPSILON) { newW = 0; newH = 0; } return {newX, newY, newW, newH}; } bool Hyprutils::Math::CBox::overlaps(const CBox& other) const { return (other.x + other.w >= x) && (x + w >= other.x) && (other.y + other.h >= y) && (y + h >= other.y); } bool Hyprutils::Math::CBox::inside(const CBox& bound) const { return bound.x < x && bound.y < y && x + w < bound.x + bound.w && y + h < bound.y + bound.h; } CBox Hyprutils::Math::CBox::roundInternal() { double flooredX = std::floor(x); double flooredY = std::floor(y); double newW = x + w - flooredX; double newH = y + h - flooredY; return CBox{flooredX, flooredY, std::floor(newW), std::floor(newH)}; } CBox Hyprutils::Math::CBox::copy() const { return CBox{*this}; } Vector2D Hyprutils::Math::CBox::pos() const { return {x, y}; } Vector2D Hyprutils::Math::CBox::size() const { return {w, h}; } Vector2D Hyprutils::Math::CBox::closestPoint(const Vector2D& vec) const { if (containsPoint(vec)) return vec; Vector2D nv = vec; nv.x = std::clamp(nv.x, x, x + w); nv.y = std::clamp(nv.y, y, y + h); if (std::fabs(nv.x - x) < EPSILON) nv.x = x; else if (std::fabs(nv.x - (x + w)) < EPSILON) nv.x = x + w; if (std::fabs(nv.y - y) < EPSILON) nv.y = y; else if (std::fabs(nv.y - (y + h)) < EPSILON) nv.y = y + h; return nv; } SBoxExtents Hyprutils::Math::CBox::extentsFrom(const CBox& small) { return {{small.x - x, small.y - y}, {w - small.w - (small.x - x), h - small.h - (small.y - y)}}; } hyprutils-0.1.5/src/math/Region.cpp000066400000000000000000000131731464043730500172420ustar00rootroot00000000000000#include #include using namespace Hyprutils::Math; constexpr const int64_t MAX_REGION_SIDE = 10000000; Hyprutils::Math::CRegion::CRegion() { pixman_region32_init(&m_rRegion); } Hyprutils::Math::CRegion::CRegion(const pixman_region32_t* const ref) { pixman_region32_init(&m_rRegion); pixman_region32_copy(&m_rRegion, ref); } Hyprutils::Math::CRegion::CRegion(double x, double y, double w, double h) { pixman_region32_init_rect(&m_rRegion, x, y, w, h); } Hyprutils::Math::CRegion::CRegion(const CBox& box) { pixman_region32_init_rect(&m_rRegion, box.x, box.y, box.w, box.h); } Hyprutils::Math::CRegion::CRegion(pixman_box32_t* box) { pixman_region32_init_rect(&m_rRegion, box->x1, box->y1, box->x2 - box->x1, box->y2 - box->y1); } Hyprutils::Math::CRegion::CRegion(const CRegion& other) { pixman_region32_init(&m_rRegion); pixman_region32_copy(&m_rRegion, const_cast(&other)->pixman()); } Hyprutils::Math::CRegion::CRegion(CRegion&& other) { pixman_region32_init(&m_rRegion); pixman_region32_copy(&m_rRegion, other.pixman()); } Hyprutils::Math::CRegion::~CRegion() { pixman_region32_fini(&m_rRegion); } CRegion& Hyprutils::Math::CRegion::clear() { pixman_region32_clear(&m_rRegion); return *this; } CRegion& Hyprutils::Math::CRegion::set(const CRegion& other) { pixman_region32_copy(&m_rRegion, const_cast(&other)->pixman()); return *this; } CRegion& Hyprutils::Math::CRegion::add(const CRegion& other) { pixman_region32_union(&m_rRegion, &m_rRegion, const_cast(&other)->pixman()); return *this; } CRegion& Hyprutils::Math::CRegion::add(double x, double y, double w, double h) { pixman_region32_union_rect(&m_rRegion, &m_rRegion, x, y, w, h); return *this; } CRegion& Hyprutils::Math::CRegion::add(const CBox& other) { pixman_region32_union_rect(&m_rRegion, &m_rRegion, other.x, other.y, other.w, other.h); return *this; } CRegion& Hyprutils::Math::CRegion::subtract(const CRegion& other) { pixman_region32_subtract(&m_rRegion, &m_rRegion, const_cast(&other)->pixman()); return *this; } CRegion& Hyprutils::Math::CRegion::intersect(const CRegion& other) { pixman_region32_intersect(&m_rRegion, &m_rRegion, const_cast(&other)->pixman()); return *this; } CRegion& Hyprutils::Math::CRegion::intersect(double x, double y, double w, double h) { pixman_region32_intersect_rect(&m_rRegion, &m_rRegion, x, y, w, h); return *this; } CRegion& Hyprutils::Math::CRegion::invert(pixman_box32_t* box) { pixman_region32_inverse(&m_rRegion, &m_rRegion, box); return *this; } CRegion& Hyprutils::Math::CRegion::invert(const CBox& box) { pixman_box32 pixmanBox = {(int32_t)box.x, (int32_t)box.y, (int32_t)box.w + (int32_t)box.x, (int32_t)box.h + (int32_t)box.y}; return this->invert(&pixmanBox); } CRegion& Hyprutils::Math::CRegion::translate(const Vector2D& vec) { pixman_region32_translate(&m_rRegion, vec.x, vec.y); return *this; } CRegion& Hyprutils::Math::CRegion::transform(const eTransform t, double w, double h) { if (t == HYPRUTILS_TRANSFORM_NORMAL) return *this; auto rects = getRects(); clear(); for (auto& r : rects) { CBox xfmd{(double)r.x1, (double)r.y1, (double)r.x2 - r.x1, (double)r.y2 - r.y1}; xfmd.transform(t, w, h); add(xfmd); } return *this; } CRegion& Hyprutils::Math::CRegion::rationalize() { intersect(CBox{-MAX_REGION_SIDE, -MAX_REGION_SIDE, MAX_REGION_SIDE * 2, MAX_REGION_SIDE * 2}); return *this; } CRegion Hyprutils::Math::CRegion::copy() const { return CRegion(*this); } CRegion& Hyprutils::Math::CRegion::scale(float scale_) { scale({scale_, scale_}); return *this; } CRegion& Hyprutils::Math::CRegion::scale(const Vector2D& scale) { if (scale == Vector2D{1, 1}) return *this; auto rects = getRects(); clear(); for (auto& r : rects) { r.x1 = std::floor(r.x1 * scale.x); r.y1 = std::floor(r.y1 * scale.x); r.x2 = std::ceil(r.x2 * scale.x); r.y2 = std::ceil(r.y2 * scale.x); add(&r); } return *this; } std::vector Hyprutils::Math::CRegion::getRects() const { std::vector result; int rectsNum = 0; const auto RECTSARR = pixman_region32_rectangles(&m_rRegion, &rectsNum); result.assign(RECTSARR, RECTSARR + rectsNum); return result; } CBox Hyprutils::Math::CRegion::getExtents() { pixman_box32_t* box = pixman_region32_extents(&m_rRegion); return {(double)box->x1, (double)box->y1, (double)box->x2 - box->x1, (double)box->y2 - box->y1}; } bool Hyprutils::Math::CRegion::containsPoint(const Vector2D& vec) const { return pixman_region32_contains_point(&m_rRegion, vec.x, vec.y, nullptr); } bool Hyprutils::Math::CRegion::empty() const { return !pixman_region32_not_empty(&m_rRegion); } Vector2D Hyprutils::Math::CRegion::closestPoint(const Vector2D& vec) const { if (containsPoint(vec)) return vec; double bestDist = __FLT_MAX__; Vector2D leader = vec; for (auto& box : getRects()) { double x = 0, y = 0; if (vec.x >= box.x2) x = box.x2 - 1; else if (vec.x < box.x1) x = box.x1; else x = vec.x; if (vec.y >= box.y2) y = box.y2 - 1; else if (vec.y < box.y1) y = box.y1; else y = vec.y; double distance = pow(x, 2) + pow(y, 2); if (distance < bestDist) { bestDist = distance; leader = {x, y}; } } return leader; }hyprutils-0.1.5/src/math/Vector2D.cpp000066400000000000000000000030421464043730500174410ustar00rootroot00000000000000#include #include #include using namespace Hyprutils::Math; Hyprutils::Math::Vector2D::Vector2D(double xx, double yy) { x = xx; y = yy; } Hyprutils::Math::Vector2D::Vector2D(int xx, int yy) { x = (double)xx; y = (double)yy; } Hyprutils::Math::Vector2D::Vector2D() { x = 0; y = 0; } Hyprutils::Math::Vector2D::~Vector2D() {} double Hyprutils::Math::Vector2D::normalize() { // get max abs const auto max = std::abs(x) > std::abs(y) ? std::abs(x) : std::abs(y); x /= max; y /= max; return max; } Vector2D Hyprutils::Math::Vector2D::floor() const { return Vector2D(std::floor(x), std::floor(y)); } Vector2D Hyprutils::Math::Vector2D::round() const { return Vector2D(std::round(x), std::round(y)); } Vector2D Hyprutils::Math::Vector2D::clamp(const Vector2D& min, const Vector2D& max) const { return Vector2D(std::clamp(this->x, min.x, max.x < min.x ? INFINITY : max.x), std::clamp(this->y, min.y, max.y < min.y ? INFINITY : max.y)); } double Hyprutils::Math::Vector2D::distance(const Vector2D& other) const { return std::sqrt(distanceSq(other)); } double Hyprutils::Math::Vector2D::distanceSq(const Vector2D& other) const { return (x - other.x) * (x - other.x) + (y - other.y) * (y - other.y); } double Hyprutils::Math::Vector2D::size() const { return std::sqrt(x * x + y * y); } Vector2D Hyprutils::Math::Vector2D::getComponentMax(const Vector2D& other) const { return Vector2D(std::max(this->x, other.x), std::max(this->y, other.y)); } hyprutils-0.1.5/src/signal/000077500000000000000000000000001464043730500156325ustar00rootroot00000000000000hyprutils-0.1.5/src/signal/Listener.cpp000066400000000000000000000011341464043730500201220ustar00rootroot00000000000000#include using namespace Hyprutils::Signal; Hyprutils::Signal::CSignalListener::CSignalListener(std::function handler) : m_fHandler(handler) { ; } void Hyprutils::Signal::CSignalListener::emit(std::any data) { if (!m_fHandler) return; m_fHandler(data); } Hyprutils::Signal::CStaticSignalListener::CStaticSignalListener(std::function handler, void* owner) : m_pOwner(owner), m_fHandler(handler) { ; } void Hyprutils::Signal::CStaticSignalListener::emit(std::any data) { m_fHandler(m_pOwner, data); } hyprutils-0.1.5/src/signal/Signal.cpp000066400000000000000000000031561464043730500175600ustar00rootroot00000000000000#include #include #include using namespace Hyprutils::Signal; using namespace Hyprutils::Memory; #define SP CSharedPointer #define WP CWeakPointer void Hyprutils::Signal::CSignal::emit(std::any data) { bool dirty = false; std::vector> listeners; for (auto& l : m_vListeners) { if (l.expired()) { dirty = true; continue; } listeners.emplace_back(l.lock()); } std::vector statics; for (auto& l : m_vStaticListeners) { statics.emplace_back(l.get()); } for (auto& l : listeners) { // if there is only one lock, it means the event is only held by the listeners // vector and was removed during our iteration if (l.strongRef() == 1) { dirty = true; continue; } l->emit(data); } for (auto& l : statics) { l->emit(data); } // release SPs listeners.clear(); if (dirty) std::erase_if(m_vListeners, [](const auto& other) { return other.expired(); }); } CHyprSignalListener Hyprutils::Signal::CSignal::registerListener(std::function handler) { CHyprSignalListener listener = makeShared(handler); m_vListeners.emplace_back(listener); return listener; } void Hyprutils::Signal::CSignal::registerStaticListener(std::function handler, void* owner) { m_vStaticListeners.emplace_back(std::make_unique(handler, owner)); }hyprutils-0.1.5/src/string/000077500000000000000000000000001464043730500156635ustar00rootroot00000000000000hyprutils-0.1.5/src/string/String.cpp000066400000000000000000000031231464043730500176340ustar00rootroot00000000000000#include #include using namespace Hyprutils::String; std::string Hyprutils::String::trim(const std::string& in) { if (in.empty()) return in; int countBefore = 0; while (countBefore < in.length() && std::isspace(in.at(countBefore))) { countBefore++; } int countAfter = 0; while (countAfter < in.length() - countBefore && std::isspace(in.at(in.length() - countAfter - 1))) { countAfter++; } std::string result = in.substr(countBefore, in.length() - countBefore - countAfter); return result; } bool Hyprutils::String::isNumber(const std::string& str, bool allowfloat) { if (str.empty()) return false; for (size_t i = 0; i < str.length(); ++i) { const char& c = str.at(i); if (i == 0 && str.at(i) == '-') { // only place where we allow - continue; } if (!isdigit(c)) { if (!allowfloat) return false; if (c != '.') return false; if (i == 0) return false; if (str.at(0) == '-') return false; continue; } } if (!isdigit(str.back())) return false; return true; } void Hyprutils::String::replaceInString(std::string& string, const std::string& what, const std::string& to) { if (string.empty()) return; size_t pos = 0; while ((pos = string.find(what, pos)) != std::string::npos) { string.replace(pos, what.length(), to); pos += to.length(); } } hyprutils-0.1.5/src/string/VarList.cpp000066400000000000000000000022421464043730500177530ustar00rootroot00000000000000#include #include #include #include using namespace Hyprutils::String; Hyprutils::String::CVarList::CVarList(const std::string& in, const size_t lastArgNo, const char delim, const bool removeEmpty) { if (in.empty()) m_vArgs.emplace_back(""); std::string args{in}; size_t idx = 0; size_t pos = 0; std::ranges::replace_if( args, [&](const char& c) { return delim == 's' ? std::isspace(c) : c == delim; }, 0); for (const auto& s : args | std::views::split(0)) { if (removeEmpty && s.empty()) continue; if (++idx == lastArgNo) { m_vArgs.emplace_back(trim(in.substr(pos))); break; } pos += s.size() + 1; m_vArgs.emplace_back(trim(std::string_view{s}.data())); } } std::string Hyprutils::String::CVarList::join(const std::string& joiner, size_t from, size_t to) const { size_t last = to == 0 ? size() : to; std::string rolling; for (size_t i = from; i < last; ++i) { rolling += m_vArgs[i] + (i + 1 < last ? joiner : ""); } return rolling; }hyprutils-0.1.5/tests/000077500000000000000000000000001464043730500147305ustar00rootroot00000000000000hyprutils-0.1.5/tests/math.cpp000066400000000000000000000047011464043730500163670ustar00rootroot00000000000000#include #include "shared.hpp" using namespace Hyprutils::Math; int main(int argc, char** argv, char** envp) { CRegion rg = {0, 0, 100, 100}; rg.add(CBox{{}, {20, 200}}); int ret = 0; EXPECT(rg.getExtents().height, 200); EXPECT(rg.getExtents().width, 100); rg.intersect(CBox{10, 10, 300, 300}); EXPECT(rg.getExtents().width, 90); EXPECT(rg.getExtents().height, 190); /*Box.cpp test cases*/ // Test default constructor and accessors { CBox box1; EXPECT(box1.x, 0); EXPECT(box1.y, 0); EXPECT(box1.width, 0); EXPECT(box1.height, 0); // Test parameterized constructor and accessors CBox box2(10, 20, 30, 40); EXPECT(box2.x, 10); EXPECT(box2.y, 20); EXPECT(box2.width, 30); EXPECT(box2.height, 40); // Test setters and getters box2.translate(Vector2D(5, -5)); EXPECT_VECTOR2D(box2.pos(), Vector2D(15, 15)); } //Test Scaling and Transformation { CBox box(10, 10, 20, 30); // Test scaling box.scale(2.0); EXPECT_VECTOR2D(box.size(), Vector2D(40, 60)); EXPECT_VECTOR2D(box.pos(), Vector2D(20, 20)); // Test scaling from center box.scaleFromCenter(0.5); EXPECT_VECTOR2D(box.size(), Vector2D(20, 30)); EXPECT_VECTOR2D(box.pos(), Vector2D(30, 35)); // Test transformation box.transform(HYPRUTILS_TRANSFORM_90, 100, 200); EXPECT_VECTOR2D(box.pos(), Vector2D(135, 30)); EXPECT_VECTOR2D(box.size(), Vector2D(30, 20)); // Test Intersection and Extents } { CBox box1(0, 0, 100, 100); CBox box2(50, 50, 100, 100); CBox intersection = box1.intersection(box2); EXPECT_VECTOR2D(intersection.pos(), Vector2D(50, 50)); EXPECT_VECTOR2D(intersection.size(), Vector2D(50, 50)); SBoxExtents extents = box1.extentsFrom(box2); EXPECT_VECTOR2D(extents.topLeft, Vector2D(50, 50)); EXPECT_VECTOR2D(extents.bottomRight, Vector2D(-50, -50)); } // Test Boundary Conditions and Special Cases { CBox box(0, 0, 50, 50); EXPECT(box.empty(), false); EXPECT(box.containsPoint(Vector2D(25, 25)), true); EXPECT(box.containsPoint(Vector2D(60, 60)), false); EXPECT(box.overlaps(CBox(25, 25, 50, 50)), true); EXPECT(box.inside(CBox(0, 0, 100, 100)), false); } return ret; }hyprutils-0.1.5/tests/memory.cpp000066400000000000000000000010361464043730500167440ustar00rootroot00000000000000#include #include "shared.hpp" using namespace Hyprutils::Memory; #define SP CSharedPointer #define WP CWeakPointer int main(int argc, char** argv, char** envp) { SP intPtr = makeShared(10); int ret = 0; EXPECT(*intPtr, 10); EXPECT(intPtr.strongRef(), 1); WP weak = intPtr; EXPECT(*intPtr, 10); EXPECT(intPtr.strongRef(), 1); EXPECT(*weak.get(), 10); EXPECT(weak.expired(), false); intPtr = {}; EXPECT(weak.expired(), true); return ret; }hyprutils-0.1.5/tests/shared.hpp000066400000000000000000000066431464043730500167200ustar00rootroot00000000000000#pragma once #include namespace Colors { constexpr const char* RED = "\x1b[31m"; constexpr const char* GREEN = "\x1b[32m"; constexpr const char* YELLOW = "\x1b[33m"; constexpr const char* BLUE = "\x1b[34m"; constexpr const char* MAGENTA = "\x1b[35m"; constexpr const char* CYAN = "\x1b[36m"; constexpr const char* RESET = "\x1b[0m"; }; #define EXPECT(expr, val) \ if (const auto RESULT = expr; RESULT != (val)) { \ std::cout << Colors::RED << "Failed: " << Colors::RESET << #expr << ", expected " << #val << " but got " << RESULT << "\n"; \ ret = 1; \ } else { \ std::cout << Colors::GREEN << "Passed " << Colors::RESET << #expr << ". Got " << val << "\n"; \ } #define EXPECT_VECTOR2D(expr, val) \ do { \ const auto& RESULT = expr; \ const auto& EXPECTED = val; \ if (!(std::abs(RESULT.x - EXPECTED.x) < 1e-6 && std::abs(RESULT.y - EXPECTED.y) < 1e-6)) { \ std::cout << Colors::RED << "Failed: " << Colors::RESET << #expr << ", expected (" << EXPECTED.x << ", " << EXPECTED.y << ") but got (" << RESULT.x << ", " \ << RESULT.y << ")\n"; \ ret = 1; \ } else { \ std::cout << Colors::GREEN << "Passed " << Colors::RESET << #expr << ". Got (" << RESULT.x << ", " << RESULT.y << ")\n"; \ } \ } while (0) hyprutils-0.1.5/tests/signal.cpp000066400000000000000000000007711464043730500167160ustar00rootroot00000000000000#include #include #include "shared.hpp" using namespace Hyprutils::Signal; using namespace Hyprutils::Memory; int main(int argc, char** argv, char** envp) { int ret = 0; CSignal signal; int data = 0; auto listener = signal.registerListener([&] (std::any d) { data = 1; }); signal.emit(); EXPECT(data, 1); data = 0; listener.reset(); signal.emit(); EXPECT(data, 0); return ret; }hyprutils-0.1.5/tests/string.cpp000066400000000000000000000025371464043730500167510ustar00rootroot00000000000000#include #include #include "shared.hpp" using namespace Hyprutils::String; int main(int argc, char** argv, char** envp) { int ret = 0; EXPECT(trim(" a "), "a"); EXPECT(trim(" a a "), "a a"); EXPECT(trim("a"), "a"); EXPECT(trim(" "), ""); EXPECT(isNumber("99214123434"), true); EXPECT(isNumber("-35252345234"), true); EXPECT(isNumber("---3423--432"), false); EXPECT(isNumber("s---3423--432"), false); EXPECT(isNumber("---3423--432s"), false); EXPECT(isNumber("1s"), false); EXPECT(isNumber(""), false); EXPECT(isNumber("-"), false); EXPECT(isNumber("--0"), false); EXPECT(isNumber("abc"), false); EXPECT(isNumber("0.0", true), true); EXPECT(isNumber("0.2", true), true); EXPECT(isNumber("0.", true), false); EXPECT(isNumber(".0", true), false); EXPECT(isNumber("", true), false); EXPECT(isNumber("vvss", true), false); EXPECT(isNumber("0.9999s", true), false); EXPECT(isNumber("s0.9999", true), false); CVarList list("hello world!", 0, 's', true); EXPECT(list[0], "hello"); EXPECT(list[1], "world!"); std::string hello = "hello world!"; replaceInString(hello, "hello", "hi"); EXPECT(hello, "hi world!"); return ret; }