summaryrefslogtreecommitdiffstats
path: root/swaybar/bar.c
diff options
context:
space:
mode:
Diffstat (limited to 'swaybar/bar.c')
-rw-r--r--swaybar/bar.c644
1 files changed, 355 insertions, 289 deletions
diff --git a/swaybar/bar.c b/swaybar/bar.c
index f12923a8..d51c4ec7 100644
--- a/swaybar/bar.c
+++ b/swaybar/bar.c
@@ -1,390 +1,456 @@
1#define _XOPEN_SOURCE 500 1#define _XOPEN_SOURCE 500
2#include <assert.h>
3#include <errno.h>
4#include <fcntl.h>
5#include <poll.h>
6#include <signal.h>
2#include <stdlib.h> 7#include <stdlib.h>
3#include <unistd.h>
4#include <string.h> 8#include <string.h>
5#include <fcntl.h>
6#include <errno.h>
7#include <sys/wait.h> 9#include <sys/wait.h>
8#include <signal.h> 10#include <unistd.h>
9#include <poll.h> 11#include <wayland-client.h>
12#include <wayland-cursor.h>
13#include <wlr/util/log.h>
10#ifdef __FreeBSD__ 14#ifdef __FreeBSD__
11#include <dev/evdev/input-event-codes.h> 15#include <dev/evdev/input-event-codes.h>
12#else 16#else
13#include <linux/input-event-codes.h> 17#include <linux/input-event-codes.h>
14#endif 18#endif
15#ifdef ENABLE_TRAY
16#include <dbus/dbus.h>
17#include "swaybar/tray/sni_watcher.h"
18#include "swaybar/tray/tray.h"
19#include "swaybar/tray/sni.h"
20#endif
21#include "swaybar/ipc.h"
22#include "swaybar/render.h" 19#include "swaybar/render.h"
23#include "swaybar/config.h" 20#include "swaybar/config.h"
24#include "swaybar/status_line.h"
25#include "swaybar/event_loop.h" 21#include "swaybar/event_loop.h"
22#include "swaybar/status_line.h"
26#include "swaybar/bar.h" 23#include "swaybar/bar.h"
24#include "swaybar/ipc.h"
27#include "ipc-client.h" 25#include "ipc-client.h"
28#include "list.h" 26#include "list.h"
29#include "log.h" 27#include "log.h"
28#include "pango.h"
29#include "pool-buffer.h"
30#include "wlr-layer-shell-unstable-v1-client-protocol.h"
30 31
31static void bar_init(struct bar *bar) { 32static void bar_init(struct swaybar *bar) {
32 bar->config = init_config(); 33 bar->config = init_config();
33 bar->status = init_status_line(); 34 wl_list_init(&bar->outputs);
34 bar->outputs = create_list();
35} 35}
36 36
37static void spawn_status_cmd_proc(struct bar *bar) { 37static void swaybar_output_free(struct swaybar_output *output) {
38 if (bar->config->status_command) { 38 if (!output) {
39 int pipe_read_fd[2]; 39 return;
40 int pipe_write_fd[2]; 40 }
41 41 wlr_log(L_DEBUG, "Removing output %s", output->name);
42 if (pipe(pipe_read_fd) != 0) { 42 zwlr_layer_surface_v1_destroy(output->layer_surface);
43 sway_log(L_ERROR, "Unable to create pipes for status_command fork"); 43 wl_surface_destroy(output->surface);
44 return; 44 wl_output_destroy(output->output);
45 } 45 destroy_buffer(&output->buffers[0]);
46 if (pipe(pipe_write_fd) != 0) { 46 destroy_buffer(&output->buffers[1]);
47 sway_log(L_ERROR, "Unable to create pipe for status_command fork (write)"); 47 struct swaybar_workspace *ws, *ws_tmp;
48 close(pipe_read_fd[0]); 48 wl_list_for_each_safe(ws, ws_tmp, &output->workspaces, link) {
49 close(pipe_read_fd[1]); 49 wl_list_remove(&ws->link);
50 return; 50 free(ws->name);
51 } 51 free(ws);
52 52 }
53 bar->status_command_pid = fork(); 53 struct swaybar_hotspot *hotspot, *hotspot_tmp;
54 if (bar->status_command_pid == 0) { 54 wl_list_for_each_safe(hotspot, hotspot_tmp, &output->hotspots, link) {
55 close(pipe_read_fd[0]); 55 if (hotspot->destroy) {
56 dup2(pipe_read_fd[1], STDOUT_FILENO); 56 hotspot->destroy(hotspot->data);
57 close(pipe_read_fd[1]);
58
59 dup2(pipe_write_fd[0], STDIN_FILENO);
60 close(pipe_write_fd[0]);
61 close(pipe_write_fd[1]);
62
63 char *const cmd[] = {
64 "sh",
65 "-c",
66 bar->config->status_command,
67 NULL,
68 };
69 execvp(cmd[0], cmd);
70 return;
71 } 57 }
72 58 free(hotspot);
73 close(pipe_read_fd[1]);
74 bar->status_read_fd = pipe_read_fd[0];
75 fcntl(bar->status_read_fd, F_SETFL, O_NONBLOCK);
76
77 close(pipe_write_fd[0]);
78 bar->status_write_fd = pipe_write_fd[1];
79 fcntl(bar->status_write_fd, F_SETFL, O_NONBLOCK);
80 } 59 }
60 wl_list_remove(&output->link);
61 free(output->name);
62 free(output);
81} 63}
82 64
83struct output *new_output(const char *name) { 65static void layer_surface_configure(void *data,
84 struct output *output = malloc(sizeof(struct output)); 66 struct zwlr_layer_surface_v1 *surface,
85 output->name = strdup(name); 67 uint32_t serial, uint32_t width, uint32_t height) {
86 output->window = NULL; 68 struct swaybar_output *output = data;
87 output->registry = NULL; 69 output->width = width;
88 output->workspaces = create_list(); 70 output->height = height;
89#ifdef ENABLE_TRAY 71 zwlr_layer_surface_v1_ack_configure(surface, serial);
90 output->items = create_list(); 72 render_frame(output->bar, output);
91#endif
92 return output;
93} 73}
94 74
95static void mouse_button_notify(struct window *window, int x, int y, 75static void layer_surface_closed(void *_output,
96 uint32_t button, uint32_t state_w) { 76 struct zwlr_layer_surface_v1 *surface) {
97 sway_log(L_DEBUG, "Mouse button %d clicked at %d %d %d", button, x, y, state_w); 77 struct swaybar_output *output = _output;
98 if (!state_w) { 78 swaybar_output_free(output);
99 return; 79}
100 }
101 80
102 struct output *clicked_output = NULL; 81struct zwlr_layer_surface_v1_listener layer_surface_listener = {
103 for (int i = 0; i < swaybar.outputs->length; i++) { 82 .configure = layer_surface_configure,
104 struct output *output = swaybar.outputs->items[i]; 83 .closed = layer_surface_closed,
105 if (window == output->window) { 84};
106 clicked_output = output; 85
86static void wl_pointer_enter(void *data, struct wl_pointer *wl_pointer,
87 uint32_t serial, struct wl_surface *surface,
88 wl_fixed_t surface_x, wl_fixed_t surface_y) {
89 struct swaybar *bar = data;
90 struct swaybar_pointer *pointer = &bar->pointer;
91 struct swaybar_output *output;
92 wl_list_for_each(output, &bar->outputs, link) {
93 if (output->surface == surface) {
94 pointer->current = output;
107 break; 95 break;
108 } 96 }
109 } 97 }
110 98 int max_scale = 1;
111 if (!sway_assert(clicked_output != NULL, "Got pointer event for non-existing output")) { 99 struct swaybar_output *_output;
112 return; 100 wl_list_for_each(_output, &bar->outputs, link) {
113 } 101 if (_output->scale > max_scale) {
114 102 max_scale = _output->scale;
115 double button_x = 0.5;
116 for (int i = 0; i < clicked_output->workspaces->length; i++) {
117 struct workspace *workspace = clicked_output->workspaces->items[i];
118 int button_width, button_height;
119
120 workspace_button_size(window, workspace->name, &button_width, &button_height);
121
122 button_x += button_width;
123 if (x <= button_x) {
124 ipc_send_workspace_command(workspace->name);
125 break;
126 } 103 }
127 } 104 }
105 wl_surface_set_buffer_scale(pointer->cursor_surface, max_scale);
106 wl_surface_attach(pointer->cursor_surface,
107 wl_cursor_image_get_buffer(pointer->cursor_image), 0, 0);
108 wl_pointer_set_cursor(wl_pointer, serial, pointer->cursor_surface,
109 pointer->cursor_image->hotspot_x / max_scale,
110 pointer->cursor_image->hotspot_y / max_scale);
111 wl_surface_commit(pointer->cursor_surface);
112}
128 113
129 switch (button) { 114static void wl_pointer_leave(void *data, struct wl_pointer *wl_pointer,
130 case BTN_LEFT: 115 uint32_t serial, struct wl_surface *surface) {
131 status_line_mouse_event(&swaybar, x, y, 1); 116 struct swaybar *bar = data;
132 break; 117 bar->pointer.current = NULL;
133 case BTN_MIDDLE: 118}
134 status_line_mouse_event(&swaybar, x, y, 2);
135 break;
136 case BTN_RIGHT:
137 status_line_mouse_event(&swaybar, x, y, 3);
138 break;
139 }
140
141#ifdef ENABLE_TRAY
142 tray_mouse_event(clicked_output, x, y, button, state_w);
143#endif
144 119
120static void wl_pointer_motion(void *data, struct wl_pointer *wl_pointer,
121 uint32_t time, wl_fixed_t surface_x, wl_fixed_t surface_y) {
122 struct swaybar *bar = data;
123 bar->pointer.x = wl_fixed_to_int(surface_x);
124 bar->pointer.y = wl_fixed_to_int(surface_y);
145} 125}
146 126
147static void mouse_scroll_notify(struct window *window, enum scroll_direction direction) { 127static void wl_pointer_button(void *data, struct wl_pointer *wl_pointer,
148 sway_log(L_DEBUG, "Mouse wheel scrolled %s", direction == SCROLL_UP ? "up" : "down"); 128 uint32_t serial, uint32_t time, uint32_t button, uint32_t state) {
149 129 struct swaybar *bar = data;
150 // If there are status blocks and click_events are enabled 130 struct swaybar_pointer *pointer = &bar->pointer;
151 // check if the position is within the status area and if so 131 struct swaybar_output *output = pointer->current;
152 // tell the status line to output the event and skip workspace 132 if (!sway_assert(output, "button with no active output")) {
153 // switching below. 133 return;
154 int num_blocks = swaybar.status->block_line->length; 134 }
155 if (swaybar.status->click_events && num_blocks > 0) { 135 if (state != WL_POINTER_BUTTON_STATE_PRESSED) {
156 struct status_block *first_block = swaybar.status->block_line->items[0]; 136 return;
157 int x = window->pointer_input.last_x; 137 }
158 int y = window->pointer_input.last_y; 138 struct swaybar_hotspot *hotspot;
159 if (x > first_block->x) { 139 wl_list_for_each(hotspot, &output->hotspots, link) {
160 if (direction == SCROLL_UP) { 140 double x = pointer->x * output->scale;
161 status_line_mouse_event(&swaybar, x, y, 4); 141 double y = pointer->y * output->scale;
162 } else { 142 if (x >= hotspot->x
163 status_line_mouse_event(&swaybar, x, y, 5); 143 && y >= hotspot->y
164 } 144 && x < hotspot->x + hotspot->width
165 return; 145 && y < hotspot->y + hotspot->height) {
146 hotspot->callback(output, pointer->x, pointer->y,
147 button, hotspot->data);
166 } 148 }
167 } 149 }
150}
168 151
169 if (!swaybar.config->wrap_scroll) { 152static void wl_pointer_axis(void *data, struct wl_pointer *wl_pointer,
170 // Find output this window lives on 153 uint32_t time, uint32_t axis, wl_fixed_t value) {
171 int i; 154 struct swaybar *bar = data;
172 struct output *output = NULL; 155 struct swaybar_output *output = bar->pointer.current;
173 for (i = 0; i < swaybar.outputs->length; ++i) { 156 if (!sway_assert(output, "axis with no active output")) {
174 output = swaybar.outputs->items[i]; 157 return;
175 if (output->window == window) { 158 }
176 break; 159 double amt = wl_fixed_to_double(value);
177 } 160 if (!bar->config->wrap_scroll) {
178 } 161 int i = 0;
179 if (!sway_assert(i != swaybar.outputs->length, "Unknown window in scroll event")) { 162 struct swaybar_workspace *ws = NULL;
180 return; 163 wl_list_for_each(ws, &output->workspaces, link) {
181 }
182 int focused = -1;
183 for (i = 0; i < output->workspaces->length; ++i) {
184 struct workspace *ws = output->workspaces->items[i];
185 if (ws->focused) { 164 if (ws->focused) {
186 focused = i;
187 break; 165 break;
188 } 166 }
167 ++i;
189 } 168 }
190 if (!sway_assert(focused != -1, "Scroll wheel event received on inactive output")) { 169 int len = wl_list_length(&output->workspaces);
170 if (!sway_assert(i != len, "axis with null workspace")) {
191 return; 171 return;
192 } 172 }
193 if ((focused == 0 && direction == SCROLL_UP) || 173 if (i == 0 && amt > 0) {
194 (focused == output->workspaces->length - 1 && direction == SCROLL_DOWN)) { 174 return; // Do not wrap
195 // Do not wrap 175 }
196 return; 176 if (i == len - 1 && amt < 0) {
177 return; // Do not wrap
197 } 178 }
198 } 179 }
199 180
200 const char *workspace_name = direction == SCROLL_UP ? "prev_on_output" : "next_on_output"; 181 const char *workspace_name =
201 ipc_send_workspace_command(workspace_name); 182 amt < 0 ? "prev_on_output" : "next_on_output";
183 ipc_send_workspace_command(bar, workspace_name);
202} 184}
203 185
204void bar_setup(struct bar *bar, const char *socket_path, const char *bar_id) { 186static void wl_pointer_frame(void *data, struct wl_pointer *wl_pointer) {
205 /* initialize bar with default values */ 187 // Who cares
206 bar_init(bar); 188}
207
208 /* Initialize event loop lists */
209 init_event_loop();
210
211 /* connect to sway ipc */
212 bar->ipc_socketfd = ipc_open_socket(socket_path);
213 bar->ipc_event_socketfd = ipc_open_socket(socket_path);
214
215 ipc_bar_init(bar, bar_id);
216
217 int i;
218 for (i = 0; i < bar->outputs->length; ++i) {
219 struct output *bar_output = bar->outputs->items[i];
220
221 bar_output->registry = registry_poll();
222
223 if (!bar_output->registry->desktop_shell) {
224 sway_abort("swaybar requires the compositor to support the desktop-shell extension.");
225 }
226
227 struct output_state *output = bar_output->registry->outputs->items[bar_output->idx];
228
229 bar_output->window = window_setup(bar_output->registry,
230 output->width / output->scale, 30, output->scale, false);
231 if (!bar_output->window) {
232 sway_abort("Failed to create window.");
233 }
234 desktop_shell_set_panel(bar_output->registry->desktop_shell,
235 output->output, bar_output->window->surface);
236 desktop_shell_set_panel_position(bar_output->registry->desktop_shell,
237 bar->config->position);
238 189
239 window_make_shell(bar_output->window); 190static void wl_pointer_axis_source(void *data, struct wl_pointer *wl_pointer,
191 uint32_t axis_source) {
192 // Who cares
193}
240 194
241 /* set font */ 195static void wl_pointer_axis_stop(void *data, struct wl_pointer *wl_pointer,
242 bar_output->window->font = bar->config->font; 196 uint32_t time, uint32_t axis) {
197 // Who cares
198}
243 199
244 /* set mouse event callbacks */ 200static void wl_pointer_axis_discrete(void *data, struct wl_pointer *wl_pointer,
245 bar_output->window->pointer_input.notify_button = mouse_button_notify; 201 uint32_t axis, int32_t discrete) {
246 bar_output->window->pointer_input.notify_scroll = mouse_scroll_notify; 202 // Who cares
203}
247 204
248 /* set window height */ 205struct wl_pointer_listener pointer_listener = {
249 set_window_height(bar_output->window, bar->config->height); 206 .enter = wl_pointer_enter,
207 .leave = wl_pointer_leave,
208 .motion = wl_pointer_motion,
209 .button = wl_pointer_button,
210 .axis = wl_pointer_axis,
211 .frame = wl_pointer_frame,
212 .axis_source = wl_pointer_axis_source,
213 .axis_stop = wl_pointer_axis_stop,
214 .axis_discrete = wl_pointer_axis_discrete,
215};
216
217static void seat_handle_capabilities(void *data, struct wl_seat *wl_seat,
218 enum wl_seat_capability caps) {
219 struct swaybar *bar = data;
220 if ((caps & WL_SEAT_CAPABILITY_POINTER)) {
221 bar->pointer.pointer = wl_seat_get_pointer(wl_seat);
222 wl_pointer_add_listener(bar->pointer.pointer, &pointer_listener, bar);
250 } 223 }
251 /* spawn status command */ 224}
252 spawn_status_cmd_proc(bar);
253 225
254#ifdef ENABLE_TRAY 226static void seat_handle_name(void *data, struct wl_seat *wl_seat,
255 init_tray(bar); 227 const char *name) {
256#endif 228 // Who cares
257} 229}
258 230
259bool dirty = true; 231const struct wl_seat_listener seat_listener = {
232 .capabilities = seat_handle_capabilities,
233 .name = seat_handle_name,
234};
260 235
261static void respond_ipc(int fd, short mask, void *_bar) { 236static void output_geometry(void *data, struct wl_output *output, int32_t x,
262 struct bar *bar = (struct bar *)_bar; 237 int32_t y, int32_t width_mm, int32_t height_mm, int32_t subpixel,
263 sway_log(L_DEBUG, "Got IPC event."); 238 const char *make, const char *model, int32_t transform) {
264 dirty = handle_ipc_event(bar); 239 // Who cares
265} 240}
266 241
267static void respond_command(int fd, short mask, void *_bar) { 242static void output_mode(void *data, struct wl_output *output, uint32_t flags,
268 struct bar *bar = (struct bar *)_bar; 243 int32_t width, int32_t height, int32_t refresh) {
269 dirty = handle_status_line(bar); 244 // Who cares
270} 245}
271 246
272static void respond_output(int fd, short mask, void *_output) { 247static void output_done(void *data, struct wl_output *output) {
273 struct output *output = (struct output *)_output; 248 // Who cares
274 if (wl_display_dispatch(output->registry->display) == -1) { 249}
275 sway_log(L_ERROR, "failed to dispatch wl: %d", errno); 250
251static void output_scale(void *data, struct wl_output *wl_output,
252 int32_t factor) {
253 struct swaybar_output *output = data;
254 output->scale = factor;
255 if (output->surface) {
256 render_frame(output->bar, output);
276 } 257 }
277} 258}
278 259
279void bar_run(struct bar *bar) { 260struct wl_output_listener output_listener = {
280 add_event(bar->ipc_event_socketfd, POLLIN, respond_ipc, bar); 261 .geometry = output_geometry,
281 add_event(bar->status_read_fd, POLLIN, respond_command, bar); 262 .mode = output_mode,
263 .done = output_done,
264 .scale = output_scale,
265};
282 266
283 int i; 267static bool bar_uses_output(struct swaybar *bar, size_t output_index) {
284 for (i = 0; i < bar->outputs->length; ++i) { 268 if (bar->config->all_outputs) {
285 struct output *output = bar->outputs->items[i]; 269 return true;
286 add_event(wl_display_get_fd(output->registry->display),
287 POLLIN, respond_output, output);
288 } 270 }
289 271 struct config_output *coutput;
290 while (1) { 272 wl_list_for_each(coutput, &bar->config->outputs, link) {
291 if (dirty) { 273 if (coutput->index == output_index) {
292 int i; 274 return true;
293 for (i = 0; i < bar->outputs->length; ++i) {
294 struct output *output = bar->outputs->items[i];
295 if (window_prerender(output->window) && output->window->cairo) {
296 render(output, bar->config, bar->status);
297 window_render(output->window);
298 wl_display_flush(output->registry->display);
299 }
300 }
301 } 275 }
276 }
277 return false;
278}
302 279
303 dirty = false; 280static void handle_global(void *data, struct wl_registry *registry,
304 281 uint32_t name, const char *interface, uint32_t version) {
305 event_loop_poll(); 282 struct swaybar *bar = data;
306#ifdef ENABLE_TRAY 283 if (strcmp(interface, wl_compositor_interface.name) == 0) {
307 dispatch_dbus(); 284 bar->compositor = wl_registry_bind(registry, name,
308#endif 285 &wl_compositor_interface, 3);
286 } else if (strcmp(interface, wl_seat_interface.name) == 0) {
287 bar->seat = wl_registry_bind(registry, name,
288 &wl_seat_interface, 1);
289 wl_seat_add_listener(bar->seat, &seat_listener, bar);
290 } else if (strcmp(interface, wl_shm_interface.name) == 0) {
291 bar->shm = wl_registry_bind(registry, name,
292 &wl_shm_interface, 1);
293 } else if (strcmp(interface, wl_output_interface.name) == 0) {
294 static size_t output_index = 0;
295 if (bar_uses_output(bar, output_index)) {
296 struct swaybar_output *output =
297 calloc(1, sizeof(struct swaybar_output));
298 output->bar = bar;
299 output->output = wl_registry_bind(registry, name,
300 &wl_output_interface, 3);
301 wl_output_add_listener(output->output, &output_listener, output);
302 output->scale = 1;
303 output->index = output_index;
304 output->wl_name = name;
305 wl_list_init(&output->workspaces);
306 wl_list_init(&output->hotspots);
307 wl_list_insert(&bar->outputs, &output->link);
308 }
309 ++output_index;
310 } else if (strcmp(interface, zwlr_layer_shell_v1_interface.name) == 0) {
311 bar->layer_shell = wl_registry_bind(
312 registry, name, &zwlr_layer_shell_v1_interface, 1);
309 } 313 }
310} 314}
311 315
312void free_workspaces(list_t *workspaces) { 316static void handle_global_remove(void *data, struct wl_registry *registry,
313 int i; 317 uint32_t name) {
314 for (i = 0; i < workspaces->length; ++i) { 318 struct swaybar *bar = data;
315 struct workspace *ws = workspaces->items[i]; 319 struct swaybar_output *output, *tmp;
316 free(ws->name); 320 wl_list_for_each_safe(output, tmp, &bar->outputs, link) {
317 free(ws); 321 if (output->wl_name == name) {
322 swaybar_output_free(output);
323 break;
324 }
318 } 325 }
319 list_free(workspaces);
320} 326}
321 327
322static void free_output(struct output *output) { 328static const struct wl_registry_listener registry_listener = {
323 window_teardown(output->window); 329 .global = handle_global,
324 if (output->registry) { 330 .global_remove = handle_global_remove,
325 registry_teardown(output->registry); 331};
332
333static void render_all_frames(struct swaybar *bar) {
334 struct swaybar_output *output;
335 wl_list_for_each(output, &bar->outputs, link) {
336 render_frame(bar, output);
326 } 337 }
338}
327 339
328 free(output->name); 340void bar_setup(struct swaybar *bar,
341 const char *socket_path, const char *bar_id) {
342 bar_init(bar);
343 init_event_loop();
329 344
330 if (output->workspaces) { 345 bar->ipc_socketfd = ipc_open_socket(socket_path);
331 free_workspaces(output->workspaces); 346 bar->ipc_event_socketfd = ipc_open_socket(socket_path);
347 ipc_initialize(bar, bar_id);
348 if (bar->config->status_command) {
349 bar->status = status_line_init(bar->config->status_command);
332 } 350 }
333 351
334 free(output); 352 bar->display = wl_display_connect(NULL);
335} 353 assert(bar->display);
336 354
337static void free_outputs(list_t *outputs) { 355 struct wl_registry *registry = wl_display_get_registry(bar->display);
338 int i; 356 wl_registry_add_listener(registry, &registry_listener, bar);
339 for (i = 0; i < outputs->length; ++i) { 357 wl_display_roundtrip(bar->display);
340 free_output(outputs->items[i]); 358 assert(bar->compositor && bar->layer_shell && bar->shm);
359 wl_display_roundtrip(bar->display);
360
361 struct swaybar_pointer *pointer = &bar->pointer;
362
363 int max_scale = 1;
364 struct swaybar_output *output;
365 wl_list_for_each(output, &bar->outputs, link) {
366 if (output->scale > max_scale) {
367 max_scale = output->scale;
368 }
341 } 369 }
342 list_free(outputs);
343}
344 370
345static void terminate_status_command(pid_t pid) { 371 pointer->cursor_theme = wl_cursor_theme_load(
346 if (pid) { 372 NULL, 24 * max_scale, bar->shm);
347 // terminate status_command process 373 assert(pointer->cursor_theme);
348 int ret = kill(pid, SIGTERM); 374 struct wl_cursor *cursor;
349 if (ret != 0) { 375 cursor = wl_cursor_theme_get_cursor(pointer->cursor_theme, "left_ptr");
350 sway_log(L_ERROR, "Unable to terminate status_command [pid: %d]", pid); 376 assert(cursor);
351 } else { 377 pointer->cursor_image = cursor->images[0];
352 int status; 378 pointer->cursor_surface = wl_compositor_create_surface(bar->compositor);
353 waitpid(pid, &status, 0); 379 assert(pointer->cursor_surface);
380
381 wl_list_for_each(output, &bar->outputs, link) {
382 struct config_output *coutput;
383 wl_list_for_each(coutput, &bar->config->outputs, link) {
384 if (coutput->index == output->index) {
385 output->name = strdup(coutput->name);
386 break;
387 }
354 } 388 }
389 output->surface = wl_compositor_create_surface(bar->compositor);
390 assert(output->surface);
391 output->layer_surface = zwlr_layer_shell_v1_get_layer_surface(
392 bar->layer_shell, output->surface, output->output,
393 ZWLR_LAYER_SHELL_V1_LAYER_BOTTOM, "panel");
394 assert(output->layer_surface);
395 zwlr_layer_surface_v1_add_listener(output->layer_surface,
396 &layer_surface_listener, output);
397 zwlr_layer_surface_v1_set_anchor(output->layer_surface,
398 bar->config->position);
355 } 399 }
400 ipc_get_workspaces(bar);
401 render_all_frames(bar);
356} 402}
357 403
358void bar_teardown(struct bar *bar) { 404static void display_in(int fd, short mask, void *_bar) {
359 if (bar->config) { 405 struct swaybar *bar = (struct swaybar *)_bar;
360 free_config(bar->config); 406 if (wl_display_dispatch(bar->display) == -1) {
407 bar_teardown(bar);
408 exit(0);
361 } 409 }
410}
362 411
363 if (bar->outputs) { 412static void ipc_in(int fd, short mask, void *_bar) {
364 free_outputs(bar->outputs); 413 struct swaybar *bar = (struct swaybar *)_bar;
414 if (handle_ipc_readable(bar)) {
415 render_all_frames(bar);
365 } 416 }
417}
366 418
367 if (bar->status) { 419static void status_in(int fd, short mask, void *_bar) {
368 free_status_line(bar->status); 420 struct swaybar *bar = (struct swaybar *)_bar;
421 if (status_handle_readable(bar->status)) {
422 render_all_frames(bar);
369 } 423 }
424}
370 425
371 /* close sockets/pipes */ 426void bar_run(struct swaybar *bar) {
372 if (bar->status_read_fd) { 427 add_event(wl_display_get_fd(bar->display), POLLIN, display_in, bar);
373 close(bar->status_read_fd); 428 add_event(bar->ipc_event_socketfd, POLLIN, ipc_in, bar);
429 if (bar->status) {
430 add_event(bar->status->read_fd, POLLIN, status_in, bar);
374 } 431 }
375 432 while (1) {
376 if (bar->status_write_fd) { 433 event_loop_poll();
377 close(bar->status_write_fd);
378 } 434 }
435}
379 436
380 if (bar->ipc_socketfd) { 437static void free_outputs(struct wl_list *list) {
381 close(bar->ipc_socketfd); 438 struct swaybar_output *output, *tmp;
439 wl_list_for_each_safe(output, tmp, list, link) {
440 wl_list_remove(&output->link);
441 free(output->name);
442 free(output);
382 } 443 }
444}
383 445
384 if (bar->ipc_event_socketfd) { 446void bar_teardown(struct swaybar *bar) {
385 close(bar->ipc_event_socketfd); 447 free_outputs(&bar->outputs);
448 if (bar->config) {
449 free_config(bar->config);
450 }
451 close(bar->ipc_event_socketfd);
452 close(bar->ipc_socketfd);
453 if (bar->status) {
454 status_line_free(bar->status);
386 } 455 }
387
388 /* terminate status command process */
389 terminate_status_command(bar->status_command_pid);
390} 456}
generated by cgit v1.2.3-54-g00ecf (git 2.45.2) at 2024-07-01 08:44:43 +0000