zedhugh/zdwm
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

style: 禁掉 clang-format 的 AlignConsecutiveAssignments 规则并重新格式化整个项目

Browse Source
This commit is contained in:
Zedhugh Chen
2026-06-24 13:05:56 +08:00
parent 8f671bd755
commit bf3de7fb92
38 changed files with 763 additions and 731 deletions
Download Patch File Download Diff File Expand all files Collapse all files

38
src/core/binding.c
View File

@@ -43,9 +43,9 @@ binding_table_add_mode(binding_table_t *table, const char *mode_name) {
}
zdwm_binding_mode_id_t id = (zdwm_binding_mode_id_t)table->count;
auto new_mode = array_push(table->modes, table->count, table->capacity);
auto new_mode = array_push(table->modes, table->count, table->capacity);
new_mode->name = mode_name;
new_mode->id = id;
new_mode->id = id;
return id;
}
@@ -82,8 +82,10 @@ static const mod_entry_t mod_table[] = {
static modifier_mask_t lookup_modifier(const char *name, size_t len) {
for (size_t i = 0; i < countof(mod_table); ++i) {
if (strlen(mod_table[i].name) == len &&
strncmp(name, mod_table[i].name, len) == 0) {
if (
strlen(mod_table[i].name) == len &&
strncmp(name, mod_table[i].name, len) == 0
) {
return mod_table[i].mask;
}
}
@@ -118,13 +120,13 @@ static bool parse_key_sequence(
if (!key_sequence || !modifiers || !keysym) return false;
modifier_mask_t mods = ZDWM_MOD_NONE;
xkb_keysym_t key = XKB_KEY_NoSymbol;
xkb_keysym_t key = XKB_KEY_NoSymbol;
const char *p = key_sequence;
const char *p = key_sequence;
const char *end = key_sequence + strlen(key_sequence);
while (p < end) {
const char *plus = strchr(p, '+');
const char *plus = strchr(p, '+');
const char *seg_end = plus ? plus : end;
const char *s = p;
@@ -139,7 +141,7 @@ static bool parse_key_sequence(
modifier_mask_t mod = lookup_modifier(s, (size_t)(e - s));
if (mod == ZDWM_MOD_NONE) return false;
mods |= mod;
p = plus + 1;
p = plus + 1;
} else {
char key_buf[64];
size_t key_len = (size_t)(e - s);
@@ -152,7 +154,7 @@ static bool parse_key_sequence(
return false;
} else {
*modifiers = mods;
*keysym = key;
*keysym = key;
return true;
}
}
@@ -171,13 +173,13 @@ bool binding_table_add_bind(
if (!mode) return false;
modifier_mask_t modifiers = 0;
xkb_keysym_t keysym = XKB_KEY_NoSymbol;
xkb_keysym_t keysym = XKB_KEY_NoSymbol;
if (!parse_key_sequence(key_sequence, &modifiers, &keysym)) return false;
auto item = array_push(mode->items, mode->count, mode->capacity);
auto item = array_push(mode->items, mode->count, mode->capacity);
item->modifiers = modifiers;
item->keysym = keysym;
item->action = action;
item->keysym = keysym;
item->action = action;
return true;
}
@@ -188,13 +190,13 @@ void binding_table_destroy(binding_table_t *table) {
for (size_t i = 0; i < table->count; ++i) {
binding_mode_t *mode = &table->modes[i];
p_delete(&mode->items);
mode->count = 0;
mode->count = 0;
mode->capacity = 0;
}
p_delete(&table->modes);
table->count = 0;
table->capacity = 0;
table->count = 0;
table->capacity = 0;
table->default_mode = ZDWM_BINDING_MODE_ID_INVALID;
p_delete(&table);
@@ -243,7 +245,7 @@ binding_table_cycle_mode(const binding_table_t *table, int32_t delta) {
} else {
for (size_t i = 0; i < table->count; ++i) {
if (table->modes[i].id == table->current_mode) {
index = i;
index = i;
matched = true;
break;
}
@@ -252,7 +254,7 @@ binding_table_cycle_mode(const binding_table_t *table, int32_t delta) {
if (!matched) return ZDWM_BINDING_MODE_ID_INVALID;
int64_t count = (int64_t)table->count;
int64_t count = (int64_t)table->count;
int64_t next_index = ((int64_t)index + (int64_t)delta) % count;
if (next_index < 0) next_index += count;

4
src/core/command_buffer.c
View File

@@ -13,11 +13,11 @@ void command_buffer_reset(command_buffer_t *buffer) {
void command_buffer_cleanup(command_buffer_t *buffer) {
p_delete(&buffer->items);
buffer->count = 0;
buffer->count = 0;
buffer->capacity = 0;
}
void command_buffer_push(command_buffer_t *buffer, const command_t *command) {
command_t *cmd = array_push(buffer->items, buffer->count, buffer->capacity);
*cmd = *command;
*cmd = *command;
}

2
src/core/event.h
View File

@@ -75,11 +75,13 @@ typedef struct window_metadata_change_event_t {
window_metadata_t metadata;
} window_metadata_change_event_t;
/* clang-format off */
typedef enum window_activation_source_t {
ZDWM_WINDOW_ACTIVATION_SOURCE_LEGACY = 0,
ZDWM_WINDOW_ACTIVATION_SOURCE_APPLICATION = 1,
ZDWM_WINDOW_ACTIVATION_SOURCE_PAGER = 2,
} window_activation_source_t;
/* clang-format on */
typedef struct window_activate_request_event_t {
window_id_t window;

8
src/core/layer.c
View File

@@ -8,7 +8,7 @@
void layer_stack_cleanup(layer_stack_t *layer) {
p_delete(&layer->order);
layer->count = 0;
layer->count = 0;
layer->capacity = 0;
}
@@ -19,7 +19,7 @@ void layer_stack_append(layer_stack_t *layer, window_id_t window) {
}
bool layer_stack_remove(layer_stack_t *layer, window_id_t window) {
bool found = false;
bool found = false;
size_t index = 0;
for (size_t i = 0; i < layer->count; ++i) {
if (layer->order[i] != window) continue;
@@ -40,7 +40,7 @@ bool layer_stack_remove(layer_stack_t *layer, window_id_t window) {
}
bool layer_stack_raise(layer_stack_t *layer, window_id_t window) {
bool found = false;
bool found = false;
size_t index = 0;
for (size_t i = 0; i < layer->count; ++i) {
if (layer->order[i] != window) continue;
@@ -64,7 +64,7 @@ bool layer_stack_raise(layer_stack_t *layer, window_id_t window) {
}
bool layer_stack_lower(layer_stack_t *layer, window_id_t window) {
bool found = false;
bool found = false;
size_t index = 0;
for (size_t i = 0; i < layer->count; ++i) {
if (layer->order[i] != window) continue;

20
src/core/layout.c
View File

@@ -10,7 +10,7 @@
void layout_result_cleanup(layout_result_t *result) {
p_delete(&result->items);
result->item_count = 0;
result->item_count = 0;
result->item_capacity = 0;
}
@@ -31,19 +31,19 @@ void layout_registry_cleanup(layout_registry_t *registry) {
}
p_delete(&registry->slots);
registry->slot_count = 0;
registry->slot_count = 0;
registry->slot_capacity = 0;
}
bool layout_registry_move(layout_registry_t *src, layout_registry_t *dest) {
if (!src || !dest) return false;
dest->slots = src->slots;
dest->slot_count = src->slot_count;
dest->slots = src->slots;
dest->slot_count = src->slot_count;
dest->slot_capacity = src->slot_capacity;
src->slots = nullptr;
src->slot_count = 0;
src->slots = nullptr;
src->slot_count = 0;
src->slot_capacity = 0;
return true;
@@ -71,11 +71,11 @@ layout_id_t layout_register(
layout_id_t id = (layout_id_t)registry->slot_count;
layout_slot_t *r =
array_push(registry->slots, registry->slot_count, registry->slot_capacity);
r->id = id;
r->name = p_strdup(name);
r->symbol = p_strdup(symbol);
r->id = id;
r->name = p_strdup(name);
r->symbol = p_strdup(symbol);
r->description = p_strdup_nullable(description);
r->fn = fn;
r->fn = fn;
return r->id;
}

42
src/core/listeners.c
View File

@@ -6,10 +6,10 @@
#include "core/layout.h"
#include "core/state.h"
#define ADD_LISTENER(FIELD) \
auto list = &listeners->FIELD; \
auto item = array_push(list->items, list->count, list->capacity); \
item->fn = fn; \
#define ADD_LISTENER(FIELD) \
auto list = &listeners->FIELD; \
auto item = array_push(list->items, list->count, list->capacity); \
item->fn = fn; \
item->user_data = user_data
void listeners_add_output_listener(
@@ -88,7 +88,7 @@ void listeners_add_window_removed_listener(
#define CLEANUP_LIST(FIELD) \
p_delete(&listeners->FIELD.items); \
listeners->FIELD.count = 0; \
listeners->FIELD.count = 0; \
listeners->FIELD.capacity = 0
void listeners_cleanup(listeners_t *listeners) {
@@ -131,14 +131,14 @@ void listeners_notify_initial_workspaces(
if (!listeners || !state) return;
size_t count = state_workspace_count(state);
auto items = count ? p_new(zdwm_workspace_t, count) : nullptr;
auto items = count ? p_new(zdwm_workspace_t, count) : nullptr;
for (size_t i = 0; i < count; ++i) {
auto workspace = state_workspace_at(state, i);
items[i] = (zdwm_workspace_t){
.output_id = workspace->output_id,
.id = workspace->id,
.name = workspace->name,
.id = workspace->id,
.name = workspace->name,
};
}
@@ -173,10 +173,10 @@ void listeners_notify_layout(
if (!slot) return;
zdwm_layout_notify_t notify = {
.workspace = workspace_id,
.id = layout_id,
.name = slot->name,
.symbol = slot->symbol,
.workspace = workspace_id,
.id = layout_id,
.name = slot->name,
.symbol = slot->symbol,
.description = slot->description,
};
@@ -191,12 +191,12 @@ void listeners_notify_binding_mode(
auto default_mode = binding_table_get_default_mode(binding_table);
auto current_mode = binding_table_get_current_mode(binding_table);
auto name = binding_table_get_mode_name(binding_table, current_mode);
auto name = binding_table_get_mode_name(binding_table, current_mode);
zdwm_binding_mode_notify_t notify = {
.is_default_mode = default_mode == current_mode,
.id = current_mode,
.name = name,
.id = current_mode,
.name = name,
};
FOR_EACH_LISTENER(binding_mode_listeners, item->fn(notify, item->user_data));
@@ -216,11 +216,11 @@ static bool listeners_window_snapshot(
if (!workspace) return false;
*out = (zdwm_window_t){
.workspace = window->workspace_id,
.id = window->id,
.title = window->title,
.focused = workspace->focused_window_id == window->id,
.urgent = window->urgent,
.workspace = window->workspace_id,
.id = window->id,
.title = window->title,
.focused = workspace->focused_window_id == window->id,
.urgent = window->urgent,
.skip_taskbar = window->skip_taskbar,
};
return true;
@@ -232,7 +232,7 @@ void listeners_notify_initial_windows(
) {
if (!listeners || !state) return;
size_t count = state_window_count(state);
size_t count = state_window_count(state);
zdwm_window_t *items = count ? p_new(zdwm_window_t, count) : nullptr;
for (size_t i = 0; i < count; ++i) {
auto window = state_window_at(state, i);

40
src/core/plan.c
View File

@@ -38,23 +38,23 @@ void plan_reset(plan_t *plan) {
void plan_cleanup(plan_t *plan) {
free_memory_hold_by_effects(plan->effects, plan->count);
p_delete(&plan->effects);
plan->count = 0;
plan->capacity = 0;
plan->count = 0;
plan->capacity = 0;
plan->need_relayout = false;
plan->quit = false;
plan->will_restart = false;
plan->quit = false;
plan->will_restart = false;
}
void plan_push_effect(plan_t *plan, const effect_t *effect) {
effect_t *eft = array_push(plan->effects, plan->count, plan->capacity);
*eft = *effect;
*eft = *effect;
}
void plan_push_map_effect(plan_t *plan, window_id_t window_id) {
if (window_id_invalid(window_id)) return;
effect_t effect = {
.type = ZDWM_EFFECT_MAP_WINDOW,
.type = ZDWM_EFFECT_MAP_WINDOW,
.as.map.window = window_id,
};
plan_push_effect(plan, &effect);
@@ -64,7 +64,7 @@ void plan_push_unmap_effect(plan_t *plan, window_id_t window_id) {
if (window_id_invalid(window_id)) return;
effect_t effect = {
.type = ZDWM_EFFECT_UNMAP_WINDOW,
.type = ZDWM_EFFECT_UNMAP_WINDOW,
.as.unmap.window = window_id,
};
plan_push_effect(plan, &effect);
@@ -74,7 +74,7 @@ void plan_push_focus_effect(plan_t *plan, window_id_t window_id) {
if (window_id_invalid(window_id)) return;
effect_t effect = {
.type = ZDWM_EFFECT_FOCUS_WINDOW,
.type = ZDWM_EFFECT_FOCUS_WINDOW,
.as.focus.window = window_id,
};
plan_push_effect(plan, &effect);
@@ -84,7 +84,7 @@ void plan_push_kill_effect(plan_t *plan, window_id_t window_id) {
if (window_id_invalid(window_id)) return;
effect_t effect = {
.type = ZDWM_EFFECT_KILL_WINDOW,
.type = ZDWM_EFFECT_KILL_WINDOW,
.as.kill.window = window_id,
};
plan_push_effect(plan, &effect);
@@ -94,7 +94,7 @@ void plan_push_withdraw_effect(plan_t *plan, window_id_t window_id) {
if (window_id_invalid(window_id)) return;
effect_t effect = {
.type = ZDWM_EFFECT_WITHDRAW_WINDOW,
.type = ZDWM_EFFECT_WITHDRAW_WINDOW,
.as.withdraw.window = window_id,
};
plan_push_effect(plan, &effect);
@@ -104,7 +104,7 @@ void plan_push_move_effect(plan_t *plan, window_id_t window_id) {
if (window_id_invalid(window_id)) return;
effect_t effect = {
.type = ZDWM_EFFECT_START_MOVE_WINDOW,
.type = ZDWM_EFFECT_START_MOVE_WINDOW,
.as.move.window = window_id,
};
plan_push_effect(plan, &effect);
@@ -114,7 +114,7 @@ void plan_push_resize_effect(plan_t *plan, window_id_t window_id) {
if (window_id_invalid(window_id)) return;
effect_t effect = {
.type = ZDWM_EFFECT_START_RESIZE_WINDOW,
.type = ZDWM_EFFECT_START_RESIZE_WINDOW,
.as.resize.window = window_id,
};
plan_push_effect(plan, &effect);
@@ -128,10 +128,10 @@ void plan_push_fullscreen_effect(
if (window_id_invalid(window_id)) return;
effect_t effect = {
.type = ZDWM_EFFECT_FULLSCREEN_WINDOW,
.type = ZDWM_EFFECT_FULLSCREEN_WINDOW,
.as.fullscreen = {
.window = window_id,
.value = value,
.value = value,
},
};
plan_push_effect(plan, &effect);
@@ -145,10 +145,10 @@ void plan_push_maximize_effect(
if (window_id_invalid(window_id)) return;
effect_t effect = {
.type = ZDWM_EFFECT_MAXIMIZE_WINDOW,
.type = ZDWM_EFFECT_MAXIMIZE_WINDOW,
.as.maximize = {
.window = window_id,
.value = value,
.value = value,
},
};
plan_push_effect(plan, &effect);
@@ -162,10 +162,10 @@ void plan_push_minimize_effect(
if (window_id_invalid(window_id)) return;
effect_t effect = {
.type = ZDWM_EFFECT_MINIMIZE_WINDOW,
.type = ZDWM_EFFECT_MINIMIZE_WINDOW,
.as.minimize = {
.window = window_id,
.value = value,
.value = value,
},
};
plan_push_effect(plan, &effect);
@@ -179,10 +179,10 @@ void plan_push_change_border_color_effect(
if (window_id_invalid(window_id) || color == nullptr) return;
effect_t effect = {
.type = ZDWM_EFFECT_CHANGE_BORDER_COLOR,
.type = ZDWM_EFFECT_CHANGE_BORDER_COLOR,
.as.change_border_color = {
.window = window_id,
.color = color,
.color = color,
},
};
plan_push_effect(plan, &effect);

304
src/core/policy.c
View File

@@ -26,7 +26,7 @@
static void quit(bool restart, command_buffer_t *command_buffer) {
command_t quit_command = {
.type = ZDWM_COMMAND_QUIT,
.type = ZDWM_COMMAND_QUIT,
.as.quit.will_restart = restart
};
command_buffer_push(command_buffer, &quit_command);
@@ -34,7 +34,7 @@ static void quit(bool restart, command_buffer_t *command_buffer) {
static const window_t *
get_next_window_by_class(const state_t *state, const char *class_name) {
auto output = state_output_at(state, state->current_output_index);
auto output = state_output_at(state, state->current_output_index);
auto workspace = state_workspace_get(state, output->current_workspace_id);
size_t start_index = 0;
@@ -68,7 +68,7 @@ static void add_switch_workspace_command(
workspace_id_t workspace
) {
command_t switch_workspace_cmd = {
.type = ZDWM_COMMAND_SWITCH_WORKSPACE,
.type = ZDWM_COMMAND_SWITCH_WORKSPACE,
.as.switch_workspace.workspace = workspace,
};
command_buffer_push(command_buffer, &switch_workspace_cmd);
@@ -77,7 +77,7 @@ static void add_switch_workspace_command(
static void
add_focus_window_command(command_buffer_t *command_buffer, window_id_t window) {
command_t focus_command = {
.type = ZDWM_COMMAND_FOCUS_WINDOW,
.type = ZDWM_COMMAND_FOCUS_WINDOW,
.as.focus.window = window,
};
command_buffer_push(command_buffer, &focus_command);
@@ -101,9 +101,9 @@ static void raise_or_run(
static output_id_t get_cycled_output(const state_t *state, int32_t delta) {
if (state->output_count <= 1) return ZDWM_OUTPUT_ID_INVALID;
int64_t count = (int64_t)state->output_count;
int64_t count = (int64_t)state->output_count;
int64_t current = (int64_t)state->current_output_index;
int64_t next = (current + (int64_t)delta) % count;
int64_t next = (current + (int64_t)delta) % count;
if (next < 0) next += count;
auto output = state_output_at(state, (size_t)next);
@@ -119,7 +119,7 @@ static void cycle_current_output(
if (output_id == ZDWM_OUTPUT_ID_INVALID) return;
command_t cmd = {
.type = ZDWM_COMMAND_SET_CURRENT_OUTPUT,
.type = ZDWM_COMMAND_SET_CURRENT_OUTPUT,
.as.current_output.output = output_id,
};
command_buffer_push(command_buffer, &cmd);
@@ -130,7 +130,7 @@ static void switch_workspace_same_output_by_index(
uint32_t index,
command_buffer_t *command_buffer
) {
auto output = state_output_at(state, state->current_output_index);
auto output = state_output_at(state, state->current_output_index);
uint32_t count = 0;
for (size_t i = 0; i < state_workspace_count(state); ++i) {
auto workspace = state_workspace_at(state, i);
@@ -149,17 +149,17 @@ static void cycle_layout(
int32_t delta,
command_buffer_t *command_buffer
) {
auto output = state_output_at(state, state->current_output_index);
auto output = state_output_at(state, state->current_output_index);
auto workspace = state_workspace_get(state, output->current_workspace_id);
int32_t index = 0;
bool matched = false;
int32_t index = 0;
bool matched = false;
auto layout_count = (int32_t)workspace->layout_count;
if (layout_count <= 1) return;
for (int32_t i = 0; i < layout_count; ++i) {
if (workspace->layout_id == workspace->available_layouts[i]) {
index = i;
index = i;
matched = true;
break;
}
@@ -167,15 +167,15 @@ static void cycle_layout(
if (!matched) return;
auto new_index = index + delta;
new_index %= layout_count;
auto new_index = index + delta;
new_index %= layout_count;
if (new_index < 0) new_index += layout_count;
if (new_index == index) return;
auto next_layout_id = workspace->available_layouts[new_index];
auto next_layout_id = workspace->available_layouts[new_index];
command_t set_layout_command = {
.type = ZDWM_COMMAND_SET_LAYOUT,
.type = ZDWM_COMMAND_SET_LAYOUT,
.as.layout = {.workspace = workspace->id, .layout = next_layout_id},
};
command_buffer_push(command_buffer, &set_layout_command);
@@ -191,14 +191,14 @@ static void cycle_binding_mode(
if (next_mode_id == ZDWM_BINDING_MODE_ID_INVALID) return;
command_t set_binding_mode_command = {
.type = ZDWM_COMMAND_SET_BINDING_MODE,
.type = ZDWM_COMMAND_SET_BINDING_MODE,
.as.binding_mode.mode = next_mode_id,
};
command_buffer_push(command_buffer, &set_binding_mode_command);
}
static const window_t *get_current_focused_window(const state_t *state) {
auto output = state_output_at(state, state->current_output_index);
auto output = state_output_at(state, state->current_output_index);
auto workspace = state_workspace_get(state, output->current_workspace_id);
return state_window_get(state, workspace->focused_window_id);
}
@@ -209,7 +209,7 @@ static const window_t *get_current_focused_window(const state_t *state) {
if (!window) return; \
\
command_t command = { \
.type = (TYPE), \
.type = (TYPE), \
.as.DATA_FIELD = {.window = window->id, .state = !window->WINDOW_FIELD}, \
}; \
command_buffer_push(command_buffer, &command); \
@@ -247,7 +247,7 @@ static void cycle_focused_window(
int32_t delta,
command_buffer_t *command_buffer
) {
auto output = state_output_at(state, state->current_output_index);
auto output = state_output_at(state, state->current_output_index);
auto workspace = state_workspace_get(state, output->current_workspace_id);
size_t count = state_window_count(state);
@@ -282,7 +282,7 @@ static void cycle_focused_window(
add_focus_window_command(command_buffer, target->id);
command_t raise_cmd = {
.type = ZDWM_COMMAND_RAISE_WINDOW,
.type = ZDWM_COMMAND_RAISE_WINDOW,
.as.raise.window = target->id,
};
command_buffer_push(command_buffer, &raise_cmd);
@@ -294,7 +294,7 @@ kill_window_action(const state_t *state, command_buffer_t *command_buffer) {
if (!window) return;
command_t kill_window_command = {
.type = ZDWM_COMMAND_KILL_WINDOW,
.type = ZDWM_COMMAND_KILL_WINDOW,
.as.kill.window = window->id,
};
command_buffer_push(command_buffer, &kill_window_command);
@@ -313,18 +313,18 @@ static void cycle_window_output(
if (data->keep_focus) {
command_t set_current_output_command = {
.type = ZDWM_COMMAND_SET_CURRENT_OUTPUT,
.type = ZDWM_COMMAND_SET_CURRENT_OUTPUT,
.as.current_output.output = output_id,
};
command_buffer_push(command_buffer, &set_current_output_command);
}
auto output = state_output_get(state, output_id);
auto output = state_output_get(state, output_id);
auto workspace = state_workspace_get(state, output->current_workspace_id);
command_t send_window_to_workspace_command = {
.type = ZDWM_COMMAND_WINDOW_SEND_TO_WORKSPACE,
.type = ZDWM_COMMAND_WINDOW_SEND_TO_WORKSPACE,
.as.send_to_workspace = {
.window = window->id,
.window = window->id,
.workspace = workspace->id,
},
};
@@ -349,9 +349,9 @@ static void send_window_to_workspace_same_output_by_index(
}
command_t send_window_to_workspace_command = {
.type = ZDWM_COMMAND_WINDOW_SEND_TO_WORKSPACE,
.type = ZDWM_COMMAND_WINDOW_SEND_TO_WORKSPACE,
.as.send_to_workspace = {
.window = current_workspace->focused_window_id,
.window = current_workspace->focused_window_id,
.workspace = target_workspace->id,
},
};
@@ -363,7 +363,7 @@ static void toggle_bar_visibility(
command_buffer_t *command_buffer
) {
command_t set_bar_visibility_command = {
.type = ZDWM_COMMAND_SET_BAR_VISIBILITY,
.type = ZDWM_COMMAND_SET_BAR_VISIBILITY,
.as.bar_visibility = {
.visible = !*bar->visible,
},
@@ -449,7 +449,7 @@ static void route_key_press(
) {
auto binding_table = ctx->bind_table;
size_t count = 0;
size_t count = 0;
auto bindings = binding_table_get_current_bindings(binding_table, &count);
if (!bindings) return;
@@ -467,15 +467,15 @@ static void route_pointer_press(
command_buffer_t *out
) {
auto window_id = data->window;
auto window = state_window_get(ctx->state, window_id);
auto window = state_window_get(ctx->state, window_id);
if (!window) return;
/* TODO: 后续改为配置 */
if (data->button == ZDWM_BUTTON_LEFT && data->modifiers == ZDWM_MOD_4) {
command_t start_move_cmd = {
.type = ZDWM_COMMAND_START_MOVE_WINDOW,
.type = ZDWM_COMMAND_START_MOVE_WINDOW,
.as.move = {
.window = window_id,
.window = window_id,
.pointer_coordinate = data->root,
},
};
@@ -483,9 +483,9 @@ static void route_pointer_press(
}
if (data->button == ZDWM_BUTTON_RIGHT && data->modifiers == ZDWM_MOD_4) {
command_t start_resize_cmd = {
.type = ZDWM_COMMAND_START_RESIZE_WINDOW,
.type = ZDWM_COMMAND_START_RESIZE_WINDOW,
.as.resize = {
.window = window_id,
.window = window_id,
.pointer_coordinate = data->root,
}
};
@@ -518,27 +518,27 @@ static void route_pointer_motion(
command_buffer_t *out
) {
auto interaction = ctx->interaction;
auto window_id = interaction->window;
auto window_id = interaction->window;
switch (interaction->mode) {
case ZDWM_WINDOW_INTERACTION_NONE:
break;
case ZDWM_WINDOW_INTERACTION_MOVE: {
auto time = interaction->last_change_time;
auto now = time_monotonic_ms();
auto now = time_monotonic_ms();
if (now - time < 1000 / ctx->fps) break;
auto rect = interaction->origin_rect;
auto rect = interaction->origin_rect;
auto start = interaction->start_coordinate;
auto end = data->root;
auto end = data->root;
command_t configure = {
.type = ZDWM_COMMAND_CONFIGURE_WINDOW,
.type = ZDWM_COMMAND_CONFIGURE_WINDOW,
.as.configure = {
.window = interaction->window,
.window = interaction->window,
.changed_fields = ZDWM_CONFIGURE_FIELD_X | ZDWM_CONFIGURE_FIELD_Y,
.x = rect.x + (end.x - start.x),
.y = rect.y + (end.y - start.y),
.x = rect.x + (end.x - start.x),
.y = rect.y + (end.y - start.y),
},
};
command_buffer_push(out, &configure);
@@ -547,35 +547,35 @@ static void route_pointer_motion(
} break;
case ZDWM_WINDOW_INTERACTION_RESIZE: {
auto time = interaction->last_change_time;
auto now = time_monotonic_ms();
auto now = time_monotonic_ms();
if (now - time < 1000 / ctx->fps) break;
auto window = state_window_get(ctx->state, window_id);
if (!window_can_resize(window)) break;
auto rect = interaction->origin_rect;
auto rect = interaction->origin_rect;
auto start = interaction->start_coordinate;
auto end = data->root;
auto end = data->root;
auto min_size = window->min_size;
auto max_size = window->max_size;
auto width = rect.width + (end.x - start.x);
auto width = rect.width + (end.x - start.x);
auto height = rect.height + (end.y - start.y);
width = MAX(width, min_size.width);
height = MAX(height, min_size.height);
width = MIN(width, max_size.width);
height = MIN(height, max_size.height);
width = MAX(width, min_size.width);
height = MAX(height, min_size.height);
width = MIN(width, max_size.width);
height = MIN(height, max_size.height);
if (!window_need_resize(window, width, height)) break;
command_t configure_cmd = {
.type = ZDWM_COMMAND_CONFIGURE_WINDOW,
.type = ZDWM_COMMAND_CONFIGURE_WINDOW,
.as.configure = {
.window = interaction->window,
.changed_fields =
ZDWM_CONFIGURE_FIELD_WIDTH | ZDWM_CONFIGURE_FIELD_HEIGHT,
.width = width,
.width = width,
.height = height,
}
};
@@ -609,32 +609,34 @@ static void route_map_request(
if (window) layer_type = MAX(window->layer, layer_type);
}
/* clang-format off */
command_t manage_window_cmd = {
.type = ZDWM_COMMAND_MANAGE_WINDOW,
.type = ZDWM_COMMAND_MANAGE_WINDOW,
.as.manage_window = {
.workspace = derive_window_workspace(state),
.info = {
.id = e->window,
.transient_for = e->transient_for,
.frame_rect = e->rect,
.info = {
.id = e->window,
.transient_for = e->transient_for,
.frame_rect = e->rect,
.title = e->metadata.title,
.app_id = e->metadata.app_id,
.role = e->metadata.role,
.class_name = e->metadata.class_name,
.instance_name = e->metadata.instance_name,
.title = e->metadata.title,
.app_id = e->metadata.app_id,
.role = e->metadata.role,
.class_name = e->metadata.class_name,
.instance_name = e->metadata.instance_name,
.layer_type = layer_type,
.fullscreen = e->fullscreen,
.maximized = e->maximized,
.minimized = e->minimized,
.urgent = e->urgent,
.skip_taskbar = e->skip_taskbar,
.min_size = e->min_size,
.max_size = e->max_size,
.layer_type = layer_type,
.fullscreen = e->fullscreen,
.maximized = e->maximized,
.minimized = e->minimized,
.urgent = e->urgent,
.skip_taskbar = e->skip_taskbar,
.min_size = e->min_size,
.max_size = e->max_size,
},
},
};
/* clang-format on */
rule_action_t action = {.workspace = ZDWM_WORKSPACE_ID_INVALID};
bool have_rule_match = rules_resolve(rules, &e->metadata, &action);
@@ -651,7 +653,7 @@ static void route_map_request(
command_buffer_push(out, &manage_window_cmd);
if (!have_rule_match || !action.switch_to_workspace) return;
workspace_id_t workspace_id = manage_window_cmd.as.manage_window.workspace;
workspace_id_t workspace_id = manage_window_cmd.as.manage_window.workspace;
const workspace_t *workspace = state_workspace_get(state, workspace_id);
if (!workspace) return;
@@ -669,14 +671,14 @@ static void route_window_remove(
switch (e->reason) {
case ZDWM_WINDOW_REMOVE_WITHDRAWN:
command_t withdrawn_window_cmd = {
.type = ZDWM_COMMAND_WITHDRAW_WINDOW,
.type = ZDWM_COMMAND_WITHDRAW_WINDOW,
.as.withdraw.window = e->window,
};
command_buffer_push(out, &withdrawn_window_cmd);
break;
case ZDWM_WINDOW_REMOVE_DESTROY:
command_t unmanage_window_cmd = {
.type = ZDWM_COMMAND_UNMANAGE_WINDOW,
.type = ZDWM_COMMAND_UNMANAGE_WINDOW,
.as.unmanage.window = e->window,
};
command_buffer_push(out, &unmanage_window_cmd);
@@ -694,7 +696,7 @@ static void route_window_metadata_changed(
if (!window) return;
auto window_id = e->window;
auto metadata = &e->metadata;
auto metadata = &e->metadata;
if (e->changed_fields & ZDWM_WINDOW_METADATA_CHANGE_TITLE) {
state_window_set_title(state, window_id, metadata->title);
@@ -723,7 +725,7 @@ static void route_window_hints_changed(
if (!window) return;
command_t change_hints_cmd = {
.type = ZDWM_COMMAND_CHANGE_HINTS,
.type = ZDWM_COMMAND_CHANGE_HINTS,
.as.hints = *data,
};
command_buffer_push(out, &change_hints_cmd);
@@ -759,9 +761,9 @@ static void route_window_state_request(
if (!window) return;
command_t change_window_state_cmd = {
.type = ZDWM_COMMAND_CHANGE_WINDOW_STATE,
.type = ZDWM_COMMAND_CHANGE_WINDOW_STATE,
.as.state_change = {
.type = e->type,
.type = e->type,
.window = e->window,
.action = e->action,
}
@@ -778,7 +780,7 @@ static void route_configure_request(
auto window = state_window_get(state, data->window);
if (!window) {
command_t configure_cmd = {
.type = ZDWM_COMMAND_CONFIGURE_WINDOW,
.type = ZDWM_COMMAND_CONFIGURE_WINDOW,
.as.configure = *data
};
command_buffer_push(out, &configure_cmd);
@@ -791,7 +793,7 @@ static void route_configure_request(
if (layout_get(layouts, workspace->layout_id)) return;
command_t configure_rect_cmd = {
.type = ZDWM_COMMAND_CONFIGURE_WINDOW,
.type = ZDWM_COMMAND_CONFIGURE_WINDOW,
.as.configure = *data,
};
configure_rect_cmd.as.configure.changed_fields &=
@@ -871,7 +873,7 @@ static void set_foucs_window(
window_id_t window_id,
plan_t *plan
) {
auto state = ctx->state;
auto state = ctx->state;
auto border = ctx->border;
auto workspace = state_workspace_get(state, workspace_id);
@@ -900,10 +902,10 @@ static void push_window_list_effect(const state_t *state, plan_t *plan) {
window_list_push(&list, window->id);
}
effect_t effect = {
.type = ZDWM_EFFECT_CHANGE_WINDOW_LIST,
.type = ZDWM_EFFECT_CHANGE_WINDOW_LIST,
.as.change_window_list = {
.windows = list.windows,
.count = list.count,
.count = list.count,
},
};
plan_push_effect(plan, &effect);
@@ -917,11 +919,11 @@ static void plan_push_grab_button_effect(plan_t *plan, window_id_t window) {
};
constexpr const size_t count = countof(buttons);
auto btns = p_new(grab_button_t, count);
auto btns = p_new(grab_button_t, count);
memcpy(btns, buttons, sizeof(buttons));
effect_t grab_button_effect = {
.type = ZDWM_EFFECT_GRAB_BUTTON,
.type = ZDWM_EFFECT_GRAB_BUTTON,
.as.grab_button = {.window = window, .buttons = btns, .count = count},
};
plan_push_effect(plan, &grab_button_effect);
@@ -932,9 +934,9 @@ static void manage_window(
const manage_window_command_t *command,
plan_t *plan
) {
auto state = ctx->state;
auto window = state_window_add(state, &command->info);
auto window_id = window->id;
auto state = ctx->state;
auto window = state_window_add(state, &command->info);
auto window_id = window->id;
auto workspace_id = command->workspace;
state_window_set_workspace(state, window_id, workspace_id);
set_foucs_window(ctx, workspace_id, window_id, plan);
@@ -948,7 +950,7 @@ static void manage_window(
state_window_set_floating(state, window_id, command->floating);
}
auto workspace = state_workspace_get(state, workspace_id);
auto workspace = state_workspace_get(state, workspace_id);
auto need_layout = window_need_layout(window);
auto layout_func = layout_get(ctx->layouts, workspace->layout_id);
@@ -966,14 +968,14 @@ static void manage_window(
plan->need_relayout = true;
effect_t configure_effect = {
.type = ZDWM_EFFECT_CONFIGURE_WINDOW,
.type = ZDWM_EFFECT_CONFIGURE_WINDOW,
.as.configure = {
.window = window_id,
.x = window->frame_rect.x,
.y = window->frame_rect.y,
.width = window->frame_rect.width - 2 * (int32_t)window->border_width,
.x = window->frame_rect.x,
.y = window->frame_rect.y,
.width = window->frame_rect.width - 2 * (int32_t)window->border_width,
.height = window->frame_rect.height - 2 * (int32_t)window->border_width,
.border_width = window->border_width,
.border_width = window->border_width,
.changed_fields = ZDWM_CONFIGURE_FIELD_X | ZDWM_CONFIGURE_FIELD_Y |
ZDWM_CONFIGURE_FIELD_WIDTH |
ZDWM_CONFIGURE_FIELD_HEIGHT |
@@ -1008,14 +1010,14 @@ static void add_switch_workspace_effects(
static void
unmanage_window(const policy_context_t *ctx, window_id_t window, plan_t *plan) {
auto state = ctx->state;
auto state = ctx->state;
const window_t *win = state_window_get(state, window);
if (!win) return;
auto workspace_id = win->workspace_id;
auto workspace = state_workspace_get(state, workspace_id);
auto output = state_output_get(state, workspace->output_id);
auto need_layout = window_need_layout(win);
auto workspace = state_workspace_get(state, workspace_id);
auto output = state_output_get(state, workspace->output_id);
auto need_layout = window_need_layout(win);
auto old_focused_window = workspace->focused_window_id;
state_window_remove(state, window);
@@ -1040,11 +1042,11 @@ unmanage_window(const policy_context_t *ctx, window_id_t window, plan_t *plan) {
static void
focus_window(const policy_context_t *ctx, window_id_t window, plan_t *plan) {
auto state = ctx->state;
auto win = state_window_get(state, window);
auto win = state_window_get(state, window);
if (!win) return;
auto workspace_id = win->workspace_id;
auto workspace = state_workspace_get(state, workspace_id);
auto workspace_id = win->workspace_id;
auto workspace = state_workspace_get(state, workspace_id);
auto old_focused_window = workspace->focused_window_id;
set_foucs_window(ctx, workspace_id, window, plan);
@@ -1073,10 +1075,10 @@ static void raise_window(state_t *state, window_id_t window, plan_t *plan) {
}
}
effect_t restack_windows_effect = {
.type = ZDWM_EFFECT_RESTACK_WINDOWS,
.type = ZDWM_EFFECT_RESTACK_WINDOWS,
.as.restack_windows = {
.windows = list.windows,
.count = list.count,
.count = list.count,
},
};
plan_push_effect(plan, &restack_windows_effect);
@@ -1098,7 +1100,7 @@ configure_window(state_t *state, const configure_data_t *data, plan_t *plan) {
auto window = state_window_get(state, data->window);
if (!window) {
effect_t configure_effect = {
.type = ZDWM_EFFECT_CONFIGURE_WINDOW,
.type = ZDWM_EFFECT_CONFIGURE_WINDOW,
.as.configure = *data,
};
plan_push_effect(plan, &configure_effect);
@@ -1116,19 +1118,19 @@ configure_window(state_t *state, const configure_data_t *data, plan_t *plan) {
#undef PICK_FIELD
auto need_move = window_need_move(window, rect.x, rect.y);
auto need_move = window_need_move(window, rect.x, rect.y);
auto need_resize = window_need_resize(window, rect.width, rect.height);
if (!need_move && !need_resize) return;
state_window_set_frame_rect(state, window->id, rect);
effect_t configure_effect = {
.type = ZDWM_EFFECT_CONFIGURE_WINDOW,
.type = ZDWM_EFFECT_CONFIGURE_WINDOW,
.as.configure = {
.window = window->id,
.x = rect.x,
.y = rect.y,
.width = rect.width,
.x = rect.x,
.y = rect.y,
.width = rect.width,
.height = rect.height,
}
};
@@ -1162,13 +1164,13 @@ static void add_window_floating_effect(
plan_t *plan
) {
effect_t configure_effect = {
.type = ZDWM_EFFECT_CONFIGURE_WINDOW,
.type = ZDWM_EFFECT_CONFIGURE_WINDOW,
.as.configure = {
.window = window->id,
.window = window->id,
.border_width = ctx->border->width,
.x = window->frame_rect.x,
.y = window->frame_rect.y,
.width = window->frame_rect.width - 2 * (int32_t)ctx->border->width,
.x = window->frame_rect.x,
.y = window->frame_rect.y,
.width = window->frame_rect.width - 2 * (int32_t)ctx->border->width,
.height = window->frame_rect.height - 2 * (int32_t)ctx->border->width,
.changed_fields = ZDWM_CONFIGURE_FIELD_X | ZDWM_CONFIGURE_FIELD_Y |
ZDWM_CONFIGURE_FIELD_WIDTH |
@@ -1203,7 +1205,7 @@ static void fullscreen_window(
bool value,
plan_t *plan
) {
auto state = ctx->state;
auto state = ctx->state;
auto window = state_window_get(state, window_id);
if (!window) return;
@@ -1272,7 +1274,7 @@ static void minimize_window(
bool value,
plan_t *plan
) {
auto state = ctx->state;
auto state = ctx->state;
auto window = state_window_get(state, window_id);
if (!window) return;
@@ -1364,16 +1366,16 @@ static void start_window_move(
plan_t *plan
) {
auto window_id = command->window;
auto window = state_window_get(ctx->state, window_id);
auto window = state_window_get(ctx->state, window_id);
if (!window) return;
plan_push_move_effect(plan, window_id);
*ctx->interaction = (window_interaction_state_t){
.mode = ZDWM_WINDOW_INTERACTION_MOVE,
.window = window_id,
.mode = ZDWM_WINDOW_INTERACTION_MOVE,
.window = window_id,
.start_coordinate = command->pointer_coordinate,
.origin_rect = window->frame_rect,
.origin_rect = window->frame_rect,
};
}
@@ -1383,7 +1385,7 @@ static void start_window_resize(
plan_t *plan
) {
auto window_id = command->window;
auto window = state_window_get(ctx->state, window_id);
auto window = state_window_get(ctx->state, window_id);
if (!window) return;
auto frame_rect = window->frame_rect;
@@ -1396,10 +1398,10 @@ static void start_window_resize(
plan_push_resize_effect(plan, window_id);
*ctx->interaction = (window_interaction_state_t){
.mode = ZDWM_WINDOW_INTERACTION_RESIZE,
.window = window_id,
.mode = ZDWM_WINDOW_INTERACTION_RESIZE,
.window = window_id,
.start_coordinate = pointer_position,
.origin_rect = frame_rect,
.origin_rect = frame_rect,
};
}
@@ -1408,7 +1410,7 @@ static void send_window_to_workspace(
const window_send_to_workspace_command_t *command,
plan_t *plan
) {
auto state = ctx->state;
auto state = ctx->state;
auto window = state_window_get(state, command->window);
if (!window) return;
if (!state_workspace_valid(state, command->workspace)) return;
@@ -1431,16 +1433,20 @@ static void send_window_to_workspace(
if (src_visible) {
if (src_ws && src_ws->focused_window_id != src_old_focused) {
if (!window_id_invalid(src_old_focused) &&
state_window_get(state, src_old_focused)) {
if (
!window_id_invalid(src_old_focused) &&
state_window_get(state, src_old_focused)
) {
plan_push_change_border_color_effect(
plan,
src_old_focused,
&ctx->border->normal_color
);
}
if (!window_id_invalid(src_ws->focused_window_id) &&
state_window_get(state, src_ws->focused_window_id)) {
if (
!window_id_invalid(src_ws->focused_window_id) &&
state_window_get(state, src_ws->focused_window_id)
) {
plan_push_focus_effect(plan, src_ws->focused_window_id);
plan_push_change_border_color_effect(
plan,
@@ -1469,8 +1475,10 @@ static void send_window_to_workspace(
auto listeners = ctx->listeners;
listeners_notify_window_updated(listeners, state, command->window);
if (src_ws && src_ws->focused_window_id != src_old_focused &&
!window_id_invalid(src_ws->focused_window_id)) {
if (
src_ws && src_ws->focused_window_id != src_old_focused &&
!window_id_invalid(src_ws->focused_window_id)
) {
listeners_notify_window_updated(
listeners,
state,
@@ -1547,20 +1555,22 @@ static void switch_workspace(
workspace_id_t workspace_id,
plan_t *plan
) {
auto state = ctx->state;
auto state = ctx->state;
auto workspace = state_workspace_get(state, workspace_id);
if (!workspace) return;
auto listeners = ctx->listeners;
auto output_id = workspace->output_id;
auto listeners = ctx->listeners;
auto output_id = workspace->output_id;
workspace_id_t old_workspace = ZDWM_WORKSPACE_ID_INVALID;
if (state_output_set_current_workspace(
state,
output_id,
workspace_id,
&old_workspace
)) {
if (
state_output_set_current_workspace(
state,
output_id,
workspace_id,
&old_workspace
)
) {
plan->need_relayout = true;
add_switch_workspace_effects(state, old_workspace, workspace_id, plan);
listeners_notify_workspace_active(listeners, output_id, workspace_id);
@@ -1581,9 +1591,9 @@ static void set_layout(
const set_layout_command_t *command,
plan_t *plan
) {
auto state = ctx->state;
auto state = ctx->state;
auto workspace_id = command->workspace;
auto layout_id = command->layout;
auto layout_id = command->layout;
if (!state_workspace_set_layout_by_id(state, workspace_id, layout_id)) return;
@@ -1603,17 +1613,17 @@ static void set_binding_mode(
) {
if (!binding_table_set_current_mode(ctx->bind_table, binding_mode)) return;
size_t count = 0;
size_t count = 0;
auto bindings = binding_table_get_current_bindings(ctx->bind_table, &count);
if (bindings && count > 0) {
auto keys = p_new(key_bind_t, count);
for (size_t i = 0; i < count; ++i) {
keys[i].keysym = bindings[i].keysym;
keys[i].keysym = bindings[i].keysym;
keys[i].modifiers = bindings[i].modifiers;
}
effect_t effect = {
.type = ZDWM_EFFECT_BIND_KEY,
.type = ZDWM_EFFECT_BIND_KEY,
.as.bind_key = {.count = count, .keys = keys},
};
plan_push_effect(plan, &effect);
@@ -1711,7 +1721,7 @@ void policy_apply_command(
break;
case ZDWM_COMMAND_WINDOW_SET_FULLSCREEN: {
auto window = cmd->as.fullscreen.window;
auto state = cmd->as.fullscreen.state;
auto state = cmd->as.fullscreen.state;
fullscreen_window(ctx, window, state, plan);
} break;
case ZDWM_COMMAND_CHANGE_HINTS:
@@ -1733,7 +1743,7 @@ void policy_apply_command(
set_bar_visibility(ctx, cmd->as.bar_visibility.visible, plan);
break;
case ZDWM_COMMAND_QUIT:
plan->quit = true;
plan->quit = true;
plan->will_restart = cmd->as.quit.will_restart;
break;
}

18
src/core/rules.c
View File

@@ -10,12 +10,12 @@
bool rules_move(rules_t *src, rules_t *dest) {
if (!dest || !src) return false;
dest->items = src->items;
dest->count = src->count;
dest->items = src->items;
dest->count = src->count;
dest->capacity = src->capacity;
src->items = nullptr;
src->count = 0;
src->items = nullptr;
src->count = 0;
src->capacity = 0;
return true;
@@ -23,7 +23,7 @@ bool rules_move(rules_t *src, rules_t *dest) {
void rules_cleanup(rules_t *rules) {
for (size_t i = 0; i < rules->count; ++i) {
rule_match_t *match = &rules->items[i].match;
rule_match_t *match = &rules->items[i].match;
rule_action_t *action = &rules->items[i].action;
p_delete(&match->app_id);
@@ -37,7 +37,7 @@ void rules_cleanup(rules_t *rules) {
p_delete(&rules->items);
rules->capacity = 0;
rules->count = 0;
rules->count = 0;
}
static inline bool str_match(const char *pattern, const char *value) {
@@ -59,9 +59,9 @@ static void rule_action_merge(const rule_action_t *src, rule_action_t *dest) {
dest->workspace = src->workspace;
}
dest->switch_to_workspace |= src->switch_to_workspace;
dest->fullscreen |= src->fullscreen;
dest->maximize |= src->maximize;
dest->floating |= src->floating;
dest->fullscreen |= src->fullscreen;
dest->maximize |= src->maximize;
dest->floating |= src->floating;
}
bool rules_resolve(

60
src/core/state.c
View File

@@ -26,13 +26,13 @@ void state_init(
state->outputs = p_new(output_t, output_count);
for (size_t i = 0; i < output_count; i++) {
const output_info_t *output_info = &outputs[i];
output_t *output = &state->outputs[i];
output_t *output = &state->outputs[i];
output->id = (output_id_t)i;
output->id = (output_id_t)i;
output->current_workspace_id = ZDWM_WORKSPACE_ID_INVALID;
output->name = p_strdup_nullable(output_info->name);
output->geometry = output_info->geometry;
output->workarea = output_info->geometry;
output->name = p_strdup_nullable(output_info->name);
output->geometry = output_info->geometry;
output->workarea = output_info->geometry;
}
state->output_count = output_count;
@@ -43,16 +43,16 @@ void state_init(
fatal("workspace desc at index %zu invalid", i);
}
output_t *output = &state->outputs[workspace_desc->output_index];
output_t *output = &state->outputs[workspace_desc->output_index];
workspace_t *workspace = &state->workspaces[i];
workspace->id = (workspace_id_t)i;
workspace->output_id = output->id;
workspace->id = (workspace_id_t)i;
workspace->output_id = output->id;
workspace->focused_window_id = ZDWM_WINDOW_ID_INVALID;
workspace->available_layouts =
p_copy(workspace_desc->layout_ids, workspace_desc->layout_count);
workspace->layout_id = workspace_desc->initial_layout_id;
workspace->layout_id = workspace_desc->initial_layout_id;
workspace->layout_count = workspace_desc->layout_count;
workspace->name = p_strdup(workspace_desc->name);
workspace->name = p_strdup(workspace_desc->name);
if (workspace_id_invalid(output->current_workspace_id)) {
output->current_workspace_id = workspace->id;
@@ -84,7 +84,7 @@ void state_cleanup(state_t *state) {
for (size_t i = 0; i < ZDWM_WINDOW_LAYER_COUNT; ++i) {
layer_stack_t *layer = &state->stacks[i];
p_delete(&layer->order);
layer->order = 0;
layer->order = 0;
layer->capacity = 0;
}
@@ -134,7 +134,7 @@ static void state_workspace_adjust_focused_window(
const layer_stack_t *layer = &state->stacks[i];
for (size_t i = layer->count; i > 0; --i) {
window_id_t window_id = layer->order[i - 1];
window = state_window_get(state, window_id);
window = state_window_get(state, window_id);
if (window && window->workspace_id == workspace_id) {
workspace->focused_window_id = window_id;
return;
@@ -218,7 +218,7 @@ bool state_workspace_valid(const state_t *state, workspace_id_t id) {
bool state_workspace_show(const state_t *state, workspace_id_t workspace_id) {
auto workspace = state_workspace_get(state, workspace_id);
auto output = state_output_get(state, workspace->output_id);
auto output = state_output_get(state, workspace->output_id);
return output->current_workspace_id == workspace_id;
}
@@ -240,12 +240,12 @@ void state_output_inset_workarea(
auto output = (output_t *)state_output_get(state, output_id);
if (!output) return;
auto workarea = output->geometry;
workarea.y += inset.top;
workarea.x += inset.left;
workarea.width -= inset.left + inset.right;
workarea.height -= inset.top + inset.bottom;
output->workarea = workarea;
auto workarea = output->geometry;
workarea.y += inset.top;
workarea.x += inset.left;
workarea.width -= inset.left + inset.right;
workarea.height -= inset.top + inset.bottom;
output->workarea = workarea;
}
void state_output_set_workarea(
@@ -308,7 +308,7 @@ bool state_set_current_output(state_t *state, output_id_t output_id) {
}
const window_t *state_window_add(state_t *state, const window_info_t *info) {
window_id_t id = info->id;
window_id_t id = info->id;
window_t *window = (window_t *)state_window_get(state, id);
if (!window) {
window =
@@ -318,10 +318,10 @@ const window_t *state_window_add(state_t *state, const window_info_t *info) {
layer_stack_append(layer, id);
p_clear(window, 1);
window->id = id;
window->id = id;
window->transient_for = info->transient_for;
window->workspace_id = ZDWM_WORKSPACE_ID_INVALID;
window->layer = info->layer_type;
window->workspace_id = ZDWM_WORKSPACE_ID_INVALID;
window->layer = info->layer_type;
}
window_set_fullscreen(window, info->fullscreen);
@@ -361,15 +361,15 @@ void state_window_remove(state_t *state, window_id_t id) {
for (size_t i = 0; i < state->window_count; i++) {
if (state->windows[i].id == id) {
matched = true;
index = i;
index = i;
break;
}
}
if (!matched) return;
window_t *window = &state->windows[index];
window_t *window = &state->windows[index];
window_layer_type_t layer_type = window->layer;
workspace_id_t workspace_id = window->workspace_id;
workspace_id_t workspace_id = window->workspace_id;
p_delete(&window->title);
p_delete(&window->app_id);
p_delete(&window->role);
@@ -379,9 +379,9 @@ void state_window_remove(state_t *state, window_id_t id) {
if (array_erase(state->windows, state->window_count, index)) {
window = &state->windows[state->window_count];
p_clear(window, 1);
window->id = ZDWM_WINDOW_ID_INVALID;
window->id = ZDWM_WINDOW_ID_INVALID;
window->transient_for = ZDWM_WINDOW_ID_INVALID;
window->workspace_id = ZDWM_WORKSPACE_ID_INVALID;
window->workspace_id = ZDWM_WORKSPACE_ID_INVALID;
for (size_t i = 0; i < state->window_count; ++i) {
window = &state->windows[i];
@@ -411,10 +411,10 @@ void state_window_set_workspace(
workspace_id_t workspace_id
) {
const workspace_t *workspace = state_workspace_get(state, workspace_id);
window_t *window = (window_t *)state_window_get(state, window_id);
window_t *window = (window_t *)state_window_get(state, window_id);
if (!workspace || !window || window->workspace_id == workspace_id) return;
workspace = state_workspace_get(state, window->workspace_id);
workspace = state_workspace_get(state, window->workspace_id);
window->workspace_id = workspace_id;
if (workspace && workspace->focused_window_id == window_id) {

2
src/core/types.h
View File

@@ -65,6 +65,7 @@ typedef enum window_state_request_action_t {
ZDWM_WINDOW_STATE_ACTION_TOGGLE,
} window_state_request_action_t;
/* clang-format off */
typedef enum configure_field_t {
ZDWM_CONFIGURE_FIELD_X = 1u << 0,
ZDWM_CONFIGURE_FIELD_Y = 1u << 1,
@@ -74,6 +75,7 @@ typedef enum configure_field_t {
ZDWM_CONFIGURE_FIELD_SIBLING = 1u << 5,
ZDWM_CONFIGURE_FIELD_STACK_MODE = 1u << 6,
} configure_field_t;
/* clang-format on */
typedef struct configure_data_t {
window_id_t window;

4
src/core/window.c
View File

@@ -84,8 +84,8 @@ void window_set_size_hint(window_t *window, zdwm_size_t min, zdwm_size_t max) {
window->max_size = max;
if (!window_should_fix_size(window)) return;
auto rect = window->frame_rect;
rect.width = min.width;
auto rect = window->frame_rect;
rect.width = min.width;
rect.height = min.height;
window_set_frame_rect(window, rect);
window_set_floating(window, true);

2
src/core/window.h
View File

@@ -40,6 +40,7 @@ typedef enum window_layer_type_t {
ZDWM_WINDOW_LAYER_COUNT,
} window_layer_type_t;
/* clang-format off */
typedef enum window_metadata_change_flags_t {
ZDWM_WINDOW_METADATA_CHANGE_TITLE = 1u << 0,
ZDWM_WINDOW_METADATA_CHANGE_APP_ID = 1u << 1,
@@ -47,6 +48,7 @@ typedef enum window_metadata_change_flags_t {
ZDWM_WINDOW_METADATA_CHANGE_CLASS = 1u << 3,
ZDWM_WINDOW_METADATA_CHANGE_INSTANCE = 1u << 4,
} window_metadata_change_flags_t;
/* clang-format on */
typedef struct window_layer_props_t {
window_type_t *types;

4
src/core/wm_desc.h
View File

@@ -46,8 +46,8 @@ static inline void workspace_desc_cleanup(workspace_desc_t *workspace) {
p_delete(&workspace->name);
p_delete(&workspace->layout_ids);
workspace->output_index = 0;
workspace->layout_count = 0;
workspace->output_index = 0;
workspace->layout_count = 0;
workspace->initial_layout_id = ZDWM_LAYOUT_ID_INVALID;
}