pgrondek/polybar-dwm
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

tray: Cleanup

Browse Source
This commit is contained in:
patrick96 2022-10-31 23:21:00 +01:00
parent ca25b5685c
commit f5d16891dd
No known key found for this signature in database
GPG Key ID: 521E5E03AEBCA1A7
7 changed files with 287 additions and 270 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

24
include/modules/tray.hpp
View File

@ -7,22 +7,22 @@
POLYBAR_NS
namespace modules {
class tray_module : public static_module<tray_module> {
public:
explicit tray_module(const bar_settings& bar_settings, string name_);
string get_format() const;
class tray_module : public static_module<tray_module> {
public:
explicit tray_module(const bar_settings& bar_settings, string name_);
string get_format() const;
void start() override;
void start() override;
bool build(builder* builder, const string& tag) const;
void update() {}
bool build(builder* builder, const string& tag) const;
void update() {}
static constexpr auto TYPE = "internal/tray";
static constexpr auto TYPE = "internal/tray";
private:
static constexpr const char* TAG_TRAY{"<tray>"};
private:
static constexpr const char* TAG_TRAY{"<tray>"};
tray_manager m_tray;
};
tray::manager m_tray;
};
} // namespace modules
POLYBAR_NS_END

15
include/x11/tray_client.hpp
View File

