File: workspace_manager.hpp

package info (click to toggle)
waybar 0.14.0-1
  • links: PTS, VCS
  • area: main
  • in suites: forky, sid
  • size: 2,364 kB
  • sloc: cpp: 24,698; xml: 742; python: 146; ansic: 77; makefile: 26
file content (143 lines) | stat: -rw-r--r-- 4,040 bytes parent folder | download
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
#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 "AModule.hpp"
#include "bar.hpp"
#include "ext-workspace-v1-client-protocol.h"

namespace waybar::modules::ext {

class WorkspaceGroup;
class Workspace;

class WorkspaceManager final : public AModule {
 public:
  WorkspaceManager(const std::string &id, const waybar::Bar &bar, const Json::Value &config);
  ~WorkspaceManager() override;
  void register_manager(wl_registry *registry, uint32_t name, uint32_t version);
  void remove_workspace_group(uint32_t id);
  void remove_workspace(uint32_t id);
  void set_needs_sorting() { needs_sorting_ = true; }

  // wl events
  void handle_workspace_group(ext_workspace_group_handle_v1 *handle);
  void handle_workspace(ext_workspace_handle_v1 *handle);
  void handle_done();
  void handle_finished();

  // wl requests
  void commit() const;

 private:
  void update() override;
  bool has_button(const Gtk::Button *button);
  void sort_workspaces();
  void clear_buttons();
  void update_buttons();

  static uint32_t group_global_id;
  static uint32_t workspace_global_id;
  uint32_t workspace_name = 0;

  bool sort_by_id_ = false;
  bool sort_by_name_ = true;
  bool sort_by_coordinates_ = false;
  bool all_outputs_ = false;

  const waybar::Bar &bar_;
  Gtk::Box box_;

  ext_workspace_manager_v1 *ext_manager_ = nullptr;
  std::vector<std::unique_ptr<WorkspaceGroup>> groups_;
  std::vector<std::unique_ptr<Workspace>> workspaces_;

  bool needs_sorting_ = false;
};

class WorkspaceGroup {
 public:
  WorkspaceGroup(WorkspaceManager &manager, ext_workspace_group_handle_v1 *handle, uint32_t id);
  ~WorkspaceGroup();

  u_int32_t id() const { return id_; }
  bool has_output(const wl_output *output);
  bool has_workspace(const ext_workspace_handle_v1 *workspace);

  // wl events
  void handle_capabilities(uint32_t capabilities);
  void handle_output_enter(wl_output *output);
  void handle_output_leave(wl_output *output);
  void handle_workspace_enter(ext_workspace_handle_v1 *handle);
  void handle_workspace_leave(ext_workspace_handle_v1 *handle);
  void handle_removed();

 private:
  WorkspaceManager &workspaces_manager_;
  ext_workspace_group_handle_v1 *ext_handle_;
  uint32_t id_;
  std::vector<wl_output *> outputs_;
  std::vector<ext_workspace_handle_v1 *> workspaces_;
};

class Workspace {
 public:
  Workspace(const Json::Value &config, WorkspaceManager &manager, ext_workspace_handle_v1 *handle,
            uint32_t id, const std::string &name);
  ~Workspace();

  ext_workspace_handle_v1 *handle() const { return ext_handle_; }
  u_int32_t id() const { return id_; }
  std::string &workspace_id() { return workspace_id_; }
  std::string &name() { return name_; }
  std::vector<u_int32_t> &coordinates() { return coordinates_; }
  Gtk::Button &button() { return button_; }
  void update();

  // wl events
  void handle_id(const std::string &id);
  void handle_name(const std::string &name);
  void handle_coordinates(const std::vector<uint32_t> &coordinates);
  void handle_state(uint32_t state);
  void handle_capabilities(uint32_t capabilities);
  void handle_removed();

  // gdk events
  bool handle_clicked(const GdkEventButton *button) const;

 private:
  bool has_state(uint32_t state) const { return (state_ & state) == state; }
  std::string icon();

  WorkspaceManager &workspace_manager_;
  ext_workspace_handle_v1 *ext_handle_ = nullptr;
  uint32_t id_;
  uint32_t state_ = 0;
  std::string workspace_id_;
  std::string name_;
  std::vector<uint32_t> coordinates_;

  bool active_only_ = false;
  bool ignore_hidden_ = true;
  std::string format_;
  bool with_icon_ = false;
  static std::map<std::string, std::string> icon_map_;
  std::string on_click_action_;
  std::string on_click_middle_action_;
  std::string on_click_right_action_;

  Gtk::Button button_;
  Gtk::Box content_;
  Gtk::Label label_;

  bool needs_updating_ = false;
};

}  // namespace waybar::modules::ext