text stringlengths 14 100k | source stringclasses 1
value | repo stringclasses 810
values | language stringclasses 13
values |
|---|---|---|---|
<|fim_suffix|>aybar::modules::cava
<|fim_prefix|>#pragma once
#ifdef HAVE_LIBCAVA
#include "cavaRaw.hpp"
#include "cava_backend.hpp"
#ifdef HAVE_LIBCAVAGLSL
#include "cavaGLSL.hpp"
#endif
#endif
namespace waybar::modules::cava {
AModule* getModule(const std::string& id, const Jso<|fim_middle|>n::Value& config) {
#ifd... | fim | Alexays/Waybar | cpp |
<|fim_prefix|>#pragma once
#include <string>
#include "AModule.hpp"
#include "util/command.hpp"
#include "util/json.hpp"
#include "util/sleeper_thread.hpp"
namespace waybar::modules {
namespace ffi {
extern "C" {
typedef struct wbcffi_module wbcffi_module;
typedef struct {
wbcffi_module* obj;
const char* wayba... | fim | Alexays/Waybar | cpp |
<|fim_suffix|>ldShift_reset},
{"tz_up", &waybar::modules::Clock::tz_up},
{"tz_down", &waybar::modules::Clock::tz_down}};
};
} // namespace waybar::modules
<|fim_prefix|>#pragma once
#include "ALabel.hpp"
#include "util/date.hpp"
#include "util/sleeper_thread.hpp"
namespace waybar::modules {
const std::... | fim | Alexays/Waybar | cpp |
<|fim_prefix|>#pragma once
#include <fmt/format.h>
#include <cstdint>
#include <fstream>
#include <numeric>
#include <string>
#include <uti<|fim_suffix|>u(const std::string&, const Json::Value&);
virtual ~Cpu() = default;
auto update() -> void override;
private:
std::vector<std::tuple<size_t, size_t>> prev_ti... | fim | Alexays/Waybar | cpp |
<|fim_prefix|>#pragma once
<|fim_suffix|>r_thread.hpp"
namespace waybar::modules {
class CpuFrequency : public ALabel {
public:
CpuFrequency(const std::string&, const Json::Value&);
virtual ~CpuFrequency() = default;
auto update() -> void override;
// This is a static member because it is also used by the c... | fim | Alexays/Waybar | cpp |
<|fim_prefix|>#pragma once
#include <fmt/format.h>
#include <cstdint>
#include <fstream>
#include <numeric>
#include <string>
#include <utility>
#include <vector>
#include "ALabel.hpp"
#include "util/sleeper_thread.hpp"
namespace waybar::modules {
class CpuUsage : public ALabel {
public:
CpuUsage(const std::str... | fim | Alexays/Waybar | cpp |
<|fim_suffix|>o update() -> void override;
void refresh(int /*signal*/) override;
private:
void delayWorker();
void continuousWorker();
void waitingWorker();
void parseOutputRaw();
void parseOutputJson();
void handleEvent();
bool handleScroll(GdkEventScroll* e) override;
bool handleToggle(GdkEventBu... | fim | Alexays/Waybar | cpp |
<|fim_prefix|>#pragma once
#include <fmt/format.h>
#include <sys/statvfs.h>
#include <fstream>
#include "ALabel.hpp"
#i<|fim_suffix|> std::string unit_;
float calc_specific_divisor(const std::string& divisor);
};
} // namespace waybar::modules
<|fim_middle|>nclude "util/format.hpp"
#include "util/sleeper_threa... | fim | Alexays/Waybar | cpp |
<|fim_prefix|>#pragma once
#include <gtkmm/button.h>
#include <wayland-client.h>
#include "AModule.hpp"
#include "bar.hpp"
#include "dwl-ipc-unstable-v2-cl<|fim_suffix|>(const std::string&, const waybar::Bar&, const Json::Value&);
virtual ~Tags();
// Handlers for wayland events
void handle_view_tags(uint32_t t... | fim | Alexays/Waybar | cpp |
<|fim_prefix|>#pragma once
#include <fmt/fo<|fim_suffix|> void handle_frame();
struct zdwl_ipc_manager_v2* status_manager_;
private:
const Bar& bar_;
std::string title_;
std::string appid_;
std::string layout_symbol_;
uint32_t layout_;
struct zdwl_ipc_output_v2* output_status_;
};
} // namespace w... | fim | Alexays/Waybar | cpp |
<|fim_suffix|>tion_;
Gtk::Button button_;
Gtk::Box content_;
Gtk::Label label_;
};
} // namespace waybar::modules::ext
<|fim_prefix|>#pragma once
#include <fmt/format.h>
#include <gtkmm/button.h>
#include <gtkmm/image.h>
#include <gtkmm/label.h>
#include <map>
#include <memory>
#include <vector>
#include "A... | fim | Alexays/Waybar | cpp |
<|fim_prefix|>#include "ext-workspace-v1-client-protocol.h"
namespace waybar::modules::ext {
void add_registry_listener(void* data);
void add_workspace_listener(ext_workspace_handle_v1* workspace_handle, void* data);
void add_workspace_group_listener(ext_workspace_group_handle_v1* workspace_group_handle,
... | fim | Alexays/Waybar | cpp |
<|fim_suffix|>o::DBus::Connection> system_connection;
bool gamemodeRunning;
guint gamemodeWatcher_id;
};
} // namespace waybar::modules
<|fim_prefix|>#pragma once
#include <iostream>
#include <map>
#include <string>
#include "ALabel.hpp"
#include "giomm/dbusconnection.h"
#include "giomm/dbusproxy.h"
#include "g... | fim | Alexays/Waybar | cpp |
<|fim_prefix|>#pragma once
#include <fmt/format.h>
#include <sys/statvfs.h>
#ifdef WANT_RFKILL
#include "util/rfkill.hpp"
#endif
#include <gps.h>
#incl<|fim_suffix|>
util::SleeperThread thread_, gps_thread_;
gps_data_t gps_data_;
std::string state_;
bool hideDisconnected = true;
bool hideNoFix = false;
}... | fim | Alexays/Waybar | cpp |
<|fim_prefix|>#pragma once
#include <atomic>
#include <filesystem>
#include <list>
#include <mutex>
#include <optional>
#include <string>
#include <thread>
#include <utility>
#include <|fim_suffix|>ic std::optional<bool> s_luaProtocolDetected_; // cached detection result
private:
void socketListener();
void pa... | fim | Alexays/Waybar | cpp |
<|fim_prefix|>#pragma once
#include <fmt/format.h>
#include <string>
#include "<|fim_suffix|>ic:
Language(const std::string&, const waybar::Bar&, const Json::Value&);
virtual ~Language();
auto update() -> void override;
private:
void onEvent(const std::string&) override;
void initLanguage();
struct ... | fim | Alexays/Waybar | cpp |
<|fim_suffix|>";
IPC& m_ipc;
};
} // namespace waybar::modules::hyprland
<|fim_prefix|>#pragma once
#include <fmt/format.h>
#include <string>
#include "ALabel.hpp"
#include "bar.hpp"
#include "modules/hyprland/backend.hpp"
#include "util/json.hpp"
namespace waybar::modules::hyprland {
class Submap : public wa... | fim | Alexays/Waybar | cpp |
<|fim_prefix|>#pragma once
#include <fmt/format.h>
#include <string>
#include "AAppIconLabel.hpp"
#include "bar.hpp"
#include "modules/hyprland/backend.hpp"
#include "util/json.hpp"
namespace waybar::modules::hyprland {
class Window : public waybar::AAppIconLabel, public EventHandler {
public:
Window(const std:... | fim | Alexays/Waybar | cpp |
<|fim_prefix|>#pragma once
#include <fmt/format.h>
#include <string>
#include "AAppIconLabel.hpp"
#include "bar.hpp"
#include "modules/hyprland/backend.hpp"
namespace waybar::modules::hyprland {
class WindowCount : public waybar::AAppIconLabel, public EventHandler {
public:
WindowCount(const std::string&, const... | fim | Alexays/Waybar | cpp |
<|fim_prefix|>#pragma once
#include <gtkmm/button.h>
#include <gtkmm/label.h>
#include <json/value.h>
#include <cstddef>
#include <cstdint>
#include <map>
#include <memory>
#include <optional>
#include <regex>
#include <string>
#include <variant>
#include <vector>
#include "AModule.hpp"
#include "bar.hpp"
#include "... | fim | Alexays/Waybar | cpp |
<|fim_suffix|>tring& workspace_icon);
bool handleClick(const GdkEventButton* event_button, WindowAddress const& addr) const;
bool shouldSkipWindow(const WindowRepr& window_repr) const;
IPC& m_ipc;
};
} // namespace waybar::modules::hyprland
<|fim_prefix|>#pragma once
#include <gtkmm/button.h>
#include <gtkmm/l... | fim | Alexays/Waybar | cpp |
<|fim_prefix|>#pragma once
#include <gtkmm/button.h>
#include <gtkmm/enums.h>
#include <gtkmm/label.h>
#include <json/value.h>
#include <sigc++/connection.h>
#include <cstdint>
#include <map>
#include <memory>
#include <optional>
#include <regex>
#include <string>
#include <vector>
#include "AModule.hpp"
#include "b... | fim | Alexays/Waybar | cpp |
#pragma once
#include <fmt/format.h>
#include "ALabel.hpp"
#include "bar.hpp"
#include "client.hpp"
namespace waybar::modules {
class IdleInhibitor : public ALabel {
sigc::connection timeout_;
public:
IdleInhibitor(const std::string&, const waybar::Bar&, const Json::Value&);
virtual ~IdleInhibitor();
auto... | fim | Alexays/Waybar | cpp |
<|fim_suffix|>();
void parseOutputRaw();
Gtk::Box box_;
Gtk::Image image_;
std::string path_;
std::string tooltip_;
int size_;
std::chrono::milliseconds interval_;
util::command::res output_;
util::SleeperThread thread_;
};
} // namespace waybar::modules
<|fim_prefix|>#pragma once
#include <fmt/f... | fim | Alexays/Waybar | cpp |
<|fim_suffix|>tr<::GDBusConnection, void (*)(::GDBusConnection*)> dbus_;
const std::string inhibitors_;
int handle_ = -1;
};
} // namespace waybar::modules
<|fim_prefix|>#pragma once
#include <gio/gio.h>
#include <memory>
#inclu<|fim_middle|>de "ALabel.hpp"
#include "bar.hpp"
namespace waybar::modules {
clas... | fim | Alexays/Waybar | cpp |
<|fim_suffix|>nt xrun();
void shutdown();
private:
std::string JACKState();
jack_client_t* client_;
jack_nframes_t bufsize_;
jack_nframes_t samplerate_;
unsigned int xruns_;
float load_;
bool running_;
std::mutex mutex_;
std::string state_;
util::SleeperThread thread_;
};
} // namespace wayba... | fim | Alexays/Waybar | cpp |
<|fim_prefix|>#pragma once
#include <fmt/chrono.h>
#include <gtkmm/label.h>
#include <mutex>
#include <set>
#include <unordered_map>
#include "AModule.hpp"
#include "bar.hpp"
#include "util/sleeper_thread.hpp"
extern "C" {
#include <libevdev/libevdev.h>
#include <libinput.h>
}
namespace waybar::modules {
class Ke... | fim | Alexays/Waybar | cpp |
<|fim_suffix|>Load();
private:
util::SleeperThread thread_;
};
} // namespace waybar::modules
<|fim_prefix|>#pragma once
#include <fmt/format.h>
#include <cstdint>
#include <fstream>
#include <numeric>
#include <string>
#include <utility>
#include <vector>
#include "ALabel.hpp"
#include "util/sleeper_thread.hp... | fim | Alexays/Waybar | cpp |
<|fim_prefix|>#pragma once
#include <fmt/forma<|fim_suffix|>rdered_map>
#include "ALabel.hpp"
#include "util/sleeper_thread.hpp"
namespace waybar::modules {
class Memory : public ALabel {
public:
Memory(const std::string&, const Json::Value&);
virtual ~Memory() = default;
auto update() -> void override;
pr... | fim | Alexays/Waybar | cpp |
<|fim_prefix|>#pragma once
#include <fmt/format.h>
#include <mpd/client.h>
#include <spdlog/spdlog.h>
#include <conditi<|fim_suffix|>e don't manage the pointer
// (It's either nullptr, or from the config)
const char* server_;
const unsigned port_;
const std::string password_;
unsigned timeout_;
detail::... | fim | Alexays/Waybar | cpp |
<|fim_prefix|>#pragma once
#include <fmt/format.h>
#include <mpd/client.h>
#include <spdlog/spdlog.h>
#include <condition_variable>
#include <thread>
#include "ALabel.hpp"
namespace waybar::modules {
class MPD;
} // namespace waybar::modules
namespace waybar::modules::detail {
using unique_connection = std::uniq... | fim | Alexays/Waybar | cpp |
<|fim_prefix|>#pragma once
namespace detail {
inline bool Context::is_connected() const { return mpd_module_->connection_ != nullptr; }
inline bool Context::is_playing() const { return mpd_module_->pla<|fim_suffix|>MPD(); }
inline void Context::fetchState() const { mpd_module_->fetchState(); }
inline void Context::em... | fim | Alexays/Waybar | cpp |
<|fim_prefix|>#pragma once
#include <iostream>
#include <optional>
#include <string>
#include "gtkmm/box.h"
#include "gtkmm/label.h"
extern "C" {
#include <playerctl/playerc<|fim_suffix|> static auto onPlayerMetadata(PlayerctlPlayer*, GVariant*, gpointer) -> void;
struct PlayerInfo {
std::string name;
Pl... | fim | Alexays/Waybar | cpp |
<|fim_suffix|>};
#endif
float frequency_{0};
};
} // namespace waybar::modules
<|fim_prefix|>#pragma once
#include <arpa/inet.h>
#include <fmt/format.h>
#include <linux/nl80211.h>
#include <netlink/genl/ctrl.h>
#include <netlink/genl/genl.h>
#include <netlink/netlink.h>
#include <sys/epoll.h>
#include <optional>
... | fim | Alexays/Waybar | cpp |
<|fim_suffix|>Socket();
void parseIPC(const std::string&);
std::mutex dataMutex_;
std::vector<Json::Value> workspaces_;
std::vector<Json::Value> windows_;
std::vector<std::string> keyboardLayoutNames_;
unsigned keyboardLayoutCurrent_;
util::JsonParser parser_;
std::mutex callbackMutex_;
std::list<st... | fim | Alexays/Waybar | cpp |
<|fim_prefix|>#pragma once
#include <string>
#include "ALabel.hpp"
#include "bar.hpp"
#include "modules/niri/backend.hpp"
namespace waybar::modules::niri {
class Language<|fim_suffix|>_short_name_;
};
} // namespace waybar::modules::niri
<|fim_middle|> : public ALabel, public EventHandler {
public:
Language(co... | fim | Alexays/Waybar | cpp |
<|fim_prefix|>#pragma once
#include <gtkmm/button.h>
#include <json/value.h>
#include "AAppIconLabel.hpp"
#include "bar.hpp"
#include "modules/niri/backend.hpp"
namespace waybar::modules::niri {
class Window : public AAppIconLabel, public EventHandler {
public:
Window(const std::string&, const Bar&, const Json::... | fim | Alexays/Waybar | cpp |
<|fim_prefix|>#pragma once
#include <gtkmm/b<|fim_suffix|>id doUpdate();
Gtk::Button& addButton(const Json::Value& ws);
std::string getIcon(const std::string& value, const Json::Value& ws);
const Bar& bar_;
Gtk::Box box_;
// Map from niri workspace id to button.
std::unordered_map<uint64_t, Gtk::Button> b... | fim | Alexays/Waybar | cpp |
<|fim_suffix|>isplay the profiles
std::vector<Profile> availableProfiles_;
// Points to the active profile in the profiles list
std::vector<Profile>::iterator activeProfile_;
// Current CSS class applied to the label
std::string currentStyle_;
// Format string
std::string tooltipFormat_;
// DBus Proxy u... | fim | Alexays/Waybar | cpp |
<|fim_prefix|>#pragma once
#include <string>
#include "gtkmm/box.h"
#include "modules/privacy/privacy_item.hpp"
#include "util/pipewire/pipewire_backend.hpp"
#include "util/pipewire/privacy_node_info.hpp"
using waybar::util::PipewireBackend::PrivacyNodeInfo;
namespace waybar::modules::privacy {
class Privacy : pub... | fim | Alexays/Waybar | cpp |
<|fim_prefix|>#pragma once
#include <json/value.h>
#include <string>
#include "gtkmm/box.h"
#include "gtkmm/image.h"
#include "gtkmm/revealer.h"
#include "util/pipewire/privacy_node_info.hpp"
using waybar::util::PipewireBackend::PrivacyNodeInfo;
using waybar::util::PipewireBackend::PrivacyNodeType;
namespace wayba... | fim | Alexays/Waybar | cpp |
<|fim_prefix|>#pragma once
#include <fmt/format.h>
#include <algorithm>
#include <array>
#include <memory>
#include "ALabel.hpp"
#include "util/audio_back<|fim_suffix|>
auto update() -> void override;
private:
bool handleScroll(GdkEventScroll* e) override;
const std::vector<std::string> getPulseIcon() const;... | fim | Alexays/Waybar | cpp |
<|fim_suffix|>eaudioSliderTarget::Sink;
};
} // namespace waybar::modules<|fim_prefix|>#pragma once
#include <memory>
#include "ASlider.hpp"
#include "util/audio_backend.hpp"
namespace waybar::modules {
enum class PulseaudioSliderTarget {
Sink,
Source,
};
class PulseaudioSlider : public ASlider {
public:
P... | fim | Alexays/Waybar | cpp |
<|fim_suffix|>or wayland events
void handle_name(const char* name);
void handle_clear();
void handle_focused_output(struct wl_output* output);
void handle_unfocused_output(struct wl_output* output);
struct zriver_status_manager_v1* status_manager_;
struct wl_seat* seat_;
private:
const waybar::Bar& bar... | fim | Alexays/Waybar | cpp |
<|fim_suffix|>manager_v1* status_manager_;
struct wl_seat* seat_;
private:
const waybar::Bar& bar_;
std::string mode_;
struct zriver_seat_status_v1* seat_status_;
};
} /* namespace waybar::modules::river */
<|fim_prefix|>#pragma once
#include <wayland-client.h>
#include "ALabel.hpp"
#include "bar.hpp"
#inc... | fim | Alexays/Waybar | cpp |
<|fim_prefix|>#pragma once
#include <gtkmm/button.h>
#include <wayland-client.h>
#include "AModule.hpp"
#include "bar.hpp"
#include "river-control-unstable-v1-client-protocol.h"
#include "river-status-unstable-v1-client-protocol.h"
#include "xdg-output-unstable-v1-client-<|fim_suffix|>rtual ~Tags();
// Handlers fo... | fim | Alexays/Waybar | cpp |
<|fim_suffix|> private:
const waybar::Bar& bar_;
struct wl_output* output_; // stores the output this module belongs to
struct wl_output* focused_output_; // stores the currently focused output
struct zriver_seat_status_v1* seat_status_;
};
} /* namespace waybar::modules::river */
<|fim_prefix|>#prag... | fim | Alexays/Waybar | cpp |
<|fim_suffix|>uto update() -> void override;
private:
util::SleeperThread thread_;
};
} // namespace waybar::modules
<|fim_prefix|>#pragma once
#include <fmt/chrono.h>
#include "ALabel.hpp"
#include "util/sleeper_thread.hpp"
namespace waybar::modules {
class Clock : public ALabel {
public:
Clock(const std:... | fim | Alexays/Waybar | cpp |
<|fim_prefix|>#pragma once
#include <sndio.h>
#include <vector>
#include "ALabel.hpp"
#include "util/sleeper_thread.hpp"
namespace waybar::modules {
class Sndio : public ALabel {
public:
Sndio(const std::string&, const Json::Value&);
virtu<|fim_suffix|>
bool handleToggle(GdkEventButton* const&) override;
... | fim | Alexays/Waybar | cpp |
<|fim_suffix|>Watcher* watcher_ = nullptr;
const Json::Value& config_;
const Bar& bar_;
const std::function<void(std::unique_ptr<Item>&)> on_add_;
const std::function<void(std::unique_ptr<Item>&)> on_remove_;
const std::function<void()> on_update_;
};
} // namespace waybar::modules::SNI
<|fim_prefix|>#pragm... | fim | Alexays/Waybar | cpp |
#pragma once
#include <json/json.h>
#include <spdlog/spdlog.h>
#include <string>
#include <unordered_map>
class IconManager {
public:
static IconManager& instance() {
static IconManager instance;
return instance;
}
void setIconsConfig(const Json::Value& icons_config) {
if (icons_config.isObject()... | fim | Alexays/Waybar | cpp |
<|fim_prefix|>#pragma once
#include <dbus-status-notifier-item.h>
#include <giomm/dbusproxy.h>
#include <glibmm/refptr.h>
#include <gtkmm/eventbox.h>
#include <gtkmm/icontheme.h>
#include <gtkmm/image.h>
#include <gtkmm/menu.h>
#include <json/json.h>
#include <libdbusmenu-gtk/dbusmenu-gtk.h>
#include <sigc++/trackable... | fim | Alexays/Waybar | cpp |
#pragma once
#include <fmt/format.h>
#include "AModule.hpp"
#include "bar.hpp"
#include "modules/sni/host.hpp"
#include "modules/sni/watcher.hpp"
#include "util/json.hpp"
namespace waybar::modules::SNI {
class Tray : public AModule {
public:
Tray(const std::string&, const Bar&, const Json::Value&);
virtual ~Tr... | fim | Alexays/Waybar | cpp |
<|fim_prefix|>#pragma once
#include <dbus-status-notifier-watcher.h>
#include <giomm.h><|fim_suffix|>pe, const gchar*, const gchar*, const gchar*, Watcher*);
static void nameVanished(GDBusConnection* connection, const char* name, gpointer data);
static void gfWatchFree(gpointer data);
void updateRegisteredItems... | fim | Alexays/Waybar | cpp |
<|fim_suffix|>ing modifier_reset_;
bool visible_by_mode_ = false;
bool visible_by_modifier_ = false;
bool visible_by_urgency_ = false;
std::atomic<bool> modifier_no_action_ = false;
SafeSignal<bool> signal_mode_;
SafeSignal<bool> signal_visible_;
SafeSignal<bool> signal_urgency_;
SafeSignal<swaybar_con... | fim | Alexays/Waybar | cpp |
<|fim_prefix|>#pragma once
#include <sigc++/sigc++.h>
#include <sys/socket.h>
#include <sys/un.h>
#include <unistd.h>
#include <cstring>
#include <memory>
#include <mutex>
#include <stdexcept>
#include <string>
#include "ipc.hpp"
#include "util/SafeSignal.hpp"
#include "util/scoped_fd.hpp"
#include "util/sleeper_thr... | fim | Alexays/Waybar | cpp |
<|fim_prefix|>#pragma once
#inclu<|fim_suffix|>sway-specific event types
IPC_EVENT_BAR_STATE_UPDATE = ((1U << 31) | 20),
IPC_EVENT_INPUT = ((1U << 31) | 21),
};
<|fim_middle|>de <cstdint>
#define event_mask(ev) (1u << (ev & 0x7F))
enum ipc_command_type : uint32_t {
// i3 command types - see i3's I3_REPLY_TYPE ... | fim | Alexays/Waybar | cpp |
<|fim_prefix|>#pragma once
#include <fmt/format.h>
#include <xkbcommon/xkbregistry.h>
#include <map>
#include <string>
#include "ALabel.hpp"
#include "bar.hpp"
#include "client.hpp"
#include "modules/sway/ipc/client.hpp"
#include "util/json.hpp"
namespace waybar::modules::sway {
class Language : public ALabel, pub... | fim | Alexays/Waybar | cpp |
<|fim_suffix|>l ~Mode() = default;
auto update() -> void override;
private:
void onEvent(const struct Ipc::ipc_response&);
std::string mode_;
util::JsonParser parser_;
std::mutex mutex_;
Ipc ipc_;
};
} // namespace waybar::modules::sway
<|fim_prefix|>#pragma once
#include <fmt/format.h>
#include "ALa... | fim | Alexays/Waybar | cpp |
<|fim_prefix|>#pragma once
#include <gtkmm/label.h>
#include <mutex>
#include <string>
#include "ALabel.hpp"
#include "bar.hpp"
#include "client.hpp"
#include "modules/sway/ipc/client.hpp"
#include "util/json.hpp"
namespace waybar::modules::sway {
class Scratchpad : public ALabel {
public:
Scratchpad(const std::... | fim | Alexays/Waybar | cpp |
<|fim_prefix|>#pragma once
#include <fmt/format.h>
#include <tuple>
#include "AAppIconLabel.hpp"
#include "bar.hpp"
#include "client.hpp"
#include "modules/sway/ipc/client.hpp"
#include "util/json.hpp"
namespace waybar::modules::sway {
class Window : public AAppIconLabel, public sigc::trackable {
public:
Window... | fim | Alexays/Waybar | cpp |
#pragma once
#include <fmt/format.h>
#include <gtkmm/button.h>
#include <gtkmm/label.h>
#include <string_view>
#include <unordered_map>
#include "AModule.hpp"
#include "bar.hpp"
#include "client.hpp"
#include "modules/sway/ipc/client.hpp"
#include "util/json.hpp"
#include "util/regex_collection.hpp"
namespace wayba... | fim | Alexays/Waybar | cpp |
<|fim_prefix|>#pragma once
#include <giomm/dbusproxy.h>
#include <string>
#include <vector>
#include "ALabel.hpp"
namespace waybar::modules {
class SystemdFailedUnits : public ALabel {
public:
SystemdFailedUnits(const std::string&, const Json::Value&<|fim_suffix|>ring load_state;
std::string active_state;
... | fim | Alexays/Waybar | cpp |
<|fim_suffix|>g(uint16_t);
std::string file_path_;
util::SleeperThread thread_;
};
} // namespace waybar::modules
<|fim_prefix|>#pragma once
#include <fmt/format.h>
#include <fstream>
#include "ALabel.hpp"
#include "util/sleeper_thread.hpp"
namespace waybar::modules {
class Temperature : public ALabel {
pu... | fim | Alexays/Waybar | cpp |
<|fim_prefix|>#pragma once
#include <giomm/dbusconnection.h>
#include <gtkmm/icontheme.h>
#include <libupower-glib/upower.h>
#include <unordered_map>
#include "AIconLabel.hpp"
namespace waybar::modules {
class UPower final : public AIconLabel {
public:
UPower(const std::string&, const Json::Value&);
virtual ~... | fim | Alexays/Waybar | cpp |
<|fim_prefix|>#pragma once
#include <fmt/chrono.h>
#include <gdkmm/pixbuf.h>
#include <glibmm/refptr.h>
#include "AIconLabel.hpp"
#include "util/sleeper_thread.hpp"
namespace waybar::modules {
class User : public AIconLabel {
<|fim_suffix|> namespace waybar::modules
<|fim_middle|>public:
User(const std::string&, ... | fim | Alexays/Waybar | cpp |
<|fim_prefix|>#pragma once
#include <json/json.h>
#include <unistd.h>
#include <functional>
#include <list>
#include <memory>
#include <mutex>
#include <optional>
#include <string>
#include <unordered_map>
#include <utility>
#include "util/sc<|fim_suffix|>────┴───────┐ ┌───────┴──────┐ ┌───────┴───────┐
│ wset #... | fim | Alexays/Waybar | cpp |
<|fim_suffix|>indow(const std::string& id, const Bar& bar, const Json::Value& config);
~Window() override;
auto update() -> void override;
auto update_icon_label() -> void;
};
} // namespace waybar::modules::wayfire
<|fim_prefix|>#pragma once
#include "AAppIconLabel.hpp"
#include "bar.hpp"
#include "modules/w... | fim | Alexays/Waybar | cpp |
<|fim_suffix|>(const std::string& id, const Bar& bar, const Json::Value& config);
~Workspaces() override;
};
} // namespace waybar::modules::wayfire
<|fim_prefix|>#pragma once
#include <gtkmm/button.h>
#include <json/json.h>
#include <memory>
#include <vector>
#include "AModule.hpp"
#include "bar.hpp"
#include "... | fim | Alexays/Waybar | cpp |
<|fim_suffix|>aultNodesApiLoaded(WpObject* p, GAsyncResult* res,
waybar::modules::Wireplumber* self);
static void onMixerApiLoaded(WpObject* p, GAsyncResult* res, waybar::modules::Wireplumber* self);
static void onObjectManagerInstalled(waybar::modules::Wireplumber* self);
st... | fim | Alexays/Waybar | cpp |
<|fim_prefix|>#pragma once
#include <gdk/gdk.h>
#include <glibmm/refptr.h>
#include <gtkmm/box.h>
#include <gtkmm/button.h>
#include <gtkmm/icontheme.h>
#include <gtkmm/image.h>
#include <gtkmm/label.h>
#include <wayland-client.h>
#include <map>
#include <memory>
#include <string>
#include <unordered_set>
#include <v... | fim | Alexays/Waybar | cpp |
<|fim_suffix|>mit();
}
}
template <typename... EmitArgs>
inline void operator()(EmitArgs&&... args) {
emit(std::forward<EmitArgs>(args)...);
}
protected:
using signal_t = sigc::signal<void(std::decay_t<Args>...)>;
using slot_t = decltype(std::declval<signal_t>().make_slot());
using arg_tuple_t ... | fim | Alexays/Waybar | cpp |
<|fim_suffix|>ks_;
std::function<void()> on_updated_cb_ = NOOP;
/* Hack to keep constructor inaccessible but still public.
* This is required to be able to use std::make_shared.
* It is important to keep this class only accessible via a reference-counted
* pointer because the destructor will manually fre... | fim | Alexays/Waybar | cpp |
<|fim_prefix|><|fim_suffix|>hangeType : char { Increase, Decrease };
} // namespace waybar::util<|fim_middle|>#pragma once
#include "AModule.hpp"
namespace waybar::util {
const static auto NOOP = []() {};
enum class C<|endoftext|> | fim | Alexays/Waybar | cpp |
<|fim_prefix|>#pragma once
#include <libud<|fim_suffix|>l_ == rhs.actual_ && lhs.max_ == rhs.max_;
}
private:
std::string name_;
int actual_ = 1;
int max_ = 1;
bool powered_ = true;
};
class BacklightBackend {
public:
BacklightBackend(std::chrono::milliseconds interval, std::function<void()> on_updated... | fim | Alexays/Waybar | cpp |
<|fim_prefix|>// Copyright 2017 Two Blue Cubes Ltd. All rights reserved.
//
// Distributed under the Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
//
// See https://github.com/philsquared/Clara for more details
// Clara v1.1.5
#ifndef C... | fim | Alexays/Waybar | cpp |
<|fim_suffix|>.unlock();
spdlog::debug("Added child to reap list: {}", pid);
}
return pid;
}
inline int32_t forkExec(const std::string& cmd) { return forkExec(cmd, ""); }
} // namespace waybar::util::command
<|fim_prefix|>#pragma once
#include <fcntl.h>
#include <giomm.h>
#include <spdlog/spdlog.h>
#includ... | fim | Alexays/Waybar | cpp |
<|fim_prefix|>#pragma once
#include <functional>
#include <string>
#include <unordered_m<|fim_suffix|>Monitors;
};
} // namespace waybar
<|fim_middle|>ap>
#include <vector>
#include "giomm/file.h"
#include "giomm/filemonitor.h"
#include "glibmm/refptr.h"
struct pollfd;
namespace waybar {
class CssReloadHelper {
p... | fim | Alexays/Waybar | cpp |
<|fim_prefix|>#pragma once
#include <chrono>
#if HAVE_CHRONO_TIMEZONES
#include <format>
#else
#include <date/tz.h>
#include <fmt/format.h>
#include <regex>
#endif
// Date
namespace date {
#if HAVE_CHRONO_TIMEZONES
using namespace std::chrono;
using std::format;
#else
using system_clock = std::chrono::system_<|fim... | fim | Alexays/Waybar | cpp |
<|fim_prefix|>#pragma once
#include <map>
#include <stdexcept>
#include <string>
namespace waybar::util {
template <typename EnumType>
struct EnumParser {
public:
EnumParser();
~EnumParser();
EnumType parseStringToEn<|fim_suffix|>umMap);
};
} // namespace waybar::util
<|fim_middle|>um(const std::string& st... | fim | Alexays/Waybar | cpp |
<|fim_prefix|>#pragma once
#include <fmt/format.h>
#include <glibmm/ustring.h>
class pow_format {
public:
pow_format(long long val, std::string&& unit, bool binary = false)
: val_(va<|fim_suffix|>s.binary_ // for the 'i' in GiB.
+ s.unit_.length();
const char* format;
std:... | fim | Alexays/Waybar | cpp |
<|fim_suffix|>mutex>
#include <string>
class DefaultGtkIconThemeWrapper {
private:
static std::mutex default_theme_mutex;
public:
static bool has_icon(const std::string&);
static Glib::RefPtr<Gdk::Pixbuf> load_icon(
const char*, int, Gtk::IconLookupFlags,
Glib::RefPtr<Gtk::StyleContext> style = Gl... | fim | Alexays/Waybar | cpp |
<|fim_suffix|>sult {
std::string css;
bool was_transformed;
};
/**
* Reads a CSS file, searches for 8-bit hex codes (#RRGGBBAA),
* and transforms them into GTK-compatible rgba() syntax.
*/
TransformResult transform_8bit_to_hex(const std::string& file_path);
<|fim_prefix|>#pragma once
#include <string>
/**
* ... | fim | Alexays/Waybar | cpp |
<|fim_suffix|>theme_name);
bool image_load_icon(Gtk::Image& image, Glib::RefPtr<Gio::DesktopAppInfo> app_info,
int size) const;
static Glib::RefPtr<Gio::DesktopAppInfo> get_app_info_from_app_id_list(
const std::string& app_id_list);
};
<|fim_prefix|>#pragma once
#include <gdkmm/general... | fim | Alexays/Waybar | cpp |
<|fim_prefix|>#pragma once
#include <fmt/ostream.h>
#include <json/json.h>
#include <algorithm>
#include <codecvt>
#include <iostream>
#include <locale>
#include <regex>
#if (FMT_VERSION >= 90000)
template <>
struct fmt::formatter<Json::Value> : ostream_formatter {};
#endif
namespace waybar::util {
class JsonPar... | fim | Alexays/Waybar | cpp |
<|fim_suffix|>"HIDE", KillSignalAction::HIDE},
{"NOOP", KillSignalAction::NOOP}};
const KillSignalAction SIGNALACTION_DEFAULT_SIGUSR1 = KillSignalAction::TOGGLE;
const KillSignalAction SIGNALACTION_DEFAULT_SIGUSR2 = KillSignalAction::RELOAD;
}; // namespace waybar::util
<|fim_prefix|>#pragma once
#include <json... | fim | Alexays/Waybar | cpp |
<|fim_prefix|>#pragma once
#include <pipewire/pipewire.h>
#include <unordered_map>
#include "util/backend_common.hpp"
#include "util/pipewire/privacy_node_info.hpp"
namespace waybar::util::PipewireBackend {
class PipewireBackend {
private:
pw_thread_loop* mainloop_;
pw_context* context_;
pw_core* core_;
... | fim | Alexays/Waybar | cpp |
<|fim_prefix|>#pragma once
#include <pipewire/pipewire.h>
#include <string>
#include "util/gtk_icon.hpp"
namespace waybar::util::PipewireBackend {
enum<|fim_suffix|>VACY_NODE_TYPE_NONE,
PRIVACY_NODE_TYPE_VIDEO_INPUT,
PRIVACY_NODE_TYPE_AUDIO_INPUT,
PRIVACY_NODE_TYPE_AUDIO_OUTPUT
};
class PrivacyNodeInfo {
p... | fim | Alexays/Waybar | cpp |
<|fim_prefix|>#include <giomm/dbusproxy.h>
#include<|fim_suffix|>:signal<void, Appearance> type_signal_appearance_changed;
type_signal_appearance_changed signal_appearance_changed() { return m_signal_appearance_changed; }
private:
type_signal_appearance_changed m_signal_appearance_changed;
Appearance currentMo... | fim | Alexays/Waybar | cpp |
<|fim_suffix|> // namespace waybar::util
<|fim_prefix|>#pragma once
#include "SafeSignal.hpp"
namespace waybar::util {
// Get a signal emitted with value true when entering sleep, and false when exiting
SafeSignal<bool>& prepare_for_sleep<|fim_middle|>();
}<|endoftext|> | fim | Alexays/Waybar | c |
<|fim_prefix|>#pragma once
#include <json/json.h>
#include <functional>
#include <regex>
#include <string>
#include <utility>
namespace wayb<|fim_suffix|>and strings, with a default string to return if no regexes.
* When a regex is matched, the corresponding string is returned.
* All regexes that are matched are c... | fim | Alexays/Waybar | cpp |
<|fim_suffix|>pace waybar::util
<|fim_prefix|>#pragma once
#include <json/json.h>
#include <string>
namespace waybar::util {
std::string rewriteString(const std::string&, const<|fim_middle|> Json::Value&);
std::string rewriteStringOnce(const std::string& value, const Json::Value& rules,
... | fim | Alexays/Waybar | cpp |
<|fim_suffix|>um rfkill_type rfkill_type_;
std::atomic_bool state_ = false;
int fd_ = -1;
bool on_event(Glib::IOCondition cond);
};
} // namespace waybar::util
<|fim_prefix|>#pragma once
#include <glibmm/iochannel.h>
#include <linux/rfkill.h>
#include <sigc++/signal.h>
#include <sigc++/trackable.h>
#include ... | fim | Alexays/Waybar | cpp |
<|fim_suffix|>l
<|fim_prefix|>#pragma once
#include <string>
namespace waybar::util {
std::string sanitize_string(std::string str);
} // namespace waybar::u<|fim_middle|>ti<|endoftext|> | fim | Alexays/Waybar | cpp |
<|fim_prefix|>#pragma once
#include <utility>
namespace waybar::util {
template <typename Fu<|fim_suffix|>d&&) = default;
ScopeGuard& operator=(const ScopeGuard&) = delete;
ScopeGuard& operator=(ScopeGuard&&) = default;
~ScopeGuard() { f(); }
private:
Func f;
};
} // namespace waybar::util
<|fim_middle|>... | fim | Alexays/Waybar | cpp |
#pragma once
#include <unistd.h>
namespace waybar::util {
class ScopedFd {
public:
explicit ScopedFd(int fd = -1) : fd_(fd) {}
~ScopedFd() {
if (fd_ != -1) {
close(fd_);
}
}
// ScopedFd is non-copyable
ScopedFd(const ScopedFd&) = delete;
ScopedFd& operator=(const ScopedFd&) = delete;
/... | fim | Alexays/Waybar | cpp |
<|fim_suffix|> to terminate thread...
pthread_cancel(handle);
}
}
~SleeperThread() {
connection_.disconnect();
stop();
if (thread_.joinable()) {
thread_.join();
}
}
private:
std::thread thread_;
std::condition_variable condvar_;
std::mutex mutex_;
std::atomic<bool> do_ru... | fim | Alexays/Waybar | cpp |
<|fim_suffix|>
}
inline std::vector<std::string> split(std::string_view s, std::string_view delimiter,
int max_splits = -1) {
std::vector<std::string> result;
size_t pos = 0;
size_t next_pos = 0;
while ((next_pos = s.find(delimiter, pos)) != std::string::npos) {
result... | fim | Alexays/Waybar | cpp |
<|fim_suffix|>id operator()(udev_device* ptr) const { udev_device_unref(ptr); }
};
struct UdevEnumerateDeleter {
void operator()(udev_enumerate* ptr) const { udev_enumerate_unref(ptr); }
};
struct UdevMonitorDeleter {
void operator()(udev_monitor* ptr) const { udev_monitor_unref(ptr); }
};
} // namespace waybar:... | fim | Alexays/Waybar | cpp |
#pragma once
#include <glibmm/ustring.h>
// calculate column width of ustring
int ustring_clen(const Glib::ustring& str);<|endoftext|> | fim | Alexays/Waybar | cpp |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.