@ -20,11 +20,13 @@ POLYBAR_NS
// fwd declarations
class connection;
class tray_client : public non_copyable_mixin, public non_movable_mixin {
namespace tray {
class client : public non_copyable_mixin, public non_movable_mixin {
public:
explicit tray_client(
explicit client(
const logger& log, connection& conn, xcb_window_t parent, xcb_window_t win, size s, uint32_t desired_background);
~tray_client();
~client();
string name() const;
@ -44,7 +46,7 @@ class tray_client : public non_copyable_mixin, public non_movable_mixin {
bool should_be_mapped() const;
xcb_window_t embedder() const;
xcb_window_t client() const;
xcb_window_t client_window() const;
void query_xembed();
bool is_xembed_supported() const;
@ -63,7 +65,6 @@ class tray_client : public non_copyable_mixin, public non_movable_mixin {
protected:
void observe_background();
protected:
const logger& m_log;
connection& m_connection;
@ -103,7 +104,7 @@ class tray_client : public non_copyable_mixin, public non_movable_mixin {
*
* Only valid if m_xembed_supported == true
*/
xembed::info m_xembed;
xembed::info m_xembed{};
/**
* Whether the wrapper window is currently mapped.
@ -125,4 +126,6 @@ class tray_client : public non_copyable_mixin, public non_movable_mixin {
unique_ptr<cairo::xcb_surface> m_surface;
};
} // namespace tray
POLYBAR_NS_END

32
include/x11/tray_manager.hpp
View File

@ -25,14 +25,16 @@
POLYBAR_NS
namespace chrono = std::chrono;
using namespace std::chrono_literals;
using std::atomic;
// fwd declarations
class connection;
class bg_slice;
namespace tray {
namespace chrono = std::chrono;
using namespace std::chrono_literals;
using std::atomic;
struct tray_settings {
/**
* Dimensions for client windows.
@ -56,16 +58,16 @@ struct tray_settings {
using on_update = std::function<void(void)>;
class tray_manager : public xpp::event::sink<evt::expose, evt::client_message, evt::configure_request,
evt::resize_request, evt::selection_clear, evt::property_notify, evt::reparent_notify,
evt::destroy_notify, evt::map_notify, evt::unmap_notify>,
public signal_receiver<SIGN_PRIORITY_TRAY, signals::ui::update_background,
signals::ui_tray::tray_pos_change, signals::ui_tray::tray_visibility> {
class manager : public xpp::event::sink<evt::expose, evt::client_message, evt::configure_request, evt::resize_request,
evt::selection_clear, evt::property_notify, evt::reparent_notify, evt::destroy_notify,
evt::map_notify, evt::unmap_notify>,
public signal_receiver<SIGN_PRIORITY_TRAY, signals::ui::update_background,
signals::ui_tray::tray_pos_change, signals::ui_tray::tray_visibility> {
public:
explicit tray_manager(connection& conn, signal_emitter& emitter, const logger& logger, const bar_settings& bar_opts,
explicit manager(connection& conn, signal_emitter& emitter, const logger& logger, const bar_settings& bar_opts,
on_update on_update);
~tray_manager();
~manager() override;
unsigned get_width() const;
@ -115,8 +117,8 @@ class tray_manager : public xpp::event::sink<evt::expose, evt::client_message, e
void update_width();
bool is_embedded(const xcb_window_t& win);
tray_client* find_client(const xcb_window_t& win);
void remove_client(const tray_client& client);
client* find_client(const xcb_window_t& win);
void remove_client(const client& client);
void remove_client(xcb_window_t win);
void clean_clients();
bool change_visibility(bool visible);
@ -140,7 +142,7 @@ class tray_manager : public xpp::event::sink<evt::expose, evt::client_message, e
connection& m_connection;
signal_emitter& m_sig;
const logger& m_log;
vector<unique_ptr<tray_client>> m_clients;
vector<unique_ptr<client>> m_clients;
tray_settings m_opts{};
const bar_settings& m_bar_opts;
@ -200,4 +202,6 @@ class tray_manager : public xpp::event::sink<evt::expose, evt::client_message, e
bool m_firstactivation{true};
};
} // namespace tray
POLYBAR_NS_END

40
include/x11/xembed.hpp
View File

@ -33,31 +33,31 @@ static constexpr uint32_t XEMBED_MAX_VERSION = 0;
*/
namespace xembed {
class info {
public:
void set(uint32_t* data);
class info {
public:
void set(const uint32_t* data);
uint32_t get_version() const;
uint32_t get_flags() const;
uint32_t get_version() const;
uint32_t get_flags() const;
bool is_mapped() const;
bool is_mapped() const;
string to_string() const;
string to_string() const;
protected:
uint32_t version;
uint32_t flags;
};
protected:
uint32_t version;
uint32_t flags;
};
bool query(connection& conn, xcb_window_t win, info& data);
void send_message(connection& conn, xcb_window_t target, uint32_t message, uint32_t d1, uint32_t d2, uint32_t d3);
void send_focus_event(connection& conn, xcb_window_t target);
void notify_embedded(connection& conn, xcb_window_t win, xcb_window_t embedder, uint32_t version);
void notify_activated(connection& conn, xcb_window_t win);
void notify_deactivated(connection& conn, xcb_window_t win);
void notify_focused(connection& conn, xcb_window_t win, uint32_t focus_type);
void notify_unfocused(connection& conn, xcb_window_t win);
void unembed(connection& conn, xcb_window_t win, xcb_window_t root);
bool query(connection& conn, xcb_window_t win, info& data);
void send_message(connection& conn, xcb_window_t target, uint32_t message, uint32_t d1, uint32_t d2, uint32_t d3);
void send_focus_event(connection& conn, xcb_window_t target);
void notify_embedded(connection& conn, xcb_window_t win, xcb_window_t embedder, uint32_t version);
void notify_activated(connection& conn, xcb_window_t win);
void notify_deactivated(connection& conn, xcb_window_t win);
void notify_focused(connection& conn, xcb_window_t win, uint32_t focus_type);
void notify_unfocused(connection& conn, xcb_window_t win);
void unembed(connection& conn, xcb_window_t win, xcb_window_t root);
} // namespace xembed
POLYBAR_NS_END

87
src/x11/tray_client.cpp
View File

@ -11,6 +11,8 @@
POLYBAR_NS
namespace tray {
/*
* TODO proper background of wrapper window
*
@ -20,7 +22,7 @@ POLYBAR_NS
* 2. Use pseudo-transparency when activated (make sure the depths match)
* 3. Use background color
*/
tray_client::tray_client(
client::client(
const logger& log, connection& conn, xcb_window_t parent, xcb_window_t win, size s, uint32_t desired_background)
: m_log(log)
, m_connection(conn)
@ -88,7 +90,7 @@ tray_client::tray_client(
xcb_params_gc_t params{};
uint32_t mask = 0;
XCB_AUX_ADD_PARAM(&mask, &params, graphics_exposures, 1);
std::array<uint32_t, 32> values;
std::array<uint32_t, 32> values{};
connection::pack_values(mask, &params, values);
m_connection.create_gc_checked(gc, pixmap, mask, values.data());
} catch (const std::exception& err) {
@ -108,7 +110,7 @@ tray_client::tray_client(
observe_background();
}
tray_client::~tray_client() {
client::~client() {
if (m_client != XCB_NONE) {
xembed::unembed(m_connection, m_client, m_connection.root());
}
@ -118,19 +120,19 @@ tray_client::~tray_client() {
}
}
string tray_client::name() const {
return "tray_client(" + m_connection.id(m_client) + ", " + m_name + ")";
string client::name() const {
return "client(" + m_connection.id(m_client) + ", " + m_name + ")";
}
unsigned int tray_client::width() const {
unsigned int client::width() const {
return m_size.w;
}
unsigned int tray_client::height() const {
unsigned int client::height() const {
return m_size.h;
}
void tray_client::clear_window() const {
void client::clear_window() const {
if (!mapped()) {
return;
}
@ -141,19 +143,20 @@ void tray_client::clear_window() const {
auto send_visibility = [&](uint8_t state) {
xcb_visibility_notify_event_t evt{};
evt.response_type = XCB_VISIBILITY_NOTIFY;
evt.window = client();
evt.window = client_window();
evt.state = state;
m_connection.send_event_checked(true, client(), XCB_EVENT_MASK_NO_EVENT, reinterpret_cast<const char*>(&evt));
m_connection.send_event_checked(
true, client_window(), XCB_EVENT_MASK_NO_EVENT, reinterpret_cast<const char*>(&evt));
};
send_visibility(XCB_VISIBILITY_FULLY_OBSCURED);
send_visibility(XCB_VISIBILITY_UNOBSCURED);
m_connection.clear_area_checked(1, client(), 0, 0, width(), height());
m_connection.clear_area_checked(1, client_window(), 0, 0, width(), height());
}
void tray_client::update_client_attributes() const {
void client::update_client_attributes() const {
uint32_t configure_mask = 0;
std::array<uint32_t, 32> configure_values{};
xcb_params_cw_t configure_params{};
@ -164,32 +167,32 @@ void tray_client::update_client_attributes() const {
connection::pack_values(configure_mask, &configure_params, configure_values);
m_log.trace("%s: Update client window", name());
m_connection.change_window_attributes_checked(client(), configure_mask, configure_values.data());
m_connection.change_window_attributes_checked(client_window(), configure_mask, configure_values.data());
}
void tray_client::reparent() const {
void client::reparent() const {
m_log.trace("%s: Reparent client", name());
m_connection.reparent_window_checked(client(), embedder(), 0, 0);
m_connection.reparent_window_checked(client_window(), embedder(), 0, 0);
}
/**
* Is this the client for the given client window
*/
bool tray_client::match(const xcb_window_t& win) const {
bool client::match(const xcb_window_t& win) const {
return win == m_client;
}
/**
* Get client window mapped state
*/
bool tray_client::mapped() const {
bool client::mapped() const {
return m_mapped;
}
/**
* Set client window mapped state
*/
void tray_client::mapped(bool state) {
void client::mapped(bool state) {
if (m_mapped != state) {
m_log.trace("%s: set mapped: %i", name(), state);
m_mapped = state;
@ -201,14 +204,14 @@ void tray_client::mapped(bool state) {
*
* Use this to trigger a mapping/unmapping
*/
void tray_client::hidden(bool state) {
void client::hidden(bool state) {
m_hidden = state;
}
/**
* Whether the current state indicates the client should be mapped.
*/
bool tray_client::should_be_mapped() const {
bool client::should_be_mapped() const {
if (m_hidden) {
return false;
}
@ -220,15 +223,15 @@ bool tray_client::should_be_mapped() const {
return true;
}
xcb_window_t tray_client::embedder() const {
xcb_window_t client::embedder() const {
return m_wrapper;
}
xcb_window_t tray_client::client() const {
xcb_window_t client::client_window() const {
return m_client;
}
void tray_client::query_xembed() {
void client::query_xembed() {
m_xembed_supported = xembed::query(m_connection, m_client, m_xembed);
if (is_xembed_supported()) {
@ -238,30 +241,30 @@ void tray_client::query_xembed() {
}
}
bool tray_client::is_xembed_supported() const {
bool client::is_xembed_supported() const {
return m_xembed_supported;
}
const xembed::info& tray_client::get_xembed() const {
const xembed::info& client::get_xembed() const {
return m_xembed;
}
void tray_client::notify_xembed() const {
void client::notify_xembed() const {
if (is_xembed_supported()) {
m_log.trace("%s: Send embedded notification to client", name());
xembed::notify_embedded(m_connection, client(), embedder(), m_xembed.get_version());
xembed::notify_embedded(m_connection, client_window(), embedder(), m_xembed.get_version());
}
}
void tray_client::add_to_save_set() const {
void client::add_to_save_set() const {
m_log.trace("%s: Add client window to the save set", name());
m_connection.change_save_set_checked(XCB_SET_MODE_INSERT, client());
m_connection.change_save_set_checked(XCB_SET_MODE_INSERT, client_window());
}
/**
* Make sure that the window mapping state is correct
*/
void tray_client::ensure_state() const {
void client::ensure_state() const {
bool new_state = should_be_mapped();
if (new_state == m_mapped) {
@ -273,10 +276,10 @@ void tray_client::ensure_state() const {
if (new_state) {
m_log.trace("%s: Map client", name());
m_connection.map_window_checked(embedder());
m_connection.map_window_checked(client());
m_connection.map_window_checked(client_window());
} else {
m_log.trace("%s: Unmap client", name());
m_connection.unmap_window_checked(client());
m_connection.unmap_window_checked(client_window());
m_connection.unmap_window_checked(embedder());
}
}
@ -284,7 +287,7 @@ void tray_client::ensure_state() const {
/**
* Configure window position
*/
void tray_client::set_position(int x, int y) {
void client::set_position(int x, int y) {
m_log.trace("%s: moving to (%d, %d)", name(), x, y);
position new_pos{x, y};
@ -312,12 +315,12 @@ void tray_client::set_position(int x, int y) {
XCB_AUX_ADD_PARAM(&configure_mask, &configure_params, x, 0);
XCB_AUX_ADD_PARAM(&configure_mask, &configure_params, y, 0);
connection::pack_values(configure_mask, &configure_params, configure_values);
m_connection.configure_window_checked(client(), configure_mask, configure_values.data());
m_connection.configure_window_checked(client_window(), configure_mask, configure_values.data());
// TODO
xcb_size_hints_t size_hints{};
xcb_icccm_size_hints_set_size(&size_hints, false, m_size.w, m_size.h);
xcb_icccm_set_wm_size_hints(m_connection, client(), XCB_ATOM_WM_NORMAL_HINTS, &size_hints);
xcb_icccm_set_wm_size_hints(m_connection, client_window(), XCB_ATOM_WM_NORMAL_HINTS, &size_hints);
// The position has changed, we need a new background slice.
observe_background();
@ -326,11 +329,11 @@ void tray_client::set_position(int x, int y) {
/**
* Respond to client resize/move requests
*/
void tray_client::configure_notify() const {
void client::configure_notify() const {
xcb_configure_notify_event_t notify;
notify.response_type = XCB_CONFIGURE_NOTIFY;
notify.event = client();
notify.window = client();
notify.event = client_window();
notify.window = client_window();
notify.override_redirect = false;
notify.above_sibling = 0;
notify.x = 0;
@ -340,13 +343,13 @@ void tray_client::configure_notify() const {
notify.border_width = 0;
unsigned int mask{XCB_EVENT_MASK_STRUCTURE_NOTIFY};
m_connection.send_event_checked(false, client(), mask, reinterpret_cast<const char*>(&notify));
m_connection.send_event_checked(false, client_window(), mask, reinterpret_cast<const char*>(&notify));
}
/**
* Redraw background using the observed background slice.
*/
void tray_client::update_bg() const {
void client::update_bg() const {
m_log.trace("%s: Update background", name());
// Composite background slice with background color.
@ -363,11 +366,13 @@ void tray_client::update_bg() const {
m_connection.flush();
}
void tray_client::observe_background() {
void client::observe_background() {
xcb_rectangle_t rect{0, 0, static_cast<uint16_t>(m_size.w), static_cast<uint16_t>(m_size.h)};
m_bg_slice = m_background_manager.observe(rect, embedder());
update_bg();
}
} // namespace tray
POLYBAR_NS_END

141
src/x11/tray_manager.cpp
View File

@ -3,6 +3,7 @@
#include <xcb/xcb_image.h>
#include <thread>
#include <utility>
#include "cairo/context.hpp"
#include "cairo/surface.hpp"
@ -50,13 +51,15 @@
POLYBAR_NS
tray_manager::tray_manager(
namespace tray {
manager::manager(
connection& conn, signal_emitter& emitter, const logger& logger, const bar_settings& bar_opts, on_update on_update)
: m_connection(conn), m_sig(emitter), m_log(logger), m_bar_opts(bar_opts), m_on_update(on_update) {
: m_connection(conn), m_sig(emitter), m_log(logger), m_bar_opts(bar_opts), m_on_update(std::move(on_update)) {
m_connection.attach_sink(this, SINK_PRIORITY_TRAY);
}
tray_manager::~tray_manager() {
manager::~manager() {
if (m_delaythread.joinable()) {
m_delaythread.join();
}
@ -64,7 +67,7 @@ tray_manager::~tray_manager() {
deactivate();
}
void tray_manager::setup(const config& conf, const string& section_name) {
void manager::setup(const config& conf, const string& section_name) {
unsigned client_height = m_bar_opts.inner_area().height;
// Add user-defined padding
@ -101,30 +104,30 @@ void tray_manager::setup(const config& conf, const string& section_name) {
activate();
}
unsigned tray_manager::get_width() const {
unsigned manager::get_width() const {
return m_tray_width;
}
bool tray_manager::is_active() const {
bool manager::is_active() const {
return m_state == state::ACTIVE;
}
bool tray_manager::is_inactive() const {
bool manager::is_inactive() const {
return m_state == state::INACTIVE;
}
bool tray_manager::is_waiting() const {
bool manager::is_waiting() const {
return m_state == state::WAITING;
}
bool tray_manager::is_visible() const {
bool manager::is_visible() const {
return is_active() && !m_hidden;
}
/**
* Activate systray management
*/
void tray_manager::activate() {
void manager::activate() {
if (is_active()) {
return;
}
@ -173,7 +176,7 @@ void tray_manager::activate() {
*
* @param other window id for current selection owner
*/
void tray_manager::wait_for_selection(xcb_window_t other) {
void manager::wait_for_selection(xcb_window_t other) {
if (is_waiting() || other == XCB_NONE) {
return;
}
@ -198,7 +201,7 @@ void tray_manager::wait_for_selection(xcb_window_t other) {
/**
* Deactivate systray management
*/
void tray_manager::deactivate() {
void manager::deactivate() {
if (is_inactive()) {
return;
}
@ -228,7 +231,7 @@ void tray_manager::deactivate() {
/**
* Reconfigure tray
*/
void tray_manager::reconfigure() {
void manager::reconfigure() {
if (!m_opts.selection_owner) {
return;
}
@ -249,7 +252,7 @@ void tray_manager::reconfigure() {
*
* TODO should we call update_width directly?
*/
void tray_manager::reconfigure_window() {
void manager::reconfigure_window() {
m_log.trace("tray: Reconfigure window (hidden=%i, clients=%i)", m_hidden, m_clients.size());
update_width();
}
@ -257,7 +260,7 @@ void tray_manager::reconfigure_window() {
/**
* TODO make sure this is always called when m_clients changes
*/
void tray_manager::update_width() {
void manager::update_width() {
unsigned new_width = calculate_w();
if (m_tray_width != new_width) {
m_tray_width = new_width;
@ -269,7 +272,7 @@ void tray_manager::update_width() {
/**
* Reconfigure clients
*/
void tray_manager::reconfigure_clients() {
void manager::reconfigure_clients() {
m_log.trace("tray: Reconfigure clients");
int x = calculate_x() + m_opts.spacing;
@ -300,7 +303,7 @@ void tray_manager::reconfigure_clients() {
/**
* Redraw client windows.
*/
void tray_manager::redraw_clients() {
void manager::redraw_clients() {
if (!is_visible()) {
return;
}
@ -323,7 +326,7 @@ void tray_manager::redraw_clients() {
/**
* Find the systray selection atom
*/
void tray_manager::query_atom() {
void manager::query_atom() {
m_log.trace("tray: Find systray selection atom for the default screen");
string name{"_NET_SYSTEM_TRAY_S" + to_string(m_connection.default_screen())};
auto reply = m_connection.intern_atom(false, name.length(), name.c_str());
@ -333,7 +336,7 @@ void tray_manager::query_atom() {
/**
* Set color atom used by clients when determing icon theme
*/
void tray_manager::set_tray_colors() {
void manager::set_tray_colors() {
m_log.trace("tray: Set _NET_SYSTEM_TRAY_COLORS to 0x%08x", m_opts.foreground);
auto r = m_opts.foreground.red_i();
@ -344,21 +347,21 @@ void tray_manager::set_tray_colors() {
const uint16_t g16 = (g << 8) | g;
const uint16_t b16 = (b << 8) | b;
const uint32_t colors[12] = {
const array<uint32_t, 12> colors = {
r16, g16, b16, // normal
r16, g16, b16, // error
r16, g16, b16, // warning
r16, g16, b16, // success
};
m_connection.change_property(
XCB_PROP_MODE_REPLACE, m_opts.selection_owner, _NET_SYSTEM_TRAY_COLORS, XCB_ATOM_CARDINAL, 32, 12, colors);
m_connection.change_property(XCB_PROP_MODE_REPLACE, m_opts.selection_owner, _NET_SYSTEM_TRAY_COLORS,
XCB_ATOM_CARDINAL, 32, colors.size(), colors.data());
}
/**
* Set the _NET_SYSTEM_TRAY_ORIENTATION atom
*/
void tray_manager::set_tray_orientation() {
void manager::set_tray_orientation() {
const uint32_t orientation = _NET_SYSTEM_TRAY_ORIENTATION_HORZ;
m_log.trace("tray: Set _NET_SYSTEM_TRAY_ORIENTATION to 0x%x", orientation);
m_connection.change_property_checked(XCB_PROP_MODE_REPLACE, m_opts.selection_owner, _NET_SYSTEM_TRAY_ORIENTATION,
@ -366,7 +369,7 @@ void tray_manager::set_tray_orientation() {
}
// TODO remove
void tray_manager::set_tray_visual() {
void manager::set_tray_visual() {
// TODO use bar visual
const uint32_t visualid = m_connection.visual_type(XCB_VISUAL_CLASS_TRUE_COLOR, 32)->visual_id;
m_log.trace("tray: Set _NET_SYSTEM_TRAY_VISUAL to 0x%x", visualid);
@ -380,7 +383,7 @@ void tray_manager::set_tray_visual() {
* @param other_owner is set to the current owner if the function fails
* @returns Whether we acquired the selection
*/
bool tray_manager::acquire_selection(xcb_window_t& other_owner) {
bool manager::acquire_selection(xcb_window_t& other_owner) {
other_owner = XCB_NONE;
xcb_window_t owner = m_connection.get_selection_owner(m_atom).owner();
@ -404,7 +407,7 @@ bool tray_manager::acquire_selection(xcb_window_t& other_owner) {
/**
* Notify pending clients about the new systray MANAGER
*/
void tray_manager::notify_clients() {
void manager::notify_clients() {
if (is_active()) {
m_log.info("tray: Notifying pending tray clients");
auto message = m_connection.make_client_message(MANAGER, m_connection.root());
@ -418,7 +421,7 @@ void tray_manager::notify_clients() {
/**
* Send delayed notification to pending clients
*/
void tray_manager::notify_clients_delayed() {
void manager::notify_clients_delayed() {
if (m_delaythread.joinable()) {
m_delaythread.join();
}
@ -432,42 +435,42 @@ void tray_manager::notify_clients_delayed() {
* Track changes to the given selection owner
* If it gets destroyed or goes away we can reactivate the tray_manager
*/
void tray_manager::track_selection_owner(xcb_window_t owner) {
void manager::track_selection_owner(xcb_window_t owner) {
if (owner != XCB_NONE) {
const unsigned mask{XCB_CW_EVENT_MASK};
const unsigned values[]{XCB_EVENT_MASK_STRUCTURE_NOTIFY};
m_connection.change_window_attributes(owner, mask, values);
const uint32_t mask{XCB_CW_EVENT_MASK};
const uint32_t value{XCB_EVENT_MASK_STRUCTURE_NOTIFY};
m_connection.change_window_attributes(owner, mask, &value);
}
}
/**
* Process client docking request
*/
void tray_manager::process_docking_request(xcb_window_t win) {
void manager::process_docking_request(xcb_window_t win) {
m_log.info("tray: Processing docking request from '%s' (%s)", ewmh_util::get_wm_name(win), m_connection.id(win));
try {
auto client = make_unique<tray_client>(
auto cl = make_unique<client>(
m_log, m_connection, m_opts.selection_owner, win, m_opts.client_size, m_bar_opts.background.value());
try {
client->query_xembed();
cl->query_xembed();
} catch (const xpp::x::error::window& err) {
m_log.err("Failed to query _XEMBED_INFO, removing %s ... (%s)", client->name(), err.what());
m_log.err("Failed to query _XEMBED_INFO, removing %s ... (%s)", cl->name(), err.what());
return;
}
client->update_client_attributes();
cl->update_client_attributes();
client->reparent();
cl->reparent();
client->add_to_save_set();
cl->add_to_save_set();
client->ensure_state();
cl->ensure_state();
client->notify_xembed();
cl->notify_xembed();
m_clients.emplace_back(std::move(client));
m_clients.emplace_back(std::move(cl));
} catch (const std::exception& err) {
m_log.err("tray: Failed to setup tray client removing... (%s)", err.what());
return;
@ -477,18 +480,18 @@ void tray_manager::process_docking_request(xcb_window_t win) {
/**
* Calculate x position of tray window
*/
int tray_manager::calculate_x() const {
int manager::calculate_x() const {
return m_bar_opts.inner_area(false).x + m_pos.x;
}
int tray_manager::calculate_y() const {
int manager::calculate_y() const {
return m_bar_opts.inner_area(false).y + m_pos.y;
}
unsigned tray_manager::calculate_w() const {
unsigned manager::calculate_w() const {
unsigned width = m_opts.spacing;
unsigned count{0};
for (auto& client : m_clients) {
for (const auto& client : m_clients) {
if (client->mapped()) {
count++;
width += m_opts.spacing + m_opts.client_size.w;
@ -500,7 +503,7 @@ unsigned tray_manager::calculate_w() const {
/**
* Calculate y position of client window
*/
int tray_manager::calculate_client_y() {
int manager::calculate_client_y() {
return (m_bar_opts.inner_area(true).height - m_opts.client_size.h) / 2;
}
@ -509,14 +512,14 @@ int tray_manager::calculate_client_y() {
*
* The given window ID can be the ID of the wrapper or the embedded window
*/
bool tray_manager::is_embedded(const xcb_window_t& win) {
bool manager::is_embedded(const xcb_window_t& win) {
return find_client(win) != nullptr;
}
/**
* Find tray client object from the wrapper or embedded window
*/
tray_client* tray_manager::find_client(const xcb_window_t& win) {
client* manager::find_client(const xcb_window_t& win) {
auto client = std::find_if(m_clients.begin(), m_clients.end(),
[win](const auto& client) { return client->match(win) || client->embedder() == win; });
@ -530,20 +533,20 @@ tray_client* tray_manager::find_client(const xcb_window_t& win) {
/**
* Remove tray client
*/
void tray_manager::remove_client(const tray_client& client) {
remove_client(client.client());
void manager::remove_client(const client& c) {
remove_client(c.client_window());
}
/**
* Remove tray client by window
*/
void tray_manager::remove_client(xcb_window_t win) {
void manager::remove_client(xcb_window_t win) {
auto old_size = m_clients.size();
m_clients.erase(
std::remove_if(m_clients.begin(), m_clients.end(), [win](const auto& client) { return client->match(win); }));
if (old_size != m_clients.size()) {
tray_manager::reconfigure();
manager::reconfigure();
}
}
@ -554,12 +557,12 @@ void tray_manager::remove_client(xcb_window_t win) {
* 1. When removing a client during iteration, the unique_ptr is reset.
* 2. Afterwards all null pointers are removed from the list.
*/
void tray_manager::clean_clients() {
void manager::clean_clients() {
m_clients.erase(
std::remove_if(m_clients.begin(), m_clients.end(), [](const auto& client) { return client.get() == nullptr; }));
}
bool tray_manager::change_visibility(bool visible) {
bool manager::change_visibility(bool visible) {
if (!is_active() || m_hidden == !visible) {
return false;
}
@ -585,7 +588,7 @@ bool tray_manager::change_visibility(bool visible) {
/**
* Event callback : XCB_EXPOSE
*/
void tray_manager::handle(const evt::expose& evt) {
void manager::handle(const evt::expose& evt) {
if (is_active() && !m_clients.empty() && evt->count == 0) {
redraw_clients();
}
@ -594,7 +597,7 @@ void tray_manager::handle(const evt::expose& evt) {
/**
* Event callback : XCB_CLIENT_MESSAGE
*/
void tray_manager::handle(const evt::client_message& evt) {
void manager::handle(const evt::client_message& evt) {
if (!is_active()) {
return;
}
@ -625,7 +628,7 @@ void tray_manager::handle(const evt::client_message& evt) {
* wants to reconfigure its window. This is of course nothing we appreciate
* so we return an answer that'll put him in place.
*/
void tray_manager::handle(const evt::configure_request& evt) {
void manager::handle(const evt::configure_request& evt) {
if (is_active() && is_embedded(evt->window)) {
auto client = find_client(evt->window);
try {
@ -639,9 +642,9 @@ void tray_manager::handle(const evt::configure_request& evt) {
}
/**
* @see tray_manager::handle(const evt::configure_request&);
* @see manager::handle(const evt::configure_request&);
*/
void tray_manager::handle(const evt::resize_request& evt) {
void manager::handle(const evt::resize_request& evt) {
if (is_active() && is_embedded(evt->window)) {
auto client = find_client(evt->window);
try {
@ -657,7 +660,7 @@ void tray_manager::handle(const evt::resize_request& evt) {
/**
* Event callback : XCB_SELECTION_CLEAR
*/
void tray_manager::handle(const evt::selection_clear& evt) {
void manager::handle(const evt::selection_clear& evt) {
if (is_inactive()) {
return;
} else if (evt->selection != m_atom) {
@ -673,7 +676,7 @@ void tray_manager::handle(const evt::selection_clear& evt) {
/**
* Event callback : XCB_PROPERTY_NOTIFY
*/
void tray_manager::handle(const evt::property_notify& evt) {
void manager::handle(const evt::property_notify& evt) {
if (!is_active()) {
return;
}
@ -708,7 +711,7 @@ void tray_manager::handle(const evt::property_notify& evt) {
/**
* Event callback : XCB_REPARENT_NOTIFY
*/
void tray_manager::handle(const evt::reparent_notify& evt) {
void manager::handle(const evt::reparent_notify& evt) {
if (!is_active()) {
return;
}
@ -729,7 +732,7 @@ void tray_manager::handle(const evt::reparent_notify& evt) {
/**
* Event callback : XCB_DESTROY_NOTIFY
*/
void tray_manager::handle(const evt::destroy_notify& evt) {
void manager::handle(const evt::destroy_notify& evt) {
if (is_waiting() && evt->window == m_othermanager) {
m_log.info("Systray selection unmanaged... re-activating");
activate();
@ -743,7 +746,7 @@ void tray_manager::handle(const evt::destroy_notify& evt) {
/**
* Event callback : XCB_MAP_NOTIFY
*/
void tray_manager::handle(const evt::map_notify& evt) {
void manager::handle(const evt::map_notify& evt) {
if (is_active() && evt->window == m_opts.selection_owner) {
m_log.trace("tray: Received map_notify for selection owner");
redraw_clients();
@ -767,7 +770,7 @@ void tray_manager::handle(const evt::map_notify& evt) {
/**
* Event callback : XCB_UNMAP_NOTIFY
*/
void tray_manager::handle(const evt::unmap_notify& evt) {
void manager::handle(const evt::unmap_notify& evt) {
if (is_active() && is_embedded(evt->window)) {
auto client = find_client(evt->window);
@ -785,13 +788,13 @@ void tray_manager::handle(const evt::unmap_notify& evt) {
}
}
bool tray_manager::on(const signals::ui::update_background&) {
bool manager::on(const signals::ui::update_background&) {
redraw_clients();
return false;
}
bool tray_manager::on(const signals::ui_tray::tray_pos_change& evt) {
bool manager::on(const signals::ui_tray::tray_pos_change& evt) {
int new_x = std::max(0, std::min(evt.cast(), (int)(m_bar_opts.size.w - m_tray_width)));
if (new_x != m_pos.x) {
@ -802,8 +805,10 @@ bool tray_manager::on(const signals::ui_tray::tray_pos_change& evt) {
return true;
}
bool tray_manager::on(const signals::ui_tray::tray_visibility& evt) {
bool manager::on(const signals::ui_tray::tray_visibility& evt) {
return change_visibility(evt.cast());
}
} // namespace tray
POLYBAR_NS_END

218
src/x11/xembed.cpp
View File

@ -11,118 +11,118 @@ POLYBAR_NS
namespace xembed {
void info::set(uint32_t* data) {
version = data[0];
flags = data[1];
void info::set(const uint32_t* data) {
version = data[0];
flags = data[1];
}
uint32_t info::get_version() const {
return version;
}
uint32_t info::get_flags() const {
return flags;
}
bool info::is_mapped() const {
return (flags & XEMBED_MAPPED) == XEMBED_MAPPED;
}
string info::to_string() const {
return sstream() << "xembed(version=0x" << std::hex << get_version() << ", flags=0x" << get_flags()
<< ", XEMBED_MAPPED=" << std::dec << is_mapped() << ")";
}
/**
* Query _XEMBED_INFO for the given window
*
* @return Whether valid XEMBED info was found
*/
bool query(connection& conn, xcb_window_t win, info& data) {
auto info = conn.get_property(false, win, _XEMBED_INFO, _XEMBED_INFO, 0L, 2);
if (info->value_len == 0) {
return false;
}
uint32_t info::get_version() const {
return version;
}
uint32_t info::get_flags() const {
return flags;
}
bool info::is_mapped() const {
return (flags & XEMBED_MAPPED) == XEMBED_MAPPED;
}
string info::to_string() const {
return sstream() << "xembed(version=0x" << std::hex << get_version() << ", flags=0x" << get_flags()
<< ", XEMBED_MAPPED=" << std::dec << is_mapped() << ")";
}
/**
* Query _XEMBED_INFO for the given window
*
* @return Whether valid XEMBED info was found
*/
bool query(connection& conn, xcb_window_t win, info& data) {
auto info = conn.get_property(false, win, _XEMBED_INFO, _XEMBED_INFO, 0L, 2);
if (info->value_len == 0) {
return false;
}
std::vector<uint32_t> xembed_data{info.value<uint32_t>().begin(), info.value<uint32_t>().end()};
data.set(xembed_data.data());
return true;
}
/**
* Send _XEMBED messages
*/
void send_message(connection& conn, xcb_window_t target, uint32_t message, uint32_t d1, uint32_t d2, uint32_t d3) {
auto msg = conn.make_client_message(_XEMBED, target);
msg.data.data32[0] = XCB_CURRENT_TIME;
msg.data.data32[1] = message;
msg.data.data32[2] = d1;
msg.data.data32[3] = d2;
msg.data.data32[4] = d3;
conn.send_client_message(msg, target);
}
/**
* Send window focus event
*/
void send_focus_event(connection& conn, xcb_window_t target) {
auto msg = conn.make_client_message(WM_PROTOCOLS, target);
msg.data.data32[0] = WM_TAKE_FOCUS;
msg.data.data32[1] = XCB_CURRENT_TIME;
conn.send_client_message(msg, target);
}
/**
* Acknowledge window embedding
*/
void notify_embedded(connection& conn, xcb_window_t win, xcb_window_t embedder, uint32_t version) {
send_message(conn, win, XEMBED_EMBEDDED_NOTIFY, 0, embedder, std::min(version, XEMBED_MAX_VERSION));
}
/**
* Send window activate notification
*/
void notify_activated(connection& conn, xcb_window_t win) {
send_message(conn, win, XEMBED_WINDOW_ACTIVATE, 0, 0, 0);
}
/**
* Send window deactivate notification
*/
void notify_deactivated(connection& conn, xcb_window_t win) {
send_message(conn, win, XEMBED_WINDOW_DEACTIVATE, 0, 0, 0);
}
/**
* Send window focused notification
*/
void notify_focused(connection& conn, xcb_window_t win, uint32_t focus_type) {
send_message(conn, win, XEMBED_FOCUS_IN, focus_type, 0, 0);
}
/**
* Send window unfocused notification
*/
void notify_unfocused(connection& conn, xcb_window_t win) {
send_message(conn, win, XEMBED_FOCUS_OUT, 0, 0, 0);
}
/**
* Unembed given window
*/
void unembed(connection& conn, xcb_window_t win, xcb_window_t root) {
assert(win != XCB_NONE);
try {
conn.unmap_window_checked(win);
conn.reparent_window_checked(win, root, 0, 0);
} catch (const xpp::x::error::window& err) {
// invalid window
// TODO
logger::make().err("tray: Failed to unembed window '%s' (%s)", ewmh_util::get_wm_name(win), conn.id(win));
}
std::vector<uint32_t> xembed_data{info.value<uint32_t>().begin(), info.value<uint32_t>().end()};
data.set(xembed_data.data());
return true;
}
/**
* Send _XEMBED messages
*/
void send_message(connection& conn, xcb_window_t target, uint32_t message, uint32_t d1, uint32_t d2, uint32_t d3) {
auto msg = conn.make_client_message(_XEMBED, target);
msg.data.data32[0] = XCB_CURRENT_TIME;
msg.data.data32[1] = message;
msg.data.data32[2] = d1;
msg.data.data32[3] = d2;
msg.data.data32[4] = d3;
conn.send_client_message(msg, target);
}
/**
* Send window focus event
*/
void send_focus_event(connection& conn, xcb_window_t target) {
auto msg = conn.make_client_message(WM_PROTOCOLS, target);
msg.data.data32[0] = WM_TAKE_FOCUS;
msg.data.data32[1] = XCB_CURRENT_TIME;
conn.send_client_message(msg, target);
}
/**
* Acknowledge window embedding
*/
void notify_embedded(connection& conn, xcb_window_t win, xcb_window_t embedder, uint32_t version) {
send_message(conn, win, XEMBED_EMBEDDED_NOTIFY, 0, embedder, std::min(version, XEMBED_MAX_VERSION));
}
/**
* Send window activate notification
*/
void notify_activated(connection& conn, xcb_window_t win) {
send_message(conn, win, XEMBED_WINDOW_ACTIVATE, 0, 0, 0);
}
/**
* Send window deactivate notification
*/
void notify_deactivated(connection& conn, xcb_window_t win) {
send_message(conn, win, XEMBED_WINDOW_DEACTIVATE, 0, 0, 0);
}
/**
* Send window focused notification
*/
void notify_focused(connection& conn, xcb_window_t win, uint32_t focus_type) {
send_message(conn, win, XEMBED_FOCUS_IN, focus_type, 0, 0);
}
/**
* Send window unfocused notification
*/
void notify_unfocused(connection& conn, xcb_window_t win) {
send_message(conn, win, XEMBED_FOCUS_OUT, 0, 0, 0);
}
/**
* Unembed given window
*/
void unembed(connection& conn, xcb_window_t win, xcb_window_t root) {
assert(win != XCB_NONE);
try {
conn.unmap_window_checked(win);
conn.reparent_window_checked(win, root, 0, 0);
} catch (const xpp::x::error::window& err) {
// invalid window
// TODO
logger::make().err("tray: Failed to unembed window '%s' (%s)", ewmh_util::get_wm_name(win), conn.id(win));
}
}
} // namespace xembed
POLYBAR_NS_END