ceos/cagebreak
1
0
Fork 0
mirror of https://cagebreak.project-repo.co/cagebreak.git synced 2026-08-22 05:24:22 +02:00
Code Issues Projects Releases Packages Wiki Activity

Apply clang-format

Browse source
This commit is contained in:
project-repo 2022-09-09 19:03:56 +02:00
commit 5de047b141
13 changed files with 471 additions and 361 deletions
Download patch file Download diff file Expand all files Collapse all files

36
cagebreak.c
View file

@ -16,29 +16,29 @@
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/wait.h>
#include <string.h>
#include <sys/wait.h>
#include <unistd.h>
#include <wayland-server-core.h>
#include <wayland-client.h>
#include <wayland-server-core.h>
#include <wlr/backend.h>
#include <wlr/types/wlr_scene.h>
#include <wlr/render/allocator.h>
#include <wlr/render/wlr_renderer.h>
#include <wlr/types/wlr_compositor.h>
#include <wlr/types/wlr_cursor.h>
#include <wlr/types/wlr_data_control_v1.h>
#include <wlr/types/wlr_primary_selection_v1.h>
#include <wlr/types/wlr_data_device.h>
#include <wlr/types/wlr_export_dmabuf_v1.h>
#include <wlr/types/wlr_gamma_control_v1.h>
#include <wlr/types/wlr_idle.h>
#include <wlr/types/wlr_viewporter.h>
#include <wlr/types/wlr_presentation_time.h>
#include <wlr/types/wlr_idle_inhibit_v1.h>
#include <wlr/types/wlr_output_layout.h>
#include <wlr/types/wlr_presentation_time.h>
#include <wlr/types/wlr_primary_selection_v1.h>
#include <wlr/types/wlr_scene.h>
#include <wlr/types/wlr_screencopy_v1.h>
#include <wlr/types/wlr_server_decoration.h>
#include <wlr/types/wlr_viewporter.h>
#if CG_HAS_XWAYLAND
#include <wlr/types/wlr_xcursor_manager.h>
#endif
@ -226,7 +226,7 @@ get_config_file() {
int
main(int argc, char *argv[]) {
printf("This is cagebreak, version %s\n",CG_VERSION);
printf("This is cagebreak, version %s\n", CG_VERSION);
struct cg_server server = {0};
struct wl_event_loop *event_loop = NULL;
struct wl_event_source *sigint_source = NULL;
@ -341,14 +341,15 @@ main(int argc, char *argv[]) {
}
server.renderer = wlr_renderer_autocreate(backend);
if (!server.renderer) {
if(!server.renderer) {
wlr_log(WLR_ERROR, "Unable to create the wlroots renderer");
ret = 1;
goto end;
}
server.allocator = wlr_allocator_autocreate(server.backend, server.renderer);
if (!server.allocator) {
server.allocator =
wlr_allocator_autocreate(server.backend, server.renderer);
if(!server.allocator) {
wlr_log(WLR_ERROR, "Unable to create the wlroots allocator");
ret = 1;
goto end;
@ -374,7 +375,7 @@ main(int argc, char *argv[]) {
}
server.scene = wlr_scene_create();
if (!server.scene) {
if(!server.scene) {
wlr_log(WLR_ERROR, "Unable to create scene");
ret = 1;
goto end;
@ -468,28 +469,28 @@ main(int argc, char *argv[]) {
server_decoration_manager, WLR_SERVER_DECORATION_MANAGER_MODE_SERVER);
viewporter = wlr_viewporter_create(server.wl_display);
if (!viewporter) {
if(!viewporter) {
wlr_log(WLR_ERROR, "Unable to create the viewporter interface");
ret = 1;
goto end;
}
presentation = wlr_presentation_create(server.wl_display, server.backend);
if (!presentation) {
if(!presentation) {
wlr_log(WLR_ERROR, "Unable to create the presentation interface");
ret = 1;
goto end;
}
wlr_scene_set_presentation(server.scene, presentation);
export_dmabuf_manager = wlr_export_dmabuf_manager_v1_create(server.wl_display);
if (!export_dmabuf_manager) {
export_dmabuf_manager =
wlr_export_dmabuf_manager_v1_create(server.wl_display);
if(!export_dmabuf_manager) {
wlr_log(WLR_ERROR, "Unable to create the export DMABUF manager");
ret = 1;
goto end;
}
screencopy_manager = wlr_screencopy_manager_v1_create(server.wl_display);
if(!screencopy_manager) {
wlr_log(WLR_ERROR, "Unable to create the screencopy manager");
@ -506,7 +507,8 @@ main(int argc, char *argv[]) {
}
if(!wlr_primary_selection_v1_device_manager_create(server.wl_display)) {
wlr_log(WLR_ERROR, "Unable to create the primary selection device manager");
wlr_log(WLR_ERROR,
"Unable to create the primary selection device manager");
ret = 1;
goto end;
}

498
keybinding.c
View file

@ -1,25 +1,25 @@
#define _POSIX_C_SOURCE 200809L
#include <string.h>
#include <unistd.h>
#include <sys/wait.h>
#include <unistd.h>
#include <wayland-server-core.h>
#include <wlr/backend/multi.h>
#include <wlr/backend/session.h>
#include <wlr/types/wlr_cursor.h>
#include <wlr/types/wlr_output_damage.h>
#include <wlr/types/wlr_output_layout.h>
#include <wlr/types/wlr_cursor.h>
#include <wlr/types/wlr_scene.h>
#include <wlr/util/log.h>
#include "input.h"
#include "util.h"
#include "input_manager.h"
#include "keybinding.h"
#include "message.h"
#include "output.h"
#include "seat.h"
#include "server.h"
#include "util.h"
#include "view.h"
#include "workspace.h"
@ -145,10 +145,12 @@ is_between_strict(int a, int b, int x) {
struct cg_tile *
find_right_tile(const struct cg_tile *tile) {
struct cg_tile *it = tile->next;
int center=tile->tile.y+tile->tile.height/2;
int center = tile->tile.y + tile->tile.height / 2;
while(it != tile) {
if(it->tile.x== tile->tile.x+tile->tile.width) {
if(is_between_strict(it->tile.y,it->tile.y+it->tile.height,center)||it->tile.y+it->tile.height==center) {
if(it->tile.x == tile->tile.x + tile->tile.width) {
if(is_between_strict(it->tile.y, it->tile.y + it->tile.height,
center) ||
it->tile.y + it->tile.height == center) {
return it;
}
}
@ -160,10 +162,12 @@ find_right_tile(const struct cg_tile *tile) {
struct cg_tile *
find_left_tile(const struct cg_tile *tile) {
struct cg_tile *it = tile->next;
int center=tile->tile.y+tile->tile.height/2;
int center = tile->tile.y + tile->tile.height / 2;
while(it != tile) {
if(it->tile.x+it->tile.width == tile->tile.x) {
if(is_between_strict(it->tile.y,it->tile.y+it->tile.height,center)||it->tile.y+it->tile.height==center) {
if(it->tile.x + it->tile.width == tile->tile.x) {
if(is_between_strict(it->tile.y, it->tile.y + it->tile.height,
center) ||
it->tile.y + it->tile.height == center) {
return it;
}
}
@ -175,10 +179,12 @@ find_left_tile(const struct cg_tile *tile) {
struct cg_tile *
find_top_tile(const struct cg_tile *tile) {
struct cg_tile *it = tile->next;
int center=tile->tile.x+tile->tile.width/2;
int center = tile->tile.x + tile->tile.width / 2;
while(it != tile) {
if(it->tile.y+it->tile.height == tile->tile.y) {
if(is_between_strict(it->tile.x,it->tile.x+it->tile.width,center)||it->tile.x+it->tile.width==center) {
if(it->tile.y + it->tile.height == tile->tile.y) {
if(is_between_strict(it->tile.x, it->tile.x + it->tile.width,
center) ||
it->tile.x + it->tile.width == center) {
return it;
}
}
@ -190,10 +196,12 @@ find_top_tile(const struct cg_tile *tile) {
struct cg_tile *
find_bottom_tile(const struct cg_tile *tile) {
struct cg_tile *it = tile->next;
int center=tile->tile.x+tile->tile.width/2;
int center = tile->tile.x + tile->tile.width / 2;
while(it != tile) {
if(it->tile.y == tile->tile.y+tile->tile.height) {
if(is_between_strict(it->tile.x,it->tile.x+it->tile.width,center)||it->tile.x+it->tile.width==center) {
if(it->tile.y == tile->tile.y + tile->tile.height) {
if(is_between_strict(it->tile.x, it->tile.x + it->tile.width,
center) ||
it->tile.x + it->tile.width == center) {
return it;
}
}
@ -223,11 +231,11 @@ swap_tile(struct cg_tile *tile,
view_maximize(swap_tile->view, swap_tile);
}
seat_set_focus(server->seat, swap_tile->view);
ipc_send_event(
tile->workspace->output->server,
"{\"event_name\":\"swap_tile\",\"tile_id\":\"%d\",\"swap_tile_id\":\"%d\",\"workspace\":\"%d\",\"output\":\"%s\"}",
tile->id, swap_tile->id, tile->workspace->num + 1,
tile->workspace->output->wlr_output->name);
ipc_send_event(tile->workspace->output->server,
"{\"event_name\":\"swap_tile\",\"tile_id\":\"%d\",\"swap_"
"tile_id\":\"%d\",\"workspace\":\"%d\",\"output\":\"%s\"}",
tile->id, swap_tile->id, tile->workspace->num + 1,
tile->workspace->output->wlr_output->name);
}
void
@ -372,7 +380,9 @@ resize(struct cg_tile *tile, const struct cg_tile *parent, int coord_offset,
view_maximize(tile->view, tile);
}
ipc_send_event(tile->workspace->output->server,
"{\"event_name\":\"resize_tile\",\"tile_id\":\"%d\",\"old_dims\":\"[%d;%d;%d;%d]\",\"new_dims\":\"[%d;%d;%d;%d]\",\"workspace\":\"%d\",\"output\":\"%s\"}",
"{\"event_name\":\"resize_tile\",\"tile_id\":\"%d\",\"old_"
"dims\":\"[%d;%d;%d;%d]\",\"new_dims\":\"[%d;%d;%d;%d]\","
"\"workspace\":\"%d\",\"output\":\"%s\"}",
tile->id, old_x, old_y, old_height, old_width, tile->tile.x,
tile->tile.y, tile->tile.height, tile->tile.width,
tile->workspace->num + 1,
@ -470,15 +480,18 @@ keybinding_workspace_fullscreen(struct cg_server *server) {
struct cg_output *output = server->curr_output;
struct cg_view *it = NULL, *tmp = NULL;
wl_list_for_each_safe(it, tmp, &output->workspaces[output->curr_workspace]->views,
link) {
wl_list_for_each_safe(
it, tmp, &output->workspaces[output->curr_workspace]->views, link) {
if(view_is_visible(it)) {
if(current_view == NULL) {
current_view = it;
}
if(&it->link!=&output->workspaces[output->curr_workspace]->views) {
if(&it->link !=
&output->workspaces[output->curr_workspace]->views) {
wl_list_remove(&it->link);
wl_list_insert(&output->workspaces[output->curr_workspace]->views, &it->link);
wl_list_insert(
&output->workspaces[output->curr_workspace]->views,
&it->link);
}
}
}
@ -500,7 +513,8 @@ keybinding_workspace_fullscreen(struct cg_server *server) {
seat_set_focus(server->seat, current_view);
ipc_send_event(output->server,
"{\"event_name\":\"fullscreen\",\"tile_id\":\"%d\",\"workspace\":\"%d\",\"output\":\"%s\"}",
"{\"event_name\":\"fullscreen\",\"tile_id\":\"%d\","
"\"workspace\":\"%d\",\"output\":\"%s\"}",
output->workspaces[output->curr_workspace]->focused_tile->id,
output->workspaces[output->curr_workspace]->num + 1,
output->wlr_output->name);
@ -594,7 +608,8 @@ keybinding_split_output(struct cg_output *output, bool vertical) {
}
ipc_send_event(
output->server,
"{\"event_name\":\"split\",\"tile_id\":\"%d\",\"new_tile_id\":\"%d\",\"workspace\":\"%d\",\"output\":\"%s\",\"vertical\":\"%d\"}",
"{\"event_name\":\"split\",\"tile_id\":\"%d\",\"new_tile_id\":\"%d\","
"\"workspace\":\"%d\",\"output\":\"%s\",\"vertical\":\"%d\"}",
curr_workspace->focused_tile->id, new_tile->id, curr_workspace->num + 1,
curr_workspace->output->wlr_output->name, vertical);
}
@ -610,7 +625,8 @@ keybinding_close_view(struct cg_view *view) {
uint32_t ws = view->workspace->num;
view->impl->close(view);
ipc_send_event(outp->server,
"{\"event_name\":\"close\",\"view_id\":\"%d\",\"tile_id\":\"%d\",\"workspace\":\"%d\",\"output\":\"%s\"}",
"{\"event_name\":\"close\",\"view_id\":\"%d\",\"tile_id\":"
"\"%d\",\"workspace\":\"%d\",\"output\":\"%s\"}",
view_id, tile_id, ws + 1, outp->wlr_output->name);
}
@ -659,9 +675,11 @@ keybinding_cycle_outputs(struct cg_server *server, bool reverse) {
}
}
set_output(server, output);
ipc_send_event(
output->server, "{\"event_name\":\"cycle_outputs\",\"old_output\":\"%s\",\"new_output\":\"%s\",\"reverse\":\"%d\"}",
old_output->wlr_output->name, output->wlr_output->name, reverse);
ipc_send_event(output->server,
"{\"event_name\":\"cycle_outputs\",\"old_output\":\"%s\","
"\"new_output\":\"%s\",\"reverse\":\"%d\"}",
old_output->wlr_output->name, output->wlr_output->name,
reverse);
}
/* Cycle through views, whereby the workspace does not change */
@ -704,11 +722,16 @@ keybinding_cycle_views(struct cg_server *server, bool reverse, bool ipc) {
next_view->link.prev, curr_workspace->focused_tile->view, link);
seat_set_focus(server->seat, next_view);
if(ipc) {
ipc_send_event(curr_workspace->output->server,
"{\"event_name\":\"cycle_views\",\"old_view_id\":\"%d\",\"new_view_id\":\"%d\",\"tile_id\":\"%d\",\"workspace\":\"%d\",\"output\":\"%s\"}",
current_view->link.next==curr_workspace->views.next?-1:(int) current_view->id, next_view==NULL?-1:(int) next_view->id, next_view->tile->id,
curr_workspace->num + 1,
curr_workspace->output->wlr_output->name);
ipc_send_event(curr_workspace->output->server,
"{\"event_name\":\"cycle_views\",\"old_view_id\":\"%d\","
"\"new_view_id\":\"%d\",\"tile_id\":\"%d\","
"\"workspace\":\"%d\",\"output\":\"%s\"}",
current_view->link.next == curr_workspace->views.next
? -1
: (int)current_view->id,
next_view == NULL ? -1 : (int)next_view->id,
next_view->tile->id, curr_workspace->num + 1,
curr_workspace->output->wlr_output->name);
}
}
@ -727,7 +750,8 @@ keybinding_cycle_tiles(struct cg_server *server, bool reverse) {
seat_set_focus(server->seat, next_view);
ipc_send_event(
output->server,
"{\"event_name\":\"cycle_tiles\",\"old_tile_id\":\"%d\",\"new_tile_id\":\"%d\",\"workspace\":\"%d\",\"output\":\"%s\"}",
"{\"event_name\":\"cycle_tiles\",\"old_tile_id\":\"%d\",\"new_tile_"
"id\":\"%d\",\"workspace\":\"%d\",\"output\":\"%s\"}",
old_tile->id, workspace->focused_tile->id, workspace->num + 1,
output->wlr_output->name);
}
@ -742,12 +766,13 @@ keybinding_switch_ws(struct cg_server *server, uint32_t ws) {
}
struct cg_output *output = server->curr_output;
uint32_t old_ws = server->curr_output->curr_workspace;
workspace_focus(output,ws);
workspace_focus(output, ws);
seat_set_focus(server->seat,
server->curr_output->workspaces[ws]->focused_tile->view);
message_printf(server->curr_output, "Workspace %d", ws + 1);
ipc_send_event(output->server,
"{\"event_name\":\"switch_ws\",\"old_workspace\":\"%d\",\"new_workspace\":\"%d\",\"output\":\"%s\"}",
"{\"event_name\":\"switch_ws\",\"old_workspace\":\"%d\","
"\"new_workspace\":\"%d\",\"output\":\"%s\"}",
old_ws + 1, ws + 1, output->wlr_output->name);
return 0;
}
@ -772,17 +797,19 @@ struct dyn_str {
char **str_arr;
};
/*Note that inp is in an invalid state after calling the function * and should no longer be used.*/
char *dyn_str_to_str(struct dyn_str *inp) {
char *outp=calloc(inp->len+1,sizeof(char));
/*Note that inp is in an invalid state after calling the function * and should
* no longer be used.*/
char *
dyn_str_to_str(struct dyn_str *inp) {
char *outp = calloc(inp->len + 1, sizeof(char));
if(outp == NULL) {
return NULL;
}
outp[inp->len]='\0';
uint32_t tmp_pos=0;
for(uint32_t i=0;i<inp->cur_pos;++i) {
strcat(outp+tmp_pos,inp->str_arr[i]);
tmp_pos+=strlen(inp->str_arr[i]);
outp[inp->len] = '\0';
uint32_t tmp_pos = 0;
for(uint32_t i = 0; i < inp->cur_pos; ++i) {
strcat(outp + tmp_pos, inp->str_arr[i]);
tmp_pos += strlen(inp->str_arr[i]);
free(inp->str_arr[i]);
}
free(inp->str_arr);
@ -797,89 +824,98 @@ print_str(struct dyn_str *outp, const char *fmt, ...) {
if(ret == NULL) {
return -1;
}
outp->str_arr[outp->cur_pos]=ret;
outp->str_arr[outp->cur_pos] = ret;
++outp->cur_pos;
outp->len+=strlen(ret);
outp->len += strlen(ret);
return 0;
}
void
print_modes(struct dyn_str *str,char **modes) {
uint32_t len=0;
char **tmp=modes;
uint32_t nmemb=0;
while(*tmp!=NULL) {
len+=strlen(*tmp);
print_modes(struct dyn_str *str, char **modes) {
uint32_t len = 0;
char **tmp = modes;
uint32_t nmemb = 0;
while(*tmp != NULL) {
len += strlen(*tmp);
++nmemb;
++tmp;
}
/* We are assuming here that we have at least one mode, which is given by the initialization of cagebreak */
char *modes_str=calloc(len+3*(nmemb-1)+1, sizeof(char));
modes_str[len+nmemb-1]='\0';
uint32_t tmp_pos=0;
for(uint32_t i=0;i<nmemb;++i) {
if(i!=0) {
strcat(modes_str+tmp_pos,"\",\"");
tmp_pos+=3;
/* We are assuming here that we have at least one mode, which is given by
* the initialization of cagebreak */
char *modes_str = calloc(len + 3 * (nmemb - 1) + 1, sizeof(char));
modes_str[len + nmemb - 1] = '\0';
uint32_t tmp_pos = 0;
for(uint32_t i = 0; i < nmemb; ++i) {
if(i != 0) {
strcat(modes_str + tmp_pos, "\",\"");
tmp_pos += 3;
}
strcat(modes_str+tmp_pos,modes[i]);
tmp_pos+=strlen(modes[i]);
strcat(modes_str + tmp_pos, modes[i]);
tmp_pos += strlen(modes[i]);
}
print_str(str,"\"modes\":[\"%s\"],\n",modes_str);
print_str(str, "\"modes\":[\"%s\"],\n", modes_str);
free(modes_str);
}
char *print_view(struct cg_view *view) {
char *
print_view(struct cg_view *view) {
struct dyn_str outp_str;
outp_str.len=0;
outp_str.cur_pos=0;
uint32_t nmemb=4;
outp_str.str_arr=calloc(nmemb,sizeof(char *));
print_str(&outp_str,"\"id\": %d,\n",view->id);
char *title_str=view->impl->get_title(view);
print_str(&outp_str,"\"title\": \"%s\",\n",title_str==NULL?"":title_str);
print_str(&outp_str,"\"coords\": [\"x\":%d,\"y\":%d],\n",view->ox,view->oy);
outp_str.len = 0;
outp_str.cur_pos = 0;
uint32_t nmemb = 4;
outp_str.str_arr = calloc(nmemb, sizeof(char *));
print_str(&outp_str, "\"id\": %d,\n", view->id);
char *title_str = view->impl->get_title(view);
print_str(&outp_str, "\"title\": \"%s\",\n",
title_str == NULL ? "" : title_str);
print_str(&outp_str, "\"coords\": [\"x\":%d,\"y\":%d],\n", view->ox,
view->oy);
#if CG_HAS_XWAYLAND
print_str(&outp_str,"\"type\": \"%s\",\n",view->type==CG_XWAYLAND_VIEW?"xwayland":"xdg");
print_str(&outp_str, "\"type\": \"%s\",\n",
view->type == CG_XWAYLAND_VIEW ? "xwayland" : "xdg");
#else
print_str(&outp_str,"\"type\": \"xdg\",\n");
print_str(&outp_str, "\"type\": \"xdg\",\n");
#endif
return dyn_str_to_str(&outp_str);
}
char *print_tile(struct cg_tile *tile) {
char *
print_tile(struct cg_tile *tile) {
struct dyn_str outp_str;
outp_str.len=0;
outp_str.cur_pos=0;
uint32_t nmemb=4;
outp_str.str_arr=calloc(nmemb,sizeof(char *));
print_str(&outp_str,"\"id\": %d,\n",tile->id);
print_str(&outp_str,"\"coords\": [\"x\":%d,\"y\":%d],\n",tile->tile.x,tile->tile.y);
print_str(&outp_str,"\"size\": [\"width\":%d,\"height\":%d],\n",tile->tile.width,tile->tile.height);
print_str(&outp_str,"\"view\": \"%d\",\n",tile->view==NULL?-1:(int)tile->view->id);
outp_str.len = 0;
outp_str.cur_pos = 0;
uint32_t nmemb = 4;
outp_str.str_arr = calloc(nmemb, sizeof(char *));
print_str(&outp_str, "\"id\": %d,\n", tile->id);
print_str(&outp_str, "\"coords\": [\"x\":%d,\"y\":%d],\n", tile->tile.x,
tile->tile.y);
print_str(&outp_str, "\"size\": [\"width\":%d,\"height\":%d],\n",
tile->tile.width, tile->tile.height);
print_str(&outp_str, "\"view\": \"%d\",\n",
tile->view == NULL ? -1 : (int)tile->view->id);
return dyn_str_to_str(&outp_str);
}
char *
print_views(struct cg_workspace *ws) {
struct dyn_str outp_str;
outp_str.len=0;
outp_str.cur_pos=0;
uint32_t nviews=wl_list_length(&ws->views);
if(nviews==0) {
outp_str.len = 0;
outp_str.cur_pos = 0;
uint32_t nviews = wl_list_length(&ws->views);
if(nviews == 0) {
return strdup("{}");
}
outp_str.str_arr=calloc(2*nviews-1,sizeof(char *));
outp_str.str_arr = calloc(2 * nviews - 1, sizeof(char *));
struct cg_view *it;
uint32_t count=0;
wl_list_for_each(it,&ws->views,link) {
if(count!=0) {
print_str(&outp_str,",");
uint32_t count = 0;
wl_list_for_each(it, &ws->views, link) {
if(count != 0) {
print_str(&outp_str, ",");
}
++count;
char *view_str=print_view(it);
if(view_str!=NULL) {
print_str(&outp_str,"{\n%s\n}",view_str);
char *view_str = print_view(it);
if(view_str != NULL) {
print_str(&outp_str, "{\n%s\n}", view_str);
free(view_str);
}
}
@ -889,27 +925,29 @@ print_views(struct cg_workspace *ws) {
char *
print_tiles(struct cg_workspace *ws) {
struct dyn_str outp_str;
outp_str.len=0;
outp_str.cur_pos=0;
uint32_t ntiles=0;
bool first=true;
for(struct cg_tile *tile=ws->focused_tile;first||tile!=ws->focused_tile;tile=tile->next) {
first=false;
outp_str.len = 0;
outp_str.cur_pos = 0;
uint32_t ntiles = 0;
bool first = true;
for(struct cg_tile *tile = ws->focused_tile;
first || tile != ws->focused_tile; tile = tile->next) {
first = false;
++ntiles;
}
if(ntiles==0) {
if(ntiles == 0) {
return strdup("{}");
}
outp_str.str_arr=calloc(2*ntiles-1,sizeof(char *));
first=true;
for(struct cg_tile *tile=ws->focused_tile;first||tile!=ws->focused_tile;tile=tile->next) {
if(first==false) {
print_str(&outp_str,",");
outp_str.str_arr = calloc(2 * ntiles - 1, sizeof(char *));
first = true;
for(struct cg_tile *tile = ws->focused_tile;
first || tile != ws->focused_tile; tile = tile->next) {
if(first == false) {
print_str(&outp_str, ",");
}
first=false;
char *tile_str=print_tile(tile);
if(tile_str!=NULL) {
print_str(&outp_str,"{\n%s\n}",tile_str);
first = false;
char *tile_str = print_tile(tile);
if(tile_str != NULL) {
print_str(&outp_str, "{\n%s\n}", tile_str);
free(tile_str);
}
}
@ -919,41 +957,41 @@ print_tiles(struct cg_workspace *ws) {
char *
print_workspace(struct cg_workspace *ws) {
struct dyn_str outp_str;
outp_str.len=0;
outp_str.cur_pos=0;
uint32_t nmemb=6;
outp_str.str_arr=calloc(nmemb,sizeof(char *));
print_str(&outp_str,"\"views\": [");
char *views_str=print_views(ws);
if(views_str!=NULL) {
print_str(&outp_str,"%s",views_str);
outp_str.len = 0;
outp_str.cur_pos = 0;
uint32_t nmemb = 6;
outp_str.str_arr = calloc(nmemb, sizeof(char *));
print_str(&outp_str, "\"views\": [");
char *views_str = print_views(ws);
if(views_str != NULL) {
print_str(&outp_str, "%s", views_str);
free(views_str);
}
print_str(&outp_str,"],");
print_str(&outp_str,"\"tiles\": [");
char *tiles_str=print_tiles(ws);
if(tiles_str!=NULL) {
print_str(&outp_str,"%s",tiles_str);
print_str(&outp_str, "],");
print_str(&outp_str, "\"tiles\": [");
char *tiles_str = print_tiles(ws);
if(tiles_str != NULL) {
print_str(&outp_str, "%s", tiles_str);
free(tiles_str);
}
print_str(&outp_str,"]");
print_str(&outp_str, "]");
return dyn_str_to_str(&outp_str);
}
char *
print_workspaces(struct cg_output *outp) {
struct dyn_str outp_str;
outp_str.len=0;
outp_str.cur_pos=0;
outp_str.str_arr=calloc((2*outp->server->nws-1)+2,sizeof(char *));
outp_str.len = 0;
outp_str.cur_pos = 0;
outp_str.str_arr = calloc((2 * outp->server->nws - 1) + 2, sizeof(char *));
print_str(&outp_str, "\"workspaces\": [");
for(int i=0;i<outp->server->nws;++i) {
if(i!=0) {
print_str(&outp_str,",");
for(int i = 0; i < outp->server->nws; ++i) {
if(i != 0) {
print_str(&outp_str, ",");
}
char *ws=print_workspace(outp->workspaces[i]);
char *ws = print_workspace(outp->workspaces[i]);
if(ws != NULL) {
print_str(&outp_str,"{%s}",ws);
print_str(&outp_str, "{%s}", ws);
free(ws);
}
}
@ -964,42 +1002,42 @@ print_workspaces(struct cg_output *outp) {
char *
print_output(struct cg_output *outp) {
struct dyn_str outp_str;
outp_str.len=0;
outp_str.cur_pos=0;
uint32_t nmemb=5;
outp_str.str_arr=calloc(nmemb,sizeof(char *));
print_str(&outp_str,"\"%s\": {\n",outp->wlr_output->name);
print_str(&outp_str,"\"priority\": %d,\n",outp->priority);
print_str(&outp_str,"\"curr_workspace\": %d,\n",outp->curr_workspace);
char *workspaces_str=print_workspaces(outp);
if(workspaces_str!=NULL) {
print_str(&outp_str, "%s",workspaces_str);
outp_str.len = 0;
outp_str.cur_pos = 0;
uint32_t nmemb = 5;
outp_str.str_arr = calloc(nmemb, sizeof(char *));
print_str(&outp_str, "\"%s\": {\n", outp->wlr_output->name);
print_str(&outp_str, "\"priority\": %d,\n", outp->priority);
print_str(&outp_str, "\"curr_workspace\": %d,\n", outp->curr_workspace);
char *workspaces_str = print_workspaces(outp);
if(workspaces_str != NULL) {
print_str(&outp_str, "%s", workspaces_str);
free(workspaces_str);
}
print_str(&outp_str,"}");
print_str(&outp_str, "}");
return dyn_str_to_str(&outp_str);
}
char *
print_outputs(struct cg_server *server) {
uint32_t noutps=wl_list_length(&server->outputs);
uint32_t noutps = wl_list_length(&server->outputs);
struct dyn_str outp_str;
outp_str.len=0;
outp_str.cur_pos=0;
outp_str.str_arr=calloc((2*noutps-1)+2,sizeof(char *));
outp_str.len = 0;
outp_str.cur_pos = 0;
outp_str.str_arr = calloc((2 * noutps - 1) + 2, sizeof(char *));
print_str(&outp_str, "\"outputs\": [");
struct cg_output *it;
uint32_t count=0;
wl_list_for_each(it,&server->outputs,link) {
if(count!=0) {
print_str(&outp_str,",");
uint32_t count = 0;
wl_list_for_each(it, &server->outputs, link) {
if(count != 0) {
print_str(&outp_str, ",");
}
++count;
char *outp=print_output(it);
char *outp = print_output(it);
if(outp == NULL) {
continue;
}
print_str(&outp_str,"%s",outp);
print_str(&outp_str, "%s", outp);
free(outp);
}
print_str(&outp_str, "],\n");
@ -1009,26 +1047,29 @@ print_outputs(struct cg_server *server) {
void
keybinding_dump(struct cg_server *server) {
struct dyn_str str;
str.len=0;
str.cur_pos=0;
uint32_t nmemb=10;
str.str_arr=calloc(nmemb,sizeof(char *));
str.len = 0;
str.cur_pos = 0;
uint32_t nmemb = 10;
str.str_arr = calloc(nmemb, sizeof(char *));
print_str(&str,"{");
print_str(&str,"\"nws\":%d,\n",server->nws);
print_str(&str,"\"bg_color\":[%f,%f,%f,%f],\n",server->bg_color[0],server->bg_color[1],server->bg_color[2],server->bg_color[3]);
print_str(&str,"\"views_curr_id\":%d,\n",server->views_curr_id);
print_str(&str,"\"tiles_curr_id\":%d,\n",server->tiles_curr_id);
print_str(&str,"\"curr_output\":%s,\n",server->curr_output->wlr_output->name);
print_modes(&str,server->modes);
char *outps_str=print_outputs(server);
print_str(&str,"%s",outps_str);
print_str(&str, "{");
print_str(&str, "\"nws\":%d,\n", server->nws);
print_str(&str, "\"bg_color\":[%f,%f,%f,%f],\n", server->bg_color[0],
server->bg_color[1], server->bg_color[2], server->bg_color[3]);
print_str(&str, "\"views_curr_id\":%d,\n", server->views_curr_id);
print_str(&str, "\"tiles_curr_id\":%d,\n", server->tiles_curr_id);
print_str(&str, "\"curr_output\":%s,\n",
server->curr_output->wlr_output->name);
print_modes(&str, server->modes);
char *outps_str = print_outputs(server);
print_str(&str, "%s", outps_str);
free(outps_str);
print_str(&str,"\"cursor_coords\":{\"x\":%f,\"y\":%f},\n",server->seat->cursor->x,server->seat->cursor->y);
print_str(&str,"}");
print_str(&str, "\"cursor_coords\":{\"x\":%f,\"y\":%f},\n",
server->seat->cursor->x, server->seat->cursor->y);
print_str(&str, "}");
char *send_str=dyn_str_to_str(&str);
if(send_str==NULL) {
char *send_str = dyn_str_to_str(&str);
if(send_str == NULL) {
wlr_log(WLR_ERROR, "Unable to create output string for \"dump\".");
}
ipc_send_event(server, send_str);
@ -1065,7 +1106,7 @@ keybinding_move_view_to_cycle_output(struct cg_server *server, bool reverse) {
wl_list_remove(&view->link);
server->curr_output->workspaces[server->curr_output->curr_workspace]
->focused_tile->view = NULL;
keybinding_cycle_views(server, false,false);
keybinding_cycle_views(server, false, false);
if(server->curr_output->workspaces[server->curr_output->curr_workspace]
->focused_tile->view == NULL) {
seat_set_focus(server->seat, NULL);
@ -1073,7 +1114,9 @@ keybinding_move_view_to_cycle_output(struct cg_server *server, bool reverse) {
}
keybinding_cycle_outputs(server, reverse);
if(view != NULL) {
struct cg_workspace *ws=server->curr_output->workspaces[server->curr_output->curr_workspace];
struct cg_workspace *ws =
server->curr_output
->workspaces[server->curr_output->curr_workspace];
wl_list_insert(&ws->views, &view->link);
ws->focused_tile->view = view;
wlr_scene_node_reparent(view->scene_node, &ws->scene->node);
@ -1082,11 +1125,11 @@ keybinding_move_view_to_cycle_output(struct cg_server *server, bool reverse) {
view_maximize(view, view->tile);
seat_set_focus(server->seat, view);
}
ipc_send_event(
server,
"{\"event_name\":\"move_view_cycle_output\",\"view_id\":\"%d\",\"old_output\":\"%s\",\"new_output\":\"%s\"}",
view->id, old_outp->wlr_output->name,
server->curr_output->wlr_output->name);
ipc_send_event(server,
"{\"event_name\":\"move_view_cycle_output\",\"view_id\":\"%"
"d\",\"old_output\":\"%s\",\"new_output\":\"%s\"}",
view->id, old_outp->wlr_output->name,
server->curr_output->wlr_output->name);
}
void
@ -1132,7 +1175,7 @@ keybinding_set_nws(struct cg_server *server, int nws) {
}
if(output->curr_workspace >= nws) {
workspace_focus(output,nws-1);
workspace_focus(output, nws - 1);
}
}
server->nws = nws;
@ -1140,8 +1183,10 @@ keybinding_set_nws(struct cg_server *server, int nws) {
server->seat,
server->curr_output->workspaces[server->curr_output->curr_workspace]
->focused_tile->view);
ipc_send_event(server, "{\"event_name\":\"set_nws\",\"old_nws\":\"%d\",\"new_nws\":\"%d\"}", old_nws,
server->nws);
ipc_send_event(
server,
"{\"event_name\":\"set_nws\",\"old_nws\":\"%d\",\"new_nws\":\"%d\"}",
old_nws, server->nws);
}
void
@ -1158,29 +1203,34 @@ keybinding_definemode(struct cg_server *server, char *mode) {
server->modes[length] = NULL;
server->modes[length - 1] = strdup(mode);
ipc_send_event(server, "{\"event_name\":\"definemode\",\"mode\":\"%s\"}", mode);
ipc_send_event(server, "{\"event_name\":\"definemode\",\"mode\":\"%s\"}",
mode);
}
void
keybinding_definekey(struct cg_server *server, struct keybinding *kb) {
keybinding_list_push(server->keybindings, kb);
ipc_send_event(server, "{\"event_name\":\"definekey\",\"modifiers\":\"%d\",\"key\":\"%d\",\"command\":\"%d\"}",
ipc_send_event(server,
"{\"event_name\":\"definekey\",\"modifiers\":\"%d\",\"key\":"
"\"%d\",\"command\":\"%d\"}",
kb->modifiers, kb->key, kb->action);
}
void
keybinding_set_background(struct cg_server *server, float *bg) {
ipc_send_event(server, "{\"event_name\":\"background\",\"old_bg\":\"[%f,%f,%f]\",\"new_bg\":\"[%f,%f,%f]\"}",
ipc_send_event(server,
"{\"event_name\":\"background\",\"old_bg\":\"[%f,%f,%f]\","
"\"new_bg\":\"[%f,%f,%f]\"}",
server->bg_color[0], server->bg_color[1],
server->bg_color[2], bg[0], bg[1], bg[2]);
server->bg_color[0] = bg[0];
server->bg_color[1] = bg[1];
server->bg_color[2] = bg[2];
struct cg_output *it=NULL;
wl_list_for_each(it,&server->outputs,link) {
struct cg_output *it = NULL;
wl_list_for_each(it, &server->outputs, link) {
wlr_scene_rect_set_color(it->bg, server->bg_color);
}
wl_list_for_each(it,&server->disabled_outputs,link) {
wl_list_for_each(it, &server->disabled_outputs, link) {
wlr_scene_rect_set_color(it->bg, server->bg_color);
}
}
@ -1193,7 +1243,9 @@ keybinding_switch_output(struct cg_server *server, int output) {
wl_list_for_each(it, &server->outputs, link) {
if(count == output) {
set_output(server, it);
ipc_send_event(server, "{\"event_name\":\"switch_output\",\"old_output\":\"%s\",\"new_output\":\"%s\"}",
ipc_send_event(server,
"{\"event_name\":\"switch_output\",\"old_output\":"
"\"%s\",\"new_output\":\"%s\"}",
old_outp->wlr_output->name, it->wlr_output->name);
return;
}
@ -1213,7 +1265,7 @@ keybinding_move_view_to_output(struct cg_server *server, int output_num) {
wl_list_remove(&view->link);
server->curr_output->workspaces[server->curr_output->curr_workspace]
->focused_tile->view = NULL;
keybinding_cycle_views(server, false,false);
keybinding_cycle_views(server, false, false);
if(server->curr_output->workspaces[server->curr_output->curr_workspace]
->focused_tile->view == NULL) {
seat_set_focus(server->seat, NULL);
@ -1237,10 +1289,12 @@ keybinding_move_view_to_output(struct cg_server *server, int output_num) {
view_title = view->impl->get_title(view);
view_id = view->id;
}
ipc_send_event(server,
"{\"event_name\":\"move_view_to_output\",\"view_id\":\"%d\",\"old_output\":\"%s\",\"new_output\":\"%s\",\"view_title\":\"%s\"}",
view_id, old_outp->wlr_output->name,
server->curr_output->wlr_output->name, view_title);
ipc_send_event(
server,
"{\"event_name\":\"move_view_to_output\",\"view_id\":\"%d\",\"old_"
"output\":\"%s\",\"new_output\":\"%s\",\"view_title\":\"%s\"}",
view_id, old_outp->wlr_output->name,
server->curr_output->wlr_output->name, view_title);
}
void
@ -1272,10 +1326,12 @@ keybinding_move_view_to_workspace(struct cg_server *server, uint32_t ws) {
seat_set_focus(server->seat, view);
}
ipc_send_event(server,
"{\"event_name\":\"move_view_to_ws\",\"view_id\":\"%d\",\"old_workspace\":\"%d\",\"new_workspace\":\"%d\",\"output\":\"%s\",\"view_title\":\"%s\"}",
view==NULL?-1:(int)view->id, old_ws, ws,
"{\"event_name\":\"move_view_to_ws\",\"view_id\":\"%d\","
"\"old_workspace\":\"%d\",\"new_workspace\":\"%d\","
"\"output\":\"%s\",\"view_title\":\"%s\"}",
view == NULL ? -1 : (int)view->id, old_ws, ws,
server->curr_output->wlr_output->name,
view==NULL?"":view->impl->get_title(view));
view == NULL ? "" : view->impl->get_title(view));
}
void
@ -1324,16 +1380,20 @@ keybinding_configure_output(struct cg_server *server,
wl_list_for_each_safe(output, tmp_output, &server->outputs, link) {
if(strcmp(config->output_name, output->wlr_output->name) == 0) {
output_configure(server, output);
ipc_send_event(output->server, "{\"event_name\":\"configure_output\",\"output\":\"%s\"}",
cfg->output_name);
ipc_send_event(
output->server,
"{\"event_name\":\"configure_output\",\"output\":\"%s\"}",
cfg->output_name);
return;
}
}
wl_list_for_each_safe(output, tmp_output, &server->disabled_outputs, link) {
if(strcmp(config->output_name, output->wlr_output->name) == 0) {
output_configure(server, output);
ipc_send_event(output->server, "{\"event_name\":\"configure_output\",\"output\":\"%s\"}",
cfg->output_name);
ipc_send_event(
output->server,
"{\"event_name\":\"configure_output\",\"output\":\"%s\"}",
cfg->output_name);
return;
}
}
@ -1343,7 +1403,9 @@ void
keybinding_configure_input(struct cg_server *server,
struct cg_input_config *cfg) {
cg_input_apply_config(cfg, server);
ipc_send_event(server, "{\"event_name\":\"configure_input\",\"input\":\"%s\"}", cfg->identifier);
ipc_send_event(server,
"{\"event_name\":\"configure_input\",\"input\":\"%s\"}",
cfg->identifier);
}
void
@ -1394,21 +1456,19 @@ run_action(enum keybinding_action action, struct cg_server *server,
case KEYBINDING_SPLIT_VERTICAL:
keybinding_split_vertical(server);
break;
case KEYBINDING_RUN_COMMAND:
{
int pid;
if((pid=fork()) == 0) {
if(fork() == 0) {
into_process(data.c);
}
_exit(0);
} else if(pid > 0) {
waitpid(pid,NULL,0);
case KEYBINDING_RUN_COMMAND: {
int pid;
if((pid = fork()) == 0) {
if(fork() == 0) {
into_process(data.c);
}
_exit(0);
} else if(pid > 0) {
waitpid(pid, NULL, 0);
}
break;
} break;
case KEYBINDING_CYCLE_VIEWS:
keybinding_cycle_views(server, data.b,true);
keybinding_cycle_views(server, data.b, true);
break;
case KEYBINDING_CYCLE_TILES:
keybinding_cycle_tiles(server, data.b);
@ -1426,7 +1486,9 @@ run_action(enum keybinding_action action, struct cg_server *server,
server->seat->mode = data.u;
break;
case KEYBINDING_SWITCH_DEFAULT_MODE:
ipc_send_event(server, "{\"event_name\":\"switch_default_mode\",\"old_mode\":\"%d\",\"mode\":\"%d\"}",
ipc_send_event(server,
"{\"event_name\":\"switch_default_mode\",\"old_mode\":"
"\"%d\",\"mode\":\"%d\"}",
server->seat->default_mode, data.u);
server->seat->mode = data.u;
server->seat->default_mode = data.u;
@ -1443,7 +1505,7 @@ run_action(enum keybinding_action action, struct cg_server *server,
keybinding_show_info(server);
break;
case KEYBINDING_DISPLAY_MESSAGE:
keybinding_display_message(server,data.c);
keybinding_display_message(server, data.c);
break;
case KEYBINDING_RESIZE_TILE_HORIZONTAL:
resize_tile(server, data.i, 0);

52
message.c
View file

@ -1,17 +1,17 @@
#include <cairo/cairo.h>
#include <drm_fourcc.h>
#include <pango/pangocairo.h>
#include <sys/mman.h>
#include <unistd.h>
#include <wayland-client.h>
#include <wlr/backend.h>
#include <wlr/render/allocator.h>
#include <wlr/render/drm_format_set.h>
#include <wlr/render/wlr_renderer.h>
#include <wlr/types/wlr_output_damage.h>
#include <wlr/types/wlr_output_layout.h>
#include <wlr/util/log.h>
#include <sys/mman.h>
#include <wlr/render/allocator.h>
#include <wlr/types/wlr_scene.h>
#include <wlr/render/drm_format_set.h>
#include <wlr/util/log.h>
#include "message.h"
#include "output.h"
@ -26,14 +26,17 @@ struct msg_buffer {
size_t stride;
};
static void msg_buffer_destroy(struct wlr_buffer *wlr_buffer) {
static void
msg_buffer_destroy(struct wlr_buffer *wlr_buffer) {
struct msg_buffer *buffer = wl_container_of(wlr_buffer, buffer, base);
free(buffer->data);
free(buffer);
}
static bool msg_buffer_begin_data_ptr_access(struct wlr_buffer *wlr_buffer,
uint32_t flags, void **data, uint32_t *format, size_t *stride) {
static bool
msg_buffer_begin_data_ptr_access(struct wlr_buffer *wlr_buffer, uint32_t flags,
void **data, uint32_t *format,
size_t *stride) {
struct msg_buffer *buffer = wl_container_of(wlr_buffer, buffer, base);
if(data != NULL) {
*data = (void *)buffer->data;
@ -47,19 +50,21 @@ static bool msg_buffer_begin_data_ptr_access(struct wlr_buffer *wlr_buffer,
return true;
}
static void msg_buffer_end_data_ptr_access(struct wlr_buffer *wlr_buffer) {
static void
msg_buffer_end_data_ptr_access(struct wlr_buffer *wlr_buffer) {
// This space is intentionally left blank
}
static const struct wlr_buffer_impl msg_buffer_impl = {
.destroy = msg_buffer_destroy,
.begin_data_ptr_access = msg_buffer_begin_data_ptr_access,
.end_data_ptr_access = msg_buffer_end_data_ptr_access,
.destroy = msg_buffer_destroy,
.begin_data_ptr_access = msg_buffer_begin_data_ptr_access,
.end_data_ptr_access = msg_buffer_end_data_ptr_access,
};
static struct msg_buffer *msg_buffer_create(uint32_t width, uint32_t height, uint32_t stride) {
static struct msg_buffer *
msg_buffer_create(uint32_t width, uint32_t height, uint32_t stride) {
struct msg_buffer *buffer = calloc(1, sizeof(*buffer));
if (buffer == NULL) {
if(buffer == NULL) {
return NULL;
}
@ -68,7 +73,7 @@ static struct msg_buffer *msg_buffer_create(uint32_t width, uint32_t height, uin
buffer->stride = stride;
buffer->data = malloc(buffer->stride * height);
if (buffer->data == NULL) {
if(buffer->data == NULL) {
free(buffer);
return NULL;
}
@ -150,14 +155,16 @@ create_message_texture(const char *string, const struct cg_output *output) {
unsigned char *data = cairo_image_surface_get_data(surface);
int stride = cairo_format_stride_for_width(CAIRO_FORMAT_ARGB32, width);
struct msg_buffer *buf=msg_buffer_create(width, height,stride);
struct msg_buffer *buf = msg_buffer_create(width, height, stride);
void *data_ptr;
if(!wlr_buffer_begin_data_ptr_access(&buf->base, WLR_BUFFER_DATA_PTR_ACCESS_WRITE,&data_ptr,NULL,NULL)) {
if(!wlr_buffer_begin_data_ptr_access(&buf->base,
WLR_BUFFER_DATA_PTR_ACCESS_WRITE,
&data_ptr, NULL, NULL)) {
wlr_log(WLR_ERROR, "Failed to get pointer access to message buffer");
return NULL;
}
memcpy(data_ptr,data,stride*height);
memcpy(data_ptr, data, stride * height);
wlr_buffer_end_data_ptr_access(&buf->base);
cairo_surface_destroy(surface);
@ -217,12 +224,15 @@ message_set_output(struct cg_output *output, const char *string,
break;
}
message->message=wlr_scene_buffer_create(&output->scene_output->scene->node,&buf->base);
message->message =
wlr_scene_buffer_create(&output->scene_output->scene->node, &buf->base);
wlr_scene_node_raise_to_top(&message->message->node);
wlr_scene_node_set_enabled(&message->message->node,true);
wlr_scene_node_set_enabled(&message->message->node, true);
struct wlr_box *outp_box = wlr_output_layout_get_box(
output->server->output_layout, output->wlr_output);
wlr_scene_node_set_position(&message->message->node, message->position->x+outp_box->x, message->position->y+outp_box->y);
wlr_scene_node_set_position(&message->message->node,
message->position->x + outp_box->x,
message->position->y + outp_box->y);
}
void
@ -279,7 +289,7 @@ message_clear(struct cg_output *output) {
struct cg_message *message, *tmp;
wl_list_for_each_safe(message, tmp, &output->messages, link) {
wl_list_remove(&message->link);
struct wlr_buffer *buf=message->message->buffer;
struct wlr_buffer *buf = message->message->buffer;
wlr_scene_node_destroy(&message->message->node);
free(message->position);
buf->impl->destroy(buf);

46
output.c
View file

@ -25,9 +25,9 @@
#include <wlr/types/wlr_output.h>
#include <wlr/types/wlr_output_damage.h>
#include <wlr/types/wlr_output_layout.h>
#include <wlr/types/wlr_scene.h>
#include <wlr/types/wlr_surface.h>
#include <wlr/types/wlr_xcursor_manager.h>
#include <wlr/types/wlr_scene.h>
#include <wlr/util/log.h>
#include <wlr/util/region.h>
#if CG_HAS_XWAYLAND
@ -71,14 +71,16 @@ output_clear(struct cg_output *output) {
first = false;
tile->view = NULL;
}
struct cg_workspace *ws=server->curr_output->workspaces[server->curr_output->curr_workspace];
struct cg_workspace *ws =
server->curr_output
->workspaces[server->curr_output->curr_workspace];
wl_list_for_each_safe(view, view_tmp, &output->workspaces[i]->views,
link) {
wl_list_remove(&view->link);
if(wl_list_empty(&server->outputs)) {
view->impl->destroy(view);
} else {
wl_list_insert(&ws->views,&view->link);
wl_list_insert(&ws->views, &view->link);
wlr_scene_node_reparent(view->scene_node, &ws->scene->node);
view->workspace = ws;
view->tile = ws->focused_tile;
@ -126,7 +128,9 @@ output_destroy(struct cg_output *output) {
free(output);
if(outp_name != NULL) {
ipc_send_event(server, "{\"event_name\":\"new_output\",\"output\":\"%s\"}", outp_name);
ipc_send_event(server,
"{\"event_name\":\"new_output\",\"output\":\"%s\"}",
outp_name);
free(outp_name);
} else {
wlr_log(WLR_ERROR,
@ -145,13 +149,13 @@ handle_output_destroy(struct wl_listener *listener, void *data) {
static void
handle_output_frame(struct wl_listener *listener, void *data) {
struct cg_output *output=wl_container_of(listener, output, frame);
struct cg_output *output = wl_container_of(listener, output, frame);
if(!output->wlr_output->enabled) {
return;
}
wlr_scene_output_commit(output->scene_output);
struct timespec now={0};
struct timespec now = {0};
clock_gettime(CLOCK_MONOTONIC, &now);
wlr_scene_output_send_frame_done(output->scene_output, &now);
}
@ -201,7 +205,10 @@ output_set_mode(struct wlr_output *output, int width, int height,
}
wlr_output_set_mode(output, best);
if(!wlr_output_test(output)) {
wlr_log(WLR_ERROR, "Unable to assign configured mode to %s, picking arbitrary available mode",output->name);
wlr_log(WLR_ERROR,
"Unable to assign configured mode to %s, picking arbitrary "
"available mode",
output->name);
struct wlr_output_mode *mode;
wl_list_for_each(mode, &output->modes, link) {
if(mode == best) {
@ -286,18 +293,20 @@ output_configure(struct cg_server *server, struct cg_output *output) {
}
}
struct wlr_scene_output *scene_output;
wl_list_for_each(scene_output,&output->server->scene->outputs,link) {
wl_list_for_each(scene_output, &output->server->scene->outputs, link) {
if(scene_output->output == wlr_output) {
output->scene_output=scene_output;
output->scene_output = scene_output;
break;
}
}
if(output->bg!=NULL) {
if(output->bg != NULL) {
wlr_scene_node_destroy(&output->bg->node);
}
output->bg=wlr_scene_rect_create(&output->scene_output->scene->node, output->wlr_output->width,output->wlr_output->height, server->bg_color);
struct wlr_box *box = wlr_output_layout_get_box(
server->output_layout, output->wlr_output);
output->bg = wlr_scene_rect_create(
&output->scene_output->scene->node, output->wlr_output->width,
output->wlr_output->height, server->bg_color);
struct wlr_box *box =
wlr_output_layout_get_box(server->output_layout, output->wlr_output);
wlr_scene_node_set_position(&output->bg->node, box->x, box->y);
wlr_scene_node_lower_to_bottom(&output->bg->node);
}
@ -349,7 +358,8 @@ handle_new_output(struct wl_listener *listener, void *data) {
struct cg_server *server = wl_container_of(listener, server, new_output);
struct wlr_output *wlr_output = data;
if(!wlr_output_init_render(wlr_output,server->allocator,server->renderer)) {
if(!wlr_output_init_render(wlr_output, server->allocator,
server->renderer)) {
wlr_log(WLR_ERROR, "Failed to initialize output rendering");
return;
}
@ -400,7 +410,7 @@ handle_new_output(struct wl_listener *listener, void *data) {
}
wlr_scene_node_raise_to_top(&output->workspaces[0]->scene->node);
workspace_focus(output,0);
workspace_focus(output, 0);
/* We are the first output. Set the current output to this one. */
if(server->curr_output == NULL) {
@ -418,8 +428,10 @@ handle_new_output(struct wl_listener *listener, void *data) {
wl_signal_add(&wlr_output->events.commit, &output->commit);
output->mode.notify = handle_output_mode;
wl_signal_add(&wlr_output->events.mode, &output->mode);
ipc_send_event(server, "{\"event_name\":\"new_output\",\"output\":\"%s\",\"priority\":\"%d\"}",
output->wlr_output->name, output->priority);
ipc_send_event(
server,
"{\"event_name\":\"new_output\",\"output\":\"%s\",\"priority\":\"%d\"}",
output->wlr_output->name, output->priority);
}
#if CG_HAS_FANALYZE
#pragma GCC diagnostic pop

8
parse.c
View file

@ -736,8 +736,9 @@ parse_command(struct cg_server *server, struct keybinding *keybinding,
} else if(strcmp(action, "message") == 0) {
keybinding->action = KEYBINDING_DISPLAY_MESSAGE;
if(saveptr == NULL) {
*errstr = log_error("Not enough paramaters to \"message\". Expected "
"string to display.");
*errstr =
log_error("Not enough paramaters to \"message\". Expected "
"string to display.");
return -1;
}
keybinding->data.c = strdup(saveptr);
@ -873,8 +874,7 @@ parse_command(struct cg_server *server, struct keybinding *keybinding,
keybinding->action = KEYBINDING_SWITCH_MODE;
char *mode = strtok_r(NULL, " ", &saveptr);
if(mode == NULL) {
*errstr =
log_error("Expected mode after \"mode\". Got nothing.");
*errstr = log_error("Expected mode after \"mode\". Got nothing.");
return -1;
}
int mode_idx = get_mode_index_from_name(server->modes, mode);

35
seat.c
View file

@ -510,12 +510,14 @@ handle_touch_down(struct wl_listener *listener, void *data) {
event->y, &lx, &ly);
double sx, sy;
struct wlr_scene_node *node=wlr_scene_node_at(&seat->server->scene->node, lx,ly,&sx,&sy);
struct wlr_scene_node *node =
wlr_scene_node_at(&seat->server->scene->node, lx, ly, &sx, &sy);
uint32_t serial = 0;
if(node&&node->type == WLR_SCENE_NODE_SURFACE) {
if(node && node->type == WLR_SCENE_NODE_SURFACE) {
serial = wlr_seat_touch_notify_down(
seat->seat, wlr_scene_surface_from_node(node)->surface, event->time_msec, event->touch_id, sx, sy);
seat->seat, wlr_scene_surface_from_node(node)->surface,
event->time_msec, event->touch_id, sx, sy);
}
if(serial && wlr_seat_touch_num_points(seat->seat) == 1) {
@ -554,11 +556,13 @@ handle_touch_motion(struct wl_listener *listener, void *data) {
event->y, &lx, &ly);
double sx, sy;
struct wlr_scene_node *node=wlr_scene_node_at(&seat->server->scene->node, lx,ly,&sx,&sy);
struct wlr_scene_node *node =
wlr_scene_node_at(&seat->server->scene->node, lx, ly, &sx, &sy);
if(node&&node->type == WLR_SCENE_NODE_SURFACE) {
wlr_seat_touch_point_focus(seat->seat, wlr_scene_surface_from_node(node)->surface, event->time_msec,
event->touch_id, sx, sy);
if(node && node->type == WLR_SCENE_NODE_SURFACE) {
wlr_seat_touch_point_focus(seat->seat,
wlr_scene_surface_from_node(node)->surface,
event->time_msec, event->touch_id, sx, sy);
wlr_seat_touch_notify_motion(seat->seat, event->time_msec,
event->touch_id, sx, sy);
} else {
@ -609,11 +613,11 @@ process_cursor_motion(struct cg_seat *seat, uint32_t time) {
struct wlr_seat *wlr_seat = seat->seat;
struct wlr_surface *surface = NULL;
struct wlr_scene_node *node=wlr_scene_node_at(&seat->server->scene->node, seat->cursor->x,seat->cursor->y,&sx,&sy);
struct wlr_scene_node *node = wlr_scene_node_at(
&seat->server->scene->node, seat->cursor->x, seat->cursor->y, &sx, &sy);
if(node&&node->type == WLR_SCENE_NODE_SURFACE) {
surface=wlr_scene_surface_from_node(node)->surface;
if(node && node->type == WLR_SCENE_NODE_SURFACE) {
surface = wlr_scene_surface_from_node(node)->surface;
wlr_seat_pointer_notify_enter(wlr_seat, surface, sx, sy);
bool focus_changed = wlr_seat->pointer_state.focused_surface != surface;
@ -676,7 +680,8 @@ drag_icon_update_position(struct cg_drag_icon *drag_icon) {
drag_icon->ly = seat->touch_ly;
break;
}
wlr_scene_node_set_position(drag_icon->scene_node, drag_icon->lx, drag_icon->ly);
wlr_scene_node_set_position(drag_icon->scene_node, drag_icon->lx,
drag_icon->ly);
}
static void
@ -732,7 +737,8 @@ handle_start_drag(struct wl_listener *listener, void *data) {
}
drag_icon->seat = seat;
drag_icon->wlr_drag_icon = wlr_drag_icon;
drag_icon->scene_node = wlr_scene_subsurface_tree_create(&seat->server->scene->node, wlr_drag_icon->surface);
drag_icon->scene_node = wlr_scene_subsurface_tree_create(
&seat->server->scene->node, wlr_drag_icon->surface);
if(!drag_icon->scene_node) {
free(drag_icon);
return;
@ -966,5 +972,6 @@ seat_set_focus(struct cg_seat *seat, struct cg_view *view) {
process_cursor_motion(seat, -1);
struct wlr_box *box = wlr_output_layout_get_box(
server->output_layout, view->workspace->output->wlr_output);
wlr_scene_node_set_position(&view->workspace->output->bg->node, box->x, box->y);
wlr_scene_node_set_position(&view->workspace->output->bg->node, box->x,
box->y);
}

2
server.c
View file

@ -12,8 +12,8 @@
#include <stdio.h>
#include <string.h>
#include <wayland-server-core.h>
#include <wlr/util/box.h>
#include <wlr/types/wlr_output.h>
#include <wlr/util/box.h>
#include "input_manager.h"
#include "output.h"

2
util.c
View file

@ -10,8 +10,8 @@
#include <wlr/util/box.h>
#include "util.h"
#include <stdlib.h>
#include <math.h>
#include <stdlib.h>
int
scale_length(int length, int offset, double scale) {

40
view.c
View file

@ -12,13 +12,13 @@
#include <stdbool.h>
#include <string.h>
#include <wayland-server-core.h>
#include <wlr/util/box.h>
#include <wlr/types/wlr_compositor.h>
#include <wlr/types/wlr_output.h>
#include <wlr/types/wlr_output_damage.h>
#include <wlr/types/wlr_surface.h>
#include <wlr/types/wlr_scene.h>
#include <wlr/types/wlr_output_layout.h>
#include <wlr/types/wlr_scene.h>
#include <wlr/types/wlr_surface.h>
#include <wlr/util/box.h>
#include "ipc_server.h"
#include "output.h"
@ -99,7 +99,8 @@ view_maximize(struct cg_view *view, struct cg_tile *tile) {
view->oy = tile->tile.y;
struct wlr_box *box = wlr_output_layout_get_box(
view->server->output_layout, view->workspace->output->wlr_output);
wlr_scene_node_set_position(view->scene_node, view->ox+box->x, view->oy+box->y);
wlr_scene_node_set_position(view->scene_node, view->ox + box->x,
view->oy + box->y);
view->impl->maximize(view, tile->tile.width, tile->tile.height);
view->tile = tile;
wlr_scene_node_raise_to_top(view->scene_node);
@ -119,9 +120,9 @@ view_unmap(struct cg_view *view) {
}
if(view->tile == NULL) {
tile_id=-1;
tile_id = -1;
} else {
tile_id=view->tile->id;
tile_id = view->tile->id;
}
wlr_scene_node_destroy(view->scene_node);
@ -161,9 +162,11 @@ view_unmap(struct cg_view *view) {
wl_list_remove(&view->link);
view->wlr_surface = NULL;
ipc_send_event(view->workspace->server,
"{\"event_name\":\"view_unmap\",\"view_id\":\"%d\",\"tile_id\":\"%d\",\"workspace\":\"%d\",\"output\":\"%s\",\"view_title\":\"%s\"}",
id, tile_id, ws + 1, output_name, title);
ipc_send_event(
view->workspace->server,
"{\"event_name\":\"view_unmap\",\"view_id\":\"%d\",\"tile_id\":\"%d\","
"\"workspace\":\"%d\",\"output\":\"%s\",\"view_title\":\"%s\"}",
id, tile_id, ws + 1, output_name, title);
}
void
@ -172,12 +175,13 @@ view_map(struct cg_view *view, struct wlr_surface *surface,
struct cg_output *output = ws->output;
view->wlr_surface = surface;
view->scene_node=wlr_scene_subsurface_tree_create(&ws->scene->node, surface);
view->scene_node =
wlr_scene_subsurface_tree_create(&ws->scene->node, surface);
if(!view->scene_node) {
wl_resource_post_no_memory(surface->resource);
return;
}
view->scene_node->data=view;
view->scene_node->data = view;
view->workspace = ws;
#if CG_HAS_XWAYLAND
@ -187,7 +191,8 @@ view_map(struct cg_view *view, struct wlr_surface *surface,
wl_list_insert(&ws->unmanaged_views, &view->link);
struct wlr_box *box = wlr_output_layout_get_box(
view->server->output_layout, view->workspace->output->wlr_output);
wlr_scene_node_set_position(view->scene_node, view->ox+box->x, view->oy+box->y);
wlr_scene_node_set_position(view->scene_node, view->ox + box->x,
view->oy + box->y);
} else
#endif
{
@ -196,15 +201,16 @@ view_map(struct cg_view *view, struct wlr_surface *surface,
wl_list_insert(&ws->views, &view->link);
}
seat_set_focus(output->server->seat, view);
int tile_id=0;
if(view->tile==NULL) {
tile_id=-1;
int tile_id = 0;
if(view->tile == NULL) {
tile_id = -1;
} else {
tile_id=view->tile->id;
tile_id = view->tile->id;
}
ipc_send_event(
output->server,
"{\"event_name\":\"view_map\",\"view_id\":\"%d\",\"tile_id\":\"%d\",\"workspace\":\"%d\",\"output\":\"%s\",\"view_title\":\"%s\"}",
"{\"event_name\":\"view_map\",\"view_id\":\"%d\",\"tile_id\":\"%d\","
"\"workspace\":\"%d\",\"output\":\"%s\",\"view_title\":\"%s\"}",
view->id, tile_id, view->workspace->num + 1,
view->workspace->output->wlr_output->name, view->impl->get_title(view));
}

2
view.h
View file

@ -20,7 +20,7 @@ enum cg_view_type {
struct cg_view {
struct cg_workspace *workspace;
struct cg_server *server;
struct wl_list link; // server::views
struct wl_list link; // server::views
struct wlr_surface *wlr_surface;
struct cg_tile *tile;
struct wlr_scene_node *scene_node;

13
workspace.c
View file

@ -12,8 +12,8 @@
#include <stdlib.h>
#include <wayland-server-core.h>
#include <wlr/types/wlr_output_layout.h>
#include <wlr/util/log.h>
#include <wlr/types/wlr_scene.h>
#include <wlr/util/log.h>
#include "message.h"
#include "output.h"
@ -58,7 +58,8 @@ full_screen_workspace(struct cg_output *output) {
}
workspace->server = output->server;
workspace->num = -1;
workspace->scene = wlr_scene_tree_create(&output->scene_output->scene->node);
workspace->scene =
wlr_scene_tree_create(&output->scene_output->scene->node);
if(full_screen_workspace_tiles(output->server->output_layout,
output->wlr_output, workspace,
&output->server->tiles_curr_id) != 0) {
@ -100,7 +101,9 @@ workspace_free(struct cg_workspace *workspace) {
void
workspace_focus(struct cg_output *outp, int ws) {
wlr_scene_node_place_above(&outp->bg->node,&outp->workspaces[outp->curr_workspace]->scene->node);
wlr_scene_node_place_above(&outp->workspaces[ws]->scene->node,&outp->bg->node);
outp->curr_workspace=ws;
wlr_scene_node_place_above(
&outp->bg->node, &outp->workspaces[outp->curr_workspace]->scene->node);
wlr_scene_node_place_above(&outp->workspaces[ws]->scene->node,
&outp->bg->node);
outp->curr_workspace = ws;
}

87
xdg_shell.c
View file

@ -9,16 +9,16 @@
#define _POSIX_C_SOURCE 200809L
#include <stdbool.h>
#include <assert.h>
#include <stdbool.h>
#include <wayland-server-core.h>
#include <wlr/util/box.h>
#include <wlr/types/wlr_output_layout.h>
#include <wlr/types/wlr_scene.h>
#include <wlr/types/wlr_xdg_decoration_v1.h>
#include <wlr/types/wlr_xdg_shell.h>
#include <wlr/util/box.h>
#include <wlr/util/edges.h>
#include <wlr/util/log.h>
#include <wlr/types/wlr_scene.h>
#include "output.h"
#include "server.h"
@ -29,26 +29,28 @@
static struct cg_view *
popup_get_view(struct wlr_xdg_popup *popup) {
while(true) {
if(popup->parent == NULL || !wlr_surface_is_xdg_surface(popup->parent)) {
if(popup->parent == NULL ||
!wlr_surface_is_xdg_surface(popup->parent)) {
return NULL;
}
struct wlr_xdg_surface *xdg_surface = wlr_xdg_surface_from_wlr_surface(popup->parent);
struct wlr_xdg_surface *xdg_surface =
wlr_xdg_surface_from_wlr_surface(popup->parent);
switch(xdg_surface->role) {
case WLR_XDG_SURFACE_ROLE_TOPLEVEL:
return xdg_surface->data;
case WLR_XDG_SURFACE_ROLE_POPUP:
popup=xdg_surface->popup;
break;
case WLR_XDG_SURFACE_ROLE_NONE:
return NULL;
case WLR_XDG_SURFACE_ROLE_TOPLEVEL:
return xdg_surface->data;
case WLR_XDG_SURFACE_ROLE_POPUP:
popup = xdg_surface->popup;
break;
case WLR_XDG_SURFACE_ROLE_NONE:
return NULL;
}
}
}
static void
xdg_decoration_handle_destroy(struct wl_listener *listener, void *data)
{
struct cg_xdg_decoration *xdg_decoration = wl_container_of(listener, xdg_decoration, destroy);
xdg_decoration_handle_destroy(struct wl_listener *listener, void *data) {
struct cg_xdg_decoration *xdg_decoration =
wl_container_of(listener, xdg_decoration, destroy);
wl_list_remove(&xdg_decoration->destroy.link);
wl_list_remove(&xdg_decoration->request_mode.link);
@ -196,31 +198,31 @@ handle_xdg_shell_surface_destroy(struct wl_listener *listener, void *_data) {
view_destroy(view);
}
static const struct cg_view_impl xdg_shell_view_impl = {
.get_title = get_title,
.is_primary = is_primary,
.activate = activate,
.close = close,
.maximize = maximize,
.destroy = destroy
};
static const struct cg_view_impl xdg_shell_view_impl = {.get_title = get_title,
.is_primary =
is_primary,
.activate = activate,
.close = close,
.maximize = maximize,
.destroy = destroy};
void
handle_xdg_shell_surface_new(struct wl_listener *listener, void *data)
{
struct cg_server *server = wl_container_of(listener, server, new_xdg_shell_surface);
handle_xdg_shell_surface_new(struct wl_listener *listener, void *data) {
struct cg_server *server =
wl_container_of(listener, server, new_xdg_shell_surface);
struct wlr_xdg_surface *xdg_surface = data;
switch (xdg_surface->role) {
switch(xdg_surface->role) {
case WLR_XDG_SURFACE_ROLE_TOPLEVEL:;
struct cg_xdg_shell_view *xdg_shell_view = calloc(1, sizeof(struct cg_xdg_shell_view));
if (!xdg_shell_view) {
struct cg_xdg_shell_view *xdg_shell_view =
calloc(1, sizeof(struct cg_xdg_shell_view));
if(!xdg_shell_view) {
wlr_log(WLR_ERROR, "Failed to allocate XDG Shell view");
return;
}
view_init(&xdg_shell_view->view, CG_XDG_SHELL_VIEW, &xdg_shell_view_impl,server);
view_init(&xdg_shell_view->view, CG_XDG_SHELL_VIEW,
&xdg_shell_view_impl, server);
xdg_shell_view->xdg_surface = xdg_surface;
@ -230,21 +232,24 @@ handle_xdg_shell_surface_new(struct wl_listener *listener, void *data)
wl_signal_add(&xdg_surface->events.unmap, &xdg_shell_view->unmap);
xdg_shell_view->destroy.notify = handle_xdg_shell_surface_destroy;
wl_signal_add(&xdg_surface->events.destroy, &xdg_shell_view->destroy);
xdg_shell_view->request_fullscreen.notify = handle_xdg_shell_surface_request_fullscreen;
wl_signal_add(&xdg_surface->toplevel->events.request_fullscreen, &xdg_shell_view->request_fullscreen);
xdg_shell_view->request_fullscreen.notify =
handle_xdg_shell_surface_request_fullscreen;
wl_signal_add(&xdg_surface->toplevel->events.request_fullscreen,
&xdg_shell_view->request_fullscreen);
xdg_surface->data = xdg_shell_view;
break;
case WLR_XDG_SURFACE_ROLE_POPUP:;
struct wlr_xdg_popup *popup = xdg_surface->popup;
struct cg_view *view = popup_get_view(popup);
if (view == NULL) {
if(view == NULL) {
return;
}
struct wlr_scene_node *parent_scene_node = NULL;
struct wlr_xdg_surface *parent = wlr_xdg_surface_from_wlr_surface(popup->parent);
switch (parent->role) {
struct wlr_xdg_surface *parent =
wlr_xdg_surface_from_wlr_surface(popup->parent);
switch(parent->role) {
case WLR_XDG_SURFACE_ROLE_TOPLEVEL:;
parent_scene_node = view->scene_node;
break;
@ -254,13 +259,15 @@ handle_xdg_shell_surface_new(struct wl_listener *listener, void *data)
case WLR_XDG_SURFACE_ROLE_NONE:
break;
}
if (parent_scene_node == NULL) {
if(parent_scene_node == NULL) {
return;
}
struct wlr_scene_node *popup_scene_node = wlr_scene_xdg_surface_create(parent_scene_node, xdg_surface);
if (popup_scene_node == NULL) {
wlr_log(WLR_ERROR, "Failed to allocate scene-graph node for XDG popup");
struct wlr_scene_node *popup_scene_node =
wlr_scene_xdg_surface_create(parent_scene_node, xdg_surface);
if(popup_scene_node == NULL) {
wlr_log(WLR_ERROR,
"Failed to allocate scene-graph node for XDG popup");
return;
}

9
xwayland.c
View file

@ -89,8 +89,9 @@ maximize(struct cg_view *view, int width, int height) {
struct wlr_box *output_box = wlr_output_layout_get_box(
view->server->output_layout, view->server->curr_output->wlr_output);
wlr_xwayland_surface_configure(xwayland_view->xwayland_surface, view->ox+output_box->x,
view->oy+output_box->y, width, height);
wlr_xwayland_surface_configure(xwayland_view->xwayland_surface,
view->ox + output_box->x,
view->oy + output_box->y, width, height);
wlr_xwayland_surface_set_maximized(xwayland_view->xwayland_surface, true);
}
@ -129,8 +130,8 @@ handle_xwayland_surface_map(struct wl_listener *listener, void *_data) {
struct wlr_output_layout *output_layout = view->server->output_layout;
struct wlr_box *output_box = wlr_output_layout_get_box(
output_layout, view->server->curr_output->wlr_output);
view->ox = xwayland_view->xwayland_surface->x-output_box->x;
view->oy = xwayland_view->xwayland_surface->y-output_box->y;
view->ox = xwayland_view->xwayland_surface->x - output_box->x;
view->oy = xwayland_view->xwayland_surface->y - output_box->y;
}
view_map(view, xwayland_view->xwayland_surface->surface,