Compare commits
No commits in common. "main" and "windows" have entirely different histories.
41 changed files with 273 additions and 3571 deletions
|
|
@ -5,22 +5,17 @@ AlignConsecutiveDeclarations: true
|
|||
AllowShortBlocksOnASingleLine: Always
|
||||
AllowShortEnumsOnASingleLine: true
|
||||
AllowShortFunctionsOnASingleLine: All
|
||||
AllowShortIfStatementsOnASingleLine: WithoutElse
|
||||
AllowShortLoopsOnASingleLine: true
|
||||
BasedOnStyle: Chromium
|
||||
BinPackArguments: false
|
||||
BinPackParameters: false
|
||||
ColumnLimit: 120
|
||||
ConstructorInitializerIndentWidth: 2
|
||||
ContinuationIndentWidth: 2
|
||||
Cpp11BracedListStyle: false
|
||||
FixNamespaceComments: false
|
||||
IndentAccessModifiers: false
|
||||
IndentExternBlock: Indent
|
||||
IndentWidth: 2
|
||||
LineEnding: LF
|
||||
NamespaceIndentation: All
|
||||
SpaceBeforeCpp11BracedList: true
|
||||
SpacesBeforeTrailingComments: 1
|
||||
QualifierAlignment: Left
|
||||
|
||||
IncludeBlocks: Regroup
|
||||
IncludeCategories:
|
||||
|
|
|
|||
50
.clang-tidy
50
.clang-tidy
|
|
@ -1,33 +1,25 @@
|
|||
# noinspection SpellCheckingInspection
|
||||
Checks: >
|
||||
*,
|
||||
-ctad-maybe-unsupported,
|
||||
-abseil-*,
|
||||
-altera-*,
|
||||
-boost-*,
|
||||
-bugprone-easily-swappable-parameters,
|
||||
-bugprone-implicit-widening-of-multiplication-result,
|
||||
-cert-env33-c,
|
||||
-concurrency-mt-unsafe,
|
||||
-cppcoreguidelines-avoid-magic-numbers,
|
||||
-cppcoreguidelines-macro-usage,
|
||||
-cppcoreguidelines-owning-memory,
|
||||
-cppcoreguidelines-pro-type-member-init,
|
||||
-cppcoreguidelines-pro-type-vararg,
|
||||
-fuchsia-*,
|
||||
-google-*,
|
||||
-hicpp-*,
|
||||
-llvm-include-order,
|
||||
-llvm-include-order,
|
||||
-llvm-namespace-comment,
|
||||
-llvmlibc-*,
|
||||
-misc-non-private-member-variables-in-classes,
|
||||
-modernize-use-nullptr,
|
||||
-readability-braces-around-statements,
|
||||
-readability-function-cognitive-complexity,
|
||||
-readability-implicit-bool-conversion,
|
||||
-readability-isolate-declaration,
|
||||
-readability-magic-numbers
|
||||
*,
|
||||
-abseil-*,
|
||||
-altera-*,
|
||||
-bugprone-easily-swappable-parameters,
|
||||
-bugprone-implicit-widening-of-multiplication-result,
|
||||
-concurrency-mt-unsafe,
|
||||
-cppcoreguidelines-avoid-magic-numbers,
|
||||
-cppcoreguidelines-owning-memory,
|
||||
-cppcoreguidelines-pro-type-member-init,
|
||||
-fuchsia-*,
|
||||
-google-*,
|
||||
-hicpp-*,
|
||||
-llvm-include-order,
|
||||
-llvm-include-order,
|
||||
-llvmlibc-*,
|
||||
-misc-non-private-member-variables-in-classes,
|
||||
-modernize-use-trailing-return-type,
|
||||
-readability-braces-around-statements,
|
||||
-readability-implicit-bool-conversion,
|
||||
-readability-isolate-declaration,
|
||||
-readability-magic-numbers
|
||||
CheckOptions:
|
||||
readability-identifier-naming.ClassCase: CamelCase
|
||||
readability-identifier-naming.EnumCase: CamelCase
|
||||
|
|
|
|||
9
.clangd
9
.clangd
|
|
@ -1,9 +0,0 @@
|
|||
CompileFlags:
|
||||
Add: [
|
||||
-D_HAS_CXX20_COROUTINES=1,
|
||||
-D_HAS_STD_BYTE=0
|
||||
]
|
||||
Diagnostics:
|
||||
Suppress: >
|
||||
-Wmissing-template-arg-list-after-template-kw,
|
||||
-Wctad-maybe-unsupported
|
||||
1
.envrc
1
.envrc
|
|
@ -1 +0,0 @@
|
|||
use_flake
|
||||
1
.gitattributes
vendored
1
.gitattributes
vendored
|
|
@ -1 +0,0 @@
|
|||
* text eol=lf
|
||||
28
.gitignore
vendored
28
.gitignore
vendored
|
|
@ -1,28 +1,2 @@
|
|||
.cache/
|
||||
.cmake/
|
||||
.direnv/
|
||||
.idea/
|
||||
.vs/
|
||||
.vscode/
|
||||
.xmake/
|
||||
.DS_Store
|
||||
|
||||
bin/
|
||||
build/
|
||||
cmake-build-debug/
|
||||
CMakeFiles/
|
||||
out/
|
||||
Testing/
|
||||
|
||||
build.ninja
|
||||
CMakeCache.txt
|
||||
cmake_install.cmake
|
||||
CMakeSettings.json
|
||||
compile_commands.json
|
||||
config.toml
|
||||
draconis++
|
||||
Makefile
|
||||
result
|
||||
/include/
|
||||
subprojects/*
|
||||
!subprojects/*.wrap
|
||||
cmake-build-*/
|
||||
3
.gitmodules
vendored
3
.gitmodules
vendored
|
|
@ -1,3 +0,0 @@
|
|||
[submodule "subprojects/glaze"]
|
||||
path = subprojects/glaze
|
||||
url = https://github.com/stephenberry/glaze
|
||||
15
CMakeLists.txt
Normal file
15
CMakeLists.txt
Normal file
|
|
@ -0,0 +1,15 @@
|
|||
cmake_minimum_required(VERSION 3.28)
|
||||
|
||||
project(draconis__)
|
||||
|
||||
set(CMAKE_CXX_STANDARD 26)
|
||||
set(CMAKE_MAKE_PROGRAM "Ninja")
|
||||
|
||||
add_executable(draconis__ main.cpp
|
||||
util.h)
|
||||
|
||||
find_package(fmt CONFIG REQUIRED)
|
||||
find_package(cppwinrt CONFIG REQUIRED)
|
||||
|
||||
target_link_libraries(draconis__ PRIVATE fmt::fmt-header-only)
|
||||
target_link_libraries(draconis__ PRIVATE WindowsApp)
|
||||
|
|
@ -1,44 +0,0 @@
|
|||
{
|
||||
"fmt": {
|
||||
"cargoLocks": null,
|
||||
"date": null,
|
||||
"extract": null,
|
||||
"name": "fmt",
|
||||
"passthru": null,
|
||||
"pinned": false,
|
||||
"src": {
|
||||
"deepClone": false,
|
||||
"fetchSubmodules": false,
|
||||
"leaveDotGit": false,
|
||||
"name": null,
|
||||
"owner": "fmtlib",
|
||||
"repo": "fmt",
|
||||
"rev": "11.1.4",
|
||||
"sha256": "sha256-sUbxlYi/Aupaox3JjWFqXIjcaQa0LFjclQAOleT+FRA=",
|
||||
"sparseCheckout": [],
|
||||
"type": "github"
|
||||
},
|
||||
"version": "11.1.4"
|
||||
},
|
||||
"tomlplusplus": {
|
||||
"cargoLocks": null,
|
||||
"date": null,
|
||||
"extract": null,
|
||||
"name": "tomlplusplus",
|
||||
"passthru": null,
|
||||
"pinned": false,
|
||||
"src": {
|
||||
"deepClone": false,
|
||||
"fetchSubmodules": false,
|
||||
"leaveDotGit": false,
|
||||
"name": null,
|
||||
"owner": "marzer",
|
||||
"repo": "tomlplusplus",
|
||||
"rev": "v3.4.0",
|
||||
"sha256": "sha256-h5tbO0Rv2tZezY58yUbyRVpsfRjY3i+5TPkkxr6La8M=",
|
||||
"sparseCheckout": [],
|
||||
"type": "github"
|
||||
},
|
||||
"version": "v3.4.0"
|
||||
}
|
||||
}
|
||||
|
|
@ -1,26 +0,0 @@
|
|||
# This file was generated by nvfetcher, please do not modify it manually.
|
||||
{ fetchgit, fetchurl, fetchFromGitHub, dockerTools }:
|
||||
{
|
||||
fmt = {
|
||||
pname = "fmt";
|
||||
version = "11.1.4";
|
||||
src = fetchFromGitHub {
|
||||
owner = "fmtlib";
|
||||
repo = "fmt";
|
||||
rev = "11.1.4";
|
||||
fetchSubmodules = false;
|
||||
sha256 = "sha256-sUbxlYi/Aupaox3JjWFqXIjcaQa0LFjclQAOleT+FRA=";
|
||||
};
|
||||
};
|
||||
tomlplusplus = {
|
||||
pname = "tomlplusplus";
|
||||
version = "v3.4.0";
|
||||
src = fetchFromGitHub {
|
||||
owner = "marzer";
|
||||
repo = "tomlplusplus";
|
||||
rev = "v3.4.0";
|
||||
fetchSubmodules = false;
|
||||
sha256 = "sha256-h5tbO0Rv2tZezY58yUbyRVpsfRjY3i+5TPkkxr6La8M=";
|
||||
};
|
||||
};
|
||||
}
|
||||
96
flake.lock
generated
96
flake.lock
generated
|
|
@ -1,96 +0,0 @@
|
|||
{
|
||||
"nodes": {
|
||||
"nixpkgs": {
|
||||
"locked": {
|
||||
"lastModified": 1741678040,
|
||||
"narHash": "sha256-rmBsz7BBcDwfvDkxnKHmolKceGJrr0nyz5PQYZg0kMk=",
|
||||
"owner": "NixOS",
|
||||
"repo": "nixpkgs",
|
||||
"rev": "3ee8818da146871cd570b164fc4f438f78479a50",
|
||||
"type": "github"
|
||||
},
|
||||
"original": {
|
||||
"owner": "NixOS",
|
||||
"ref": "nixpkgs-unstable",
|
||||
"repo": "nixpkgs",
|
||||
"type": "github"
|
||||
}
|
||||
},
|
||||
"nixpkgs_2": {
|
||||
"locked": {
|
||||
"lastModified": 1735554305,
|
||||
"narHash": "sha256-zExSA1i/b+1NMRhGGLtNfFGXgLtgo+dcuzHzaWA6w3Q=",
|
||||
"owner": "nixos",
|
||||
"repo": "nixpkgs",
|
||||
"rev": "0e82ab234249d8eee3e8c91437802b32c74bb3fd",
|
||||
"type": "github"
|
||||
},
|
||||
"original": {
|
||||
"owner": "nixos",
|
||||
"ref": "nixpkgs-unstable",
|
||||
"repo": "nixpkgs",
|
||||
"type": "github"
|
||||
}
|
||||
},
|
||||
"root": {
|
||||
"inputs": {
|
||||
"nixpkgs": "nixpkgs",
|
||||
"treefmt-nix": "treefmt-nix",
|
||||
"utils": "utils"
|
||||
}
|
||||
},
|
||||
"systems": {
|
||||
"locked": {
|
||||
"lastModified": 1681028828,
|
||||
"narHash": "sha256-Vy1rq5AaRuLzOxct8nz4T6wlgyUR7zLU309k9mBC768=",
|
||||
"owner": "nix-systems",
|
||||
"repo": "default",
|
||||
"rev": "da67096a3b9bf56a91d16901293e51ba5b49a27e",
|
||||
"type": "github"
|
||||
},
|
||||
"original": {
|
||||
"owner": "nix-systems",
|
||||
"repo": "default",
|
||||
"type": "github"
|
||||
}
|
||||
},
|
||||
"treefmt-nix": {
|
||||
"inputs": {
|
||||
"nixpkgs": "nixpkgs_2"
|
||||
},
|
||||
"locked": {
|
||||
"lastModified": 1739829690,
|
||||
"narHash": "sha256-mL1szCeIsjh6Khn3nH2cYtwO5YXG6gBiTw1A30iGeDU=",
|
||||
"owner": "numtide",
|
||||
"repo": "treefmt-nix",
|
||||
"rev": "3d0579f5cc93436052d94b73925b48973a104204",
|
||||
"type": "github"
|
||||
},
|
||||
"original": {
|
||||
"owner": "numtide",
|
||||
"repo": "treefmt-nix",
|
||||
"type": "github"
|
||||
}
|
||||
},
|
||||
"utils": {
|
||||
"inputs": {
|
||||
"systems": "systems"
|
||||
},
|
||||
"locked": {
|
||||
"lastModified": 1731533236,
|
||||
"narHash": "sha256-l0KFg5HjrsfsO/JpG+r7fRrqm12kzFHyUHqHCVpMMbI=",
|
||||
"owner": "numtide",
|
||||
"repo": "flake-utils",
|
||||
"rev": "11707dc2f618dd54ca8739b309ec4fc024de578b",
|
||||
"type": "github"
|
||||
},
|
||||
"original": {
|
||||
"owner": "numtide",
|
||||
"repo": "flake-utils",
|
||||
"type": "github"
|
||||
}
|
||||
}
|
||||
},
|
||||
"root": "root",
|
||||
"version": 7
|
||||
}
|
||||
145
flake.nix
145
flake.nix
|
|
@ -1,145 +0,0 @@
|
|||
{
|
||||
description = "C/C++ environment";
|
||||
|
||||
inputs = {
|
||||
nixpkgs.url = "github:NixOS/nixpkgs/nixpkgs-unstable";
|
||||
treefmt-nix.url = "github:numtide/treefmt-nix";
|
||||
utils.url = "github:numtide/flake-utils";
|
||||
};
|
||||
|
||||
outputs = {
|
||||
self,
|
||||
nixpkgs,
|
||||
treefmt-nix,
|
||||
utils,
|
||||
...
|
||||
}:
|
||||
utils.lib.eachDefaultSystem (
|
||||
system: let
|
||||
pkgs = import nixpkgs {inherit system;};
|
||||
|
||||
llvmPackages = with pkgs;
|
||||
if hostPlatform.isLinux
|
||||
then llvmPackages_20
|
||||
else llvmPackages_19;
|
||||
|
||||
stdenv = with pkgs;
|
||||
(
|
||||
if hostPlatform.isLinux
|
||||
then stdenvAdapters.useMoldLinker
|
||||
else lib.id
|
||||
)
|
||||
llvmPackages.stdenv;
|
||||
|
||||
sources = import ./_sources/generated.nix {
|
||||
inherit (pkgs) fetchFromGitHub fetchgit fetchurl dockerTools;
|
||||
};
|
||||
|
||||
fmt = pkgs.pkgsStatic.fmt.overrideAttrs (old: {
|
||||
inherit (sources.fmt) pname version src;
|
||||
});
|
||||
|
||||
tomlplusplus = pkgs.pkgsStatic.tomlplusplus.overrideAttrs {
|
||||
inherit (sources.tomlplusplus) pname version src;
|
||||
doCheck = false;
|
||||
};
|
||||
|
||||
deps = with pkgs;
|
||||
[
|
||||
(glaze.override {enableAvx2 = hostPlatform.isx86;})
|
||||
]
|
||||
++ (with pkgsStatic; [
|
||||
curl
|
||||
fmt
|
||||
ftxui
|
||||
libiconv
|
||||
sqlitecpp
|
||||
tomlplusplus
|
||||
])
|
||||
++ linuxPkgs;
|
||||
|
||||
linuxPkgs = nixpkgs.lib.optionals stdenv.isLinux (with pkgs;
|
||||
[
|
||||
valgrind
|
||||
]
|
||||
++ (with pkgsStatic; [
|
||||
dbus
|
||||
xorg.libX11
|
||||
wayland
|
||||
]));
|
||||
in
|
||||
with pkgs; {
|
||||
packages = rec {
|
||||
draconisplusplus = stdenv.mkDerivation {
|
||||
name = "draconis++";
|
||||
version = "0.1.0";
|
||||
src = self;
|
||||
|
||||
nativeBuildInputs = [
|
||||
cmake
|
||||
meson
|
||||
ninja
|
||||
pkg-config
|
||||
];
|
||||
|
||||
buildInputs = deps;
|
||||
|
||||
configurePhase = ''
|
||||
meson setup build
|
||||
'';
|
||||
|
||||
buildPhase = ''
|
||||
meson compile -C build
|
||||
'';
|
||||
|
||||
installPhase = ''
|
||||
mkdir -p $out/bin
|
||||
mv build/draconis++ $out/bin/draconis++
|
||||
'';
|
||||
};
|
||||
|
||||
default = draconisplusplus;
|
||||
};
|
||||
|
||||
formatter = treefmt-nix.lib.mkWrapper pkgs {
|
||||
projectRootFile = "flake.nix";
|
||||
programs = {
|
||||
alejandra.enable = true;
|
||||
deadnix.enable = true;
|
||||
|
||||
clang-format = {
|
||||
enable = true;
|
||||
package = pkgs.llvmPackages.clang-tools;
|
||||
};
|
||||
};
|
||||
};
|
||||
|
||||
devShell = mkShell.override {inherit stdenv;} {
|
||||
packages =
|
||||
[
|
||||
alejandra
|
||||
bear
|
||||
llvmPackages.clang-tools
|
||||
cmake
|
||||
lldb
|
||||
hyperfine
|
||||
meson
|
||||
ninja
|
||||
nvfetcher
|
||||
pkg-config
|
||||
unzip
|
||||
|
||||
(writeScriptBin "build" "meson compile -C build")
|
||||
(writeScriptBin "clean" "meson setup build --wipe")
|
||||
(writeScriptBin "run" "meson compile -C build && build/draconis++")
|
||||
]
|
||||
++ deps;
|
||||
|
||||
LD_LIBRARY_PATH = "${lib.makeLibraryPath deps}";
|
||||
NIX_ENFORCE_NO_NATIVE = 0;
|
||||
|
||||
name = "C++";
|
||||
};
|
||||
}
|
||||
);
|
||||
}
|
||||
199
main.cpp
Normal file
199
main.cpp
Normal file
|
|
@ -0,0 +1,199 @@
|
|||
#include <fmt/chrono.h>
|
||||
#include <fmt/core.h>
|
||||
#include <iostream>
|
||||
#include <windows.h>
|
||||
#include <winrt/Windows.Foundation.h> // ReSharper disable once CppUnusedIncludeDirective
|
||||
#include <winrt/Windows.Media.Control.h>
|
||||
#include <winrt/base.h>
|
||||
#include <winrt/impl/windows.media.control.2.h>
|
||||
|
||||
#include "util.h"
|
||||
|
||||
using namespace winrt;
|
||||
using namespace winrt::Windows::Media::Control;
|
||||
|
||||
struct KBToGiB {
|
||||
u64 value;
|
||||
};
|
||||
|
||||
template <>
|
||||
struct fmt::formatter<KBToGiB> : formatter<double> {
|
||||
template <typename FormatContext>
|
||||
typename FormatContext::iterator
|
||||
format(const KBToGiB KTG, FormatContext& ctx) {
|
||||
typename FormatContext::iterator out = formatter<double>::format(
|
||||
static_cast<double>(KTG.value) / pow(1024, 2), ctx
|
||||
);
|
||||
|
||||
*out++ = 'G';
|
||||
*out++ = 'i';
|
||||
*out++ = 'B';
|
||||
|
||||
return out;
|
||||
}
|
||||
};
|
||||
|
||||
enum DateNum : u8 { Ones, Twos, Threes, Default };
|
||||
|
||||
DateNum ParseDate(std::string const& input) {
|
||||
if (input == "1" || input == "21" || input == "31") return Ones;
|
||||
if (input == "2" || input == "22") return Twos;
|
||||
if (input == "3" || input == "23") return Threes;
|
||||
return Default;
|
||||
}
|
||||
|
||||
std::string GetNowPlaying() {
|
||||
using namespace winrt::Windows::Media::Control;
|
||||
using namespace winrt::Windows::Foundation;
|
||||
|
||||
using MediaProperties =
|
||||
GlobalSystemMediaTransportControlsSessionMediaProperties;
|
||||
using Session = GlobalSystemMediaTransportControlsSession;
|
||||
using SessionManager = GlobalSystemMediaTransportControlsSessionManager;
|
||||
|
||||
try {
|
||||
// Request the session manager asynchronously
|
||||
const IAsyncOperation<SessionManager> sessionManagerOp =
|
||||
SessionManager::RequestAsync();
|
||||
const SessionManager sessionManager = sessionManagerOp.get();
|
||||
|
||||
if (const Session currentSession = sessionManager.GetCurrentSession()) {
|
||||
// Try to get the media properties asynchronously
|
||||
const IAsyncOperation<MediaProperties> mediaPropertiesOp =
|
||||
currentSession.TryGetMediaPropertiesAsync();
|
||||
const MediaProperties mediaProperties = mediaPropertiesOp.get();
|
||||
|
||||
// Convert the hstring title to std::string
|
||||
return to_string(mediaProperties.Title());
|
||||
}
|
||||
|
||||
// If we reach this point, there is no current session
|
||||
return "No current media session.";
|
||||
} catch (...) { return "Failed to get media properties."; }
|
||||
}
|
||||
|
||||
std::string GetRegistryValue(
|
||||
const HKEY& hKey,
|
||||
const std::string& subKey,
|
||||
const std::string& valueName
|
||||
) {
|
||||
HKEY key = nullptr;
|
||||
if (RegOpenKeyExA(hKey, subKey.c_str(), 0, KEY_READ, &key) != ERROR_SUCCESS)
|
||||
return "";
|
||||
|
||||
DWORD dataSize = 0;
|
||||
if (RegQueryValueExA(
|
||||
key, valueName.c_str(), nullptr, nullptr, nullptr, &dataSize
|
||||
) != ERROR_SUCCESS) {
|
||||
RegCloseKey(key);
|
||||
return "";
|
||||
}
|
||||
|
||||
std::string value(dataSize, '\0');
|
||||
if (RegQueryValueExA(
|
||||
key,
|
||||
valueName.c_str(),
|
||||
nullptr,
|
||||
nullptr,
|
||||
reinterpret_cast<LPBYTE>(value.data()), // NOLINT(*-reinterpret-cast)
|
||||
&dataSize
|
||||
) != ERROR_SUCCESS) {
|
||||
RegCloseKey(key);
|
||||
return "";
|
||||
}
|
||||
|
||||
RegCloseKey(key);
|
||||
// Remove null terminator if present
|
||||
if (!value.empty() && value.back() == '\0') value.pop_back();
|
||||
|
||||
return value;
|
||||
}
|
||||
|
||||
std::string GetPrettyWindowsName() {
|
||||
std::string productName = GetRegistryValue(
|
||||
HKEY_LOCAL_MACHINE,
|
||||
R"(SOFTWARE\Microsoft\Windows NT\CurrentVersion)",
|
||||
"ProductName"
|
||||
);
|
||||
|
||||
const std::string displayVersion = GetRegistryValue(
|
||||
HKEY_LOCAL_MACHINE,
|
||||
R"(SOFTWARE\Microsoft\Windows NT\CurrentVersion)",
|
||||
"DisplayVersion"
|
||||
);
|
||||
|
||||
const std::string releaseId = GetRegistryValue(
|
||||
HKEY_LOCAL_MACHINE,
|
||||
R"(SOFTWARE\Microsoft\Windows NT\CurrentVersion)",
|
||||
"ReleaseId"
|
||||
);
|
||||
|
||||
const int buildNumber = stoi(GetRegistryValue(
|
||||
HKEY_LOCAL_MACHINE,
|
||||
R"(SOFTWARE\Microsoft\Windows NT\CurrentVersion)",
|
||||
"CurrentBuildNumber"
|
||||
));
|
||||
|
||||
fmt::println("Build number: {}", buildNumber);
|
||||
|
||||
// Check if the build number is 22000 or higher
|
||||
if (buildNumber >= 22000 &&
|
||||
productName.find("Windows 10") != std::string::npos)
|
||||
productName.replace(productName.find("Windows 10"), 10, "Windows 11");
|
||||
|
||||
if (!productName.empty()) {
|
||||
std::string result = productName;
|
||||
|
||||
if (!displayVersion.empty())
|
||||
result += " " + displayVersion;
|
||||
else if (!releaseId.empty())
|
||||
result += " " + releaseId;
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
return "";
|
||||
}
|
||||
|
||||
int main() {
|
||||
init_apartment();
|
||||
|
||||
u64 memInfo = 0;
|
||||
GetPhysicallyInstalledSystemMemory(&memInfo);
|
||||
fmt::println("Installed RAM: {:.2f}", KBToGiB {memInfo});
|
||||
|
||||
fmt::println("Now playing: {}", GetNowPlaying());
|
||||
|
||||
const std::tm localTime = fmt::localtime(time(nullptr));
|
||||
|
||||
std::string date = fmt::format("{:%e}", localTime);
|
||||
|
||||
auto start = date.begin();
|
||||
while (start != date.end() && std::isspace(*start)) ++start;
|
||||
date.erase(date.begin(), start);
|
||||
|
||||
switch (ParseDate(date)) {
|
||||
case Ones:
|
||||
date += "st";
|
||||
break;
|
||||
|
||||
case Twos:
|
||||
date += "nd";
|
||||
break;
|
||||
|
||||
case Threes:
|
||||
date += "rd";
|
||||
break;
|
||||
|
||||
case Default:
|
||||
date += "th";
|
||||
break;
|
||||
}
|
||||
|
||||
fmt::println("{:%B} {}, {:%-I:%0M %p}", localTime, date, localTime);
|
||||
|
||||
fmt::println("Version: {}", GetPrettyWindowsName());
|
||||
|
||||
uninit_apartment();
|
||||
return 0;
|
||||
}
|
||||
192
meson.build
192
meson.build
|
|
@ -1,192 +0,0 @@
|
|||
# ----------------------- #
|
||||
# Project Configuration #
|
||||
# ----------------------- #
|
||||
project(
|
||||
'draconis++',
|
||||
'cpp',
|
||||
version: '0.1.0',
|
||||
default_options: [
|
||||
'default_library=static',
|
||||
'warning_level=everything',
|
||||
'buildtype=debugoptimized',
|
||||
'b_vscrt=mt',
|
||||
],
|
||||
)
|
||||
|
||||
cpp = meson.get_compiler('cpp')
|
||||
host_system = host_machine.system()
|
||||
|
||||
# ------------------------ #
|
||||
# Compiler Configuration #
|
||||
# ------------------------ #
|
||||
common_warning_flags = [
|
||||
'-Wno-c++20-compat',
|
||||
'-Wno-c++20-extensions',
|
||||
'-Wno-c++98-compat',
|
||||
'-Wno-c++98-compat-pedantic',
|
||||
'-Wno-disabled-macro-expansion',
|
||||
'-Wno-missing-prototypes',
|
||||
'-Wno-padded',
|
||||
'-Wno-pre-c++20-compat-pedantic',
|
||||
'-Wunused-function',
|
||||
]
|
||||
|
||||
common_cpp_flags = {
|
||||
'common': [
|
||||
'-fno-strict-enums',
|
||||
'-fvisibility=hidden',
|
||||
'-fvisibility-inlines-hidden',
|
||||
'-std=c++26',
|
||||
],
|
||||
'msvc': [
|
||||
'-DNOMINMAX',
|
||||
'/MT',
|
||||
'/Zc:__cplusplus',
|
||||
'/Zc:preprocessor',
|
||||
'/std:c++latest',
|
||||
],
|
||||
'unix_extra': [
|
||||
'-march=native',
|
||||
'-nostdlib++',
|
||||
],
|
||||
'windows_extra': '-DCURL_STATICLIB',
|
||||
}
|
||||
|
||||
# Configure Objective-C++ for macOS
|
||||
if host_system == 'darwin'
|
||||
add_languages('objcpp', native: false)
|
||||
objcpp = meson.get_compiler('objcpp')
|
||||
objcpp_flags = common_warning_flags + [
|
||||
'-Wno-switch-default',
|
||||
'-std=c++2b',
|
||||
'-fvisibility=hidden',
|
||||
'-fvisibility-inlines-hidden',
|
||||
]
|
||||
add_project_arguments(objcpp.get_supported_arguments(objcpp_flags), language: 'objcpp')
|
||||
endif
|
||||
|
||||
# Apply C++ compiler arguments
|
||||
if cpp.get_id() in ['msvc', 'clang-cl']
|
||||
common_cpp_args = common_cpp_flags['msvc']
|
||||
if cpp.get_id() == 'clang-cl'
|
||||
common_cpp_args += common_warning_flags + common_cpp_flags['common']
|
||||
endif
|
||||
else
|
||||
common_cpp_args = common_warning_flags + common_cpp_flags['common'] + common_cpp_flags['unix_extra']
|
||||
if host_system == 'windows'
|
||||
common_cpp_args += common_cpp_flags['windows_extra']
|
||||
endif
|
||||
common_cpp_args = cpp.get_supported_arguments(common_cpp_args)
|
||||
endif
|
||||
|
||||
add_project_arguments(common_cpp_args, language: 'cpp')
|
||||
|
||||
# ------- #
|
||||
# Files #
|
||||
# ------- #
|
||||
base_sources = files('src/config/config.cpp', 'src/config/weather.cpp', 'src/main.cpp')
|
||||
|
||||
platform_sources = {
|
||||
'linux': ['src/os/linux.cpp', 'src/os/linux/issetugid_stub.cpp'],
|
||||
'freebsd': ['src/os/freebsd.cpp'],
|
||||
'darwin': ['src/os/macos.cpp', 'src/os/macos/bridge.mm'],
|
||||
'windows': ['src/os/windows.cpp'],
|
||||
}
|
||||
|
||||
sources = base_sources + files(platform_sources.get(host_system, []))
|
||||
|
||||
# --------------------- #
|
||||
# Dependencies Config #
|
||||
# --------------------- #
|
||||
common_deps = [
|
||||
dependency('fmt', include_type: 'system', static: true),
|
||||
dependency('libcurl', include_type: 'system', static: true),
|
||||
dependency('tomlplusplus', include_type: 'system', static: true),
|
||||
dependency('openssl', include_type: 'system', static: true, required: false),
|
||||
]
|
||||
|
||||
# Platform-specific dependencies
|
||||
platform_deps = []
|
||||
|
||||
if host_system == 'darwin'
|
||||
platform_deps += [
|
||||
dependency(
|
||||
'appleframeworks',
|
||||
modules: ['foundation', 'mediaplayer', 'systemconfiguration'],
|
||||
static: true,
|
||||
),
|
||||
dependency('iconv'),
|
||||
]
|
||||
elif host_system == 'windows'
|
||||
platform_deps += [
|
||||
cpp.find_library('dwmapi'),
|
||||
cpp.find_library('windowsapp'),
|
||||
]
|
||||
elif host_system == 'linux' or host_system == 'freebsd'
|
||||
platform_deps += [
|
||||
dependency('SQLiteCpp'),
|
||||
dependency('x11'),
|
||||
dependency('xcb'),
|
||||
dependency('xau'),
|
||||
dependency('xdmcp'),
|
||||
dependency('wayland-client'),
|
||||
dependency('dbus-1', include_type: 'system'),
|
||||
]
|
||||
endif
|
||||
|
||||
# FTXUI configuration
|
||||
ftxui_components = ['ftxui::screen', 'ftxui::dom', 'ftxui::component']
|
||||
ftxui_dep = dependency(
|
||||
'ftxui',
|
||||
modules: ftxui_components,
|
||||
include_type: 'system',
|
||||
static: true,
|
||||
required: false,
|
||||
)
|
||||
|
||||
if not ftxui_dep.found()
|
||||
ftxui_dep = declare_dependency(
|
||||
dependencies: [
|
||||
dependency('ftxui-dom', fallback: ['ftxui', 'dom_dep']),
|
||||
dependency('ftxui-screen', fallback: ['ftxui', 'screen_dep']),
|
||||
dependency('ftxui-component', fallback: ['ftxui', 'component_dep']),
|
||||
],
|
||||
)
|
||||
endif
|
||||
|
||||
glaze_dep = dependency('glaze', include_type: 'system', required: false)
|
||||
|
||||
if not glaze_dep.found()
|
||||
cmake = import('cmake')
|
||||
|
||||
glaze_proj = cmake.subproject('glaze')
|
||||
|
||||
glaze_dep = glaze_proj.dependency('glaze_glaze', include_type: 'system')
|
||||
endif
|
||||
|
||||
# Combine all dependencies
|
||||
deps = common_deps + platform_deps + ftxui_dep + glaze_dep
|
||||
|
||||
# ------------------------- #
|
||||
# Link/ObjC Configuration #
|
||||
# ------------------------- #
|
||||
link_args = []
|
||||
objc_args = []
|
||||
|
||||
if host_system == 'darwin'
|
||||
objc_args += ['-fobjc-arc']
|
||||
elif cpp.get_id() == 'clang'
|
||||
link_args += ['-static-libgcc', '-static-libstdc++']
|
||||
endif
|
||||
|
||||
# ------------------- #
|
||||
# Executable Target #
|
||||
# ------------------- #
|
||||
executable(
|
||||
'draconis++',
|
||||
sources,
|
||||
objc_args: objc_args,
|
||||
link_args: link_args,
|
||||
dependencies: deps,
|
||||
install: true,
|
||||
)
|
||||
|
|
@ -1,7 +0,0 @@
|
|||
[fmt]
|
||||
src.github = "fmtlib/fmt"
|
||||
fetch.github = "fmtlib/fmt"
|
||||
|
||||
[tomlplusplus]
|
||||
src.github = "marzer/tomlplusplus"
|
||||
fetch.github = "marzer/tomlplusplus"
|
||||
|
|
@ -1,176 +0,0 @@
|
|||
#include <cstdlib>
|
||||
#include <filesystem>
|
||||
#include <fmt/core.h>
|
||||
#include <iostream>
|
||||
#include <stdexcept>
|
||||
|
||||
#include "config.h"
|
||||
|
||||
#include "src/util/macros.h"
|
||||
|
||||
namespace fs = std::filesystem;
|
||||
|
||||
namespace {
|
||||
fn GetConfigPath() -> fs::path {
|
||||
std::vector<fs::path> possiblePaths;
|
||||
|
||||
#ifdef _WIN32
|
||||
// Windows possible paths in order of preference
|
||||
if (auto result = GetEnv("LOCALAPPDATA"); result)
|
||||
possiblePaths.push_back(fs::path(*result) / "draconis++" / "config.toml");
|
||||
|
||||
if (auto result = GetEnv("USERPROFILE"); result) {
|
||||
// Support for .config style on Windows (some users prefer this)
|
||||
possiblePaths.push_back(fs::path(*result) / ".config" / "draconis++" / "config.toml");
|
||||
// Traditional Windows location alternative
|
||||
possiblePaths.push_back(fs::path(*result) / "AppData" / "Local" / "draconis++" / "config.toml");
|
||||
}
|
||||
|
||||
if (auto result = GetEnv("APPDATA"); result)
|
||||
possiblePaths.push_back(fs::path(*result) / "draconis++" / "config.toml");
|
||||
|
||||
// Portable app option - config in same directory as executable
|
||||
possiblePaths.push_back(fs::path(".") / "config.toml");
|
||||
#else
|
||||
// Unix/Linux paths in order of preference
|
||||
if (auto result = getEnv("XDG_CONFIG_HOME"); result)
|
||||
possiblePaths.push_back(fs::path(*result) / "draconis++" / "config.toml");
|
||||
|
||||
if (auto result = getEnv("HOME"); result) {
|
||||
possiblePaths.push_back(fs::path(*result) / ".config" / "draconis++" / "config.toml");
|
||||
possiblePaths.push_back(fs::path(*result) / ".draconis++" / "config.toml");
|
||||
}
|
||||
|
||||
// System-wide config
|
||||
possiblePaths.push_back(fs::path("/etc/draconis++/config.toml"));
|
||||
#endif
|
||||
|
||||
// Check if any of these configs already exist
|
||||
for (const auto& path : possiblePaths)
|
||||
if (std::error_code errc; exists(path, errc) && !errc)
|
||||
return path;
|
||||
|
||||
// If no config exists yet, return the default (first in priority)
|
||||
if (!possiblePaths.empty()) {
|
||||
// Create directory structure for the default path
|
||||
const fs::path defaultDir = possiblePaths[0].parent_path();
|
||||
|
||||
if (std::error_code errc; !exists(defaultDir, errc) && !errc) {
|
||||
create_directories(defaultDir, errc);
|
||||
if (errc)
|
||||
WARN_LOG("Warning: Failed to create config directory: {}", errc.message());
|
||||
}
|
||||
|
||||
return possiblePaths[0];
|
||||
}
|
||||
|
||||
// Ultimate fallback if somehow we have no paths
|
||||
throw std::runtime_error("Could not determine a valid config path");
|
||||
}
|
||||
|
||||
fn CreateDefaultConfig(const fs::path& configPath) -> bool {
|
||||
try {
|
||||
// Ensure the directory exists
|
||||
std::error_code errc;
|
||||
create_directories(configPath.parent_path(), errc);
|
||||
if (errc) {
|
||||
ERROR_LOG("Failed to create config directory: {}", errc.message());
|
||||
return false;
|
||||
}
|
||||
|
||||
// Create a default TOML document
|
||||
toml::table root;
|
||||
|
||||
// Get default username for General section
|
||||
std::string defaultName;
|
||||
#ifdef _WIN32
|
||||
std::array<char, 256> username;
|
||||
DWORD size = sizeof(username);
|
||||
defaultName = GetUserNameA(username.data(), &size) ? username.data() : "User";
|
||||
#else
|
||||
if (struct passwd* pwd = getpwuid(getuid()); pwd)
|
||||
defaultName = pwd->pw_name;
|
||||
else if (const char* envUser = getenv("USER"))
|
||||
defaultName = envUser;
|
||||
else
|
||||
defaultName = "User";
|
||||
#endif
|
||||
|
||||
// General section
|
||||
toml::table* general = root.insert("general", toml::table {}).first->second.as_table();
|
||||
general->insert("name", defaultName);
|
||||
|
||||
// Now Playing section
|
||||
toml::table* nowPlaying = root.insert("now_playing", toml::table {}).first->second.as_table();
|
||||
nowPlaying->insert("enabled", false);
|
||||
|
||||
// Weather section
|
||||
toml::table* weather = root.insert("weather", toml::table {}).first->second.as_table();
|
||||
weather->insert("enabled", false);
|
||||
weather->insert("show_town_name", false);
|
||||
weather->insert("api_key", "");
|
||||
weather->insert("units", "metric");
|
||||
weather->insert("location", "London");
|
||||
|
||||
// Write to file (using a stringstream for comments + TOML)
|
||||
std::ofstream file(configPath);
|
||||
if (!file) {
|
||||
ERROR_LOG("Failed to open config file for writing: {}", configPath.string());
|
||||
return false;
|
||||
}
|
||||
|
||||
file << "# Draconis++ Configuration File\n\n";
|
||||
|
||||
file << "# General settings\n";
|
||||
file << "[general]\n";
|
||||
file << "name = \"" << defaultName << "\" # Your display name\n\n";
|
||||
|
||||
file << "# Now Playing integration\n";
|
||||
file << "[now_playing]\n";
|
||||
file << "enabled = false # Set to true to enable media integration\n\n";
|
||||
|
||||
file << "# Weather settings\n";
|
||||
file << "[weather]\n";
|
||||
file << "enabled = false # Set to true to enable weather display\n";
|
||||
file << "show_town_name = false # Show location name in weather display\n";
|
||||
file << "api_key = \"\" # Your weather API key\n";
|
||||
file << "units = \"metric\" # Use \"metric\" for °C or \"imperial\" for °F\n";
|
||||
file << "location = \"London\" # Your city name\n\n";
|
||||
|
||||
file << "# Alternatively, you can specify coordinates instead of a city name:\n";
|
||||
file << "# [weather.location]\n";
|
||||
file << "# lat = 51.5074\n";
|
||||
file << "# lon = -0.1278\n";
|
||||
|
||||
INFO_LOG("Created default config file at {}", configPath.string());
|
||||
return true;
|
||||
} catch (const std::exception& e) {
|
||||
ERROR_LOG("Failed to create default config file: {}", e.what());
|
||||
return false;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn Config::getInstance() -> Config {
|
||||
try {
|
||||
const fs::path configPath = GetConfigPath();
|
||||
|
||||
// Check if the config file exists
|
||||
if (!exists(configPath)) {
|
||||
INFO_LOG("Config file not found, creating defaults at {}", configPath.string());
|
||||
|
||||
// Create default config
|
||||
if (!CreateDefaultConfig(configPath)) {
|
||||
WARN_LOG("Failed to create default config, using in-memory defaults");
|
||||
return {};
|
||||
}
|
||||
}
|
||||
|
||||
// Now we should have a config file to read
|
||||
const toml::parse_result config = toml::parse_file(configPath.string());
|
||||
return fromToml(config);
|
||||
} catch (const std::exception& e) {
|
||||
DEBUG_LOG("Config loading failed: {}, using defaults", e.what());
|
||||
return {};
|
||||
}
|
||||
}
|
||||
|
|
@ -1,107 +0,0 @@
|
|||
#pragma once
|
||||
|
||||
#ifdef _WIN32
|
||||
#include <windows.h>
|
||||
#else
|
||||
#include <pwd.h> // For getpwuid
|
||||
#include <unistd.h> // For getuid
|
||||
#endif
|
||||
|
||||
#include <toml++/toml.hpp>
|
||||
|
||||
#include "src/util/macros.h"
|
||||
#include "weather.h"
|
||||
|
||||
using Location = std::variant<string, Coords>;
|
||||
|
||||
struct General {
|
||||
string name = []() -> string {
|
||||
#ifdef _WIN32
|
||||
std::array<char, 256> username;
|
||||
DWORD size = sizeof(username);
|
||||
return GetUserNameA(username.data(), &size) ? username.data() : "User";
|
||||
#else
|
||||
if (struct passwd* pwd = getpwuid(getuid()); pwd)
|
||||
return pwd->pw_name;
|
||||
|
||||
if (const char* envUser = getenv("USER"))
|
||||
return envUser;
|
||||
|
||||
return "User";
|
||||
#endif
|
||||
}();
|
||||
|
||||
static fn fromToml(const toml::table& tbl) -> General {
|
||||
General gen;
|
||||
|
||||
if (const std::optional<string> name = tbl["name"].value<string>())
|
||||
gen.name = *name;
|
||||
|
||||
return gen;
|
||||
}
|
||||
};
|
||||
|
||||
struct NowPlaying {
|
||||
bool enabled = false;
|
||||
|
||||
static fn fromToml(const toml::table& tbl) -> NowPlaying {
|
||||
NowPlaying nowPlaying;
|
||||
nowPlaying.enabled = tbl["enabled"].value<bool>().value_or(false);
|
||||
return nowPlaying;
|
||||
}
|
||||
};
|
||||
|
||||
struct Weather {
|
||||
bool enabled = false;
|
||||
bool show_town_name = false;
|
||||
Location location;
|
||||
string api_key;
|
||||
string units;
|
||||
|
||||
static fn fromToml(const toml::table& tbl) -> Weather {
|
||||
Weather weather;
|
||||
weather.enabled = tbl["enabled"].value<bool>().value_or(false);
|
||||
weather.show_town_name = tbl["show_town_name"].value<bool>().value_or(false);
|
||||
weather.api_key = tbl["api_key"].value<string>().value_or("");
|
||||
weather.units = tbl["units"].value<string>().value_or("metric");
|
||||
|
||||
if (const toml::node_view<const toml::node> location = tbl["location"]) {
|
||||
if (location.is_string()) {
|
||||
weather.location = location.value<string>().value();
|
||||
} else if (location.is_table()) {
|
||||
const auto* coord = location.as_table();
|
||||
Coords coords;
|
||||
coords.lat = coord->get("lat")->value<double>().value();
|
||||
coords.lon = coord->get("lon")->value<double>().value();
|
||||
weather.location = coords;
|
||||
}
|
||||
}
|
||||
|
||||
return weather;
|
||||
}
|
||||
|
||||
[[nodiscard]] fn getWeatherInfo() const -> WeatherOutput;
|
||||
};
|
||||
|
||||
struct Config {
|
||||
General general;
|
||||
NowPlaying now_playing;
|
||||
Weather weather;
|
||||
|
||||
static fn fromToml(const toml::table& tbl) -> Config {
|
||||
Config cfg;
|
||||
|
||||
if (const auto* general = tbl["general"].as_table())
|
||||
cfg.general = General::fromToml(*general);
|
||||
|
||||
if (const auto* nowPlaying = tbl["now_playing"].as_table())
|
||||
cfg.now_playing = NowPlaying::fromToml(*nowPlaying);
|
||||
|
||||
if (const auto* weather = tbl["weather"].as_table())
|
||||
cfg.weather = Weather::fromToml(*weather);
|
||||
|
||||
return cfg;
|
||||
}
|
||||
|
||||
static fn getInstance() -> Config;
|
||||
};
|
||||
|
|
@ -1,177 +0,0 @@
|
|||
#include <chrono>
|
||||
#include <curl/curl.h>
|
||||
#include <expected>
|
||||
#include <filesystem>
|
||||
#include <fmt/core.h>
|
||||
#include <fstream>
|
||||
|
||||
#include "weather.h"
|
||||
|
||||
#include "config.h"
|
||||
#include "src/util/macros.h"
|
||||
|
||||
namespace fs = std::filesystem;
|
||||
using namespace std::string_literals;
|
||||
|
||||
namespace {
|
||||
constexpr glz::opts glaze_opts = { .error_on_unknown_keys = false };
|
||||
|
||||
fn GetCachePath() -> std::expected<fs::path, string> {
|
||||
std::error_code errc;
|
||||
fs::path cachePath = fs::temp_directory_path(errc);
|
||||
|
||||
if (errc)
|
||||
return std::unexpected("Failed to get temp directory: " + errc.message());
|
||||
|
||||
cachePath /= "weather_cache.json";
|
||||
return cachePath;
|
||||
}
|
||||
|
||||
fn ReadCacheFromFile() -> std::expected<WeatherOutput, string> {
|
||||
std::expected<fs::path, string> cachePath = GetCachePath();
|
||||
|
||||
if (!cachePath)
|
||||
return std::unexpected(cachePath.error());
|
||||
|
||||
std::ifstream ifs(*cachePath, std::ios::binary);
|
||||
|
||||
if (!ifs.is_open())
|
||||
return std::unexpected("Cache file not found: " + cachePath->string());
|
||||
|
||||
DEBUG_LOG("Reading from cache file...");
|
||||
|
||||
try {
|
||||
const string content((std::istreambuf_iterator<char>(ifs)), std::istreambuf_iterator<char>());
|
||||
WeatherOutput result;
|
||||
|
||||
if (const glz::error_ctx errc = glz::read<glaze_opts>(result, content); errc.ec != glz::error_code::none)
|
||||
return std::unexpected("JSON parse error: " + glz::format_error(errc, content));
|
||||
|
||||
DEBUG_LOG("Successfully read from cache file.");
|
||||
return result;
|
||||
} catch (const std::exception& e) { return std::unexpected("Error reading cache: "s + e.what()); }
|
||||
}
|
||||
|
||||
fn WriteCacheToFile(const WeatherOutput& data) -> std::expected<void, string> {
|
||||
std::expected<fs::path, string> cachePath = GetCachePath();
|
||||
|
||||
if (!cachePath)
|
||||
return std::unexpected(cachePath.error());
|
||||
|
||||
DEBUG_LOG("Writing to cache file...");
|
||||
fs::path tempPath = *cachePath;
|
||||
tempPath += ".tmp";
|
||||
|
||||
try {
|
||||
{
|
||||
std::ofstream ofs(tempPath, std::ios::binary | std::ios::trunc);
|
||||
if (!ofs.is_open())
|
||||
return std::unexpected("Failed to open temp file: " + tempPath.string());
|
||||
|
||||
string jsonStr;
|
||||
|
||||
if (const glz::error_ctx errc = glz::write_json(data, jsonStr); errc.ec != glz::error_code::none)
|
||||
return std::unexpected("JSON serialization error: " + glz::format_error(errc, jsonStr));
|
||||
|
||||
ofs << jsonStr;
|
||||
if (!ofs)
|
||||
return std::unexpected("Failed to write to temp file");
|
||||
}
|
||||
|
||||
std::error_code errc;
|
||||
fs::rename(tempPath, *cachePath, errc);
|
||||
if (errc) {
|
||||
fs::remove(tempPath, errc);
|
||||
return std::unexpected("Failed to replace cache file: " + errc.message());
|
||||
}
|
||||
|
||||
DEBUG_LOG("Successfully wrote to cache file.");
|
||||
return {};
|
||||
} catch (const std::exception& e) { return std::unexpected("File operation error: "s + e.what()); }
|
||||
}
|
||||
|
||||
fn WriteCallback(void* contents, const size_t size, const size_t nmemb, string* str) -> size_t {
|
||||
const size_t totalSize = size * nmemb;
|
||||
str->append(static_cast<char*>(contents), totalSize);
|
||||
return totalSize;
|
||||
}
|
||||
|
||||
fn MakeApiRequest(const string& url) -> std::expected<WeatherOutput, string> {
|
||||
DEBUG_LOG("Making API request to URL: {}", url);
|
||||
CURL* curl = curl_easy_init();
|
||||
string responseBuffer;
|
||||
|
||||
if (!curl)
|
||||
return std::unexpected("Failed to initialize cURL");
|
||||
|
||||
curl_easy_setopt(curl, CURLOPT_URL, url.c_str());
|
||||
curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, WriteCallback);
|
||||
curl_easy_setopt(curl, CURLOPT_WRITEDATA, &responseBuffer);
|
||||
curl_easy_setopt(curl, CURLOPT_TIMEOUT, 10);
|
||||
curl_easy_setopt(curl, CURLOPT_CONNECTTIMEOUT, 5);
|
||||
|
||||
const CURLcode res = curl_easy_perform(curl);
|
||||
curl_easy_cleanup(curl);
|
||||
|
||||
if (res != CURLE_OK)
|
||||
return std::unexpected(fmt::format("cURL error: {}", curl_easy_strerror(res)));
|
||||
|
||||
WeatherOutput output;
|
||||
|
||||
if (const glz::error_ctx errc = glz::read<glaze_opts>(output, responseBuffer); errc.ec != glz::error_code::none)
|
||||
return std::unexpected("API response parse error: " + glz::format_error(errc, responseBuffer));
|
||||
|
||||
return std::move(output);
|
||||
}
|
||||
}
|
||||
|
||||
fn Weather::getWeatherInfo() const -> WeatherOutput {
|
||||
using namespace std::chrono;
|
||||
|
||||
if (std::expected<WeatherOutput, string> data = ReadCacheFromFile()) {
|
||||
const WeatherOutput& dataVal = *data;
|
||||
|
||||
if (const duration<double> cacheAge = system_clock::now() - system_clock::time_point(seconds(dataVal.dt));
|
||||
cacheAge < 10min) {
|
||||
DEBUG_LOG("Using valid cache");
|
||||
return dataVal;
|
||||
}
|
||||
|
||||
DEBUG_LOG("Cache expired");
|
||||
} else {
|
||||
DEBUG_LOG("Cache error: {}", data.error());
|
||||
}
|
||||
|
||||
fn handleApiResult = [](const std::expected<WeatherOutput, string>& result) -> WeatherOutput {
|
||||
if (!result) {
|
||||
ERROR_LOG("API request failed: {}", result.error());
|
||||
return WeatherOutput {};
|
||||
}
|
||||
|
||||
if (std::expected<void, string> writeResult = WriteCacheToFile(*result); !writeResult)
|
||||
ERROR_LOG("Failed to write cache: {}", writeResult.error());
|
||||
|
||||
return *result;
|
||||
};
|
||||
|
||||
if (std::holds_alternative<string>(location)) {
|
||||
const auto& city = std::get<string>(location);
|
||||
char* escaped = curl_easy_escape(nullptr, city.c_str(), static_cast<int>(city.length()));
|
||||
DEBUG_LOG("Requesting city: {}", escaped);
|
||||
|
||||
const string apiUrl =
|
||||
fmt::format("https://api.openweathermap.org/data/2.5/weather?q={}&appid={}&units={}", escaped, api_key, units);
|
||||
|
||||
curl_free(escaped);
|
||||
return handleApiResult(MakeApiRequest(apiUrl));
|
||||
}
|
||||
|
||||
const auto& [lat, lon] = std::get<Coords>(location);
|
||||
DEBUG_LOG("Requesting coordinates: lat={:.3f}, lon={:.3f}", lat, lon);
|
||||
|
||||
const string apiUrl = fmt::format(
|
||||
"https://api.openweathermap.org/data/2.5/weather?lat={:.3f}&lon={:.3f}&appid={}&units={}", lat, lon, api_key, units
|
||||
);
|
||||
|
||||
return handleApiResult(MakeApiRequest(apiUrl));
|
||||
}
|
||||
|
|
@ -1,42 +0,0 @@
|
|||
#pragma once
|
||||
|
||||
#include <glaze/glaze.hpp>
|
||||
|
||||
#include "../util/types.h"
|
||||
|
||||
// NOLINTBEGIN(readability-identifier-naming)
|
||||
struct Condition {
|
||||
string description;
|
||||
|
||||
struct glaze {
|
||||
using T = Condition;
|
||||
static constexpr auto value = glz::object("description", &T::description);
|
||||
};
|
||||
};
|
||||
|
||||
struct Main {
|
||||
f64 temp;
|
||||
|
||||
struct glaze {
|
||||
using T = Main;
|
||||
static constexpr auto value = glz::object("temp", &T::temp);
|
||||
};
|
||||
};
|
||||
|
||||
struct Coords {
|
||||
double lat;
|
||||
double lon;
|
||||
};
|
||||
|
||||
struct WeatherOutput {
|
||||
Main main;
|
||||
string name;
|
||||
std::vector<Condition> weather;
|
||||
usize dt;
|
||||
|
||||
struct glaze {
|
||||
using T = WeatherOutput;
|
||||
static constexpr auto value = glz::object("main", &T::main, "name", &T::name, "weather", &T::weather, "dt", &T::dt);
|
||||
};
|
||||
};
|
||||
// NOLINTEND(readability-identifier-naming)
|
||||
327
src/main.cpp
327
src/main.cpp
|
|
@ -1,327 +0,0 @@
|
|||
#include <ctime>
|
||||
#include <expected>
|
||||
#include <fmt/chrono.h>
|
||||
#include <fmt/color.h>
|
||||
#include <fmt/format.h>
|
||||
#include <ftxui/dom/elements.hpp>
|
||||
#include <ftxui/screen/screen.hpp>
|
||||
#include <future>
|
||||
#include <string>
|
||||
#include <utility>
|
||||
#include <variant>
|
||||
|
||||
#include "config/config.h"
|
||||
#include "ftxui/screen/color.hpp"
|
||||
#include "os/os.h"
|
||||
|
||||
constexpr bool SHOW_ICONS = true;
|
||||
|
||||
struct BytesToGiB {
|
||||
u64 value;
|
||||
};
|
||||
|
||||
// 1024^3 (size of 1 GiB)
|
||||
constexpr u64 GIB = 1'073'741'824;
|
||||
|
||||
template <>
|
||||
struct fmt::formatter<BytesToGiB> : fmt::formatter<double> {
|
||||
template <typename FmtCtx>
|
||||
constexpr fn format(const BytesToGiB& BTG, FmtCtx& ctx) const -> typename FmtCtx::iterator {
|
||||
// Format as double with GiB suffix, no space
|
||||
return fmt::format_to(ctx.out(), "{:.2f}GiB", static_cast<f64>(BTG.value) / GIB);
|
||||
}
|
||||
};
|
||||
|
||||
namespace {
|
||||
fn GetDate() -> std::string {
|
||||
// Get current local time
|
||||
const std::time_t now = std::time(nullptr);
|
||||
std::tm localTime;
|
||||
|
||||
#ifdef _WIN32
|
||||
if (localtime_s(&localTime, &now) != 0)
|
||||
ERROR_LOG("localtime_s failed");
|
||||
#else
|
||||
if (localtime_r(&now, &localTime) == nullptr)
|
||||
ERROR_LOG("localtime_r failed");
|
||||
#endif
|
||||
|
||||
// Format the date using fmt::format
|
||||
std::string date = fmt::format("{:%e}", localTime);
|
||||
|
||||
// Remove leading whitespace
|
||||
if (!date.empty() && std::isspace(date.front()))
|
||||
date.erase(date.begin());
|
||||
|
||||
// Append appropriate suffix for the datE
|
||||
if (date.back() == '1' && date != "11")
|
||||
date += "st";
|
||||
else if (date.back() == '2' && date != "12")
|
||||
date += "nd";
|
||||
else if (date.back() == '3' && date != "13")
|
||||
date += "rd";
|
||||
else
|
||||
date += "th";
|
||||
|
||||
return fmt::format("{:%B} {}", localTime, date);
|
||||
}
|
||||
|
||||
struct SystemData {
|
||||
std::string date;
|
||||
std::string host;
|
||||
std::string kernel_version;
|
||||
std::expected<string, string> os_version;
|
||||
std::expected<u64, std::string> mem_info;
|
||||
std::optional<string> desktop_environment;
|
||||
std::string window_manager;
|
||||
std::optional<std::expected<string, NowPlayingError>> now_playing;
|
||||
std::optional<WeatherOutput> weather_info;
|
||||
u64 disk_used;
|
||||
u64 disk_total;
|
||||
std::string shell;
|
||||
|
||||
static fn fetchSystemData(const Config& config) -> SystemData {
|
||||
SystemData data;
|
||||
|
||||
// Single-threaded execution for core system info (faster on Windows)
|
||||
data.date = GetDate();
|
||||
data.host = GetHost();
|
||||
data.kernel_version = GetKernelVersion();
|
||||
data.os_version = GetOSVersion();
|
||||
data.mem_info = GetMemInfo();
|
||||
|
||||
// Desktop environment info
|
||||
data.desktop_environment = GetDesktopEnvironment();
|
||||
data.window_manager = GetWindowManager();
|
||||
|
||||
// Parallel execution for disk/shell only
|
||||
auto diskShell = std::async(std::launch::async, [] {
|
||||
auto [used, total] = GetDiskUsage();
|
||||
return std::make_tuple(used, total, GetShell());
|
||||
});
|
||||
|
||||
// Conditional tasks
|
||||
std::future<WeatherOutput> weather;
|
||||
std::future<std::expected<string, NowPlayingError>> nowPlaying;
|
||||
|
||||
if (config.weather.enabled)
|
||||
weather = std::async(std::launch::async, [&config] { return config.weather.getWeatherInfo(); });
|
||||
|
||||
if (config.now_playing.enabled)
|
||||
nowPlaying = std::async(std::launch::async, GetNowPlaying);
|
||||
|
||||
// Get remaining results
|
||||
auto [used, total, shell] = diskShell.get();
|
||||
data.disk_used = used;
|
||||
data.disk_total = total;
|
||||
data.shell = shell;
|
||||
|
||||
if (weather.valid())
|
||||
data.weather_info = weather.get();
|
||||
if (nowPlaying.valid())
|
||||
data.now_playing = nowPlaying.get();
|
||||
|
||||
return data;
|
||||
}
|
||||
};
|
||||
|
||||
using namespace ftxui;
|
||||
|
||||
fn CreateColorCircles() -> Element {
|
||||
Elements circles(16);
|
||||
|
||||
std::generate_n(circles.begin(), 16, [colorIndex = 0]() mutable {
|
||||
return hbox({ text("◯") | bold | color(static_cast<Color::Palette256>(colorIndex++)), text(" ") });
|
||||
});
|
||||
|
||||
return hbox(circles);
|
||||
}
|
||||
|
||||
fn SystemInfoBox(const Config& config, const SystemData& data) -> Element {
|
||||
// Fetch data
|
||||
const string& name = config.general.name;
|
||||
const Weather weather = config.weather;
|
||||
const bool nowPlayingEnabled = config.now_playing.enabled;
|
||||
|
||||
const char *calendarIcon = "", *hostIcon = "", *kernelIcon = "", *osIcon = "", *memoryIcon = "", *weatherIcon = "",
|
||||
*musicIcon = "";
|
||||
|
||||
if (SHOW_ICONS) {
|
||||
calendarIcon = " ";
|
||||
hostIcon = " ";
|
||||
kernelIcon = " ";
|
||||
osIcon = " ";
|
||||
memoryIcon = " ";
|
||||
weatherIcon = " ";
|
||||
musicIcon = " ";
|
||||
}
|
||||
|
||||
constexpr Color::Palette16 labelColor = Color::Yellow;
|
||||
constexpr Color::Palette16 valueColor = Color::White;
|
||||
constexpr Color::Palette16 borderColor = Color::GrayLight;
|
||||
constexpr Color::Palette16 iconColor = Color::Cyan;
|
||||
|
||||
Elements content;
|
||||
|
||||
content.push_back(text(" Hello " + name + "! ") | bold | color(Color::Cyan));
|
||||
content.push_back(separator() | color(borderColor));
|
||||
content.push_back(hbox(
|
||||
{
|
||||
text(" ") | color(iconColor), // Palette icon
|
||||
CreateColorCircles(),
|
||||
}
|
||||
));
|
||||
content.push_back(separator() | color(borderColor));
|
||||
|
||||
// Helper function for aligned rows
|
||||
fn createRow = [&](const std::string& icon, const std::string& label, const std::string& value) {
|
||||
return hbox(
|
||||
{
|
||||
text(icon) | color(iconColor),
|
||||
text(label) | color(labelColor),
|
||||
filler(),
|
||||
text(value) | color(valueColor),
|
||||
text(" "),
|
||||
}
|
||||
);
|
||||
};
|
||||
|
||||
// System info rows
|
||||
content.push_back(createRow(calendarIcon, "Date", data.date));
|
||||
|
||||
// Weather row
|
||||
if (weather.enabled && data.weather_info.has_value()) {
|
||||
const WeatherOutput& weatherInfo = data.weather_info.value();
|
||||
|
||||
if (weather.show_town_name)
|
||||
content.push_back(hbox(
|
||||
{
|
||||
text(weatherIcon) | color(iconColor),
|
||||
text("Weather") | color(labelColor),
|
||||
filler(),
|
||||
|
||||
hbox(
|
||||
{
|
||||
text(fmt::format("{}°F ", std::lround(weatherInfo.main.temp))),
|
||||
text("in "),
|
||||
text(weatherInfo.name),
|
||||
text(" "),
|
||||
}
|
||||
) |
|
||||
color(valueColor),
|
||||
}
|
||||
));
|
||||
else
|
||||
content.push_back(hbox(
|
||||
{
|
||||
text(weatherIcon) | color(iconColor),
|
||||
text("Weather") | color(labelColor),
|
||||
filler(),
|
||||
|
||||
hbox(
|
||||
{
|
||||
text(fmt::format("{}°F, {}", std::lround(weatherInfo.main.temp), weatherInfo.weather[0].description)),
|
||||
text(" "),
|
||||
}
|
||||
) |
|
||||
color(valueColor),
|
||||
}
|
||||
));
|
||||
}
|
||||
|
||||
content.push_back(separator() | color(borderColor));
|
||||
|
||||
if (!data.host.empty())
|
||||
content.push_back(createRow(hostIcon, "Host", data.host));
|
||||
|
||||
if (!data.kernel_version.empty())
|
||||
content.push_back(createRow(kernelIcon, "Kernel", data.kernel_version));
|
||||
|
||||
if (data.os_version.has_value())
|
||||
content.push_back(createRow(osIcon, "OS", *data.os_version));
|
||||
else
|
||||
ERROR_LOG("Failed to get OS version: {}", data.os_version.error());
|
||||
|
||||
if (data.mem_info.has_value())
|
||||
content.push_back(createRow(memoryIcon, "RAM", fmt::format("{}", BytesToGiB { *data.mem_info })));
|
||||
else
|
||||
ERROR_LOG("Failed to get memory info: {}", data.mem_info.error());
|
||||
|
||||
// Add Disk usage row
|
||||
content.push_back(
|
||||
createRow(" ", "Disk", fmt::format("{}/{}", BytesToGiB { data.disk_used }, BytesToGiB { data.disk_total }))
|
||||
);
|
||||
|
||||
content.push_back(createRow(" ", "Shell", data.shell));
|
||||
|
||||
content.push_back(separator() | color(borderColor));
|
||||
|
||||
if (data.desktop_environment.has_value() && *data.desktop_environment != data.window_manager)
|
||||
content.push_back(createRow(" ", "DE", *data.desktop_environment));
|
||||
|
||||
if (!data.window_manager.empty())
|
||||
content.push_back(createRow(" ", "WM", data.window_manager));
|
||||
|
||||
// Now Playing row
|
||||
if (nowPlayingEnabled && data.now_playing.has_value()) {
|
||||
if (const std::expected<string, NowPlayingError>& nowPlayingResult = *data.now_playing;
|
||||
nowPlayingResult.has_value()) {
|
||||
const std::string& npText = *nowPlayingResult;
|
||||
|
||||
content.push_back(separator() | color(borderColor));
|
||||
content.push_back(hbox(
|
||||
{
|
||||
text(musicIcon) | color(iconColor),
|
||||
text("Playing") | color(labelColor),
|
||||
text(" "),
|
||||
filler(),
|
||||
paragraph(npText) | color(Color::Magenta) | size(WIDTH, LESS_THAN, 30),
|
||||
text(" "),
|
||||
}
|
||||
));
|
||||
} else {
|
||||
const NowPlayingError& error = nowPlayingResult.error();
|
||||
|
||||
if (std::holds_alternative<NowPlayingCode>(error))
|
||||
switch (std::get<NowPlayingCode>(error)) {
|
||||
case NowPlayingCode::NoPlayers:
|
||||
DEBUG_LOG("No players found");
|
||||
break;
|
||||
case NowPlayingCode::NoActivePlayer:
|
||||
DEBUG_LOG("No active player found");
|
||||
break;
|
||||
#pragma clang diagnostic push
|
||||
#pragma clang diagnostic ignored "-Wcovered-switch-default"
|
||||
default:
|
||||
std::unreachable();
|
||||
#pragma clang diagnostic pop
|
||||
}
|
||||
|
||||
#ifdef __linux__
|
||||
if (std::holds_alternative<LinuxError>(error))
|
||||
DEBUG_LOG("DBus error: {}", std::get<LinuxError>(error));
|
||||
#endif
|
||||
|
||||
#ifdef _WIN32
|
||||
if (std::holds_alternative<WindowsError>(error))
|
||||
DEBUG_LOG("WinRT error: {}", to_string(std::get<WindowsError>(error).message()));
|
||||
#endif
|
||||
}
|
||||
}
|
||||
|
||||
return vbox(content) | borderRounded | color(Color::White);
|
||||
}
|
||||
}
|
||||
|
||||
fn main() -> i32 {
|
||||
const Config& config = Config::getInstance();
|
||||
const SystemData data = SystemData::fetchSystemData(config);
|
||||
|
||||
Element document = vbox({ hbox({ SystemInfoBox(config, data), filler() }), text("") });
|
||||
|
||||
Screen screen = Screen::Create(Dimension::Full(), Dimension::Fit(document));
|
||||
Render(screen, document);
|
||||
screen.Print();
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -1,117 +0,0 @@
|
|||
#ifdef __FreeBSD__
|
||||
|
||||
#include <fmt/format.h>
|
||||
#include <fstream>
|
||||
#include <iostream>
|
||||
#include <sdbus-c++/sdbus-c++.h>
|
||||
#include <sys/sysctl.h>
|
||||
|
||||
#include "os.h"
|
||||
|
||||
fn GetMemInfo() -> u64 {
|
||||
u64 mem = 0;
|
||||
usize size = sizeof(mem);
|
||||
|
||||
sysctlbyname("hw.physmem", &mem, &size, nullptr, 0);
|
||||
|
||||
return mem;
|
||||
}
|
||||
|
||||
fn GetOSVersion() -> string {
|
||||
std::ifstream file("/etc/os-release");
|
||||
|
||||
if (!file.is_open()) {
|
||||
std::cerr << "Failed to open /etc/os-release" << std::endl;
|
||||
return ""; // Return empty string indicating failure
|
||||
}
|
||||
|
||||
string line;
|
||||
const string prefix = "PRETTY_NAME=";
|
||||
|
||||
while (std::getline(file, line)) {
|
||||
if (line.find(prefix) == 0) {
|
||||
string prettyName = line.substr(prefix.size());
|
||||
|
||||
// Remove surrounding quotes if present
|
||||
if (!prettyName.empty() && prettyName.front() == '"' && prettyName.back() == '"')
|
||||
prettyName = prettyName.substr(1, prettyName.size() - 2);
|
||||
|
||||
return prettyName;
|
||||
}
|
||||
}
|
||||
|
||||
return ""; // Return empty string if PRETTY_NAME= line not found
|
||||
}
|
||||
|
||||
fn GetMprisPlayers(sdbus::IConnection& connection) -> std::vector<string> {
|
||||
const sdbus::ServiceName dbusInterface = sdbus::ServiceName("org.freedesktop.DBus");
|
||||
const sdbus::ObjectPath dbusObjectPath = sdbus::ObjectPath("/org/freedesktop/DBus");
|
||||
const char* dbusMethodListNames = "ListNames";
|
||||
|
||||
const std::unique_ptr<sdbus::IProxy> dbusProxy =
|
||||
createProxy(connection, dbusInterface, dbusObjectPath);
|
||||
|
||||
std::vector<string> names;
|
||||
|
||||
dbusProxy->callMethod(dbusMethodListNames).onInterface(dbusInterface).storeResultsTo(names);
|
||||
|
||||
std::vector<string> mprisPlayers;
|
||||
|
||||
for (const std::basic_string<char>& name : names)
|
||||
if (const char* mprisInterfaceName = "org.mpris.MediaPlayer2";
|
||||
name.find(mprisInterfaceName) != std::string::npos)
|
||||
mprisPlayers.push_back(name);
|
||||
|
||||
return mprisPlayers;
|
||||
}
|
||||
|
||||
fn GetActivePlayer(const std::vector<string>& mprisPlayers) -> string {
|
||||
if (!mprisPlayers.empty())
|
||||
return mprisPlayers.front();
|
||||
|
||||
return "";
|
||||
}
|
||||
|
||||
fn GetNowPlaying() -> string {
|
||||
try {
|
||||
const char *playerObjectPath = "/org/mpris/MediaPlayer2",
|
||||
*playerInterfaceName = "org.mpris.MediaPlayer2.Player";
|
||||
|
||||
std::unique_ptr<sdbus::IConnection> connection = sdbus::createSessionBusConnection();
|
||||
|
||||
std::vector<string> mprisPlayers = GetMprisPlayers(*connection);
|
||||
|
||||
if (mprisPlayers.empty())
|
||||
return "";
|
||||
|
||||
string activePlayer = GetActivePlayer(mprisPlayers);
|
||||
|
||||
if (activePlayer.empty())
|
||||
return "";
|
||||
|
||||
auto playerProxy = sdbus::createProxy(
|
||||
*connection, sdbus::ServiceName(activePlayer), sdbus::ObjectPath(playerObjectPath)
|
||||
);
|
||||
|
||||
sdbus::Variant metadataVariant =
|
||||
playerProxy->getProperty("Metadata").onInterface(playerInterfaceName);
|
||||
|
||||
if (metadataVariant.containsValueOfType<std::map<std::string, sdbus::Variant>>()) {
|
||||
const auto& metadata = metadataVariant.get<std::map<std::string, sdbus::Variant>>();
|
||||
|
||||
auto iter = metadata.find("xesam:title");
|
||||
|
||||
if (iter != metadata.end() && iter->second.containsValueOfType<std::string>())
|
||||
return iter->second.get<std::string>();
|
||||
}
|
||||
} catch (const sdbus::Error& e) {
|
||||
if (e.getName() != "com.github.altdesktop.playerctld.NoActivePlayer")
|
||||
return fmt::format("Error: {}", e.what());
|
||||
|
||||
return "No active player";
|
||||
}
|
||||
|
||||
return "";
|
||||
}
|
||||
|
||||
#endif
|
||||
735
src/os/linux.cpp
735
src/os/linux.cpp
|
|
@ -1,735 +0,0 @@
|
|||
#ifdef __linux__
|
||||
|
||||
#include <X11/Xatom.h>
|
||||
#include <X11/Xlib.h>
|
||||
#include <algorithm>
|
||||
#include <cstring>
|
||||
#include <dbus/dbus.h>
|
||||
#include <dirent.h>
|
||||
#include <expected>
|
||||
#include <filesystem>
|
||||
#include <fmt/format.h>
|
||||
#include <fstream>
|
||||
#include <iostream>
|
||||
#include <mutex>
|
||||
#include <optional>
|
||||
#include <ranges>
|
||||
#include <sys/socket.h>
|
||||
#include <sys/statvfs.h>
|
||||
#include <sys/utsname.h>
|
||||
#include <unistd.h>
|
||||
#include <vector>
|
||||
#include <wayland-client.h>
|
||||
|
||||
#include "os.h"
|
||||
#include "src/util/macros.h"
|
||||
|
||||
// Minimal global using declarations needed for function signatures
|
||||
using std::expected;
|
||||
using std::optional;
|
||||
|
||||
namespace fs = std::filesystem;
|
||||
using namespace std::literals::string_view_literals;
|
||||
|
||||
namespace {
|
||||
// Local using declarations for the anonymous namespace
|
||||
using std::array;
|
||||
using std::bit_cast;
|
||||
using std::getenv;
|
||||
using std::ifstream;
|
||||
using std::istreambuf_iterator;
|
||||
using std::less;
|
||||
using std::lock_guard;
|
||||
using std::mutex;
|
||||
using std::nullopt;
|
||||
using std::ofstream;
|
||||
using std::pair;
|
||||
using std::string_view;
|
||||
using std::to_string;
|
||||
using std::unexpected;
|
||||
using std::vector;
|
||||
using std::ranges::is_sorted;
|
||||
using std::ranges::lower_bound;
|
||||
using std::ranges::replace;
|
||||
using std::ranges::subrange;
|
||||
using std::ranges::transform;
|
||||
|
||||
fn GetX11WindowManager() -> string {
|
||||
Display* display = XOpenDisplay(nullptr);
|
||||
|
||||
// If XOpenDisplay fails, likely in a TTY
|
||||
if (!display)
|
||||
return "";
|
||||
|
||||
Atom supportingWmCheck = XInternAtom(display, "_NET_SUPPORTING_WM_CHECK", False);
|
||||
Atom wmName = XInternAtom(display, "_NET_WM_NAME", False);
|
||||
Atom utf8String = XInternAtom(display, "UTF8_STRING", False);
|
||||
|
||||
#pragma clang diagnostic push
|
||||
#pragma clang diagnostic ignored "-Wold-style-cast"
|
||||
#pragma clang diagnostic ignored "-Wunsafe-buffer-usage"
|
||||
Window root = DefaultRootWindow(display); // NOLINT
|
||||
#pragma clang diagnostic pop
|
||||
|
||||
Window wmWindow = 0;
|
||||
Atom actualType = 0;
|
||||
int actualFormat = 0;
|
||||
unsigned long nitems = 0, bytesAfter = 0;
|
||||
unsigned char* data = nullptr;
|
||||
|
||||
if (XGetWindowProperty(
|
||||
display,
|
||||
root,
|
||||
supportingWmCheck,
|
||||
0,
|
||||
1,
|
||||
False,
|
||||
// XA_WINDOW
|
||||
static_cast<Atom>(33),
|
||||
&actualType,
|
||||
&actualFormat,
|
||||
&nitems,
|
||||
&bytesAfter,
|
||||
&data
|
||||
) == Success &&
|
||||
data) {
|
||||
wmWindow = *bit_cast<Window*>(data);
|
||||
XFree(data);
|
||||
data = nullptr;
|
||||
|
||||
if (XGetWindowProperty(
|
||||
display,
|
||||
wmWindow,
|
||||
wmName,
|
||||
0,
|
||||
1024,
|
||||
False,
|
||||
utf8String,
|
||||
&actualType,
|
||||
&actualFormat,
|
||||
&nitems,
|
||||
&bytesAfter,
|
||||
&data
|
||||
) == Success &&
|
||||
data) {
|
||||
string name(bit_cast<char*>(data));
|
||||
XFree(data);
|
||||
XCloseDisplay(display);
|
||||
return name;
|
||||
}
|
||||
}
|
||||
|
||||
XCloseDisplay(display);
|
||||
|
||||
return "Unknown (X11)"; // Changed to empty string
|
||||
}
|
||||
|
||||
fn TrimHyprlandWrapper(const string& input) -> string {
|
||||
if (input.contains("hyprland"))
|
||||
return "Hyprland";
|
||||
return input;
|
||||
}
|
||||
|
||||
fn ReadProcessCmdline(int pid) -> string {
|
||||
string path = "/proc/" + to_string(pid) + "/cmdline";
|
||||
ifstream cmdlineFile(path);
|
||||
string cmdline;
|
||||
if (getline(cmdlineFile, cmdline)) {
|
||||
// Replace null bytes with spaces
|
||||
replace(cmdline, '\0', ' ');
|
||||
return cmdline;
|
||||
}
|
||||
return "";
|
||||
}
|
||||
|
||||
fn DetectHyprlandSpecific() -> string {
|
||||
// Check environment variables first
|
||||
const char* xdgCurrentDesktop = getenv("XDG_CURRENT_DESKTOP");
|
||||
if (xdgCurrentDesktop && strcasestr(xdgCurrentDesktop, "hyprland"))
|
||||
return "Hyprland";
|
||||
|
||||
// Check for Hyprland's specific environment variable
|
||||
if (getenv("HYPRLAND_INSTANCE_SIGNATURE"))
|
||||
return "Hyprland";
|
||||
|
||||
// Check for Hyprland socket
|
||||
if (fs::exists("/run/user/" + to_string(getuid()) + "/hypr"))
|
||||
return "Hyprland";
|
||||
|
||||
return "";
|
||||
}
|
||||
|
||||
fn GetWaylandCompositor() -> string {
|
||||
// First try Hyprland-specific detection
|
||||
string hypr = DetectHyprlandSpecific();
|
||||
if (!hypr.empty())
|
||||
return hypr;
|
||||
|
||||
// Then try the standard Wayland detection
|
||||
wl_display* display = wl_display_connect(nullptr);
|
||||
|
||||
if (!display)
|
||||
return "";
|
||||
|
||||
int fileDescriptor = wl_display_get_fd(display);
|
||||
|
||||
struct ucred cred;
|
||||
socklen_t len = sizeof(cred);
|
||||
|
||||
if (getsockopt(fileDescriptor, SOL_SOCKET, SO_PEERCRED, &cred, &len) == -1) {
|
||||
wl_display_disconnect(display);
|
||||
return "";
|
||||
}
|
||||
|
||||
// Read both comm and cmdline
|
||||
string compositorName;
|
||||
|
||||
// 1. Check comm (might be wrapped)
|
||||
string commPath = "/proc/" + to_string(cred.pid) + "/comm";
|
||||
ifstream commFile(commPath);
|
||||
if (commFile >> compositorName) {
|
||||
subrange removedRange = std::ranges::remove(compositorName, '\n');
|
||||
compositorName.erase(removedRange.begin(), compositorName.end());
|
||||
}
|
||||
|
||||
// 2. Check cmdline for actual binary reference
|
||||
string cmdline = ReadProcessCmdline(cred.pid);
|
||||
if (cmdline.contains("hyprland")) {
|
||||
wl_display_disconnect(display);
|
||||
return "Hyprland";
|
||||
}
|
||||
|
||||
// 3. Check exe symlink
|
||||
string exePath = "/proc/" + to_string(cred.pid) + "/exe";
|
||||
array<char, PATH_MAX> buf;
|
||||
ssize_t lenBuf = readlink(exePath.c_str(), buf.data(), buf.size() - 1);
|
||||
if (lenBuf != -1) {
|
||||
buf.at(static_cast<usize>(lenBuf)) = '\0';
|
||||
string exe(buf.data());
|
||||
if (exe.contains("hyprland")) {
|
||||
wl_display_disconnect(display);
|
||||
return "Hyprland";
|
||||
}
|
||||
}
|
||||
|
||||
wl_display_disconnect(display);
|
||||
|
||||
// Final cleanup of wrapper names
|
||||
return TrimHyprlandWrapper(compositorName);
|
||||
}
|
||||
|
||||
fn DetectFromEnvVars() -> optional<string> {
|
||||
// Use RAII to guard against concurrent env modifications
|
||||
static mutex EnvMutex;
|
||||
lock_guard<mutex> lock(EnvMutex);
|
||||
|
||||
// XDG_CURRENT_DESKTOP
|
||||
if (const char* xdgCurrentDesktop = getenv("XDG_CURRENT_DESKTOP")) {
|
||||
const string_view sview(xdgCurrentDesktop);
|
||||
const size_t colon = sview.find(':');
|
||||
return string(sview.substr(0, colon)); // Direct construct from view
|
||||
}
|
||||
|
||||
// DESKTOP_SESSION
|
||||
if (const char* desktopSession = getenv("DESKTOP_SESSION"))
|
||||
return string(string_view(desktopSession)); // Avoid intermediate view storage
|
||||
|
||||
return nullopt;
|
||||
}
|
||||
|
||||
fn DetectFromSessionFiles() -> optional<string> {
|
||||
static constexpr array<pair<string_view, string_view>, 12> DE_PATTERNS = {
|
||||
// clang-format off
|
||||
pair { "Budgie"sv, "budgie"sv },
|
||||
pair { "Cinnamon"sv, "cinnamon"sv },
|
||||
pair { "LXQt"sv, "lxqt"sv },
|
||||
pair { "MATE"sv, "mate"sv },
|
||||
pair { "Unity"sv, "unity"sv },
|
||||
pair { "gnome"sv, "GNOME"sv },
|
||||
pair { "gnome-wayland"sv, "GNOME"sv },
|
||||
pair { "gnome-xorg"sv, "GNOME"sv },
|
||||
pair { "kde"sv, "KDE"sv },
|
||||
pair { "plasma"sv, "KDE"sv },
|
||||
pair { "plasmax11"sv, "KDE"sv },
|
||||
pair { "xfce"sv, "XFCE"sv },
|
||||
// clang-format on
|
||||
};
|
||||
|
||||
static_assert(is_sorted(DE_PATTERNS, {}, &pair<string_view, string_view>::first));
|
||||
|
||||
// Precomputed session paths
|
||||
static constexpr array<string_view, 2> SESSION_PATHS = { "/usr/share/xsessions", "/usr/share/wayland-sessions" };
|
||||
|
||||
// Single memory reserve for lowercase conversions
|
||||
string lowercaseStem;
|
||||
lowercaseStem.reserve(32);
|
||||
|
||||
for (const auto& path : SESSION_PATHS) {
|
||||
if (!fs::exists(path))
|
||||
continue;
|
||||
|
||||
for (const auto& entry : fs::directory_iterator(path)) {
|
||||
if (!entry.is_regular_file())
|
||||
continue;
|
||||
|
||||
// Reuse buffer
|
||||
lowercaseStem = entry.path().stem().string();
|
||||
transform(lowercaseStem, lowercaseStem.begin(), ::tolower);
|
||||
|
||||
// Modern ranges version
|
||||
const pair<string_view, string_view>* const patternIter = lower_bound(
|
||||
DE_PATTERNS, lowercaseStem, less {}, &pair<string_view, string_view>::first // Projection
|
||||
);
|
||||
|
||||
if (patternIter != DE_PATTERNS.end() && patternIter->first == lowercaseStem)
|
||||
return string(patternIter->second);
|
||||
}
|
||||
}
|
||||
|
||||
return nullopt;
|
||||
}
|
||||
|
||||
fn DetectFromProcesses() -> optional<string> {
|
||||
const array processChecks = {
|
||||
// clang-format off
|
||||
pair { "plasmashell"sv, "KDE"sv },
|
||||
pair { "gnome-shell"sv, "GNOME"sv },
|
||||
pair { "xfce4-session"sv, "XFCE"sv },
|
||||
pair { "mate-session"sv, "MATE"sv },
|
||||
pair { "cinnamon-sessio"sv, "Cinnamon"sv },
|
||||
pair { "budgie-wm"sv, "Budgie"sv },
|
||||
pair { "lxqt-session"sv, "LXQt"sv },
|
||||
// clang-format on
|
||||
};
|
||||
|
||||
ifstream cmdline("/proc/self/environ");
|
||||
string envVars((istreambuf_iterator<char>(cmdline)), istreambuf_iterator<char>());
|
||||
|
||||
for (const auto& [process, deName] : processChecks)
|
||||
if (envVars.contains(process))
|
||||
return string(deName);
|
||||
|
||||
return nullopt;
|
||||
}
|
||||
|
||||
#pragma clang diagnostic push
|
||||
#pragma clang diagnostic ignored "-Wold-style-cast"
|
||||
fn GetMprisPlayers(DBusConnection* connection) -> vector<string> {
|
||||
vector<string> mprisPlayers;
|
||||
DBusError err;
|
||||
dbus_error_init(&err);
|
||||
|
||||
// Create a method call to org.freedesktop.DBus.ListNames
|
||||
DBusMessage* msg = dbus_message_new_method_call(
|
||||
"org.freedesktop.DBus", // target service
|
||||
"/org/freedesktop/DBus", // object path
|
||||
"org.freedesktop.DBus", // interface name
|
||||
"ListNames" // method name
|
||||
);
|
||||
|
||||
if (!msg) {
|
||||
DEBUG_LOG("Failed to create message for ListNames.");
|
||||
return mprisPlayers;
|
||||
}
|
||||
|
||||
// Send the message and block until we get a reply.
|
||||
DBusMessage* reply = dbus_connection_send_with_reply_and_block(connection, msg, -1, &err);
|
||||
dbus_message_unref(msg);
|
||||
|
||||
if (dbus_error_is_set(&err)) {
|
||||
DEBUG_LOG("DBus error in ListNames: {}", err.message);
|
||||
dbus_error_free(&err);
|
||||
return mprisPlayers;
|
||||
}
|
||||
|
||||
if (!reply) {
|
||||
DEBUG_LOG("No reply received for ListNames.");
|
||||
return mprisPlayers;
|
||||
}
|
||||
|
||||
// The expected reply signature is "as" (an array of strings)
|
||||
DBusMessageIter iter;
|
||||
|
||||
if (!dbus_message_iter_init(reply, &iter)) {
|
||||
DEBUG_LOG("Reply has no arguments.");
|
||||
dbus_message_unref(reply);
|
||||
return mprisPlayers;
|
||||
}
|
||||
|
||||
if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_ARRAY) {
|
||||
DEBUG_LOG("Reply argument is not an array.");
|
||||
dbus_message_unref(reply);
|
||||
return mprisPlayers;
|
||||
}
|
||||
|
||||
// Iterate over the array of strings
|
||||
DBusMessageIter subIter;
|
||||
dbus_message_iter_recurse(&iter, &subIter);
|
||||
|
||||
while (dbus_message_iter_get_arg_type(&subIter) != DBUS_TYPE_INVALID) {
|
||||
if (dbus_message_iter_get_arg_type(&subIter) == DBUS_TYPE_STRING) {
|
||||
const char* name = nullptr;
|
||||
dbus_message_iter_get_basic(&subIter, static_cast<void*>(&name));
|
||||
if (name && std::string_view(name).contains("org.mpris.MediaPlayer2"))
|
||||
mprisPlayers.emplace_back(name);
|
||||
}
|
||||
dbus_message_iter_next(&subIter);
|
||||
}
|
||||
|
||||
dbus_message_unref(reply);
|
||||
return mprisPlayers;
|
||||
}
|
||||
#pragma clang diagnostic pop
|
||||
|
||||
fn GetActivePlayer(const vector<string>& mprisPlayers) -> optional<string> {
|
||||
if (!mprisPlayers.empty())
|
||||
return mprisPlayers.front();
|
||||
return nullopt;
|
||||
}
|
||||
}
|
||||
|
||||
fn GetOSVersion() -> expected<string, string> {
|
||||
constexpr const char* path = "/etc/os-release";
|
||||
|
||||
ifstream file(path);
|
||||
|
||||
if (!file.is_open())
|
||||
return unexpected("Failed to open " + string(path));
|
||||
|
||||
string line;
|
||||
const string prefix = "PRETTY_NAME=";
|
||||
|
||||
while (getline(file, line))
|
||||
if (line.starts_with(prefix)) {
|
||||
string prettyName = line.substr(prefix.size());
|
||||
|
||||
if (!prettyName.empty() && prettyName.front() == '"' && prettyName.back() == '"')
|
||||
return prettyName.substr(1, prettyName.size() - 2);
|
||||
|
||||
return prettyName;
|
||||
}
|
||||
|
||||
return unexpected("PRETTY_NAME line not found in " + string(path));
|
||||
}
|
||||
|
||||
fn GetMemInfo() -> expected<u64, string> {
|
||||
using std::from_chars, std::errc;
|
||||
|
||||
constexpr const char* path = "/proc/meminfo";
|
||||
|
||||
ifstream input(path);
|
||||
|
||||
if (!input.is_open())
|
||||
return unexpected("Failed to open " + string(path));
|
||||
|
||||
string line;
|
||||
while (getline(input, line)) {
|
||||
if (line.starts_with("MemTotal")) {
|
||||
const size_t colonPos = line.find(':');
|
||||
|
||||
if (colonPos == string::npos)
|
||||
return unexpected("Invalid MemTotal line: no colon found");
|
||||
|
||||
string_view view(line);
|
||||
view.remove_prefix(colonPos + 1);
|
||||
|
||||
// Trim leading whitespace
|
||||
const size_t firstNonSpace = view.find_first_not_of(' ');
|
||||
|
||||
if (firstNonSpace == string_view::npos)
|
||||
return unexpected("No number found after colon in MemTotal line");
|
||||
|
||||
view.remove_prefix(firstNonSpace);
|
||||
|
||||
// Find the end of the numeric part
|
||||
const size_t end = view.find_first_not_of("0123456789");
|
||||
if (end != string_view::npos)
|
||||
view = view.substr(0, end);
|
||||
|
||||
// Get pointers via iterators
|
||||
const char* startPtr = &*view.begin();
|
||||
const char* endPtr = &*view.end();
|
||||
|
||||
u64 value = 0;
|
||||
const auto result = from_chars(startPtr, endPtr, value);
|
||||
|
||||
if (result.ec != errc() || result.ptr != endPtr)
|
||||
return unexpected("Failed to parse number in MemTotal line");
|
||||
|
||||
return value * 1024;
|
||||
}
|
||||
}
|
||||
|
||||
return unexpected("MemTotal line not found in " + string(path));
|
||||
}
|
||||
|
||||
#pragma clang diagnostic push
|
||||
#pragma clang diagnostic ignored "-Wold-style-cast"
|
||||
fn GetNowPlaying() -> expected<string, NowPlayingError> {
|
||||
DBusError err;
|
||||
dbus_error_init(&err);
|
||||
|
||||
// Connect to the session bus
|
||||
DBusConnection* connection = dbus_bus_get(DBUS_BUS_SESSION, &err);
|
||||
|
||||
if (!connection)
|
||||
if (dbus_error_is_set(&err)) {
|
||||
ERROR_LOG("DBus connection error: {}", err.message);
|
||||
|
||||
NowPlayingError error = LinuxError(err.message);
|
||||
dbus_error_free(&err);
|
||||
|
||||
return unexpected(error);
|
||||
}
|
||||
|
||||
vector<string> mprisPlayers = GetMprisPlayers(connection);
|
||||
|
||||
if (mprisPlayers.empty()) {
|
||||
dbus_connection_unref(connection);
|
||||
return unexpected(NowPlayingError { NowPlayingCode::NoPlayers });
|
||||
}
|
||||
|
||||
optional<string> activePlayer = GetActivePlayer(mprisPlayers);
|
||||
|
||||
if (!activePlayer.has_value()) {
|
||||
dbus_connection_unref(connection);
|
||||
return unexpected(NowPlayingError { NowPlayingCode::NoActivePlayer });
|
||||
}
|
||||
|
||||
// Prepare a call to the Properties.Get method to fetch "Metadata"
|
||||
DBusMessage* msg = dbus_message_new_method_call(
|
||||
activePlayer->c_str(), // target service (active player)
|
||||
"/org/mpris/MediaPlayer2", // object path
|
||||
"org.freedesktop.DBus.Properties", // interface
|
||||
"Get" // method name
|
||||
);
|
||||
|
||||
if (!msg) {
|
||||
dbus_connection_unref(connection);
|
||||
return unexpected(NowPlayingError { /* error creating message */ });
|
||||
}
|
||||
|
||||
const char* interfaceName = "org.mpris.MediaPlayer2.Player";
|
||||
const char* propertyName = "Metadata";
|
||||
|
||||
if (!dbus_message_append_args(
|
||||
msg, DBUS_TYPE_STRING, &interfaceName, DBUS_TYPE_STRING, &propertyName, DBUS_TYPE_INVALID
|
||||
)) {
|
||||
dbus_message_unref(msg);
|
||||
dbus_connection_unref(connection);
|
||||
return unexpected(NowPlayingError { /* error appending arguments */ });
|
||||
}
|
||||
|
||||
// Call the method and block until reply is received.
|
||||
DBusMessage* reply = dbus_connection_send_with_reply_and_block(connection, msg, -1, &err);
|
||||
dbus_message_unref(msg);
|
||||
|
||||
if (dbus_error_is_set(&err)) {
|
||||
ERROR_LOG("DBus error in Properties.Get: {}", err.message);
|
||||
|
||||
NowPlayingError error = LinuxError(err.message);
|
||||
dbus_error_free(&err);
|
||||
dbus_connection_unref(connection);
|
||||
|
||||
return unexpected(error);
|
||||
}
|
||||
|
||||
if (!reply) {
|
||||
dbus_connection_unref(connection);
|
||||
return unexpected(NowPlayingError { /* no reply error */ });
|
||||
}
|
||||
|
||||
// The reply should contain a variant holding a dictionary ("a{sv}")
|
||||
DBusMessageIter iter;
|
||||
|
||||
if (!dbus_message_iter_init(reply, &iter)) {
|
||||
dbus_message_unref(reply);
|
||||
dbus_connection_unref(connection);
|
||||
return unexpected(NowPlayingError { /* no arguments in reply */ });
|
||||
}
|
||||
|
||||
if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_VARIANT) {
|
||||
dbus_message_unref(reply);
|
||||
dbus_connection_unref(connection);
|
||||
return unexpected(NowPlayingError { /* unexpected argument type */ });
|
||||
}
|
||||
|
||||
// Recurse into the variant to get the dictionary
|
||||
DBusMessageIter variantIter;
|
||||
dbus_message_iter_recurse(&iter, &variantIter);
|
||||
|
||||
if (dbus_message_iter_get_arg_type(&variantIter) != DBUS_TYPE_ARRAY) {
|
||||
dbus_message_unref(reply);
|
||||
dbus_connection_unref(connection);
|
||||
return unexpected(NowPlayingError { /* expected array type */ });
|
||||
}
|
||||
|
||||
string title;
|
||||
string artist;
|
||||
DBusMessageIter arrayIter;
|
||||
dbus_message_iter_recurse(&variantIter, &arrayIter);
|
||||
|
||||
// Iterate over each dictionary entry (each entry is of type dict entry)
|
||||
while (dbus_message_iter_get_arg_type(&arrayIter) != DBUS_TYPE_INVALID) {
|
||||
if (dbus_message_iter_get_arg_type(&arrayIter) == DBUS_TYPE_DICT_ENTRY) {
|
||||
DBusMessageIter dictEntry;
|
||||
dbus_message_iter_recurse(&arrayIter, &dictEntry);
|
||||
|
||||
// Get the key (a string)
|
||||
const char* key = nullptr;
|
||||
|
||||
if (dbus_message_iter_get_arg_type(&dictEntry) == DBUS_TYPE_STRING)
|
||||
dbus_message_iter_get_basic(&dictEntry, static_cast<void*>(&key));
|
||||
|
||||
// Move to the value (a variant)
|
||||
dbus_message_iter_next(&dictEntry);
|
||||
|
||||
if (dbus_message_iter_get_arg_type(&dictEntry) == DBUS_TYPE_VARIANT) {
|
||||
DBusMessageIter valueIter;
|
||||
dbus_message_iter_recurse(&dictEntry, &valueIter);
|
||||
|
||||
if (key && std::string_view(key) == "xesam:title") {
|
||||
if (dbus_message_iter_get_arg_type(&valueIter) == DBUS_TYPE_STRING) {
|
||||
const char* val = nullptr;
|
||||
dbus_message_iter_get_basic(&valueIter, static_cast<void*>(&val));
|
||||
|
||||
if (val)
|
||||
title = val;
|
||||
}
|
||||
} else if (key && std::string_view(key) == "xesam:artist") {
|
||||
// Expect an array of strings
|
||||
if (dbus_message_iter_get_arg_type(&valueIter) == DBUS_TYPE_ARRAY) {
|
||||
DBusMessageIter subIter;
|
||||
dbus_message_iter_recurse(&valueIter, &subIter);
|
||||
|
||||
if (dbus_message_iter_get_arg_type(&subIter) == DBUS_TYPE_STRING) {
|
||||
const char* val = nullptr;
|
||||
dbus_message_iter_get_basic(&subIter, static_cast<void*>(&val));
|
||||
|
||||
if (val)
|
||||
artist = val;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
dbus_message_iter_next(&arrayIter);
|
||||
}
|
||||
|
||||
dbus_message_unref(reply);
|
||||
dbus_connection_unref(connection);
|
||||
|
||||
string result;
|
||||
|
||||
if (!artist.empty() && !title.empty())
|
||||
result = artist + " - " + title;
|
||||
else if (!title.empty())
|
||||
result = title;
|
||||
else if (!artist.empty())
|
||||
result = artist;
|
||||
else
|
||||
result = "";
|
||||
|
||||
return result;
|
||||
}
|
||||
#pragma clang diagnostic pop
|
||||
|
||||
fn GetWindowManager() -> string {
|
||||
// Check environment variables first
|
||||
const char* xdgSessionType = getenv("XDG_SESSION_TYPE");
|
||||
const char* waylandDisplay = getenv("WAYLAND_DISPLAY");
|
||||
|
||||
// Prefer Wayland detection if Wayland session
|
||||
if ((waylandDisplay != nullptr) || (xdgSessionType && string_view(xdgSessionType).contains("wayland"))) {
|
||||
string compositor = GetWaylandCompositor();
|
||||
if (!compositor.empty())
|
||||
return compositor;
|
||||
|
||||
// Fallback environment check
|
||||
const char* xdgCurrentDesktop = getenv("XDG_CURRENT_DESKTOP");
|
||||
if (xdgCurrentDesktop) {
|
||||
string desktop(xdgCurrentDesktop);
|
||||
transform(compositor, compositor.begin(), ::tolower);
|
||||
if (desktop.contains("hyprland"))
|
||||
return "hyprland";
|
||||
}
|
||||
}
|
||||
|
||||
// X11 detection
|
||||
string x11wm = GetX11WindowManager();
|
||||
if (!x11wm.empty())
|
||||
return x11wm;
|
||||
|
||||
return "Unknown";
|
||||
}
|
||||
|
||||
fn GetDesktopEnvironment() -> optional<string> {
|
||||
// Try environment variables first
|
||||
if (auto desktopEnvironment = DetectFromEnvVars(); desktopEnvironment.has_value())
|
||||
return desktopEnvironment;
|
||||
|
||||
// Try session files next
|
||||
if (auto desktopEnvironment = DetectFromSessionFiles(); desktopEnvironment.has_value())
|
||||
return desktopEnvironment;
|
||||
|
||||
// Fallback to process detection
|
||||
return DetectFromProcesses();
|
||||
}
|
||||
|
||||
fn GetShell() -> string {
|
||||
const string_view shell = getenv("SHELL");
|
||||
|
||||
if (shell.ends_with("bash"))
|
||||
return "Bash";
|
||||
if (shell.ends_with("zsh"))
|
||||
return "Zsh";
|
||||
if (shell.ends_with("fish"))
|
||||
return "Fish";
|
||||
if (shell.ends_with("nu"))
|
||||
return "Nushell";
|
||||
if (shell.ends_with("sh"))
|
||||
return "SH";
|
||||
|
||||
return !shell.empty() ? string(shell) : "";
|
||||
}
|
||||
|
||||
fn GetHost() -> string {
|
||||
constexpr const char* path = "/sys/class/dmi/id/product_family";
|
||||
|
||||
ifstream file(path);
|
||||
if (!file.is_open()) {
|
||||
ERROR_LOG("Failed to open {}", path);
|
||||
return "";
|
||||
}
|
||||
|
||||
string productFamily;
|
||||
if (!getline(file, productFamily)) {
|
||||
ERROR_LOG("Failed to read from {}", path);
|
||||
return "";
|
||||
}
|
||||
|
||||
return productFamily;
|
||||
}
|
||||
|
||||
fn GetKernelVersion() -> string {
|
||||
struct utsname uts;
|
||||
|
||||
if (uname(&uts) == -1) {
|
||||
ERROR_LOG("uname() failed: {}", strerror(errno));
|
||||
return "";
|
||||
}
|
||||
|
||||
return static_cast<const char*>(uts.release);
|
||||
}
|
||||
|
||||
fn GetDiskUsage() -> pair<u64, u64> {
|
||||
struct statvfs stat;
|
||||
if (statvfs("/", &stat) == -1) {
|
||||
ERROR_LOG("statvfs() failed: {}", strerror(errno));
|
||||
return { 0, 0 };
|
||||
}
|
||||
return { (stat.f_blocks * stat.f_frsize) - (stat.f_bfree * stat.f_frsize), stat.f_blocks * stat.f_frsize };
|
||||
}
|
||||
|
||||
#endif
|
||||
|
|
@ -1,3 +0,0 @@
|
|||
#include "src/util/macros.h"
|
||||
|
||||
extern "C" fn issetugid() -> usize { return 0; } // NOLINT
|
||||
|
|
@ -1,9 +0,0 @@
|
|||
#include "src/os/linux/pkg_count.h"
|
||||
|
||||
namespace fs = std::filesystem;
|
||||
|
||||
fn GetApkPackageCount() -> optional<usize> {
|
||||
fs::path apkDbPath("/lib/apk/db/installed");
|
||||
|
||||
return std::nullopt;
|
||||
}
|
||||
|
|
@ -1,38 +0,0 @@
|
|||
#pragma once
|
||||
|
||||
#include "src/util/macros.h"
|
||||
|
||||
using std::optional;
|
||||
|
||||
// Get package count from dpkg (Debian/Ubuntu)
|
||||
fn GetDpkgPackageCount() -> optional<usize>;
|
||||
|
||||
// Get package count from RPM (Red Hat/Fedora/CentOS)
|
||||
fn GetRpmPackageCount() -> std::optional<usize>;
|
||||
|
||||
// Get package count from pacman (Arch Linux)
|
||||
fn GetPacmanPackageCount() -> std::optional<usize>;
|
||||
|
||||
// Get package count from Portage (Gentoo)
|
||||
fn GetPortagePackageCount() -> std::optional<usize>;
|
||||
|
||||
// Get package count from zypper (openSUSE)
|
||||
fn GetZypperPackageCount() -> std::optional<usize>;
|
||||
|
||||
// Get package count from apk (Alpine)
|
||||
fn GetApkPackageCount() -> std::optional<usize>;
|
||||
|
||||
// Get package count from nix
|
||||
fn GetNixPackageCount() -> std::optional<usize>;
|
||||
|
||||
// Get package count from flatpak
|
||||
fn GetFlatpakPackageCount() -> std::optional<usize>;
|
||||
|
||||
// Get package count from snap
|
||||
fn GetSnapPackageCount() -> std::optional<usize>;
|
||||
|
||||
// Get package count from AppImage
|
||||
fn GetAppimagePackageCount() -> std::optional<usize>;
|
||||
|
||||
// Get total package count from all available package managers
|
||||
fn GetTotalPackageCount() -> std::optional<usize>;
|
||||
211
src/os/macos.cpp
211
src/os/macos.cpp
|
|
@ -1,211 +0,0 @@
|
|||
#ifdef __APPLE__
|
||||
|
||||
#include <expected>
|
||||
#include <map>
|
||||
#include <sys/statvfs.h>
|
||||
#include <sys/sysctl.h>
|
||||
|
||||
#include "macos/bridge.h"
|
||||
#include "os.h"
|
||||
#include "src/util/types.h"
|
||||
|
||||
fn GetMemInfo() -> expected<u64, string> {
|
||||
u64 mem = 0;
|
||||
usize size = sizeof(mem);
|
||||
|
||||
if (sysctlbyname("hw.memsize", &mem, &size, nullptr, 0) == -1)
|
||||
return std::unexpected(string("sysctlbyname failed: ") + strerror(errno));
|
||||
|
||||
return mem;
|
||||
}
|
||||
|
||||
fn GetNowPlaying() -> expected<string, NowPlayingError> { return GetCurrentPlayingInfo(); }
|
||||
|
||||
fn GetOSVersion() -> expected<string, string> { return GetMacOSVersion(); }
|
||||
|
||||
fn GetDesktopEnvironment() -> optional<string> { return std::nullopt; }
|
||||
|
||||
fn GetWindowManager() -> string { return "Yabai"; }
|
||||
|
||||
fn GetKernelVersion() -> string {
|
||||
std::array<char, 256> kernelVersion;
|
||||
usize kernelVersionLen = sizeof(kernelVersion);
|
||||
|
||||
sysctlbyname("kern.osrelease", kernelVersion.data(), &kernelVersionLen, nullptr, 0);
|
||||
|
||||
return kernelVersion.data();
|
||||
}
|
||||
|
||||
fn GetHost() -> string {
|
||||
std::array<char, 256> hwModel;
|
||||
size_t hwModelLen = sizeof(hwModel);
|
||||
|
||||
sysctlbyname("hw.model", hwModel.data(), &hwModelLen, nullptr, 0);
|
||||
|
||||
// taken from https://github.com/fastfetch-cli/fastfetch/blob/dev/src/detection/host/host_mac.c
|
||||
// shortened a lot of the entries to remove unnecessary info
|
||||
std::map<std::string, std::string> modelNameByHwModel = {
|
||||
// MacBook Pro
|
||||
{ "MacBookPro18,3", "MacBook Pro (14-inch, 2021)" },
|
||||
{ "MacBookPro18,4", "MacBook Pro (14-inch, 2021)" },
|
||||
{ "MacBookPro18,1", "MacBook Pro (16-inch, 2021)" },
|
||||
{ "MacBookPro18,2", "MacBook Pro (16-inch, 2021)" },
|
||||
{ "MacBookPro17,1", "MacBook Pro (13-inch, M1, 2020)" },
|
||||
{ "MacBookPro16,3", "MacBook Pro (13-inch, 2020)" },
|
||||
{ "MacBookPro16,2", "MacBook Pro (13-inch, 2020)" },
|
||||
{ "MacBookPro16,4", "MacBook Pro (16-inch, 2019)" },
|
||||
{ "MacBookPro16,1", "MacBook Pro (16-inch, 2019)" },
|
||||
{ "MacBookPro15,4", "MacBook Pro (13-inch, 2019)" },
|
||||
{ "MacBookPro15,3", "MacBook Pro (15-inch, 2019)" },
|
||||
{ "MacBookPro15,2", "MacBook Pro (13-inch, 2018/2019)" },
|
||||
{ "MacBookPro15,1", "MacBook Pro (15-inch, 2018/2019)" },
|
||||
{ "MacBookPro14,3", "MacBook Pro (15-inch, 2017)" },
|
||||
{ "MacBookPro14,2", "MacBook Pro (13-inch, 2017)" },
|
||||
{ "MacBookPro14,1", "MacBook Pro (13-inch, 2017)" },
|
||||
{ "MacBookPro13,3", "MacBook Pro (15-inch, 2016)" },
|
||||
{ "MacBookPro13,2", "MacBook Pro (13-inch, 2016)" },
|
||||
{ "MacBookPro13,1", "MacBook Pro (13-inch, 2016)" },
|
||||
{ "MacBookPro12,1", "MacBook Pro (13-inch, 2015)" },
|
||||
{ "MacBookPro11,4", "MacBook Pro (15-inch, 2015)" },
|
||||
{ "MacBookPro11,5", "MacBook Pro (15-inch, 2015)" },
|
||||
{ "MacBookPro11,2", "MacBook Pro (15-inch, 2013/2014)" },
|
||||
{ "MacBookPro11,3", "MacBook Pro (15-inch, 2013/2014)" },
|
||||
{ "MacBookPro11,1", "MacBook Pro (13-inch, 2013/2014)" },
|
||||
{ "MacBookPro10,2", "MacBook Pro (13-inch, 2012/2013)" },
|
||||
{ "MacBookPro10,1", "MacBook Pro (15-inch, 2012/2013)" },
|
||||
{ "MacBookPro9,2", "MacBook Pro (13-inch, 2012)" },
|
||||
{ "MacBookPro9,1", "MacBook Pro (15-inch, 2012)" },
|
||||
{ "MacBookPro8,3", "MacBook Pro (17-inch, 2011)" },
|
||||
{ "MacBookPro8,2", "MacBook Pro (15-inch, 2011)" },
|
||||
{ "MacBookPro8,1", "MacBook Pro (13-inch, 2011)" },
|
||||
{ "MacBookPro7,1", "MacBook Pro (13-inch, 2010)" },
|
||||
{ "MacBookPro6,2", "MacBook Pro (15-inch, 2010)" },
|
||||
{ "MacBookPro6,1", "MacBook Pro (17-inch, 2010)" },
|
||||
{ "MacBookPro5,5", "MacBook Pro (13-inch, 2009)" },
|
||||
{ "MacBookPro5,3", "MacBook Pro (15-inch, 2009)" },
|
||||
{ "MacBookPro5,2", "MacBook Pro (17-inch, 2009)" },
|
||||
{ "MacBookPro5,1", "MacBook Pro (15-inch, 2008)" },
|
||||
{ "MacBookPro4,1", "MacBook Pro (17/15-inch, 2008)" },
|
||||
|
||||
// MacBook Air
|
||||
{ "MacBookAir10,1", "MacBook Air (M1, 2020)" },
|
||||
{ "MacBookAir9,1", "MacBook Air (13-inch, 2020)" },
|
||||
{ "MacBookAir8,2", "MacBook Air (13-inch, 2019)" },
|
||||
{ "MacBookAir8,1", "MacBook Air (13-inch, 2018)" },
|
||||
{ "MacBookAir7,2", "MacBook Air (13-inch, 2015/2017)" },
|
||||
{ "MacBookAir7,1", "MacBook Air (11-inch, 2015)" },
|
||||
{ "MacBookAir6,2", "MacBook Air (13-inch, 2013/2014)" },
|
||||
{ "MacBookAir6,1", "MacBook Air (11-inch, 2013/2014)" },
|
||||
{ "MacBookAir5,2", "MacBook Air (13-inch, 2012)" },
|
||||
{ "MacBookAir5,1", "MacBook Air (11-inch, 2012)" },
|
||||
{ "MacBookAir4,2", "MacBook Air (13-inch, 2011)" },
|
||||
{ "MacBookAir4,1", "MacBook Air (11-inch, 2011)" },
|
||||
{ "MacBookAir3,2", "MacBook Air (13-inch, 2010)" },
|
||||
{ "MacBookAir3,1", "MacBook Air (11-inch, 2010)" },
|
||||
{ "MacBookAir2,1", "MacBook Air (2009)" },
|
||||
|
||||
// Mac mini
|
||||
{ "Macmini9,1", "Mac mini (M1, 2020)" },
|
||||
{ "Macmini8,1", "Mac mini (2018)" },
|
||||
{ "Macmini7,1", "Mac mini (2014)" },
|
||||
{ "Macmini6,1", "Mac mini (2012)" },
|
||||
{ "Macmini6,2", "Mac mini (2012)" },
|
||||
{ "Macmini5,1", "Mac mini (2011)" },
|
||||
{ "Macmini5,2", "Mac mini (2011)" },
|
||||
{ "Macmini4,1", "Mac mini (2010)" },
|
||||
{ "Macmini3,1", "Mac mini (2009)" },
|
||||
|
||||
// MacBook
|
||||
{ "MacBook10,1", "MacBook (12-inch, 2017)" },
|
||||
{ "MacBook9,1", "MacBook (12-inch, 2016)" },
|
||||
{ "MacBook8,1", "MacBook (12-inch, 2015)" },
|
||||
{ "MacBook7,1", "MacBook (13-inch, 2010)" },
|
||||
{ "MacBook6,1", "MacBook (13-inch, 2009)" },
|
||||
{ "MacBook5,2", "MacBook (13-inch, 2009)" },
|
||||
|
||||
// Mac Pro
|
||||
{ "MacPro7,1", "Mac Pro (2019)" },
|
||||
{ "MacPro6,1", "Mac Pro (2013)" },
|
||||
{ "MacPro5,1", "Mac Pro (2010 - 2012)" },
|
||||
{ "MacPro4,1", "Mac Pro (2009)" },
|
||||
|
||||
// Mac (Generic)
|
||||
{ "Mac16,3", "iMac (24-inch, 2024)" },
|
||||
{ "Mac16,2", "iMac (24-inch, 2024)" },
|
||||
{ "Mac16,1", "MacBook Pro (14-inch, 2024)" },
|
||||
{ "Mac16,6", "MacBook Pro (14-inch, 2024)" },
|
||||
{ "Mac16,8", "MacBook Pro (14-inch, 2024)" },
|
||||
{ "Mac16,7", "MacBook Pro (16-inch, 2024)" },
|
||||
{ "Mac16,5", "MacBook Pro (16-inch, 2024)" },
|
||||
{ "Mac16,15", "Mac mini (2024)" },
|
||||
{ "Mac16,10", "Mac mini (2024)" },
|
||||
{ "Mac15,13", "MacBook Air (15-inch, M3, 2024)" },
|
||||
{ "Mac15,2", "MacBook Air (13-inch, M3, 2024)" },
|
||||
{ "Mac15,3", "MacBook Pro (14-inch, Nov 2023)" },
|
||||
{ "Mac15,4", "iMac (24-inch, 2023)" },
|
||||
{ "Mac15,5", "iMac (24-inch, 2023)" },
|
||||
{ "Mac15,6", "MacBook Pro (14-inch, Nov 2023)" },
|
||||
{ "Mac15,8", "MacBook Pro (14-inch, Nov 2023)" },
|
||||
{ "Mac15,10", "MacBook Pro (14-inch, Nov 2023)" },
|
||||
{ "Mac15,7", "MacBook Pro (16-inch, Nov 2023)" },
|
||||
{ "Mac15,9", "MacBook Pro (16-inch, Nov 2023)" },
|
||||
{ "Mac15,11", "MacBook Pro (16-inch, Nov 2023)" },
|
||||
{ "Mac14,15", "MacBook Air (15-inch, M2, 2023)" },
|
||||
{ "Mac14,14", "Mac Studio (M2 Ultra, 2023)" },
|
||||
{ "Mac14,13", "Mac Studio (M2 Max, 2023)" },
|
||||
{ "Mac14,8", "Mac Pro (2023)" },
|
||||
{ "Mac14,6", "MacBook Pro (16-inch, 2023)" },
|
||||
{ "Mac14,10", "MacBook Pro (16-inch, 2023)" },
|
||||
{ "Mac14,5", "MacBook Pro (14-inch, 2023)" },
|
||||
{ "Mac14,9", "MacBook Pro (14-inch, 2023)" },
|
||||
{ "Mac14,3", "Mac mini (M2, 2023)" },
|
||||
{ "Mac14,12", "Mac mini (M2, 2023)" },
|
||||
{ "Mac14,7", "MacBook Pro (13-inch, M2, 2022)" },
|
||||
{ "Mac14,2", "MacBook Air (M2, 2022)" },
|
||||
{ "Mac13,1", "Mac Studio (M1 Max, 2022)" },
|
||||
{ "Mac13,2", "Mac Studio (M1 Ultra, 2022)" },
|
||||
|
||||
// iMac
|
||||
{ "iMac21,1", "iMac (24-inch, M1, 2021)" },
|
||||
{ "iMac21,2", "iMac (24-inch, M1, 2021)" },
|
||||
{ "iMac20,1", "iMac (27-inch, 2020)" },
|
||||
{ "iMac20,2", "iMac (27-inch, 2020)" },
|
||||
{ "iMac19,1", "iMac (27-inch, 2019)" },
|
||||
{ "iMac19,2", "iMac (21.5-inch, 2019)" },
|
||||
{ "iMacPro1,1", "iMac Pro (2017)" },
|
||||
{ "iMac18,3", "iMac (27-inch, 2017)" },
|
||||
{ "iMac18,2", "iMac (21.5-inch, 2017)" },
|
||||
{ "iMac18,1", "iMac (21.5-inch, 2017)" },
|
||||
{ "iMac17,1", "iMac (27-inch, 2015)" },
|
||||
{ "iMac16,2", "iMac (21.5-inch, 2015)" },
|
||||
{ "iMac16,1", "iMac (21.5-inch, 2015)" },
|
||||
{ "iMac15,1", "iMac (27-inch, 2014/2015)" },
|
||||
{ "iMac14,4", "iMac (21.5-inch, 2014)" },
|
||||
{ "iMac14,2", "iMac (27-inch, 2013)" },
|
||||
{ "iMac14,1", "iMac (21.5-inch, 2013)" },
|
||||
{ "iMac13,2", "iMac (27-inch, 2012)" },
|
||||
{ "iMac13,1", "iMac (21.5-inch, 2012)" },
|
||||
{ "iMac12,2", "iMac (27-inch, 2011)" },
|
||||
{ "iMac12,1", "iMac (21.5-inch, 2011)" },
|
||||
{ "iMac11,3", "iMac (27-inch, 2010)" },
|
||||
{ "iMac11,2", "iMac (21.5-inch, 2010)" },
|
||||
{ "iMac10,1", "iMac (27/21.5-inch, 2009)" },
|
||||
{ "iMac9,1", "iMac (24/20-inch, 2009)" },
|
||||
};
|
||||
|
||||
return modelNameByHwModel[hwModel.data()];
|
||||
}
|
||||
|
||||
// returns free/total
|
||||
fn GetDiskUsage() -> std::pair<u64, u64> {
|
||||
struct statvfs vfs;
|
||||
|
||||
if (statvfs("/", &vfs) != 0)
|
||||
return { 0, 0 };
|
||||
|
||||
return { (vfs.f_blocks - vfs.f_bfree) * vfs.f_frsize, vfs.f_blocks * vfs.f_frsize };
|
||||
}
|
||||
|
||||
fn GetShell() -> string { return ""; }
|
||||
|
||||
#endif
|
||||
|
|
@ -1,27 +0,0 @@
|
|||
#pragma once
|
||||
|
||||
#ifdef __APPLE__
|
||||
|
||||
#include <expected>
|
||||
#include <string>
|
||||
|
||||
#include "../../util/macros.h"
|
||||
|
||||
#ifdef __OBJC__
|
||||
|
||||
#import <Foundation/Foundation.h>
|
||||
|
||||
@interface Bridge : NSObject
|
||||
+ (void)fetchCurrentPlayingMetadata:(void (^)(std::expected<NSDictionary*, const char*>))completion;
|
||||
+ (std::expected<string, string>)macOSVersion;
|
||||
@end
|
||||
|
||||
#else
|
||||
|
||||
extern "C++" {
|
||||
fn GetCurrentPlayingInfo() -> std::expected<std::string, NowPlayingError>;
|
||||
fn GetMacOSVersion() -> std::expected<std::string, const char*>;
|
||||
}
|
||||
|
||||
#endif
|
||||
#endif
|
||||
|
|
@ -1,121 +0,0 @@
|
|||
#ifdef __APPLE__
|
||||
|
||||
#import <dispatch/dispatch.h>
|
||||
#include <expected>
|
||||
#import <objc/runtime.h>
|
||||
#include <string>
|
||||
|
||||
#import "bridge.h"
|
||||
|
||||
using MRMediaRemoteGetNowPlayingInfoFunction =
|
||||
void (*)(dispatch_queue_t queue, void (^handler)(NSDictionary* information));
|
||||
|
||||
@implementation Bridge
|
||||
+ (void)fetchCurrentPlayingMetadata:(void (^)(std::expected<NSDictionary*, const char*>))completion {
|
||||
CFURLRef ref = CFURLCreateWithFileSystemPath(
|
||||
kCFAllocatorDefault, CFSTR("/System/Library/PrivateFrameworks/MediaRemote.framework"), kCFURLPOSIXPathStyle, false
|
||||
);
|
||||
|
||||
if (!ref) {
|
||||
completion(std::unexpected("Failed to create CFURL for MediaRemote framework"));
|
||||
return;
|
||||
}
|
||||
|
||||
CFBundleRef bundle = CFBundleCreate(kCFAllocatorDefault, ref);
|
||||
CFRelease(ref);
|
||||
|
||||
if (!bundle) {
|
||||
completion(std::unexpected("Failed to create bundle for MediaRemote framework"));
|
||||
return;
|
||||
}
|
||||
|
||||
auto mrMediaRemoteGetNowPlayingInfo = std::bit_cast<MRMediaRemoteGetNowPlayingInfoFunction>(
|
||||
CFBundleGetFunctionPointerForName(bundle, CFSTR("MRMediaRemoteGetNowPlayingInfo"))
|
||||
);
|
||||
|
||||
if (!mrMediaRemoteGetNowPlayingInfo) {
|
||||
CFRelease(bundle);
|
||||
completion(std::unexpected("Failed to get MRMediaRemoteGetNowPlayingInfo function pointer"));
|
||||
return;
|
||||
}
|
||||
|
||||
mrMediaRemoteGetNowPlayingInfo(
|
||||
dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0),
|
||||
^(NSDictionary* information) {
|
||||
NSDictionary* nowPlayingInfo = information; // Immutable, no copy needed
|
||||
CFRelease(bundle);
|
||||
completion(
|
||||
nowPlayingInfo ? std::expected<NSDictionary*, const char*>(nowPlayingInfo)
|
||||
: std::unexpected("No now playing information")
|
||||
);
|
||||
}
|
||||
);
|
||||
}
|
||||
|
||||
+ (std::expected<string, string>)macOSVersion {
|
||||
NSProcessInfo* processInfo = [NSProcessInfo processInfo];
|
||||
NSOperatingSystemVersion osVersion = [processInfo operatingSystemVersion];
|
||||
|
||||
NSString* versionNumber = nil;
|
||||
if (osVersion.patchVersion == 0) {
|
||||
versionNumber = [NSString stringWithFormat:@"%ld.%ld", osVersion.majorVersion, osVersion.minorVersion];
|
||||
} else {
|
||||
versionNumber = [NSString
|
||||
stringWithFormat:@"%ld.%ld.%ld", osVersion.majorVersion, osVersion.minorVersion, osVersion.patchVersion];
|
||||
}
|
||||
|
||||
NSDictionary* versionNames =
|
||||
@{ @11 : @"Big Sur", @12 : @"Monterey", @13 : @"Ventura", @14 : @"Sonoma", @15 : @"Sequoia" };
|
||||
|
||||
NSNumber* majorVersion = @(osVersion.majorVersion);
|
||||
NSString* versionName = versionNames[majorVersion] ? versionNames[majorVersion] : @"Unknown";
|
||||
|
||||
NSString* fullVersion = [NSString stringWithFormat:@"macOS %@ %@", versionNumber, versionName];
|
||||
return std::string([fullVersion UTF8String]);
|
||||
}
|
||||
@end
|
||||
|
||||
extern "C++" {
|
||||
// NOLINTBEGIN(misc-use-internal-linkage)
|
||||
fn GetCurrentPlayingInfo() -> std::expected<std::string, NowPlayingError> {
|
||||
__block std::expected<std::string, NowPlayingError> result;
|
||||
dispatch_semaphore_t semaphore = dispatch_semaphore_create(0);
|
||||
|
||||
[Bridge fetchCurrentPlayingMetadata:^(std::expected<NSDictionary*, const char*> metadataResult) {
|
||||
if (!metadataResult) {
|
||||
result = std::unexpected(NowPlayingError { metadataResult.error() });
|
||||
dispatch_semaphore_signal(semaphore);
|
||||
return;
|
||||
}
|
||||
|
||||
NSDictionary* metadata = *metadataResult;
|
||||
if (!metadata) {
|
||||
result = std::unexpected(NowPlayingError { NowPlayingCode::NoPlayers });
|
||||
dispatch_semaphore_signal(semaphore);
|
||||
return;
|
||||
}
|
||||
|
||||
NSString* title = [metadata objectForKey:@"kMRMediaRemoteNowPlayingInfoTitle"];
|
||||
NSString* artist = [metadata objectForKey:@"kMRMediaRemoteNowPlayingInfoArtist"];
|
||||
|
||||
if (!title && !artist)
|
||||
result = std::unexpected("No metadata");
|
||||
else if (!title)
|
||||
result = std::string([artist UTF8String]);
|
||||
else if (!artist)
|
||||
result = std::string([title UTF8String]);
|
||||
else
|
||||
result = std::string([[NSString stringWithFormat:@"%@ - %@", title, artist] UTF8String]);
|
||||
|
||||
dispatch_semaphore_signal(semaphore);
|
||||
}];
|
||||
|
||||
dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
|
||||
return result;
|
||||
}
|
||||
|
||||
fn GetMacOSVersion() -> std::expected<string, string> { return [Bridge macOSVersion]; }
|
||||
// NOLINTEND(misc-use-internal-linkage)
|
||||
}
|
||||
|
||||
#endif
|
||||
59
src/os/os.h
59
src/os/os.h
|
|
@ -1,59 +0,0 @@
|
|||
#pragma once
|
||||
|
||||
#include <expected>
|
||||
|
||||
#include "../util/macros.h"
|
||||
#include "../util/types.h"
|
||||
|
||||
using std::optional, std::expected;
|
||||
|
||||
/**
|
||||
* @brief Get the amount of installed RAM in bytes.
|
||||
*/
|
||||
fn GetMemInfo() -> expected<u64, string>;
|
||||
|
||||
/**
|
||||
* @brief Get the currently playing song metadata.
|
||||
*/
|
||||
fn GetNowPlaying() -> expected<string, NowPlayingError>;
|
||||
|
||||
/**
|
||||
* @brief Get the OS version.
|
||||
*/
|
||||
fn GetOSVersion() -> expected<string, string>;
|
||||
|
||||
/**
|
||||
* @brief Get the current desktop environment.
|
||||
*/
|
||||
fn GetDesktopEnvironment() -> optional<string>;
|
||||
|
||||
/**
|
||||
* @brief Get the current window manager.
|
||||
*/
|
||||
fn GetWindowManager() -> string;
|
||||
|
||||
/**
|
||||
* @brief Get the current shell.
|
||||
*/
|
||||
fn GetShell() -> string;
|
||||
|
||||
/**
|
||||
* @brief Get the product family
|
||||
*/
|
||||
fn GetHost() -> string;
|
||||
|
||||
/**
|
||||
* @brief Get the kernel version.
|
||||
*/
|
||||
fn GetKernelVersion() -> string;
|
||||
|
||||
/**
|
||||
* @brief Get the number of installed packages.
|
||||
*/
|
||||
fn GetPackageCount() -> u64;
|
||||
|
||||
/**
|
||||
* @brief Get the current disk usage.
|
||||
* @return std::pair<u64, u64> Used space/total space
|
||||
*/
|
||||
fn GetDiskUsage() -> std::pair<u64, u64>;
|
||||
|
|
@ -1,471 +0,0 @@
|
|||
#include <ranges>
|
||||
#ifdef _WIN32
|
||||
|
||||
// clang-format off
|
||||
#define WIN32_LEAN_AND_MEAN
|
||||
#include <windows.h>
|
||||
#include <wincrypt.h>
|
||||
#include <dwmapi.h>
|
||||
#include <tlhelp32.h>
|
||||
#include <algorithm>
|
||||
#include <vector>
|
||||
#include <cstring>
|
||||
// clang-format on
|
||||
|
||||
#include <guiddef.h>
|
||||
#include <winrt/Windows.Foundation.h>
|
||||
#include <winrt/Windows.Media.Control.h>
|
||||
#include <winrt/Windows.Storage.h>
|
||||
#include <winrt/Windows.System.Diagnostics.h>
|
||||
#include <winrt/base.h>
|
||||
#include <winrt/impl/Windows.Media.Control.2.h>
|
||||
|
||||
#include "os.h"
|
||||
|
||||
using std::string_view;
|
||||
using RtlGetVersionPtr = NTSTATUS(WINAPI*)(PRTL_OSVERSIONINFOW);
|
||||
|
||||
// NOLINTBEGIN(*-pro-type-cstyle-cast,*-no-int-to-ptr,*-pro-type-reinterpret-cast)
|
||||
namespace {
|
||||
class ProcessSnapshot {
|
||||
public:
|
||||
ProcessSnapshot() : h_snapshot(CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0)) {}
|
||||
|
||||
ProcessSnapshot(ProcessSnapshot&&) = delete;
|
||||
ProcessSnapshot(const ProcessSnapshot&) = delete;
|
||||
fn operator=(ProcessSnapshot&&)->ProcessSnapshot& = delete;
|
||||
fn operator=(const ProcessSnapshot&)->ProcessSnapshot& = delete;
|
||||
|
||||
~ProcessSnapshot() {
|
||||
if (h_snapshot != INVALID_HANDLE_VALUE)
|
||||
CloseHandle(h_snapshot);
|
||||
}
|
||||
|
||||
[[nodiscard]] fn isValid() const -> bool { return h_snapshot != INVALID_HANDLE_VALUE; }
|
||||
|
||||
[[nodiscard]] fn getProcesses() const -> std::vector<std::pair<DWORD, string>> {
|
||||
std::vector<std::pair<DWORD, string>> processes;
|
||||
|
||||
if (!isValid())
|
||||
return processes;
|
||||
|
||||
PROCESSENTRY32 pe32;
|
||||
pe32.dwSize = sizeof(PROCESSENTRY32);
|
||||
|
||||
if (!Process32First(h_snapshot, &pe32))
|
||||
return processes;
|
||||
|
||||
// Get first process
|
||||
if (Process32First(h_snapshot, &pe32)) {
|
||||
// Add first process to vector
|
||||
processes.emplace_back(pe32.th32ProcessID, string(reinterpret_cast<const char*>(pe32.szExeFile)));
|
||||
|
||||
// Add remaining processes
|
||||
while (Process32Next(h_snapshot, &pe32))
|
||||
processes.emplace_back(pe32.th32ProcessID, string(reinterpret_cast<const char*>(pe32.szExeFile)));
|
||||
}
|
||||
|
||||
return processes;
|
||||
}
|
||||
|
||||
HANDLE h_snapshot;
|
||||
};
|
||||
|
||||
fn GetRegistryValue(const HKEY& hKey, const string& subKey, const string& valueName) -> string {
|
||||
HKEY key = nullptr;
|
||||
if (RegOpenKeyExA(hKey, subKey.c_str(), 0, KEY_READ, &key) != ERROR_SUCCESS)
|
||||
return "";
|
||||
|
||||
DWORD dataSize = 0;
|
||||
DWORD type = 0;
|
||||
if (RegQueryValueExA(key, valueName.c_str(), nullptr, &type, nullptr, &dataSize) != ERROR_SUCCESS) {
|
||||
RegCloseKey(key);
|
||||
return "";
|
||||
}
|
||||
|
||||
// For string values, allocate one less byte to avoid the null terminator
|
||||
string value((type == REG_SZ || type == REG_EXPAND_SZ) ? dataSize - 1 : dataSize, '\0');
|
||||
|
||||
if (RegQueryValueExA(key, valueName.c_str(), nullptr, nullptr, std::bit_cast<LPBYTE>(value.data()), &dataSize) !=
|
||||
ERROR_SUCCESS) {
|
||||
RegCloseKey(key);
|
||||
return "";
|
||||
}
|
||||
|
||||
RegCloseKey(key);
|
||||
return value;
|
||||
}
|
||||
|
||||
fn GetProcessInfo() -> std::vector<std::pair<DWORD, string>> {
|
||||
const ProcessSnapshot snapshot;
|
||||
return snapshot.isValid() ? snapshot.getProcesses() : std::vector<std::pair<DWORD, string>> {};
|
||||
}
|
||||
|
||||
fn IsProcessRunning(const std::vector<string>& processes, const string& name) -> bool {
|
||||
return std::ranges::any_of(processes, [&name](const string& proc) -> bool {
|
||||
return _stricmp(proc.c_str(), name.c_str()) == 0;
|
||||
});
|
||||
}
|
||||
|
||||
fn GetParentProcessId(const DWORD pid) -> DWORD {
|
||||
const ProcessSnapshot snapshot;
|
||||
if (!snapshot.isValid())
|
||||
return 0;
|
||||
|
||||
PROCESSENTRY32 pe32;
|
||||
pe32.dwSize = sizeof(PROCESSENTRY32);
|
||||
|
||||
if (!Process32First(snapshot.h_snapshot, &pe32))
|
||||
return 0;
|
||||
|
||||
if (pe32.th32ProcessID == pid)
|
||||
return pe32.th32ParentProcessID;
|
||||
|
||||
while (Process32Next(snapshot.h_snapshot, &pe32))
|
||||
if (pe32.th32ProcessID == pid)
|
||||
return pe32.th32ParentProcessID;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
fn GetProcessName(const DWORD pid) -> string {
|
||||
const ProcessSnapshot snapshot;
|
||||
if (!snapshot.isValid())
|
||||
return "";
|
||||
|
||||
PROCESSENTRY32 pe32;
|
||||
pe32.dwSize = sizeof(PROCESSENTRY32);
|
||||
|
||||
if (!Process32First(snapshot.h_snapshot, &pe32))
|
||||
return "";
|
||||
|
||||
if (pe32.th32ProcessID == pid)
|
||||
return reinterpret_cast<const char*>(pe32.szExeFile);
|
||||
|
||||
while (Process32Next(snapshot.h_snapshot, &pe32))
|
||||
if (pe32.th32ProcessID == pid)
|
||||
return reinterpret_cast<const char*>(pe32.szExeFile);
|
||||
|
||||
return "";
|
||||
}
|
||||
}
|
||||
|
||||
fn GetMemInfo() -> expected<u64, string> {
|
||||
try {
|
||||
using namespace winrt::Windows::System::Diagnostics;
|
||||
const SystemDiagnosticInfo diag = SystemDiagnosticInfo::GetForCurrentSystem();
|
||||
return diag.MemoryUsage().GetReport().TotalPhysicalSizeInBytes();
|
||||
} catch (const winrt::hresult_error& e) {
|
||||
return std::unexpected("Failed to get memory info: " + to_string(e.message()));
|
||||
}
|
||||
}
|
||||
|
||||
fn GetNowPlaying() -> expected<string, NowPlayingError> {
|
||||
using namespace winrt::Windows::Media::Control;
|
||||
using namespace winrt::Windows::Foundation;
|
||||
|
||||
using MediaProperties = GlobalSystemMediaTransportControlsSessionMediaProperties;
|
||||
using Session = GlobalSystemMediaTransportControlsSession;
|
||||
using SessionManager = GlobalSystemMediaTransportControlsSessionManager;
|
||||
|
||||
try {
|
||||
// Request the session manager asynchronously
|
||||
const IAsyncOperation<SessionManager> sessionManagerOp = SessionManager::RequestAsync();
|
||||
const SessionManager sessionManager = sessionManagerOp.get();
|
||||
|
||||
if (const Session currentSession = sessionManager.GetCurrentSession()) {
|
||||
// Try to get the media properties asynchronously
|
||||
const MediaProperties mediaProperties = currentSession.TryGetMediaPropertiesAsync().get();
|
||||
|
||||
// Convert the hstring title to string
|
||||
return to_string(mediaProperties.Title());
|
||||
}
|
||||
|
||||
// If we reach this point, there is no current session
|
||||
return std::unexpected(NowPlayingError { NowPlayingCode::NoActivePlayer });
|
||||
} catch (const winrt::hresult_error& e) { return std::unexpected(NowPlayingError { e }); }
|
||||
}
|
||||
|
||||
fn GetOSVersion() -> expected<string, string> {
|
||||
// First try using the native Windows API
|
||||
constexpr OSVERSIONINFOEXW osvi = { sizeof(OSVERSIONINFOEXW), 0, 0, 0, 0, { 0 }, 0, 0, 0, 0, 0 };
|
||||
NTSTATUS status = 0;
|
||||
|
||||
// Get RtlGetVersion function from ntdll.dll (not affected by application manifest)
|
||||
if (const HMODULE ntdllHandle = GetModuleHandleW(L"ntdll.dll"))
|
||||
if (const auto rtlGetVersion = std::bit_cast<RtlGetVersionPtr>(GetProcAddress(ntdllHandle, "RtlGetVersion")))
|
||||
status = rtlGetVersion(std::bit_cast<PRTL_OSVERSIONINFOW>(&osvi));
|
||||
|
||||
string productName;
|
||||
string edition;
|
||||
|
||||
if (status == 0) { // STATUS_SUCCESS
|
||||
// We need to get the edition information which isn't available from version API
|
||||
// Use GetProductInfo which is available since Vista
|
||||
DWORD productType = 0;
|
||||
if (GetProductInfo(
|
||||
osvi.dwMajorVersion, osvi.dwMinorVersion, osvi.wServicePackMajor, osvi.wServicePackMinor, &productType
|
||||
)) {
|
||||
if (osvi.dwMajorVersion == 10) {
|
||||
if (osvi.dwBuildNumber >= 22000) {
|
||||
productName = "Windows 11";
|
||||
} else {
|
||||
productName = "Windows 10";
|
||||
}
|
||||
|
||||
switch (productType) {
|
||||
case PRODUCT_PROFESSIONAL:
|
||||
edition = " Pro";
|
||||
break;
|
||||
case PRODUCT_ENTERPRISE:
|
||||
edition = " Enterprise";
|
||||
break;
|
||||
case PRODUCT_EDUCATION:
|
||||
edition = " Education";
|
||||
break;
|
||||
case PRODUCT_HOME_BASIC:
|
||||
case PRODUCT_HOME_PREMIUM:
|
||||
edition = " Home";
|
||||
break;
|
||||
case PRODUCT_CLOUDEDITION:
|
||||
edition = " Cloud";
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
} else {
|
||||
// Fallback to registry method if the API approach fails
|
||||
productName =
|
||||
GetRegistryValue(HKEY_LOCAL_MACHINE, R"(SOFTWARE\Microsoft\Windows NT\CurrentVersion)", "ProductName");
|
||||
|
||||
// Check for Windows 11
|
||||
if (const i32 buildNumber = stoi(
|
||||
GetRegistryValue(HKEY_LOCAL_MACHINE, R"(SOFTWARE\Microsoft\Windows NT\CurrentVersion)", "CurrentBuildNumber")
|
||||
);
|
||||
buildNumber >= 22000 && productName.find("Windows 10") != string::npos)
|
||||
productName.replace(productName.find("Windows 10"), 10, "Windows 11");
|
||||
}
|
||||
|
||||
if (!productName.empty()) {
|
||||
string result = productName + edition;
|
||||
|
||||
const string displayVersion =
|
||||
GetRegistryValue(HKEY_LOCAL_MACHINE, R"(SOFTWARE\Microsoft\Windows NT\CurrentVersion)", "DisplayVersion");
|
||||
|
||||
if (!displayVersion.empty())
|
||||
result += " " + displayVersion;
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
return "Windows";
|
||||
}
|
||||
|
||||
fn GetHost() -> string {
|
||||
string hostName = GetRegistryValue(HKEY_LOCAL_MACHINE, R"(SYSTEM\HardwareConfig\Current)", "SystemFamily");
|
||||
|
||||
return hostName;
|
||||
}
|
||||
|
||||
fn GetKernelVersion() -> string {
|
||||
// ReSharper disable once CppLocalVariableMayBeConst
|
||||
if (HMODULE ntdllHandle = GetModuleHandleW(L"ntdll.dll")) {
|
||||
if (const auto rtlGetVersion = std::bit_cast<RtlGetVersionPtr>(GetProcAddress(ntdllHandle, "RtlGetVersion"))) {
|
||||
RTL_OSVERSIONINFOW osInfo = {};
|
||||
osInfo.dwOSVersionInfoSize = sizeof(osInfo);
|
||||
|
||||
if (rtlGetVersion(&osInfo) == 0) {
|
||||
return std::format(
|
||||
"{}.{}.{}.{}", osInfo.dwMajorVersion, osInfo.dwMinorVersion, osInfo.dwBuildNumber, osInfo.dwPlatformId
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return "";
|
||||
}
|
||||
|
||||
fn GetWindowManager() -> string {
|
||||
// Get process information once and reuse it
|
||||
const auto processInfo = GetProcessInfo();
|
||||
std::vector<string> processNames;
|
||||
|
||||
processNames.reserve(processInfo.size());
|
||||
for (const auto& name : processInfo | std::views::values) processNames.push_back(name);
|
||||
|
||||
// Check for third-party WMs using a map for cleaner code
|
||||
const std::unordered_map<string, string> wmProcesses = {
|
||||
{ "glazewm.exe", "GlazeWM" },
|
||||
{ "fancywm.exe", "FancyWM" },
|
||||
{ "komorebi.exe", "Komorebi" },
|
||||
{ "komorebic.exe", "Komorebi" }
|
||||
};
|
||||
|
||||
for (const auto& [processName, wmName] : wmProcesses) {
|
||||
if (IsProcessRunning(processNames, processName))
|
||||
return wmName;
|
||||
}
|
||||
|
||||
// Fallback to DWM detection
|
||||
BOOL compositionEnabled = FALSE;
|
||||
if (SUCCEEDED(DwmIsCompositionEnabled(&compositionEnabled)))
|
||||
return compositionEnabled ? "DWM" : "Windows Manager (Basic)";
|
||||
|
||||
return "Windows Manager";
|
||||
}
|
||||
|
||||
fn GetDesktopEnvironment() -> optional<string> {
|
||||
// Get version information from registry
|
||||
const string buildStr =
|
||||
GetRegistryValue(HKEY_LOCAL_MACHINE, R"(SOFTWARE\Microsoft\Windows NT\CurrentVersion)", "CurrentBuildNumber");
|
||||
|
||||
if (buildStr.empty()) {
|
||||
DEBUG_LOG("Failed to get CurrentBuildNumber from registry");
|
||||
return std::nullopt;
|
||||
}
|
||||
|
||||
try {
|
||||
const i32 build = stoi(buildStr);
|
||||
|
||||
// Windows 11+ (Fluent)
|
||||
if (build >= 22000)
|
||||
return "Fluent (Windows 11)";
|
||||
|
||||
// Windows 10 Fluent Era
|
||||
if (build >= 15063)
|
||||
return "Fluent (Windows 10)";
|
||||
|
||||
// Windows 8.1/10 Metro Era
|
||||
if (build >= 9200) { // Windows 8+
|
||||
// Distinguish between Windows 8 and 10
|
||||
const string productName =
|
||||
GetRegistryValue(HKEY_LOCAL_MACHINE, R"(SOFTWARE\Microsoft\Windows NT\CurrentVersion)", "ProductName");
|
||||
|
||||
if (productName.find("Windows 10") != string::npos)
|
||||
return "Metro (Windows 10)";
|
||||
|
||||
if (build >= 9600)
|
||||
return "Metro (Windows 8.1)";
|
||||
|
||||
return "Metro (Windows 8)";
|
||||
}
|
||||
|
||||
// Windows 7 Aero
|
||||
if (build >= 7600)
|
||||
return "Aero (Windows 7)";
|
||||
|
||||
// Older versions
|
||||
return "Classic";
|
||||
} catch (...) {
|
||||
DEBUG_LOG("Failed to parse CurrentBuildNumber");
|
||||
return std::nullopt;
|
||||
}
|
||||
}
|
||||
|
||||
fn GetShell() -> string {
|
||||
// Define known shells map once for reuse
|
||||
const std::unordered_map<string, string> knownShells = {
|
||||
{ "cmd.exe", "Command Prompt" },
|
||||
{ "powershell.exe", "PowerShell" },
|
||||
{ "pwsh.exe", "PowerShell Core" },
|
||||
{ "windowsterminal.exe", "Windows Terminal" },
|
||||
{ "mintty.exe", "Mintty" },
|
||||
{ "bash.exe", "Windows Subsystem for Linux" }
|
||||
};
|
||||
|
||||
// Detect MSYS2/MinGW shells
|
||||
char* msystemEnv = nullptr;
|
||||
if (_dupenv_s(&msystemEnv, nullptr, "MSYSTEM") == 0 && msystemEnv != nullptr) {
|
||||
const std::unique_ptr<char, decltype(&free)> msystemEnvGuard(msystemEnv, free);
|
||||
|
||||
// Get shell from environment variables
|
||||
char* shell = nullptr;
|
||||
size_t shellLen = 0;
|
||||
_dupenv_s(&shell, &shellLen, "SHELL");
|
||||
const std::unique_ptr<char, decltype(&free)> shellGuard(shell, free);
|
||||
|
||||
// If SHELL is empty, try LOGINSHELL
|
||||
if (!shell || strlen(shell) == 0) {
|
||||
char* loginShell = nullptr;
|
||||
size_t loginShellLen = 0;
|
||||
_dupenv_s(&loginShell, &loginShellLen, "LOGINSHELL");
|
||||
const std::unique_ptr<char, decltype(&free)> loginShellGuard(loginShell, free);
|
||||
shell = loginShell;
|
||||
}
|
||||
|
||||
if (shell) {
|
||||
string shellExe;
|
||||
const string shellPath = shell;
|
||||
const size_t lastSlash = shellPath.find_last_of("\\/");
|
||||
shellExe = (lastSlash != string::npos) ? shellPath.substr(lastSlash + 1) : shellPath;
|
||||
std::ranges::transform(shellExe, shellExe.begin(), ::tolower);
|
||||
|
||||
// Use a map for shell name lookup instead of multiple if statements
|
||||
const std::unordered_map<string_view, string> shellNames = {
|
||||
{ "bash", "Bash" },
|
||||
{ "zsh", "Zsh" },
|
||||
{ "fish", "Fish" }
|
||||
};
|
||||
|
||||
for (const auto& [pattern, name] : shellNames) {
|
||||
if (shellExe.find(pattern) != string::npos)
|
||||
return name;
|
||||
}
|
||||
|
||||
return shellExe.empty() ? "MSYS2" : "MSYS2/" + shellExe;
|
||||
}
|
||||
|
||||
// Fallback to process ancestry with cached process info
|
||||
const auto processInfo = GetProcessInfo();
|
||||
DWORD pid = GetCurrentProcessId();
|
||||
|
||||
while (pid != 0) {
|
||||
string processName = GetProcessName(pid);
|
||||
std::ranges::transform(processName, processName.begin(), ::tolower);
|
||||
|
||||
const std::unordered_map<string, string> msysShells = {
|
||||
{ "bash.exe", "Bash" },
|
||||
{ "zsh.exe", "Zsh" },
|
||||
{ "fish.exe", "Fish" },
|
||||
{ "mintty.exe", "Mintty" }
|
||||
};
|
||||
|
||||
for (const auto& [msysShellExe, shellName] : msysShells) {
|
||||
if (processName == msysShellExe)
|
||||
return shellName;
|
||||
}
|
||||
|
||||
pid = GetParentProcessId(pid);
|
||||
}
|
||||
|
||||
return "MSYS2";
|
||||
}
|
||||
|
||||
// Detect Windows shells
|
||||
DWORD pid = GetCurrentProcessId();
|
||||
while (pid != 0) {
|
||||
string processName = GetProcessName(pid);
|
||||
std::ranges::transform(processName, processName.begin(), ::tolower);
|
||||
|
||||
if (auto shellIterator = knownShells.find(processName); shellIterator != knownShells.end())
|
||||
return shellIterator->second;
|
||||
|
||||
pid = GetParentProcessId(pid);
|
||||
}
|
||||
|
||||
return "Windows Console";
|
||||
}
|
||||
|
||||
fn GetDiskUsage() -> std::pair<u64, u64> {
|
||||
ULARGE_INTEGER freeBytes, totalBytes;
|
||||
|
||||
if (GetDiskFreeSpaceExW(L"C:\\", nullptr, &totalBytes, &freeBytes))
|
||||
return { totalBytes.QuadPart - freeBytes.QuadPart, totalBytes.QuadPart };
|
||||
|
||||
return { 0, 0 };
|
||||
}
|
||||
// NOLINTEND(*-pro-type-cstyle-cast,*-no-int-to-ptr,*-pro-type-reinterpret-cast)
|
||||
|
||||
#endif
|
||||
|
|
@ -1,84 +0,0 @@
|
|||
#pragma once
|
||||
|
||||
// probably stupid but it fixes the issue with windows.h defining ERROR
|
||||
#undef ERROR
|
||||
|
||||
#include <filesystem>
|
||||
#include <fmt/chrono.h>
|
||||
#include <fmt/color.h>
|
||||
#include <fmt/format.h>
|
||||
#include <source_location>
|
||||
|
||||
#include "types.h"
|
||||
|
||||
#define fn auto // Rust-style function shorthand
|
||||
|
||||
namespace log_colors {
|
||||
using fmt::terminal_color;
|
||||
constexpr auto debug = terminal_color::cyan, info = terminal_color::green, warn = terminal_color::yellow,
|
||||
error = terminal_color::red, timestamp = terminal_color::bright_white,
|
||||
file_info = terminal_color::bright_white;
|
||||
}
|
||||
|
||||
enum class LogLevel : u8 { DEBUG, INFO, WARN, ERROR };
|
||||
|
||||
template <typename... Args>
|
||||
void LogImpl(const LogLevel level, const std::source_location& loc, fmt::format_string<Args...> fmt, Args&&... args) {
|
||||
const time_t now = std::time(nullptr);
|
||||
const auto [color, levelStr] = [&] {
|
||||
switch (level) {
|
||||
case LogLevel::DEBUG:
|
||||
return std::make_pair(log_colors::debug, "DEBUG");
|
||||
case LogLevel::INFO:
|
||||
return std::make_pair(log_colors::info, "INFO ");
|
||||
case LogLevel::WARN:
|
||||
return std::make_pair(log_colors::warn, "WARN ");
|
||||
case LogLevel::ERROR:
|
||||
return std::make_pair(log_colors::error, "ERROR");
|
||||
#pragma clang diagnostic push
|
||||
#pragma clang diagnostic ignored "-Wcovered-switch-default"
|
||||
default:
|
||||
std::unreachable();
|
||||
#pragma clang diagnostic pop
|
||||
}
|
||||
}();
|
||||
|
||||
const string filename = std::filesystem::path(loc.file_name()).lexically_normal().string();
|
||||
std::tm time;
|
||||
|
||||
#ifdef _WIN32
|
||||
if (localtime_s(&time, &now) != 0)
|
||||
throw std::runtime_error("localtime_s failed");
|
||||
#else
|
||||
if (localtime_r(&now, &time) == nullptr)
|
||||
throw std::runtime_error("localtime_r failed");
|
||||
#endif
|
||||
|
||||
// Timestamp and level
|
||||
fmt::print(fg(log_colors::timestamp), "[{:%H:%M:%S}] ", time);
|
||||
fmt::print(fmt::emphasis::bold | fg(color), "{} ", levelStr);
|
||||
|
||||
// Message
|
||||
fmt::print(fmt, std::forward<Args>(args)...);
|
||||
|
||||
// File info (debug builds only)
|
||||
#ifndef NDEBUG
|
||||
fmt::print(fg(log_colors::file_info), "\n{:>14} ", "╰──");
|
||||
fmt::print(fmt::emphasis::italic | fg(log_colors::file_info), "{}:{}", filename, loc.line());
|
||||
#endif
|
||||
|
||||
fmt::print("\n");
|
||||
}
|
||||
|
||||
#pragma clang diagnostic push
|
||||
#pragma clang diagnostic ignored "-Wunused-macros"
|
||||
#ifdef NDEBUG
|
||||
#define DEBUG_LOG(...) static_cast<void>(0)
|
||||
#else
|
||||
#define DEBUG_LOG(...) LogImpl(LogLevel::DEBUG, std::source_location::current(), __VA_ARGS__)
|
||||
#endif
|
||||
|
||||
#define INFO_LOG(...) LogImpl(LogLevel::INFO, std::source_location::current(), __VA_ARGS__)
|
||||
#define WARN_LOG(...) LogImpl(LogLevel::WARN, std::source_location::current(), __VA_ARGS__)
|
||||
#define ERROR_LOG(...) LogImpl(LogLevel::ERROR, std::source_location::current(), __VA_ARGS__)
|
||||
#pragma clang diagnostic pop
|
||||
203
src/util/types.h
203
src/util/types.h
|
|
@ -1,203 +0,0 @@
|
|||
#pragma once
|
||||
|
||||
#include <cstddef>
|
||||
#include <cstdint>
|
||||
#include <string>
|
||||
|
||||
#ifdef _WIN32
|
||||
#include <expected>
|
||||
// ReSharper disable once CppUnusedIncludeDirective
|
||||
#include <guiddef.h>
|
||||
#include <variant>
|
||||
#include <winrt/base.h>
|
||||
#else
|
||||
#include <variant>
|
||||
#endif
|
||||
|
||||
/**
|
||||
* @typedef u8
|
||||
* @brief Represents an 8-bit unsigned integer.
|
||||
*
|
||||
* This type alias is used for 8-bit unsigned integers, ranging from 0 to 255.
|
||||
* It is based on the std::uint8_t type.
|
||||
*/
|
||||
using u8 = std::uint8_t;
|
||||
|
||||
/**
|
||||
* @typedef u16
|
||||
* @brief Represents a 16-bit unsigned integer.
|
||||
*
|
||||
* This type alias is used for 16-bit unsigned integers, ranging from 0 to 65,535.
|
||||
* It is based on the std::uint16_t type.
|
||||
*/
|
||||
using u16 = std::uint16_t;
|
||||
|
||||
/**
|
||||
* @typedef u32
|
||||
* @brief Represents a 32-bit unsigned integer.
|
||||
*
|
||||
* This type alias is used for 32-bit unsigned integers, ranging from 0 to 4,294,967,295.
|
||||
* It is based on the std::uint32_t type.
|
||||
*/
|
||||
using u32 = std::uint32_t;
|
||||
|
||||
/**
|
||||
* @typedef u64
|
||||
* @brief Represents a 64-bit unsigned integer.
|
||||
*
|
||||
* This type alias is used for 64-bit unsigned integers, ranging from 0 to
|
||||
* 18,446,744,073,709,551,615. It is based on the std::uint64_t type.
|
||||
*/
|
||||
using u64 = std::uint64_t;
|
||||
|
||||
// Type Aliases for Signed Integers
|
||||
|
||||
/**
|
||||
* @typedef i8
|
||||
* @brief Represents an 8-bit signed integer.
|
||||
*
|
||||
* This type alias is used for 8-bit signed integers, ranging from -128 to 127.
|
||||
* It is based on the std::int8_t type.
|
||||
*/
|
||||
using i8 = std::int8_t;
|
||||
|
||||
/**
|
||||
* @typedef i16
|
||||
* @brief Represents a 16-bit signed integer.
|
||||
*
|
||||
* This type alias is used for 16-bit signed integers, ranging from -32,768 to 32,767.
|
||||
* It is based on the std::int16_t type.
|
||||
*/
|
||||
using i16 = std::int16_t;
|
||||
|
||||
/**
|
||||
* @typedef i32
|
||||
* @brief Represents a 32-bit signed integer.
|
||||
*
|
||||
* This type alias is used for 32-bit signed integers, ranging from -2,147,483,648 to 2,147,483,647.
|
||||
* It is based on the std::int32_t type.
|
||||
*/
|
||||
using i32 = std::int32_t;
|
||||
|
||||
/**
|
||||
* @typedef i64
|
||||
* @brief Represents a 64-bit signed integer.
|
||||
*
|
||||
* This type alias is used for 64-bit signed integers, ranging from -9,223,372,036,854,775,808 to
|
||||
* 9,223,372,036,854,775,807. It is based on the std::int64_t type.
|
||||
*/
|
||||
using i64 = std::int64_t;
|
||||
|
||||
// Type Aliases for Floating-Point Numbers
|
||||
|
||||
/**
|
||||
* @typedef f32
|
||||
* @brief Represents a 32-bit floating-point number.
|
||||
*
|
||||
* This type alias is used for 32-bit floating-point numbers, which follow the IEEE 754 standard.
|
||||
* It is based on the float type.
|
||||
*/
|
||||
using f32 = float;
|
||||
|
||||
/**
|
||||
* @typedef f64
|
||||
* @brief Represents a 64-bit floating-point number.
|
||||
*
|
||||
* This type alias is used for 64-bit floating-point numbers, which follow the IEEE 754 standard.
|
||||
* It is based on the double type.
|
||||
*/
|
||||
using f64 = double;
|
||||
|
||||
// Type Aliases for Size Types
|
||||
|
||||
/**
|
||||
* @typedef usize
|
||||
* @brief Represents an unsigned size type.
|
||||
*
|
||||
* This type alias is used for representing the size of objects in bytes.
|
||||
* It is based on the std::size_t type, which is the result type of the sizeof operator.
|
||||
*/
|
||||
using usize = std::size_t;
|
||||
|
||||
/**
|
||||
* @typedef isize
|
||||
* @brief Represents a signed size type.
|
||||
*
|
||||
* This type alias is used for representing pointer differences.
|
||||
* It is based on the std::ptrdiff_t type, which is the signed integer type returned when
|
||||
* subtracting two pointers.
|
||||
*/
|
||||
using isize = std::ptrdiff_t;
|
||||
|
||||
/**
|
||||
* @typedef string
|
||||
* @brief Represents a string.
|
||||
*/
|
||||
using string = std::string;
|
||||
|
||||
/**
|
||||
* @enum NowPlayingCode
|
||||
* @brief Represents error codes for Now Playing functionality.
|
||||
*/
|
||||
enum class NowPlayingCode : u8 {
|
||||
NoPlayers,
|
||||
NoActivePlayer,
|
||||
};
|
||||
|
||||
// Platform-specific error details
|
||||
#ifdef __linux__
|
||||
/**
|
||||
* @typedef LinuxError
|
||||
* @brief Represents a Linux-specific error.
|
||||
*/
|
||||
using LinuxError = std::string;
|
||||
#elif defined(__APPLE__)
|
||||
/**
|
||||
* @typedef MacError
|
||||
* @brief Represents a macOS-specific error.
|
||||
*/
|
||||
using MacError = std::string;
|
||||
#elif defined(_WIN32)
|
||||
/**
|
||||
* @typedef WindowsError
|
||||
* @brief Represents a Windows-specific error.
|
||||
*/
|
||||
using WindowsError = winrt::hresult_error;
|
||||
#endif
|
||||
|
||||
// Unified error type
|
||||
using NowPlayingError = std::variant<
|
||||
NowPlayingCode,
|
||||
#ifdef __linux__
|
||||
LinuxError
|
||||
#elif defined(__APPLE__)
|
||||
MacError
|
||||
#elif defined(_WIN32)
|
||||
WindowsError
|
||||
#endif
|
||||
>;
|
||||
|
||||
enum class EnvError : u8 { NotFound, AccessError };
|
||||
|
||||
inline auto GetEnv(const std::string& name) -> std::expected<std::string, EnvError> {
|
||||
#ifdef _WIN32
|
||||
char* rawPtr = nullptr;
|
||||
size_t bufferSize = 0;
|
||||
|
||||
if (_dupenv_s(&rawPtr, &bufferSize, name.c_str()) != 0)
|
||||
return std::unexpected(EnvError::AccessError);
|
||||
|
||||
if (!rawPtr)
|
||||
return std::unexpected(EnvError::NotFound);
|
||||
|
||||
const std::string result(rawPtr);
|
||||
free(rawPtr);
|
||||
return result;
|
||||
#else
|
||||
const char* value = std::getenv(name.c_str());
|
||||
if (!value)
|
||||
return std::unexpected(EnvError::NotFound);
|
||||
|
||||
return std::string(value);
|
||||
#endif
|
||||
}
|
||||
|
|
@ -1,13 +0,0 @@
|
|||
[wrap-file]
|
||||
directory = curl-8.10.1
|
||||
source_url = https://github.com/curl/curl/releases/download/curl-8_10_1/curl-8.10.1.tar.xz
|
||||
source_fallback_url = https://github.com/mesonbuild/wrapdb/releases/download/curl_8.10.1-1/curl-8.10.1.tar.xz
|
||||
source_filename = curl-8.10.1.tar.xz
|
||||
source_hash = 73a4b0e99596a09fa5924a4fb7e4b995a85fda0d18a2c02ab9cf134bebce04ee
|
||||
patch_filename = curl_8.10.1-1_patch.zip
|
||||
patch_url = https://wrapdb.mesonbuild.com/v2/curl_8.10.1-1/get_patch
|
||||
patch_hash = 707c28f35fc9b0e8d68c0c2800712007612f922a31da9637ce706a2159f3ddd8
|
||||
wrapdb_version = 8.10.1-1
|
||||
|
||||
[provide]
|
||||
dependency_names = libcurl
|
||||
|
|
@ -1,13 +0,0 @@
|
|||
[wrap-file]
|
||||
directory = fmt-11.1.1
|
||||
source_url = https://github.com/fmtlib/fmt/archive/11.1.1.tar.gz
|
||||
source_filename = fmt-11.1.1.tar.gz
|
||||
source_hash = 482eed9efbc98388dbaee5cb5f368be5eca4893456bb358c18b7ff71f835ae43
|
||||
patch_filename = fmt_11.1.1-2_patch.zip
|
||||
patch_url = https://wrapdb.mesonbuild.com/v2/fmt_11.1.1-2/get_patch
|
||||
patch_hash = eee2e90d5d43061a0a1f0b9f8eb188c5b8820ef3e1b15e4b8a4eb791ef82b325
|
||||
source_fallback_url = https://github.com/mesonbuild/wrapdb/releases/download/fmt_11.1.1-2/fmt-11.1.1.tar.gz
|
||||
wrapdb_version = 11.1.1-2
|
||||
|
||||
[provide]
|
||||
fmt = fmt_dep
|
||||
|
|
@ -1,15 +0,0 @@
|
|||
[wrap-file]
|
||||
directory = FTXUI-5.0.0
|
||||
source_url = https://github.com/ArthurSonzogni/FTXUI/archive/refs/tags/v5.0.0.tar.gz
|
||||
source_filename = FTXUI-5.0.0.tar.gz
|
||||
source_hash = a2991cb222c944aee14397965d9f6b050245da849d8c5da7c72d112de2786b5b
|
||||
patch_filename = ftxui_5.0.0-1_patch.zip
|
||||
patch_url = https://wrapdb.mesonbuild.com/v2/ftxui_5.0.0-1/get_patch
|
||||
patch_hash = 21c654e82739b90b95bd98c1d321264608d37c50d29fbcc3487f790fd5412909
|
||||
source_fallback_url = https://github.com/mesonbuild/wrapdb/releases/download/ftxui_5.0.0-1/FTXUI-5.0.0.tar.gz
|
||||
wrapdb_version = 5.0.0-1
|
||||
|
||||
[provide]
|
||||
ftxui-screen = screen_dep
|
||||
ftxui-dom = dom_dep
|
||||
ftxui-component = component_dep
|
||||
|
|
@ -1 +0,0 @@
|
|||
Subproject commit bad0345d6358a649d5f72e90ada2be75d04b75cd
|
||||
|
|
@ -1,15 +0,0 @@
|
|||
[wrap-file]
|
||||
directory = openssl-3.0.8
|
||||
source_url = https://www.openssl.org/source/openssl-3.0.8.tar.gz
|
||||
source_filename = openssl-3.0.8.tar.gz
|
||||
source_hash = 6c13d2bf38fdf31eac3ce2a347073673f5d63263398f1f69d0df4a41253e4b3e
|
||||
patch_filename = openssl_3.0.8-3_patch.zip
|
||||
patch_url = https://wrapdb.mesonbuild.com/v2/openssl_3.0.8-3/get_patch
|
||||
patch_hash = 300da189e106942347d61a4a4295aa2edbcf06184f8d13b4cee0bed9fb936963
|
||||
source_fallback_url = https://github.com/mesonbuild/wrapdb/releases/download/openssl_3.0.8-3/openssl-3.0.8.tar.gz
|
||||
wrapdb_version = 3.0.8-3
|
||||
|
||||
[provide]
|
||||
libcrypto = libcrypto_dep
|
||||
libssl = libssl_dep
|
||||
openssl = openssl_dep
|
||||
|
|
@ -1,10 +0,0 @@
|
|||
[wrap-file]
|
||||
directory = SQLiteCpp-3.3.2
|
||||
source_url = https://github.com/SRombauts/SQLiteCpp/archive/refs/tags/3.3.2.zip
|
||||
source_filename = sqlitecpp-3.3.2.zip
|
||||
source_hash = 1f41ef7322da573fdfca95655bd1329282638b4d9d3dc16a48f4bad16008eda8
|
||||
source_fallback_url = https://github.com/mesonbuild/wrapdb/releases/download/sqlitecpp_3.3.2-1/sqlitecpp-3.3.2.zip
|
||||
wrapdb_version = 3.3.2-1
|
||||
|
||||
[provide]
|
||||
sqlitecpp = sqlitecpp_dep
|
||||
|
|
@ -1,10 +0,0 @@
|
|||
[wrap-file]
|
||||
directory = tomlplusplus-3.4.0
|
||||
source_url = https://github.com/marzer/tomlplusplus/archive/v3.4.0.tar.gz
|
||||
source_filename = tomlplusplus-3.4.0.tar.gz
|
||||
source_hash = 8517f65938a4faae9ccf8ebb36631a38c1cadfb5efa85d9a72e15b9e97d25155
|
||||
source_fallback_url = https://github.com/mesonbuild/wrapdb/releases/download/tomlplusplus_3.4.0-1/tomlplusplus-3.4.0.tar.gz
|
||||
wrapdb_version = 3.4.0-1
|
||||
|
||||
[provide]
|
||||
dependency_names = tomlplusplus
|
||||
23
util.h
Normal file
23
util.h
Normal file
|
|
@ -0,0 +1,23 @@
|
|||
#pragma once
|
||||
|
||||
#include <cstdint>
|
||||
|
||||
// Unsigned integers
|
||||
using u8 = std::uint8_t;
|
||||
using u16 = std::uint16_t;
|
||||
using u32 = std::uint32_t;
|
||||
using u64 = std::uint64_t;
|
||||
|
||||
// Signed integers
|
||||
using i8 = std::int8_t;
|
||||
using i16 = std::int16_t;
|
||||
using i32 = std::int32_t;
|
||||
using i64 = std::int64_t;
|
||||
|
||||
// Floating-points
|
||||
using f32 = float;
|
||||
using f64 = double;
|
||||
|
||||
// Size types
|
||||
using usize = std::size_t;
|
||||
using isize = std::ptrdiff_t;
|
||||
12
vcpkg.json
Normal file
12
vcpkg.json
Normal file
|
|
@ -0,0 +1,12 @@
|
|||
{
|
||||
"name" : "draconispp",
|
||||
"version-string" : "1.0.0",
|
||||
"builtin-baseline" : "14b91796a68c87bc8d5cb35911b39287ccb7bd95",
|
||||
"dependencies" : [ {
|
||||
"name" : "fmt",
|
||||
"version>=" : "10.2.1#2"
|
||||
}, {
|
||||
"name" : "cppwinrt",
|
||||
"version>=" : "2.0.240111.5"
|
||||
} ]
|
||||
}
|
||||
Loading…
Add table
Reference in a new issue