speckitor/absinthe
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

simplier .clang-format and fix swap focus

Browse Source
This commit is contained in:
speckitor
2026-05-14 18:16:40 +07:00
parent 5c7dbfbe03
commit 090659d582
21 changed files with 1614 additions and 2052 deletions
Download Patch File Download Diff File Expand all files Collapse all files
.clang-format
+16 -182
View File
@@ -1,183 +1,17 @@
BasedOnStyle: LLVM
# FreeBSD .clang-format IndentWidth: 4
TabWidth: 4
--- UseTab: Never
BasedOnStyle: WebKit ColumnLimit: 120
AlignAfterOpenBracket: DontAlign AllowShortFunctionsOnASingleLine: false
AlignConsecutiveMacros: AcrossEmptyLines
AlignConsecutiveAssignments: false
AlignConsecutiveDeclarations: false
AlignEscapedNewlines: Left
AlignOperands: false
AlignTrailingComments: true
AllowAllArgumentsOnNextLine: false
AllowAllParametersOfDeclarationOnNextLine: false
AllowShortBlocksOnASingleLine: Never
AllowShortCaseLabelsOnASingleLine: false
AllowShortFunctionsOnASingleLine: InlineOnly
AllowShortIfStatementsOnASingleLine: Never
AllowShortLoopsOnASingleLine: false
AlwaysBreakAfterReturnType: TopLevelDefinitions
AlwaysBreakBeforeMultilineStrings: false
AlwaysBreakTemplateDeclarations: MultiLine
BinPackArguments: true
BinPackParameters: true
BreakBeforeBinaryOperators: None
BreakBeforeBraces: WebKit
BreakBeforeTernaryOperators: false
BreakStringLiterals: false
PenaltyBreakAssignment: 100
PenaltyBreakBeforeFirstCallParameter: 100
CompactNamespaces: true
DerivePointerAlignment: false
DisableFormat: false
ForEachMacros:
- ARB_ARRFOREACH
- ARB_ARRFOREACH_REVWCOND
- ARB_ARRFOREACH_REVERSE
- ARB_FOREACH
- ARB_FOREACH_FROM
- ARB_FOREACH_SAFE
- ARB_FOREACH_REVERSE
- ARB_FOREACH_REVERSE_FROM
- ARB_FOREACH_REVERSE_SAFE
- BIT_FOREACH_ISCLR
- BIT_FOREACH_ISSET
- CPU_FOREACH
- CPU_FOREACH_ISCLR
- CPU_FOREACH_ISSET
- FOREACH_THREAD_IN_PROC
- FOREACH_PROC_IN_SYSTEM
- FOREACH_PRISON_CHILD
- FOREACH_PRISON_DESCENDANT
- FOREACH_PRISON_DESCENDANT_LOCKED
- FOREACH_PRISON_DESCENDANT_LOCKED_LEVEL
- MNT_VNODE_FOREACH_ALL
- MNT_VNODE_FOREACH_ACTIVE
- RB_FOREACH
- RB_FOREACH_FROM
- RB_FOREACH_SAFE
- RB_FOREACH_REVERSE
- RB_FOREACH_REVERSE_FROM
- RB_FOREACH_REVERSE_SAFE
- SLIST_FOREACH
- SLIST_FOREACH_FROM
- SLIST_FOREACH_FROM_SAFE
- SLIST_FOREACH_SAFE
- SLIST_FOREACH_PREVPTR
- SPLAY_FOREACH
- LIST_FOREACH
- LIST_FOREACH_FROM
- LIST_FOREACH_FROM_SAFE
- LIST_FOREACH_SAFE
- STAILQ_FOREACH
- STAILQ_FOREACH_FROM
- STAILQ_FOREACH_FROM_SAFE
- STAILQ_FOREACH_SAFE
- TAILQ_FOREACH
- TAILQ_FOREACH_FROM
- TAILQ_FOREACH_FROM_SAFE
- TAILQ_FOREACH_REVERSE
- TAILQ_FOREACH_REVERSE_FROM
- TAILQ_FOREACH_REVERSE_FROM_SAFE
- TAILQ_FOREACH_REVERSE_SAFE
- TAILQ_FOREACH_SAFE
- VM_MAP_ENTRY_FOREACH
- VM_PAGE_DUMP_FOREACH
SpaceBeforeParens: ControlStatementsExceptForEachMacros
IndentCaseLabels: false
IndentPPDirectives: None
Language: Cpp
NamespaceIndentation: None
PointerAlignment: Right
ContinuationIndentWidth: 4
IndentWidth: 8
TabWidth: 8
ColumnLimit: 80
UseTab: Always
SpaceAfterCStyleCast: false
IncludeBlocks: Regroup
IncludeCategories:
- Regex: '^\"opt_.*\.h\"'
Priority: 1
SortPriority: 10
- Regex: '^<sys/cdefs\.h>'
Priority: 2
SortPriority: 20
- Regex: '^<sys/types\.h>'
Priority: 2
SortPriority: 21
- Regex: '^<sys/param\.h>'
Priority: 2
SortPriority: 22
- Regex: '^<sys/systm\.h>'
Priority: 2
SortPriority: 23
- Regex: '^<sys.*/'
Priority: 2
SortPriority: 24
- Regex: '^<vm/vm\.h>'
Priority: 3
SortPriority: 30
- Regex: '^<vm/'
Priority: 3
SortPriority: 31
- Regex: '^<machine/'
Priority: 4
SortPriority: 40
- Regex: '^<(x86|amd64|i386|xen)/'
Priority: 5
SortPriority: 50
- Regex: '^<dev/'
Priority: 6
SortPriority: 60
- Regex: '^<net.*/'
Priority: 7
SortPriority: 70
- Regex: '^<protocols/'
Priority: 7
SortPriority: 71
- Regex: '^<(fs|nfs(|client|server)|ufs)/'
Priority: 8
SortPriority: 80
- Regex: '^<[^/].*'
Priority: 9
SortPriority: 90
- Regex: '^\".*\"'
Priority: 10
SortPriority: 100
IncludeIsMainRegex: 'BLAH_DONT_MATCH_ANYTHING'
SortIncludes: true SortIncludes: true
KeepEmptyLinesAtTheStartOfBlocks: false BreakBeforeBraces: Custom
TypenameMacros: BraceWrapping:
- ARB_ELMTYPE AfterFunction: true
- ARB_HEAD AfterControlStatement: false
- ARB8_HEAD AfterClass: false
- ARB16_HEAD AfterNamespace: false
- ARB32_HEAD AfterEnum: false
- ARB_ENTRY AfterStruct: false
- ARB8_ENTRY AfterUnion: false
- ARB16_ENTRY AfterExternBlock: false
- ARB32_ENTRY
- LIST_CLASS_ENTRY
- LIST_CLASS_HEAD
- LIST_ENTRY
- LIST_HEAD
- QUEUE_TYPEOF
- RB_ENTRY
- RB_HEAD
- SLIST_CLASS_HEAD
- SLIST_CLASS_ENTRY
- SLIST_HEAD
- SLIST_ENTRY
- SMR_POINTER
- SPLAY_ENTRY
- SPLAY_HEAD
- STAILQ_CLASS_ENTRY
- STAILQ_CLASS_HEAD
- STAILQ_ENTRY
- STAILQ_HEAD
- TAILQ_CLASS_ENTRY
- TAILQ_CLASS_HEAD
- TAILQ_ENTRY
- TAILQ_HEAD
config.mk
+1 -1
View File
@@ -4,7 +4,7 @@ XLIBS = xcb xcb-icccm
# tools # tools
PKG_CONFIG ?= pkg-config PKG_CONFIG ?= pkg-config
CC ?= clang CC ?= clang
CLANG_FORMAT ?= clang-format22 CLANG_FORMAT ?= clang-format
PKGS = wayland-server xkbcommon libinput $(XLIBS) PKGS = wayland-server xkbcommon libinput $(XLIBS)
include/config.h
+50 -65
View File
@@ -4,93 +4,78 @@
#include "keybinds.h" #include "keybinds.h"
#include "types.h" #include "types.h"
#define CURSOR_MOD WLR_MODIFIER_ALT #define CURSOR_MOD WLR_MODIFIER_ALT
#define CURSOR_MOVE_BUTTON BTN_LEFT #define CURSOR_MOVE_BUTTON BTN_LEFT
#define CURSOR_RESIZE_BUTTON BTN_RIGHT #define CURSOR_RESIZE_BUTTON BTN_RIGHT
#define TOPLEVEL_BW 2 #define TOPLEVEL_BW 2
static const float bgcolor[4] = { 0.0, 0.0, 0.0, 1.0 }; static const float bgcolor[4] = {0.0, 0.0, 0.0, 1.0};
static const float focused_bc[4] = { 1.0, 0.4, 0.6, 1.0 }; static const float focused_bc[4] = {1.0, 0.4, 0.6, 1.0};
static const float urgent_bc[4] = { 1.0, 0.0, 0.0, 1.0 }; static const float urgent_bc[4] = {1.0, 0.0, 0.0, 1.0};
static const float unfocused_bc[4] = { 0.28, 0.28, 0.28, 1.0 }; static const float unfocused_bc[4] = {0.28, 0.28, 0.28, 1.0};
#define STACK_COUNT 1 #define STACK_COUNT 1
#define STACK_SIZE 0.5 #define STACK_SIZE 0.5
#define OUTPUT_GAP 10 #define OUTPUT_GAP 10
#define LAYOUT_GAP 5 #define LAYOUT_GAP 5
#define ALT WLR_MODIFIER_ALT #define ALT WLR_MODIFIER_ALT
#define CTRL WLR_MODIFIER_CTRL #define CTRL WLR_MODIFIER_CTRL
#define SHIFT WLR_MODIFIER_SHIFT #define SHIFT WLR_MODIFIER_SHIFT
#define LOGO WLR_MODIFIER_LOGO #define LOGO WLR_MODIFIER_LOGO
static const char *workspaces[] = { static const char *workspaces[] = {
"1", "1", "2", "3", "4", "5", "6", "7", "8", "9", "10",
"2",
"3",
"4",
"5",
"6",
"7",
"8",
"9",
"10",
}; };
static const absn_keybind keybinds[] = { static const absn_keybind keybinds[] = {
{ ALT, XKB_KEY_Escape, quit, { 0 } }, {ALT, XKB_KEY_Escape, quit, {0}},
{ ALT, XKB_KEY_Return, &run, { .v = "alacritty" } }, {ALT, XKB_KEY_Return, &run, {.v = "alacritty"}},
{ ALT, XKB_KEY_q, kill_focus, { 0 } }, {ALT, XKB_KEY_q, kill_focus, {0}},
{ ALT, XKB_KEY_j, cycle_focus, { .i = +1 } }, {ALT, XKB_KEY_j, cycle_focus, {.i = +1}},
{ ALT, XKB_KEY_k, cycle_focus, { .i = -1 } }, {ALT, XKB_KEY_k, cycle_focus, {.i = -1}},
{ ALT | SHIFT, XKB_KEY_j, swap_focus, { .i = +1 } }, {ALT | SHIFT, XKB_KEY_j, swap_focus, {.i = +1}},
{ ALT | SHIFT, XKB_KEY_k, swap_focus, { .i = -1 } }, {ALT | SHIFT, XKB_KEY_k, swap_focus, {.i = -1}},
{ ALT, XKB_KEY_f, toggle_fullscreen, { 0 } }, {ALT, XKB_KEY_f, toggle_fullscreen, {0}},
{ ALT, XKB_KEY_h, increase_master_count, { .i = +1 } }, {ALT, XKB_KEY_h, increase_master_count, {.i = +1}},
{ ALT, XKB_KEY_l, increase_master_count, { .i = -1 } }, {ALT, XKB_KEY_l, increase_master_count, {.i = -1}},
{ ALT | SHIFT, XKB_KEY_h, increase_master_width, { .f = -0.05 } }, {ALT | SHIFT, XKB_KEY_h, increase_master_width, {.f = -0.05}},
{ ALT | SHIFT, XKB_KEY_l, increase_master_width, { .f = +0.05 } }, {ALT | SHIFT, XKB_KEY_l, increase_master_width, {.f = +0.05}},
{ ALT, XKB_KEY_t, set_layout, { .i = LAYOUT_TILE } }, {ALT, XKB_KEY_t, set_layout, {.i = LAYOUT_TILE}},
{ ALT, XKB_KEY_r, set_layout, { .i = LAYOUT_TILELEFT } }, {ALT, XKB_KEY_r, set_layout, {.i = LAYOUT_TILELEFT}},
{ ALT, XKB_KEY_m, set_layout, { .i = LAYOUT_MONOCLE } }, {ALT, XKB_KEY_m, set_layout, {.i = LAYOUT_MONOCLE}},
{ ALT, XKB_KEY_1, switch_workspace, { .v = "1" } }, {ALT, XKB_KEY_1, switch_workspace, {.v = "1"}},
{ ALT, XKB_KEY_2, switch_workspace, { .v = "2" } }, {ALT, XKB_KEY_2, switch_workspace, {.v = "2"}},
{ ALT, XKB_KEY_3, switch_workspace, { .v = "3" } }, {ALT, XKB_KEY_3, switch_workspace, {.v = "3"}},
{ ALT, XKB_KEY_4, switch_workspace, { .v = "4" } }, {ALT, XKB_KEY_4, switch_workspace, {.v = "4"}},
{ ALT, XKB_KEY_5, switch_workspace, { .v = "5" } }, {ALT, XKB_KEY_5, switch_workspace, {.v = "5"}},
{ ALT, XKB_KEY_6, switch_workspace, { .v = "6" } }, {ALT, XKB_KEY_6, switch_workspace, {.v = "6"}},
{ ALT, XKB_KEY_7, switch_workspace, { .v = "7" } }, {ALT, XKB_KEY_7, switch_workspace, {.v = "7"}},
{ ALT, XKB_KEY_8, switch_workspace, { .v = "8" } }, {ALT, XKB_KEY_8, switch_workspace, {.v = "8"}},
{ ALT, XKB_KEY_9, switch_workspace, { .v = "9" } }, {ALT, XKB_KEY_9, switch_workspace, {.v = "9"}},
{ ALT, XKB_KEY_0, switch_workspace, { .v = "10" } }, {ALT, XKB_KEY_0, switch_workspace, {.v = "10"}},
{ ALT | SHIFT, XKB_KEY_exclam, move_focus_to_workspace, { .v = "1" } }, {ALT | SHIFT, XKB_KEY_exclam, move_focus_to_workspace, {.v = "1"}},
{ ALT | SHIFT, XKB_KEY_at, move_focus_to_workspace, { .v = "2" } }, {ALT | SHIFT, XKB_KEY_at, move_focus_to_workspace, {.v = "2"}},
{ ALT | SHIFT, XKB_KEY_numbersign, move_focus_to_workspace, {ALT | SHIFT, XKB_KEY_numbersign, move_focus_to_workspace, {.v = "3"}},
{ .v = "3" } }, {ALT | SHIFT, XKB_KEY_dollar, move_focus_to_workspace, {.v = "4"}},
{ ALT | SHIFT, XKB_KEY_dollar, move_focus_to_workspace, { .v = "4" } }, {ALT | SHIFT, XKB_KEY_percent, move_focus_to_workspace, {.v = "5"}},
{ ALT | SHIFT, XKB_KEY_percent, move_focus_to_workspace, { .v = "5" } }, {ALT | SHIFT, XKB_KEY_asciicircum, move_focus_to_workspace, {.v = "6"}},
{ ALT | SHIFT, XKB_KEY_asciicircum, move_focus_to_workspace, {ALT | SHIFT, XKB_KEY_ampersand, move_focus_to_workspace, {.v = "7"}},
{ .v = "6" } }, {ALT | SHIFT, XKB_KEY_asterisk, move_focus_to_workspace, {.v = "8"}},
{ ALT | SHIFT, XKB_KEY_ampersand, move_focus_to_workspace, {ALT | SHIFT, XKB_KEY_parenleft, move_focus_to_workspace, {.v = "9"}},
{ .v = "7" } }, {ALT | SHIFT, XKB_KEY_parenright, move_focus_to_workspace, {.v = "10"}},
{ ALT | SHIFT, XKB_KEY_asterisk, move_focus_to_workspace,
{ .v = "8" } },
{ ALT | SHIFT, XKB_KEY_parenleft, move_focus_to_workspace,
{ .v = "9" } },
{ ALT | SHIFT, XKB_KEY_parenright, move_focus_to_workspace,
{ .v = "10" } },
}; };
#endif #endif
include/toplevel.h
+2 -2
View File
@@ -3,8 +3,8 @@
#include "types.h" #include "types.h"
absn_toplevel *toplevel_at(absn_server *server, double lx, double ly, absn_toplevel *toplevel_at(absn_server *server, double lx, double ly, struct wlr_surface **surface, double *sx,
struct wlr_surface **surface, double *sx, double *sy); double *sy);
bool toplevel_is_unmanaged(absn_toplevel *toplevel); bool toplevel_is_unmanaged(absn_toplevel *toplevel);
include/types.h
+170 -170
View File
@@ -21,259 +21,259 @@
#include <xcb/xcb_icccm.h> #include <xcb/xcb_icccm.h>
#endif #endif
#define BTN_LEFT 0x110 #define BTN_LEFT 0x110
#define BTN_RIGHT 0x111 #define BTN_RIGHT 0x111
#define BTN_MIDDLE 0x112 #define BTN_MIDDLE 0x112
#define MAX(A, B) (A) > (B) ? (A) : (B) #define MAX(A, B) (A) > (B) ? (A) : (B)
#define MIN(A, B) (A) < (B) ? (A) : (B) #define MIN(A, B) (A) < (B) ? (A) : (B)
/* macro for adding listener for event */ /* macro for adding listener for event */
#define LISTEN(L, C, E) \ #define LISTEN(L, C, E) \
do { \ do { \
(L).notify = (C); \ (L).notify = (C); \
wl_signal_add(&(E), &(L)); \ wl_signal_add(&(E), &(L)); \
} while (0); } while (0);
#define UNUSED(X) (void)(X) #define UNUSED(X) (void)(X)
#define CLEANMASK(M) (M & ~WLR_MODIFIER_CAPS) #define CLEANMASK(M) (M & ~WLR_MODIFIER_CAPS)
/* cursor mode */ /* cursor mode */
enum { enum {
CURSOR_PASSTHROUGH, CURSOR_PASSTHROUGH,
CURSOR_MOVE, CURSOR_MOVE,
CURSOR_RESIZE, CURSOR_RESIZE,
}; };
/* resizing corners */ /* resizing corners */
enum { enum {
TOP_LEFT, TOP_LEFT,
TOP_RIGHT, TOP_RIGHT,
BOTTOM_LEFT, BOTTOM_LEFT,
BOTTOM_RIGHT, BOTTOM_RIGHT,
}; };
/* toplevel types */ /* toplevel types */
enum { enum {
TOPLEVEL_XDG, TOPLEVEL_XDG,
TOPLEVEL_X11, TOPLEVEL_X11,
LAYER_SURFACE, LAYER_SURFACE,
}; };
/* layers for wlr layer shell */ /* layers for wlr layer shell */
enum { enum {
LAYER_BACKGROUND, LAYER_BACKGROUND,
LAYER_BOTTOM, LAYER_BOTTOM,
LAYER_TILE, LAYER_TILE,
LAYER_FLOAT, LAYER_FLOAT,
LAYER_FULLSCREEN, LAYER_FULLSCREEN,
LAYER_TOP, LAYER_TOP,
LAYER_OVERLAY, LAYER_OVERLAY,
LAYERS_COUNT, LAYERS_COUNT,
}; };
static const int layermap[] = { static const int layermap[] = {
LAYER_BACKGROUND, LAYER_BACKGROUND,
LAYER_BOTTOM, LAYER_BOTTOM,
LAYER_TOP, LAYER_TOP,
LAYER_FULLSCREEN, LAYER_FULLSCREEN,
}; };
enum { enum {
LAYOUT_TILE, LAYOUT_TILE,
LAYOUT_TILELEFT, LAYOUT_TILELEFT,
LAYOUT_TILETOP, LAYOUT_TILETOP,
LAYOUT_TILEBOTTOM, LAYOUT_TILEBOTTOM,
LAYOUT_MONOCLE, LAYOUT_MONOCLE,
LAYOUT_SPIRAL, LAYOUT_SPIRAL,
LAYOUT_DWINDLE, LAYOUT_DWINDLE,
LAYOUT_VGRID, LAYOUT_VGRID,
LAYOUT_HGRID, LAYOUT_HGRID,
}; };
typedef struct absn_output absn_output; typedef struct absn_output absn_output;
typedef struct absn_toplevel absn_toplevel; typedef struct absn_toplevel absn_toplevel;
typedef struct { typedef struct {
int layout; int layout;
const char *name; const char *name;
absn_output *output; absn_output *output;
int count; int count;
float size; float size;
} absn_workspace; } absn_workspace;
typedef struct { typedef struct {
struct wl_display *display; struct wl_display *display;
struct wlr_backend *backend; struct wlr_backend *backend;
struct wlr_renderer *renderer; struct wlr_renderer *renderer;
struct wlr_allocator *allocator; struct wlr_allocator *allocator;
struct wlr_compositor *compositor; struct wlr_compositor *compositor;
struct wlr_scene *scene; struct wlr_scene *scene;
struct wlr_scene_output_layout *scene_layout; struct wlr_scene_output_layout *scene_layout;
struct wlr_scene_rect *bg; struct wlr_scene_rect *bg;
struct wlr_xdg_shell *xdg_shell; struct wlr_xdg_shell *xdg_shell;
struct wl_listener new_xdg_toplevel; struct wl_listener new_xdg_toplevel;
struct wl_listener new_xdg_popup; struct wl_listener new_xdg_popup;
struct wlr_xdg_decoration_manager_v1 *xdg_deco_mgr; struct wlr_xdg_decoration_manager_v1 *xdg_deco_mgr;
struct wl_listener new_xdg_deco; struct wl_listener new_xdg_deco;
struct wlr_layer_shell_v1 *layer_shell; struct wlr_layer_shell_v1 *layer_shell;
struct wl_listener new_layer_surface; struct wl_listener new_layer_surface;
struct wlr_scene_tree *layers[LAYERS_COUNT]; struct wlr_scene_tree *layers[LAYERS_COUNT];
#ifdef XWAYLAND #ifdef XWAYLAND
struct wlr_xwayland *xwayland; struct wlr_xwayland *xwayland;
struct wl_listener xw_new_surface; struct wl_listener xw_new_surface;
struct wl_listener xw_ready; struct wl_listener xw_ready;
#endif #endif
struct wlr_cursor *cursor; struct wlr_cursor *cursor;
struct wlr_xcursor_manager *cursor_mgr; struct wlr_xcursor_manager *cursor_mgr;
struct wl_listener cursor_motion; struct wl_listener cursor_motion;
struct wl_listener cursor_motion_abs; struct wl_listener cursor_motion_abs;
struct wl_listener cursor_button; struct wl_listener cursor_button;
struct wl_listener cursor_axis; struct wl_listener cursor_axis;
struct wl_listener cursor_frame; struct wl_listener cursor_frame;
struct wlr_seat *seat; struct wlr_seat *seat;
struct wl_listener new_input; struct wl_listener new_input;
struct wl_listener request_cursor; struct wl_listener request_cursor;
struct wl_listener pointer_focus_change; struct wl_listener pointer_focus_change;
struct wl_listener request_set_selection; struct wl_listener request_set_selection;
struct wl_list keyboards; struct wl_list keyboards;
int cursor_mode; int cursor_mode;
int resize_corner; int resize_corner;
struct wlr_box grab_geom; struct wlr_box grab_geom;
int32_t grab_x, grab_y; int32_t grab_x, grab_y;
struct wl_list toplevels; struct wl_list toplevels;
struct wl_list focus_stack; struct wl_list focus_stack;
absn_toplevel *focused_toplevel; absn_toplevel *focused_toplevel;
absn_output *focused_output; absn_output *focused_output;
struct wl_list outputs; struct wl_list outputs;
struct wl_listener new_output; struct wl_listener new_output;
struct wlr_output_layout *output_layout; struct wlr_output_layout *output_layout;
struct wl_listener layout_change; struct wl_listener layout_change;
struct wlr_output_manager_v1 *output_mgr; struct wlr_output_manager_v1 *output_mgr;
struct wl_listener mgr_apply; struct wl_listener mgr_apply;
struct wl_listener mgr_test; struct wl_listener mgr_test;
int workspaces_count; int workspaces_count;
absn_workspace *workspaces; absn_workspace *workspaces;
} absn_server; } absn_server;
struct absn_output { struct absn_output {
struct wl_list link; struct wl_list link;
absn_server *server; absn_server *server;
absn_workspace *workspace; absn_workspace *workspace;
struct wlr_box geom; struct wlr_box geom;
struct wlr_box usable_area; struct wlr_box usable_area;
struct wlr_output *wlr; struct wlr_output *wlr;
struct wl_listener frame; struct wl_listener frame;
struct wl_listener request_state; struct wl_listener request_state;
struct wl_listener destroy; struct wl_listener destroy;
struct wl_list layers[4]; struct wl_list layers[4];
}; };
typedef struct { typedef struct {
struct wl_list link; struct wl_list link;
absn_server *server; absn_server *server;
absn_output *output; absn_output *output;
int type; /* LAYER_SURFACE */ int type; /* LAYER_SURFACE */
struct wlr_scene_tree *scene_tree; struct wlr_scene_tree *scene_tree;
struct wlr_scene_layer_surface_v1 *scene_layer; struct wlr_scene_layer_surface_v1 *scene_layer;
struct wlr_layer_surface_v1 *wlr; struct wlr_layer_surface_v1 *wlr;
struct wl_listener map; struct wl_listener map;
struct wl_listener unmap; struct wl_listener unmap;
struct wl_listener commit; struct wl_listener commit;
struct wl_listener new_popup; struct wl_listener new_popup;
struct wl_listener destroy; struct wl_listener destroy;
} absn_layer_surface; } absn_layer_surface;
struct absn_toplevel { struct absn_toplevel {
struct wl_list link; struct wl_list link;
struct wl_list flink; /* link for focus stack */ struct wl_list flink; /* link for focus stack */
uint32_t tag; uint32_t tag;
absn_server *server; absn_server *server;
absn_output *output; absn_output *output;
absn_workspace *workspace; absn_workspace *workspace;
struct wlr_scene_tree *scene_tree; struct wlr_scene_tree *scene_tree;
struct wlr_scene_tree *scene_surface; struct wlr_scene_tree *scene_surface;
int32_t bw; int32_t bw;
struct wlr_scene_rect *border[4]; struct wlr_scene_rect *border[4];
struct wlr_xdg_toplevel_decoration_v1 *deco; struct wlr_xdg_toplevel_decoration_v1 *deco;
bool floating; bool floating;
bool fullscreen; bool fullscreen;
bool urgent; bool urgent;
uint32_t resizing; uint32_t resizing;
struct wlr_box geom; struct wlr_box geom;
struct wlr_box prev_geom; struct wlr_box prev_geom;
int type; int type;
union { union {
struct wlr_xdg_toplevel *xdg; struct wlr_xdg_toplevel *xdg;
struct wlr_xwayland_surface *xw; struct wlr_xwayland_surface *xw;
}; };
struct wl_listener map; struct wl_listener map;
struct wl_listener unmap; struct wl_listener unmap;
struct wl_listener commit; struct wl_listener commit;
struct wl_listener destroy; struct wl_listener destroy;
struct wl_listener request_move; struct wl_listener request_move;
struct wl_listener request_resize; struct wl_listener request_resize;
struct wl_listener request_maximize; struct wl_listener request_maximize;
struct wl_listener request_fullscreen; struct wl_listener request_fullscreen;
struct wl_listener deco_request_mode; struct wl_listener deco_request_mode;
struct wl_listener deco_destroy; struct wl_listener deco_destroy;
#ifdef XWAYLAND #ifdef XWAYLAND
struct wl_listener xw_activate; struct wl_listener xw_activate;
struct wl_listener xw_associate; struct wl_listener xw_associate;
struct wl_listener xw_dissociate; struct wl_listener xw_dissociate;
struct wl_listener xw_configure; struct wl_listener xw_configure;
struct wl_listener xw_set_hints; struct wl_listener xw_set_hints;
#endif #endif
}; };
typedef struct { typedef struct {
struct wlr_xdg_popup *wlr; struct wlr_xdg_popup *wlr;
struct wl_listener commit; struct wl_listener commit;
struct wl_listener destroy; struct wl_listener destroy;
} absn_popup; } absn_popup;
typedef struct { typedef struct {
struct wl_list link; struct wl_list link;
absn_server *server; absn_server *server;
struct wlr_keyboard *wlr; struct wlr_keyboard *wlr;
struct wl_listener modifiers; struct wl_listener modifiers;
struct wl_listener key; struct wl_listener key;
struct wl_listener destroy; struct wl_listener destroy;
} absn_keyboard; } absn_keyboard;
typedef struct { typedef struct {
int i; int i;
float f; float f;
const void *v; const void *v;
} absn_arg; } absn_arg;
typedef struct { typedef struct {
uint32_t mods; uint32_t mods;
xkb_keysym_t keysym; xkb_keysym_t keysym;
void (*cb)(absn_server *, const absn_arg *); void (*cb)(absn_server *, const absn_arg *);
const absn_arg arg; const absn_arg arg;
} absn_keybind; } absn_keybind;
#endif /* __TYPES_H_ */ #endif /* __TYPES_H_ */
src/absinthe.c
+149 -179
View File
@@ -24,224 +24,194 @@
#include "server.h" #include "server.h"
#include "types.h" #include "types.h"
static int static int setup(absn_server *server)
setup(absn_server *server)
{ {
wlr_log_init(WLR_DEBUG, NULL); wlr_log_init(WLR_DEBUG, NULL);
server->display = wl_display_create(); server->display = wl_display_create();
if (!server->display) { if (!server->display) {
wlr_log(WLR_ERROR, "Failed to create wl_display"); wlr_log(WLR_ERROR, "Failed to create wl_display");
return 1; return 1;
} }
server->backend = wlr_backend_autocreate(wl_display_get_event_loop( server->backend = wlr_backend_autocreate(wl_display_get_event_loop(server->display), NULL);
server->display), if (!server->backend) {
NULL); wlr_log(WLR_ERROR, "Failed to create wlr_backend");
if (!server->backend) { return 1;
wlr_log(WLR_ERROR, "Failed to create wlr_backend"); }
return 1;
}
server->renderer = wlr_renderer_autocreate(server->backend); server->renderer = wlr_renderer_autocreate(server->backend);
if (!server->renderer) { if (!server->renderer) {
wlr_log(WLR_ERROR, "Failed to create wlr_renderer"); wlr_log(WLR_ERROR, "Failed to create wlr_renderer");
return 1; return 1;
} }
wlr_renderer_init_wl_shm(server->renderer, server->display); wlr_renderer_init_wl_shm(server->renderer, server->display);
server->scene = wlr_scene_create(); server->scene = wlr_scene_create();
if (wlr_renderer_get_texture_formats(server->renderer, if (wlr_renderer_get_texture_formats(server->renderer, WLR_BUFFER_CAP_DMABUF)) {
WLR_BUFFER_CAP_DMABUF)) { wlr_drm_create(server->display, server->renderer);
wlr_drm_create(server->display, server->renderer); wlr_scene_set_linux_dmabuf_v1(server->scene,
wlr_scene_set_linux_dmabuf_v1(server->scene, wlr_linux_dmabuf_v1_create_with_renderer(server->display, 5, server->renderer));
wlr_linux_dmabuf_v1_create_with_renderer(server->display, 5, }
server->renderer)); server->bg = wlr_scene_rect_create(&server->scene->tree, 0, 0, bgcolor);
}
server->bg = wlr_scene_rect_create(&server->scene->tree, 0, 0, bgcolor);
server->allocator = wlr_allocator_autocreate(server->backend, server->allocator = wlr_allocator_autocreate(server->backend, server->renderer);
server->renderer); if (!server->allocator) {
if (!server->allocator) { wlr_log(WLR_ERROR, "Failed to create wlr_allocator");
wlr_log(WLR_ERROR, "Failed to create wlr_allocator"); return 1;
return 1; }
}
/* wlroots managers */ /* wlroots managers */
server->compositor = wlr_compositor_create(server->display, 6, server->compositor = wlr_compositor_create(server->display, 6, server->renderer);
server->renderer); wlr_subcompositor_create(server->display);
wlr_subcompositor_create(server->display); wlr_data_device_manager_create(server->display);
wlr_data_device_manager_create(server->display); wlr_screencopy_manager_v1_create(server->display);
wlr_screencopy_manager_v1_create(server->display); wlr_data_control_manager_v1_create(server->display);
wlr_data_control_manager_v1_create(server->display); wlr_viewporter_create(server->display);
wlr_viewporter_create(server->display); wlr_single_pixel_buffer_manager_v1_create(server->display);
wlr_single_pixel_buffer_manager_v1_create(server->display); wlr_fractional_scale_manager_v1_create(server->display, 1);
wlr_fractional_scale_manager_v1_create(server->display, 1); wlr_presentation_create(server->display, server->backend, 2);
wlr_presentation_create(server->display, server->backend, 2); wlr_alpha_modifier_v1_create(server->display);
wlr_alpha_modifier_v1_create(server->display); wlr_export_dmabuf_manager_v1_create(server->display);
wlr_export_dmabuf_manager_v1_create(server->display); wlr_ext_foreign_toplevel_list_v1_create(server->display, 1);
wlr_ext_foreign_toplevel_list_v1_create(server->display, 1);
wlr_server_decoration_manager_set_default_mode( wlr_server_decoration_manager_set_default_mode(wlr_server_decoration_manager_create(server->display),
wlr_server_decoration_manager_create(server->display), WLR_SERVER_DECORATION_MANAGER_MODE_SERVER);
WLR_SERVER_DECORATION_MANAGER_MODE_SERVER); server->xdg_deco_mgr = wlr_xdg_decoration_manager_v1_create(server->display);
server->xdg_deco_mgr = wlr_xdg_decoration_manager_v1_create( LISTEN(server->new_xdg_deco, new_xdg_decoration, server->xdg_deco_mgr->events.new_toplevel_decoration);
server->display);
LISTEN(server->new_xdg_deco, new_xdg_decoration,
server->xdg_deco_mgr->events.new_toplevel_decoration);
/* toplevels lists */ /* toplevels lists */
wl_list_init(&server->toplevels); wl_list_init(&server->toplevels);
wl_list_init(&server->focus_stack); wl_list_init(&server->focus_stack);
/* output */ /* output */
wl_list_init(&server->outputs); wl_list_init(&server->outputs);
LISTEN(server->new_output, new_output, LISTEN(server->new_output, new_output, server->backend->events.new_output);
server->backend->events.new_output);
server->output_layout = wlr_output_layout_create(server->display); server->output_layout = wlr_output_layout_create(server->display);
LISTEN(server->layout_change, output_layout_change, LISTEN(server->layout_change, output_layout_change, server->output_layout->events.change);
server->output_layout->events.change);
server->output_mgr = wlr_output_manager_v1_create(server->display); server->output_mgr = wlr_output_manager_v1_create(server->display);
wlr_xdg_output_manager_v1_create(server->display, wlr_xdg_output_manager_v1_create(server->display, server->output_layout);
server->output_layout);
server->scene_layout = wlr_scene_attach_output_layout(server->scene, server->scene_layout = wlr_scene_attach_output_layout(server->scene, server->output_layout);
server->output_layout);
/* xdg_shell */ /* xdg_shell */
server->xdg_shell = wlr_xdg_shell_create(server->display, 6); server->xdg_shell = wlr_xdg_shell_create(server->display, 6);
LISTEN(server->new_xdg_toplevel, new_xdg_toplevel, LISTEN(server->new_xdg_toplevel, new_xdg_toplevel, server->xdg_shell->events.new_toplevel);
server->xdg_shell->events.new_toplevel); LISTEN(server->new_xdg_popup, new_xdg_popup, server->xdg_shell->events.new_popup);
LISTEN(server->new_xdg_popup, new_xdg_popup,
server->xdg_shell->events.new_popup);
/* cursor */ /* cursor */
server->cursor = wlr_cursor_create(); server->cursor = wlr_cursor_create();
wlr_cursor_attach_output_layout(server->cursor, server->output_layout); wlr_cursor_attach_output_layout(server->cursor, server->output_layout);
server->cursor_mgr = wlr_xcursor_manager_create(NULL, 24); server->cursor_mgr = wlr_xcursor_manager_create(NULL, 24);
server->cursor_mode = CURSOR_PASSTHROUGH; server->cursor_mode = CURSOR_PASSTHROUGH;
LISTEN(server->cursor_motion, cursor_motion, LISTEN(server->cursor_motion, cursor_motion, server->cursor->events.motion);
server->cursor->events.motion); LISTEN(server->cursor_motion_abs, cursor_motion_abs, server->cursor->events.motion_absolute);
LISTEN(server->cursor_motion_abs, cursor_motion_abs, LISTEN(server->cursor_button, cursor_button, server->cursor->events.button);
server->cursor->events.motion_absolute); LISTEN(server->cursor_axis, cursor_axis, server->cursor->events.axis);
LISTEN(server->cursor_button, cursor_button, LISTEN(server->cursor_frame, cursor_frame, server->cursor->events.frame);
server->cursor->events.button);
LISTEN(server->cursor_axis, cursor_axis, server->cursor->events.axis);
LISTEN(server->cursor_frame, cursor_frame,
server->cursor->events.frame);
/* keyboard */ /* keyboard */
wl_list_init(&server->keyboards); wl_list_init(&server->keyboards);
server->seat = wlr_seat_create(server->display, "seat0"); server->seat = wlr_seat_create(server->display, "seat0");
LISTEN(server->new_input, new_input, server->backend->events.new_input); LISTEN(server->new_input, new_input, server->backend->events.new_input);
LISTEN(server->request_cursor, request_cursor, LISTEN(server->request_cursor, request_cursor, server->seat->events.request_set_cursor);
server->seat->events.request_set_cursor); LISTEN(server->pointer_focus_change, pointer_focus_change, server->seat->pointer_state.events.focus_change);
LISTEN(server->pointer_focus_change, pointer_focus_change, LISTEN(server->request_set_selection, request_cursor, server->seat->events.request_set_selection);
server->seat->pointer_state.events.focus_change);
LISTEN(server->request_set_selection, request_cursor,
server->seat->events.request_set_selection);
/* layer shell */ /* layer shell */
server->layer_shell = wlr_layer_shell_v1_create(server->display, 1); server->layer_shell = wlr_layer_shell_v1_create(server->display, 1);
for (int i = 0; i < LAYERS_COUNT; ++i) for (int i = 0; i < LAYERS_COUNT; ++i)
server->layers[i] = wlr_scene_tree_create(&server->scene->tree); server->layers[i] = wlr_scene_tree_create(&server->scene->tree);
/* workspaces */ /* workspaces */
int workspaces_count = sizeof(workspaces) / sizeof(workspaces[0]); int workspaces_count = sizeof(workspaces) / sizeof(workspaces[0]);
server->workspaces_count = workspaces_count; server->workspaces_count = workspaces_count;
server->workspaces = calloc(workspaces_count, sizeof(absn_workspace)); server->workspaces = calloc(workspaces_count, sizeof(absn_workspace));
for (int i = 0; i < workspaces_count; ++i) { for (int i = 0; i < workspaces_count; ++i) {
server->workspaces[i].layout = LAYOUT_TILE; server->workspaces[i].layout = LAYOUT_TILE;
server->workspaces[i].name = workspaces[i]; server->workspaces[i].name = workspaces[i];
server->workspaces[i].count = STACK_COUNT; server->workspaces[i].count = STACK_COUNT;
server->workspaces[i].size = STACK_SIZE; server->workspaces[i].size = STACK_SIZE;
server->workspaces[i].output = NULL; server->workspaces[i].output = NULL;
} }
unsetenv("DISPLAY"); unsetenv("DISPLAY");
#ifdef XWAYLAND #ifdef XWAYLAND
if ((server->xwayland = wlr_xwayland_create(server->display, if ((server->xwayland = wlr_xwayland_create(server->display, server->compositor, 1))) {
server->compositor, 1))) { LISTEN(server->xw_ready, xwayland_ready, server->xwayland->events.ready);
LISTEN(server->xw_ready, xwayland_ready, LISTEN(server->xw_new_surface, xwayland_new_surface, server->xwayland->events.new_surface);
server->xwayland->events.ready);
LISTEN(server->xw_new_surface, xwayland_new_surface,
server->xwayland->events.new_surface);
setenv("DISPLAY", server->xwayland->display_name, 1); setenv("DISPLAY", server->xwayland->display_name, 1);
wlr_log(WLR_INFO, "Running XWayland, DISPLAY=%s", wlr_log(WLR_INFO, "Running XWayland, DISPLAY=%s", server->xwayland->display_name);
server->xwayland->display_name); } else {
} else { wlr_log(WLR_ERROR, "Failed to setup XWayland, continuing without it");
wlr_log(WLR_ERROR, }
"Failed to setup XWayland, continuing without it");
}
#endif #endif
const char *socket = wl_display_add_socket_auto(server->display); const char *socket = wl_display_add_socket_auto(server->display);
if (!socket) { if (!socket) {
wlr_log(WLR_ERROR, "Failed to add socket"); wlr_log(WLR_ERROR, "Failed to add socket");
wlr_backend_destroy(server->backend); wlr_backend_destroy(server->backend);
return 1; return 1;
} }
if (!wlr_backend_start(server->backend)) { if (!wlr_backend_start(server->backend)) {
wlr_log(WLR_ERROR, "Failed to start wlr_backend"); wlr_log(WLR_ERROR, "Failed to start wlr_backend");
wlr_backend_destroy(server->backend); wlr_backend_destroy(server->backend);
wl_display_destroy(server->display); wl_display_destroy(server->display);
return 1; return 1;
} }
setenv("WAYLAND_DISPLAY", socket, true); setenv("WAYLAND_DISPLAY", socket, true);
wlr_log(WLR_INFO, "Running absinthe on WAYLAND_DISPLAY=%s", socket); wlr_log(WLR_INFO, "Running absinthe on WAYLAND_DISPLAY=%s", socket);
return 0; return 0;
} }
static void static void cleanup(absn_server *server)
cleanup(absn_server *server)
{ {
wl_display_destroy_clients(server->display); wl_display_destroy_clients(server->display);
wl_list_remove(&server->new_xdg_toplevel.link); wl_list_remove(&server->new_xdg_toplevel.link);
wl_list_remove(&server->new_xdg_popup.link); wl_list_remove(&server->new_xdg_popup.link);
wl_list_remove(&server->new_xdg_deco.link); wl_list_remove(&server->new_xdg_deco.link);
wl_list_remove(&server->cursor_motion.link); wl_list_remove(&server->cursor_motion.link);
wl_list_remove(&server->cursor_motion_abs.link); wl_list_remove(&server->cursor_motion_abs.link);
wl_list_remove(&server->cursor_button.link); wl_list_remove(&server->cursor_button.link);
wl_list_remove(&server->cursor_axis.link); wl_list_remove(&server->cursor_axis.link);
wl_list_remove(&server->cursor_frame.link); wl_list_remove(&server->cursor_frame.link);
wl_list_remove(&server->new_input.link); wl_list_remove(&server->new_input.link);
wl_list_remove(&server->request_cursor.link); wl_list_remove(&server->request_cursor.link);
wl_list_remove(&server->pointer_focus_change.link); wl_list_remove(&server->pointer_focus_change.link);
wl_list_remove(&server->request_set_selection.link); wl_list_remove(&server->request_set_selection.link);
wl_list_remove(&server->new_output.link); wl_list_remove(&server->new_output.link);
wl_list_remove(&server->new_layer_surface.link); wl_list_remove(&server->new_layer_surface.link);
wlr_scene_node_destroy(&server->scene->tree.node); wlr_scene_node_destroy(&server->scene->tree.node);
wlr_xcursor_manager_destroy(server->cursor_mgr); wlr_xcursor_manager_destroy(server->cursor_mgr);
wlr_cursor_destroy(server->cursor); wlr_cursor_destroy(server->cursor);
wlr_allocator_destroy(server->allocator); wlr_allocator_destroy(server->allocator);
wlr_renderer_destroy(server->renderer); wlr_renderer_destroy(server->renderer);
wlr_backend_destroy(server->backend); wlr_backend_destroy(server->backend);
wl_display_destroy(server->display); wl_display_destroy(server->display);
} }
int int main(void)
main(void)
{ {
absn_server server = { 0 }; absn_server server = {0};
int err = setup(&server); int err = setup(&server);
if (err) if (err)
return EXIT_FAILURE; return EXIT_FAILURE;
wl_display_run(server.display); wl_display_run(server.display);
cleanup(&server); cleanup(&server);
return EXIT_SUCCESS; return EXIT_SUCCESS;
} }
src/cursor.c
+110 -119
View File
@@ -5,158 +5,149 @@
#include "toplevel.h" #include "toplevel.h"
#include "types.h" #include "types.h"
void void reset_cursor_mode(absn_server *server)
reset_cursor_mode(absn_server *server)
{ {
server->cursor_mode = CURSOR_PASSTHROUGH; server->cursor_mode = CURSOR_PASSTHROUGH;
wlr_cursor_set_xcursor(server->cursor, server->cursor_mgr, "default"); wlr_cursor_set_xcursor(server->cursor, server->cursor_mgr, "default");
if (server->focused_toplevel) { if (server->focused_toplevel) {
wlr_xdg_toplevel_set_resizing(server->focused_toplevel->xdg, wlr_xdg_toplevel_set_resizing(server->focused_toplevel->xdg, false);
false); }
}
} }
static void static void process_cursor_move(absn_server *server)
process_cursor_move(absn_server *server)
{ {
struct absn_toplevel *toplevel = server->focused_toplevel; struct absn_toplevel *toplevel = server->focused_toplevel;
if (!toplevel) if (!toplevel)
return; return;
if (toplevel->fullscreen) { if (toplevel->fullscreen) {
toplevel->prev_geom = toplevel->geom; toplevel->prev_geom = toplevel->geom;
toplevel_set_fullscreen(toplevel, false); toplevel_set_fullscreen(toplevel, false);
} }
uint32_t new_x, new_y; uint32_t new_x, new_y;
new_x = server->cursor->x - server->grab_x + server->grab_geom.x; new_x = server->cursor->x - server->grab_x + server->grab_geom.x;
new_y = server->cursor->y - server->grab_y + server->grab_geom.y; new_y = server->cursor->y - server->grab_y + server->grab_geom.y;
toplevel_set_pos(toplevel, new_x, new_y); toplevel_set_pos(toplevel, new_x, new_y);
if (!toplevel->floating) if (!toplevel->floating)
toplevel_set_floating(toplevel, true); toplevel_set_floating(toplevel, true);
} }
static void static void apply_resize(absn_toplevel *toplevel, struct wlr_box *new_geom)
apply_resize(absn_toplevel *toplevel, struct wlr_box *new_geom)
{ {
if (toplevel->type == TOPLEVEL_XDG) { if (toplevel->type == TOPLEVEL_XDG) {
int32_t min_width = toplevel->xdg->current.min_width; int32_t min_width = toplevel->xdg->current.min_width;
int32_t min_height = toplevel->xdg->current.min_height; int32_t min_height = toplevel->xdg->current.min_height;
int32_t max_width = toplevel->xdg->current.max_width; int32_t max_width = toplevel->xdg->current.max_width;
int32_t max_height = toplevel->xdg->current.max_height; int32_t max_height = toplevel->xdg->current.max_height;
if (max_width == 0) if (max_width == 0)
max_width = 10000; max_width = 10000;
if (max_height == 0) if (max_height == 0)
max_height = 10000; max_height = 10000;
if (!(new_geom->width >= min_width && if (!(new_geom->width >= min_width && new_geom->width <= max_width)) {
new_geom->width <= max_width)) { new_geom->width = toplevel->geom.width;
new_geom->width = toplevel->geom.width; new_geom->x = toplevel->geom.x;
new_geom->x = toplevel->geom.x; }
}
if (!(new_geom->height >= min_height && if (!(new_geom->height >= min_height && new_geom->height <= max_height)) {
new_geom->height <= max_height)) { new_geom->height = toplevel->geom.height;
new_geom->height = toplevel->geom.height; new_geom->y = toplevel->geom.y;
new_geom->y = toplevel->geom.y; }
} }
}
toplevel_set_geom(toplevel, new_geom); toplevel_set_geom(toplevel, new_geom);
} }
static void static void process_cursor_resize(absn_server *server)
process_cursor_resize(absn_server *server)
{ {
struct absn_toplevel *toplevel = server->focused_toplevel; struct absn_toplevel *toplevel = server->focused_toplevel;
if (!toplevel) if (!toplevel)
return; return;
if (toplevel->resizing) if (toplevel->resizing)
return; return;
if (toplevel->fullscreen) if (toplevel->fullscreen)
toplevel_set_fullscreen(toplevel, false); toplevel_set_fullscreen(toplevel, false);
if (!toplevel->floating) if (!toplevel->floating)
toplevel_set_floating(toplevel, true); toplevel_set_floating(toplevel, true);
int32_t new_x, new_y, new_width, new_height; int32_t new_x, new_y, new_width, new_height;
new_x = server->grab_geom.x; new_x = server->grab_geom.x;
new_y = server->grab_geom.y; new_y = server->grab_geom.y;
new_width = server->grab_geom.width; new_width = server->grab_geom.width;
new_height = server->grab_geom.height; new_height = server->grab_geom.height;
int32_t dx = server->cursor->x - server->grab_x; int32_t dx = server->cursor->x - server->grab_x;
int32_t dy = server->cursor->y - server->grab_y; int32_t dy = server->cursor->y - server->grab_y;
if (dx == 0 && dy == 0) if (dx == 0 && dy == 0)
return; return;
switch (server->resize_corner) { switch (server->resize_corner) {
case TOP_LEFT: case TOP_LEFT:
new_x += dx; new_x += dx;
new_y += dy; new_y += dy;
new_width -= dx; new_width -= dx;
new_height -= dy; new_height -= dy;
break; break;
case TOP_RIGHT: case TOP_RIGHT:
new_y += dy; new_y += dy;
new_width += dx; new_width += dx;
new_height -= dy; new_height -= dy;
break; break;
case BOTTOM_LEFT: case BOTTOM_LEFT:
new_x += dx; new_x += dx;
new_width -= dx; new_width -= dx;
new_height += dy; new_height += dy;
break; break;
case BOTTOM_RIGHT: case BOTTOM_RIGHT:
new_width += dx; new_width += dx;
new_height += dy; new_height += dy;
break; break;
default: // unreachable default: // unreachable
break; break;
} }
if (new_width > 0 && new_height > 0) { if (new_width > 0 && new_height > 0) {
struct wlr_box new_geometry = { struct wlr_box new_geometry = {
.x = new_x, .x = new_x,
.y = new_y, .y = new_y,
.width = new_width, .width = new_width,
.height = new_height, .height = new_height,
}; };
apply_resize(server->focused_toplevel, &new_geometry); apply_resize(server->focused_toplevel, &new_geometry);
} }
} }
void void process_cursor_motion(absn_server *server, uint32_t time)
process_cursor_motion(absn_server *server, uint32_t time)
{ {
double sx, sy; double sx, sy;
struct wlr_surface *surface = NULL; struct wlr_surface *surface = NULL;
toplevel_at(server, server->cursor->x, server->cursor->y, &surface, &sx, toplevel_at(server, server->cursor->x, server->cursor->y, &surface, &sx, &sy);
&sy); struct wlr_seat *seat = server->seat;
struct wlr_seat *seat = server->seat;
if (server->cursor_mode == CURSOR_MOVE) { if (server->cursor_mode == CURSOR_MOVE) {
process_cursor_move(server); process_cursor_move(server);
return; return;
} else if (server->cursor_mode == CURSOR_RESIZE) { } else if (server->cursor_mode == CURSOR_RESIZE) {
process_cursor_resize(server); process_cursor_resize(server);
return; return;
} }
if (surface) { if (surface) {
wlr_seat_pointer_notify_enter(seat, surface, sx, sy); wlr_seat_pointer_notify_enter(seat, surface, sx, sy);
wlr_seat_pointer_notify_motion(seat, time, sx, sy); wlr_seat_pointer_notify_motion(seat, time, sx, sy);
} else { } else {
wlr_seat_pointer_clear_focus(seat); wlr_seat_pointer_clear_focus(seat);
} }
} }
src/focus.c
+39 -45
View File
@@ -6,69 +6,63 @@
#include "toplevel.h" #include "toplevel.h"
#include "types.h" #include "types.h"
void void unfocus_toplevel(absn_toplevel *toplevel)
unfocus_toplevel(absn_toplevel *toplevel)
{ {
if (!toplevel) if (!toplevel)
return; return;
if (toplevel->type == TOPLEVEL_XDG) if (toplevel->type == TOPLEVEL_XDG)
wlr_xdg_toplevel_set_activated(toplevel->xdg, false); wlr_xdg_toplevel_set_activated(toplevel->xdg, false);
toplevel_set_border_color(toplevel, unfocused_bc); toplevel_set_border_color(toplevel, unfocused_bc);
} }
void void focus_toplevel(absn_toplevel *toplevel)
focus_toplevel(absn_toplevel *toplevel)
{ {
if (!toplevel) if (!toplevel)
return; return;
absn_server *server = toplevel->server; absn_server *server = toplevel->server;
struct wlr_seat *seat = server->seat; struct wlr_seat *seat = server->seat;
struct wlr_surface *prev_surface = seat->keyboard_state.focused_surface; struct wlr_surface *prev_surface = seat->keyboard_state.focused_surface;
struct wlr_surface *surface; struct wlr_surface *surface;
#ifdef XWAYLAND #ifdef XWAYLAND
if (toplevel->type == TOPLEVEL_X11) if (toplevel->type == TOPLEVEL_X11)
surface = toplevel->xw->surface; surface = toplevel->xw->surface;
else else
#endif #endif
surface = toplevel->xdg->base->surface; surface = toplevel->xdg->base->surface;
if (surface == prev_surface) if (surface == prev_surface)
return; return;
if (prev_surface) if (prev_surface)
unfocus_toplevel(prev_surface->data); unfocus_toplevel(prev_surface->data);
toplevel->server->focused_toplevel = toplevel; toplevel->server->focused_toplevel = toplevel;
struct wlr_keyboard *keyboard = wlr_seat_get_keyboard(seat); struct wlr_keyboard *keyboard = wlr_seat_get_keyboard(seat);
wlr_scene_node_raise_to_top(&toplevel->scene_tree->node); wlr_scene_node_raise_to_top(&toplevel->scene_tree->node);
wl_list_remove(&toplevel->flink); wl_list_remove(&toplevel->flink);
wl_list_insert(&server->focus_stack, &toplevel->flink); wl_list_insert(&server->focus_stack, &toplevel->flink);
if (toplevel->type != TOPLEVEL_X11) if (toplevel->type != TOPLEVEL_X11)
wlr_xdg_toplevel_set_activated(toplevel->xdg, true); wlr_xdg_toplevel_set_activated(toplevel->xdg, true);
toplevel_set_border_color(toplevel, focused_bc); toplevel_set_border_color(toplevel, focused_bc);
if (keyboard) if (keyboard)
wlr_seat_keyboard_notify_enter(seat, surface, wlr_seat_keyboard_notify_enter(seat, surface, keyboard->keycodes, keyboard->num_keycodes, &keyboard->modifiers);
keyboard->keycodes, keyboard->num_keycodes,
&keyboard->modifiers);
} }
/* /*
* get first toplevel on monitor * get first toplevel on monitor
* (last focused toplevel) * (last focused toplevel)
*/ */
absn_toplevel * absn_toplevel *focus_get_topmost(absn_server *server)
focus_get_topmost(absn_server *server)
{ {
absn_toplevel *toplevel; absn_toplevel *toplevel;
wl_list_for_each(toplevel, &server->focus_stack, flink) wl_list_for_each(toplevel, &server->focus_stack, flink)
{ {
if (toplevel && if (toplevel && toplevel->workspace == server->focused_output->workspace)
toplevel->workspace == server->focused_output->workspace) return toplevel;
return toplevel; }
} return NULL;
return NULL;
} }
src/keybinds.c
+173 -172
View File
@@ -9,245 +9,246 @@
#include "toplevel.h" #include "toplevel.h"
#include "types.h" #include "types.h"
void void run(absn_server *server, const absn_arg *arg)
run(absn_server *server, const absn_arg *arg)
{ {
UNUSED(server); UNUSED(server);
if (fork() == 0) { if (fork() == 0) {
setsid(); setsid();
execl("/bin/sh", "sh", "-c", arg->v, NULL); execl("/bin/sh", "sh", "-c", arg->v, NULL);
} }
} }
void void kill_focus(absn_server *server, const absn_arg *arg)
kill_focus(absn_server *server, const absn_arg *arg)
{ {
UNUSED(arg); UNUSED(arg);
if (!server->focused_toplevel) if (!server->focused_toplevel)
return; return;
absn_toplevel *focus = server->focused_toplevel; absn_toplevel *focus = server->focused_toplevel;
#ifdef XWAYLAND #ifdef XWAYLAND
if (focus->type == TOPLEVEL_X11) { if (focus->type == TOPLEVEL_X11) {
wlr_xwayland_surface_close(focus->xw); wlr_xwayland_surface_close(focus->xw);
} else } else
#endif #endif
{ {
wlr_xdg_toplevel_send_close(focus->xdg); wlr_xdg_toplevel_send_close(focus->xdg);
} }
} }
void void cycle_focus(absn_server *server, const absn_arg *arg)
cycle_focus(absn_server *server, const absn_arg *arg)
{ {
absn_toplevel *toplevel = focus_get_topmost(server); absn_toplevel *toplevel = focus_get_topmost(server);
if (!toplevel || toplevel->fullscreen) if (!toplevel || toplevel->fullscreen)
return; return;
absn_toplevel *new_focus; absn_toplevel *new_focus;
if (arg->i > 0) { if (arg->i > 0) {
wl_list_for_each(new_focus, &toplevel->link, link) wl_list_for_each(new_focus, &toplevel->link, link)
{ {
if (toplevel->workspace == new_focus->workspace) if (toplevel->workspace == new_focus->workspace)
break; break;
} }
} else { } else {
wl_list_for_each_reverse(new_focus, &toplevel->link, link) wl_list_for_each_reverse(new_focus, &toplevel->link, link)
{ {
if (toplevel->workspace == new_focus->workspace) if (toplevel->workspace == new_focus->workspace)
break; break;
} }
} }
focus_toplevel(new_focus); focus_toplevel(new_focus);
} }
void void swap_focus(absn_server *server, const absn_arg *arg)
swap_focus(absn_server *server, const absn_arg *arg)
{ {
absn_toplevel *toplevel = focus_get_topmost(server); absn_toplevel *toplevel = focus_get_topmost(server);
if (!toplevel || toplevel->fullscreen || toplevel->floating) if (!toplevel || toplevel->fullscreen || toplevel->floating)
return; return;
absn_toplevel *swap; absn_toplevel *temp = NULL;
if (arg->i > 0) { absn_toplevel *first = NULL;
if (server->toplevels.prev == &toplevel->link) { absn_toplevel *last = NULL;
wl_list_remove(&toplevel->link);
wl_list_insert(&server->toplevels, &toplevel->link);
goto arrange;
}
wl_list_for_each(swap, &toplevel->link, link) wl_list_for_each(temp, &server->toplevels, link) {
{ if (temp->workspace == toplevel->workspace)
if (toplevel->workspace == swap->workspace) last = temp;
break; if (!first && temp->workspace == toplevel->workspace)
} first = temp;
}
wl_list_remove(&toplevel->link); if (first == last)
wl_list_insert(&swap->link, &toplevel->link); return;
} else {
if (server->toplevels.next == &toplevel->link) {
wl_list_remove(&toplevel->link);
wl_list_insert(server->toplevels.prev, &toplevel->link);
goto arrange;
}
wl_list_for_each_reverse(swap, &toplevel->link, link) absn_toplevel *swap = NULL;
{ if (arg->i > 0) {
if (toplevel->workspace == swap->workspace) if (toplevel == last) {
break; wl_list_remove(&toplevel->link);
} wl_list_insert(&server->toplevels, &toplevel->link);
goto arrange;
}
wl_list_remove(&swap->link); wl_list_for_each(swap, &toplevel->link, link)
wl_list_insert(&toplevel->link, &swap->link); {
} if (toplevel->workspace == swap->workspace)
break;
}
wl_list_remove(&toplevel->link);
wl_list_insert(&swap->link, &toplevel->link);
} else {
if (toplevel == first) {
wl_list_remove(&toplevel->link);
wl_list_insert(server->toplevels.prev, &toplevel->link);
goto arrange;
}
wl_list_for_each_reverse(swap, &toplevel->link, link)
{
if (toplevel->workspace == swap->workspace)
break;
}
wl_list_remove(&swap->link);
wl_list_insert(&toplevel->link, &swap->link);
}
arrange: arrange:
layout_arrange(toplevel->output); layout_arrange(toplevel->output);
} }
void void toggle_fullscreen(absn_server *server, const absn_arg *arg)
toggle_fullscreen(absn_server *server, const absn_arg *arg)
{ {
UNUSED(arg); UNUSED(arg);
if (!server->focused_toplevel) if (!server->focused_toplevel)
return; return;
absn_toplevel *focus = server->focused_toplevel; absn_toplevel *focus = server->focused_toplevel;
toplevel_set_fullscreen(focus, !focus->fullscreen); toplevel_set_fullscreen(focus, !focus->fullscreen);
} }
void void increase_master_width(absn_server *server, const absn_arg *arg)
increase_master_width(absn_server *server, const absn_arg *arg)
{ {
absn_workspace *workspace = server->focused_output->workspace; absn_workspace *workspace = server->focused_output->workspace;
if (workspace->size + arg->f >= 1.0 || workspace->size + arg->f <= 0.0) if (workspace->size + arg->f >= 1.0 || workspace->size + arg->f <= 0.0)
return; return;
workspace->size += arg->f; workspace->size += arg->f;
layout_arrange(workspace->output); layout_arrange(workspace->output);
} }
void void increase_master_count(absn_server *server, const absn_arg *arg)
increase_master_count(absn_server *server, const absn_arg *arg)
{ {
absn_workspace *workspace = server->focused_output->workspace; absn_workspace *workspace = server->focused_output->workspace;
if (workspace->count + arg->i <= 0) if (workspace->count + arg->i <= 0)
return; return;
workspace->count += arg->i; workspace->count += arg->i;
layout_arrange(workspace->output); layout_arrange(workspace->output);
} }
void void switch_workspace(absn_server *server, const absn_arg *arg)
switch_workspace(absn_server *server, const absn_arg *arg)
{ {
int i; int i;
for (i = 0; i < server->workspaces_count; ++i) { for (i = 0; i < server->workspaces_count; ++i) {
if (arg->v == server->workspaces[i].name) if (arg->v == server->workspaces[i].name)
break; /* found it */ break; /* found it */
} }
if (&server->workspaces[i] == server->focused_output->workspace) if (&server->workspaces[i] == server->focused_output->workspace)
return; return;
if (!server->workspaces[i].output) { if (!server->workspaces[i].output) {
server->workspaces[i].output = server->focused_output; server->workspaces[i].output = server->focused_output;
} else if (server->focused_output == server->workspaces[i].output) { } else if (server->focused_output == server->workspaces[i].output) {
server->focused_output->workspace = &server->workspaces[i]; server->focused_output->workspace = &server->workspaces[i];
} else { } else {
server->focused_output = server->workspaces[i].output; server->focused_output = server->workspaces[i].output;
struct wlr_box *geom = &server->focused_output->geom; struct wlr_box *geom = &server->focused_output->geom;
int32_t new_x = geom->x + (geom->width / 2); int32_t new_x = geom->x + (geom->width / 2);
int32_t new_y = geom->y + (geom->height / 2); int32_t new_y = geom->y + (geom->height / 2);
wlr_cursor_warp(server->cursor, NULL, new_x, new_y); wlr_cursor_warp(server->cursor, NULL, new_x, new_y);
} }
server->focused_output->workspace = &server->workspaces[i]; server->focused_output->workspace = &server->workspaces[i];
absn_toplevel *focus = NULL; absn_toplevel *focus = NULL;
absn_toplevel *toplevel; absn_toplevel *toplevel;
wl_list_for_each(toplevel, &server->toplevels, link) wl_list_for_each(toplevel, &server->toplevels, link)
{ {
if (!focus && toplevel && toplevel->workspace == &server->workspaces[i]) { if (!focus && toplevel && toplevel->workspace == &server->workspaces[i]) {
focus = toplevel; /* found it */ focus = toplevel; /* found it */
} }
if (toplevel && toplevel->workspace == &server->workspaces[i] && if (toplevel && toplevel->workspace == &server->workspaces[i] && toplevel->fullscreen) {
toplevel->fullscreen) /* overwrite if there is a fullscreen window */
{ focus = toplevel;
/* overwrite if there is a fullscreen window */ break;
focus = toplevel; }
break; }
}
}
unfocus_toplevel(server->focused_toplevel); unfocus_toplevel(server->focused_toplevel);
if (focus) { if (focus) {
/* crazy way to make it focus client if it was focused before */ /* crazy way to make it focus client if it was focused before */
struct wlr_surface *surface; struct wlr_surface *surface;
#ifdef XWAYLAND #ifdef XWAYLAND
if (focus->type == TOPLEVEL_X11) if (focus->type == TOPLEVEL_X11)
surface = focus->xw->surface; surface = focus->xw->surface;
else else
#endif #endif
surface = focus->xdg->base->surface; surface = focus->xdg->base->surface;
if (surface == server->seat->keyboard_state.focused_surface) if (surface == server->seat->keyboard_state.focused_surface)
server->seat->keyboard_state.focused_surface = NULL; server->seat->keyboard_state.focused_surface = NULL;
focus_toplevel(focus); focus_toplevel(focus);
} }
layout_arrange(server->focused_output); layout_arrange(server->focused_output);
} }
void void move_focus_to_workspace(absn_server *server, const absn_arg *arg)
move_focus_to_workspace(absn_server *server, const absn_arg *arg)
{ {
if (!server->focused_toplevel) if (!server->focused_toplevel)
return; return;
if (server->focused_toplevel->fullscreen) if (server->focused_toplevel->fullscreen)
toplevel_set_fullscreen(server->focused_toplevel, false); toplevel_set_fullscreen(server->focused_toplevel, false);
int i; int i;
for (i = 0; i < server->workspaces_count; ++i) { for (i = 0; i < server->workspaces_count; ++i) {
if (arg->v == server->workspaces[i].name) if (arg->v == server->workspaces[i].name)
break; /* found it */ break; /* found it */
} }
if (&server->workspaces[i] == server->focused_toplevel->workspace) if (&server->workspaces[i] == server->focused_toplevel->workspace)
return; return;
if (!server->workspaces[i].output) if (!server->workspaces[i].output)
server->workspaces[i].output = server->focused_output; server->workspaces[i].output = server->focused_output;
server->focused_toplevel->output = server->workspaces[i].output; server->focused_toplevel->output = server->workspaces[i].output;
server->focused_toplevel->workspace = &server->workspaces[i]; server->focused_toplevel->workspace = &server->workspaces[i];
focus_toplevel(focus_get_topmost(server)); focus_toplevel(focus_get_topmost(server));
layout_arrange(server->focused_output); layout_arrange(server->focused_output);
layout_arrange(server->focused_toplevel->output); layout_arrange(server->focused_toplevel->output);
} }
void void set_layout(absn_server *server, const absn_arg *arg)
set_layout(absn_server *server, const absn_arg *arg)
{ {
server->focused_output->workspace->layout = arg->i; server->focused_output->workspace->layout = arg->i;
layout_arrange(server->focused_output); layout_arrange(server->focused_output);
} }
noreturn void noreturn void quit(absn_server *server, const absn_arg *arg)
quit(absn_server *server, const absn_arg *arg)
{ {
UNUSED(arg); UNUSED(arg);
wl_display_terminate(server->display); wl_display_terminate(server->display);
exit(EXIT_SUCCESS); exit(EXIT_SUCCESS);
} }
src/keyboard.c
+41 -53
View File
@@ -8,74 +8,62 @@
#include "config.h" #include "config.h"
#include "types.h" #include "types.h"
void void handle_modifiers(struct wl_listener *listener, void *data)
handle_modifiers(struct wl_listener *listener, void *data)
{ {
UNUSED(data); UNUSED(data);
absn_keyboard *keyboard = wl_container_of(listener, keyboard, absn_keyboard *keyboard = wl_container_of(listener, keyboard, modifiers);
modifiers);
wlr_seat_set_keyboard(keyboard->server->seat, keyboard->wlr); wlr_seat_set_keyboard(keyboard->server->seat, keyboard->wlr);
wlr_seat_keyboard_notify_modifiers(keyboard->server->seat, wlr_seat_keyboard_notify_modifiers(keyboard->server->seat, &keyboard->wlr->modifiers);
&keyboard->wlr->modifiers);
} }
static bool static bool handle_keybind(absn_server *server, uint32_t mods, xkb_keysym_t keysym)
handle_keybind(absn_server *server, uint32_t mods, xkb_keysym_t keysym)
{ {
int nkeyb = sizeof(keybinds) / sizeof(keybinds[0]); int nkeyb = sizeof(keybinds) / sizeof(keybinds[0]);
for (int i = 0; i < nkeyb; ++i) { for (int i = 0; i < nkeyb; ++i) {
if (CLEANMASK(keybinds[i].mods) == CLEANMASK(mods) && if (CLEANMASK(keybinds[i].mods) == CLEANMASK(mods) &&
xkb_keysym_to_lower(keybinds[i].keysym) == xkb_keysym_to_lower(keybinds[i].keysym) == xkb_keysym_to_lower(keysym)) {
xkb_keysym_to_lower(keysym)) { keybinds[i].cb(server, &keybinds[i].arg);
keybinds[i].cb(server, &keybinds[i].arg); return true;
return true; }
} }
} return false;
return false;
} }
void void handle_key(struct wl_listener *listener, void *data)
handle_key(struct wl_listener *listener, void *data)
{ {
absn_keyboard *keyboard = wl_container_of(listener, keyboard, key); absn_keyboard *keyboard = wl_container_of(listener, keyboard, key);
struct wlr_keyboard_key_event *event = data; struct wlr_keyboard_key_event *event = data;
/* translate keycode to xkbcommon */ /* translate keycode to xkbcommon */
uint32_t code = event->keycode + 8; uint32_t code = event->keycode + 8;
uint32_t mods = wlr_keyboard_get_modifiers(keyboard->wlr); uint32_t mods = wlr_keyboard_get_modifiers(keyboard->wlr);
const xkb_keysym_t *syms; const xkb_keysym_t *syms;
int nsyms = xkb_state_key_get_syms(keyboard->wlr->xkb_state, code, int nsyms = xkb_state_key_get_syms(keyboard->wlr->xkb_state, code, &syms);
&syms);
bool handled = false; bool handled = false;
if (event->state == WL_KEYBOARD_KEY_STATE_PRESSED) { if (event->state == WL_KEYBOARD_KEY_STATE_PRESSED) {
for (int i = 0; i < nsyms; ++i) { for (int i = 0; i < nsyms; ++i) {
handled = handle_keybind(keyboard->server, mods, handled = handle_keybind(keyboard->server, mods, syms[i]) || handled;
syms[i]) || }
handled; }
}
}
if (handled) if (handled)
return; return;
wlr_seat_set_keyboard(keyboard->server->seat, keyboard->wlr); wlr_seat_set_keyboard(keyboard->server->seat, keyboard->wlr);
wlr_seat_keyboard_notify_key(keyboard->server->seat, event->time_msec, wlr_seat_keyboard_notify_key(keyboard->server->seat, event->time_msec, event->keycode, event->state);
event->keycode, event->state);
} }
void void handle_destroy(struct wl_listener *listener, void *data)
handle_destroy(struct wl_listener *listener, void *data)
{ {
UNUSED(data); UNUSED(data);
absn_keyboard *keyboard = wl_container_of(listener, keyboard, absn_keyboard *keyboard = wl_container_of(listener, keyboard, modifiers);
modifiers);
wl_list_remove(&keyboard->modifiers.link); wl_list_remove(&keyboard->modifiers.link);
wl_list_remove(&keyboard->key.link); wl_list_remove(&keyboard->key.link);
wl_list_remove(&keyboard->destroy.link); wl_list_remove(&keyboard->destroy.link);
wl_list_remove(&keyboard->link); wl_list_remove(&keyboard->link);
free(keyboard); free(keyboard);
} }
src/layer-surface.c
+23 -29
View File
@@ -1,47 +1,41 @@
#include "types.h" #include "types.h"
void void layer_surface_map(struct wl_listener *listener, void *data)
layer_surface_map(struct wl_listener *listener, void *data)
{ {
UNUSED(listener); UNUSED(listener);
UNUSED(data); UNUSED(data);
} }
void void layer_surface_unmap(struct wl_listener *listener, void *data)
layer_surface_unmap(struct wl_listener *listener, void *data)
{ {
UNUSED(listener); UNUSED(listener);
UNUSED(data); UNUSED(data);
} }
void void layer_surface_commit(struct wl_listener *listener, void *data)
layer_surface_commit(struct wl_listener *listener, void *data)
{ {
UNUSED(listener); UNUSED(listener);
UNUSED(data); UNUSED(data);
} }
void void layer_surface_new_popup(struct wl_listener *listener, void *data)
layer_surface_new_popup(struct wl_listener *listener, void *data)
{ {
UNUSED(listener); UNUSED(listener);
UNUSED(data); UNUSED(data);
} }
void void layer_surface_destroy(struct wl_listener *listener, void *data)
layer_surface_destroy(struct wl_listener *listener, void *data)
{ {
UNUSED(data); UNUSED(data);
absn_layer_surface *layer_surface = wl_container_of(listener, absn_layer_surface *layer_surface = wl_container_of(listener, layer_surface, destroy);
layer_surface, destroy);
wl_list_remove(&layer_surface->link); wl_list_remove(&layer_surface->link);
wl_list_remove(&layer_surface->map.link); wl_list_remove(&layer_surface->map.link);
wl_list_remove(&layer_surface->unmap.link); wl_list_remove(&layer_surface->unmap.link);
wl_list_remove(&layer_surface->commit.link); wl_list_remove(&layer_surface->commit.link);
wl_list_remove(&layer_surface->new_popup.link); wl_list_remove(&layer_surface->new_popup.link);
wl_list_remove(&layer_surface->destroy.link); wl_list_remove(&layer_surface->destroy.link);
wlr_scene_node_destroy(&layer_surface->scene_tree->node); wlr_scene_node_destroy(&layer_surface->scene_tree->node);
free(layer_surface); free(layer_surface);
} }
src/layout.c
+219 -241
View File
@@ -6,321 +6,299 @@
#include "types.h" #include "types.h"
/* returns number of toplevels on workspace */ /* returns number of toplevels on workspace */
static int static int prepare_output(struct absn_output *output)
prepare_output(struct absn_output *output)
{ {
int res = 0; int res = 0;
absn_toplevel *toplevel; absn_toplevel *toplevel;
wl_list_for_each(toplevel, &output->server->toplevels, link) wl_list_for_each(toplevel, &output->server->toplevels, link)
{ {
if (toplevel->workspace == output->workspace) { if (toplevel->workspace == output->workspace) {
wlr_scene_node_set_enabled(&toplevel->scene_tree->node, wlr_scene_node_set_enabled(&toplevel->scene_tree->node, true);
true); if (!toplevel->floating && !toplevel->fullscreen)
if (!toplevel->floating && !toplevel->fullscreen) res++;
res++; } else if (toplevel->output == output && toplevel->workspace != output->workspace) {
} else if (toplevel->output == output && wlr_scene_node_set_enabled(&toplevel->scene_tree->node, false);
toplevel->workspace != output->workspace) { }
wlr_scene_node_set_enabled(&toplevel->scene_tree->node, }
false);
}
}
return res; return res;
} }
static void static void tile(struct absn_output *output)
tile(struct absn_output *output)
{ {
int toplevels_count = prepare_output(output); int toplevels_count = prepare_output(output);
if (toplevels_count < 1) if (toplevels_count < 1)
return; return;
int32_t og = OUTPUT_GAP; int32_t og = OUTPUT_GAP;
struct wlr_box new_geom; struct wlr_box new_geom;
absn_toplevel *toplevel; absn_toplevel *toplevel;
if (toplevels_count == 1) { if (toplevels_count == 1) {
wl_list_for_each(toplevel, &output->server->toplevels, link) wl_list_for_each(toplevel, &output->server->toplevels, link)
{ {
if (toplevel->workspace == output->workspace && if (toplevel->workspace == output->workspace && !toplevel->floating && !toplevel->fullscreen)
!toplevel->floating && !toplevel->fullscreen) break;
break; }
} new_geom.x = output->geom.x + og, new_geom.y = output->geom.y + og,
new_geom.x = output->geom.x + og, new_geom.width = output->geom.width - 2 * og, new_geom.height = output->geom.height - 2 * og,
new_geom.y = output->geom.y + og,
new_geom.width = output->geom.width - 2 * og,
new_geom.height = output->geom.height - 2 * og,
toplevel_set_geom(toplevel, &new_geom); toplevel_set_geom(toplevel, &new_geom);
return; return;
} }
int32_t lg = LAYOUT_GAP; int32_t lg = LAYOUT_GAP;
int32_t total_lg; int32_t total_lg;
int mcount = output->workspace->count; int mcount = output->workspace->count;
float msize = output->workspace->size; float msize = output->workspace->size;
int32_t main_stack_width = (toplevels_count <= mcount) ? int32_t main_stack_width =
output->geom.width - 2 * og : (toplevels_count <= mcount) ? output->geom.width - 2 * og : msize * (output->geom.width - 2 * og);
msize * (output->geom.width - 2 * og); int32_t w = output->geom.width - main_stack_width - 2 * og - lg;
int32_t w = output->geom.width - main_stack_width - 2 * og - lg;
int32_t pure_h; int32_t pure_h;
int32_t h; int32_t h;
int32_t cur_h; int32_t cur_h;
int32_t r; int32_t r;
int32_t dy = og; int32_t dy = og;
int i = 0; int i = 0;
if (toplevels_count <= mcount) { if (toplevels_count <= mcount) {
total_lg = (toplevels_count - 1) * lg; total_lg = (toplevels_count - 1) * lg;
pure_h = output->geom.height - 2 * og - total_lg; pure_h = output->geom.height - 2 * og - total_lg;
h = pure_h / toplevels_count; h = pure_h / toplevels_count;
r = pure_h % toplevels_count; r = pure_h % toplevels_count;
wl_list_for_each(toplevel, &output->server->toplevels, link) wl_list_for_each(toplevel, &output->server->toplevels, link)
{ {
if (toplevel->workspace != output->workspace || if (toplevel->workspace != output->workspace || toplevel->floating || toplevel->fullscreen)
toplevel->floating || toplevel->fullscreen) continue;
continue;
cur_h = h + (i < r ? 1 : 0); cur_h = h + (i < r ? 1 : 0);
new_geom.x = output->geom.x + og; new_geom.x = output->geom.x + og;
new_geom.y = output->geom.y + dy; new_geom.y = output->geom.y + dy;
new_geom.width = main_stack_width; new_geom.width = main_stack_width;
new_geom.height = cur_h; new_geom.height = cur_h;
toplevel_set_geom(toplevel, &new_geom); toplevel_set_geom(toplevel, &new_geom);
dy += cur_h + lg; dy += cur_h + lg;
i++; i++;
} }
return; return;
} }
wl_list_for_each(toplevel, &output->server->toplevels, link) wl_list_for_each(toplevel, &output->server->toplevels, link)
{ {
if (toplevel->workspace != output->workspace || if (toplevel->workspace != output->workspace || toplevel->floating || toplevel->fullscreen)
toplevel->floating || toplevel->fullscreen) continue;
continue;
if (i < mcount) { if (i < mcount) {
total_lg = (mcount - 1) * lg; total_lg = (mcount - 1) * lg;
pure_h = output->geom.height - 2 * og - total_lg; pure_h = output->geom.height - 2 * og - total_lg;
h = pure_h / mcount; h = pure_h / mcount;
r = pure_h % mcount; r = pure_h % mcount;
cur_h = h + (i < r ? 1 : 0); cur_h = h + (i < r ? 1 : 0);
new_geom.x = output->geom.x + og; new_geom.x = output->geom.x + og;
new_geom.y = output->geom.y + dy; new_geom.y = output->geom.y + dy;
new_geom.width = main_stack_width; new_geom.width = main_stack_width;
new_geom.height = cur_h; new_geom.height = cur_h;
toplevel_set_geom(toplevel, &new_geom); toplevel_set_geom(toplevel, &new_geom);
dy += cur_h + lg; dy += cur_h + lg;
} else { } else {
if (i == mcount) if (i == mcount)
dy = og; dy = og;
int32_t stack_count = toplevels_count - mcount; int32_t stack_count = toplevels_count - mcount;
total_lg = (stack_count - 1) * lg; total_lg = (stack_count - 1) * lg;
pure_h = output->geom.height - 2 * og - total_lg; pure_h = output->geom.height - 2 * og - total_lg;
h = pure_h / stack_count; h = pure_h / stack_count;
r = pure_h % stack_count; r = pure_h % stack_count;
cur_h = h + (i - mcount < r ? 1 : 0); cur_h = h + (i - mcount < r ? 1 : 0);
new_geom.x = output->geom.x + main_stack_width + lg + new_geom.x = output->geom.x + main_stack_width + lg + og;
og; new_geom.y = output->geom.y + dy;
new_geom.y = output->geom.y + dy; new_geom.width = w;
new_geom.width = w; new_geom.height = cur_h;
new_geom.height = cur_h;
toplevel_set_geom(toplevel, &new_geom); toplevel_set_geom(toplevel, &new_geom);
dy += cur_h + lg; dy += cur_h + lg;
} }
i++; i++;
} }
} }
static void static void tile_left(struct absn_output *output)
tile_left(struct absn_output *output)
{ {
int toplevels_count = prepare_output(output); int toplevels_count = prepare_output(output);
if (toplevels_count < 1) if (toplevels_count < 1)
return; return;
int32_t og = OUTPUT_GAP; int32_t og = OUTPUT_GAP;
struct wlr_box new_geom; struct wlr_box new_geom;
absn_toplevel *toplevel; absn_toplevel *toplevel;
if (toplevels_count == 1) { if (toplevels_count == 1) {
wl_list_for_each(toplevel, &output->server->toplevels, link) wl_list_for_each(toplevel, &output->server->toplevels, link)
{ {
if (toplevel->workspace == output->workspace && if (toplevel->workspace == output->workspace && !toplevel->floating && !toplevel->fullscreen)
!toplevel->floating && !toplevel->fullscreen) break;
break; }
} new_geom.x = output->geom.x + og, new_geom.y = output->geom.y + og,
new_geom.x = output->geom.x + og, new_geom.width = output->geom.width - 2 * og, new_geom.height = output->geom.height - 2 * og,
new_geom.y = output->geom.y + og,
new_geom.width = output->geom.width - 2 * og,
new_geom.height = output->geom.height - 2 * og,
toplevel_set_geom(toplevel, &new_geom); toplevel_set_geom(toplevel, &new_geom);
return; return;
} }
int32_t lg = LAYOUT_GAP; int32_t lg = LAYOUT_GAP;
int32_t total_lg; int32_t total_lg;
int mcount = output->workspace->count; int mcount = output->workspace->count;
float msize = output->workspace->size; float msize = output->workspace->size;
int32_t main_stack_width = (toplevels_count <= mcount) ? int32_t main_stack_width =
output->geom.width - 2 * og : (toplevels_count <= mcount) ? output->geom.width - 2 * og : msize * (output->geom.width - 2 * og);
msize * (output->geom.width - 2 * og); int32_t w = output->geom.width - main_stack_width - 2 * og - lg;
int32_t w = output->geom.width - main_stack_width - 2 * og - lg;
int32_t pure_h; int32_t pure_h;
int32_t h; int32_t h;
int32_t cur_h; int32_t cur_h;
int32_t r; int32_t r;
int32_t dy = og; int32_t dy = og;
int i = 0; int i = 0;
if (toplevels_count <= mcount) { if (toplevels_count <= mcount) {
total_lg = (toplevels_count - 1) * lg; total_lg = (toplevels_count - 1) * lg;
pure_h = output->geom.height - 2 * og - total_lg; pure_h = output->geom.height - 2 * og - total_lg;
h = pure_h / toplevels_count; h = pure_h / toplevels_count;
r = pure_h % toplevels_count; r = pure_h % toplevels_count;
wl_list_for_each(toplevel, &output->server->toplevels, link) wl_list_for_each(toplevel, &output->server->toplevels, link)
{ {
if (toplevel->workspace != output->workspace || if (toplevel->workspace != output->workspace || toplevel->floating || toplevel->fullscreen)
toplevel->floating || toplevel->fullscreen) continue;
continue;
cur_h = h + (i < r ? 1 : 0); cur_h = h + (i < r ? 1 : 0);
new_geom.x = output->geom.x + og; new_geom.x = output->geom.x + og;
new_geom.y = output->geom.y + dy; new_geom.y = output->geom.y + dy;
new_geom.width = main_stack_width; new_geom.width = main_stack_width;
new_geom.height = cur_h; new_geom.height = cur_h;
toplevel_set_geom(toplevel, &new_geom); toplevel_set_geom(toplevel, &new_geom);
dy += cur_h + lg; dy += cur_h + lg;
i++; i++;
} }
return; return;
} }
wl_list_for_each(toplevel, &output->server->toplevels, link) wl_list_for_each(toplevel, &output->server->toplevels, link)
{ {
if (toplevel->workspace != output->workspace || if (toplevel->workspace != output->workspace || toplevel->floating || toplevel->fullscreen)
toplevel->floating || toplevel->fullscreen) continue;
continue;
if (i < mcount) { if (i < mcount) {
total_lg = (mcount - 1) * lg; total_lg = (mcount - 1) * lg;
pure_h = output->geom.height - 2 * og - total_lg; pure_h = output->geom.height - 2 * og - total_lg;
h = pure_h / mcount; h = pure_h / mcount;
r = pure_h % mcount; r = pure_h % mcount;
cur_h = h + (i < r ? 1 : 0); cur_h = h + (i < r ? 1 : 0);
new_geom.x = output->geom.width - og - main_stack_width; new_geom.x = output->geom.width - og - main_stack_width;
new_geom.y = output->geom.y + dy; new_geom.y = output->geom.y + dy;
new_geom.width = main_stack_width; new_geom.width = main_stack_width;
new_geom.height = cur_h; new_geom.height = cur_h;
toplevel_set_geom(toplevel, &new_geom); toplevel_set_geom(toplevel, &new_geom);
dy += cur_h + lg; dy += cur_h + lg;
} else { } else {
if (i == mcount) if (i == mcount)
dy = og; dy = og;
int32_t stack_count = toplevels_count - mcount; int32_t stack_count = toplevels_count - mcount;
total_lg = (stack_count - 1) * lg; total_lg = (stack_count - 1) * lg;
pure_h = output->geom.height - 2 * og - total_lg; pure_h = output->geom.height - 2 * og - total_lg;
h = pure_h / stack_count; h = pure_h / stack_count;
r = pure_h % stack_count; r = pure_h % stack_count;
cur_h = h + (i - mcount < r ? 1 : 0); cur_h = h + (i - mcount < r ? 1 : 0);
new_geom.x = output->geom.x + og; new_geom.x = output->geom.x + og;
new_geom.y = output->geom.y + dy; new_geom.y = output->geom.y + dy;
new_geom.width = w; new_geom.width = w;
new_geom.height = cur_h; new_geom.height = cur_h;
toplevel_set_geom(toplevel, &new_geom); toplevel_set_geom(toplevel, &new_geom);
dy += cur_h + lg; dy += cur_h + lg;
} }
i++; i++;
} }
} }
static void static void monocle(struct absn_output *output)
monocle(struct absn_output *output)
{ {
int toplevels_count = prepare_output(output); int toplevels_count = prepare_output(output);
if (toplevels_count < 1) if (toplevels_count < 1)
return; return;
int32_t og = OUTPUT_GAP; int32_t og = OUTPUT_GAP;
struct wlr_box new_geom = { struct wlr_box new_geom = {
.x = output->geom.x + og, .x = output->geom.x + og,
.y = output->geom.y + og, .y = output->geom.y + og,
.width = output->geom.width - 2 * og, .width = output->geom.width - 2 * og,
.height = output->geom.height - 2 * og, .height = output->geom.height - 2 * og,
}; };
absn_toplevel *toplevel; absn_toplevel *toplevel;
wl_list_for_each(toplevel, &output->server->toplevels, link) wl_list_for_each(toplevel, &output->server->toplevels, link)
{ {
if (toplevel->workspace != output->workspace || if (toplevel->workspace != output->workspace || toplevel->floating || toplevel->fullscreen)
toplevel->floating || toplevel->fullscreen) continue;
continue;
toplevel_set_geom(toplevel, &new_geom); toplevel_set_geom(toplevel, &new_geom);
} }
} }
void void layout_arrange(struct absn_output *output)
layout_arrange(struct absn_output *output)
{ {
if (!output) if (!output)
return; return;
switch (output->workspace->layout) { switch (output->workspace->layout) {
case LAYOUT_TILE: case LAYOUT_TILE:
tile(output); tile(output);
break; break;
case LAYOUT_TILELEFT: case LAYOUT_TILELEFT:
tile_left(output); tile_left(output);
break; break;
case LAYOUT_MONOCLE: case LAYOUT_MONOCLE:
monocle(output); monocle(output);
break; break;
default: /* currently not implemented layouts */ default: /* currently not implemented layouts */
tile(output); tile(output);
break; break;
} }
} }
src/output.c
+91 -111
View File
@@ -6,147 +6,127 @@
#include "toplevel.h" #include "toplevel.h"
#include "types.h" #include "types.h"
void void output_frame(struct wl_listener *listener, void *data)
output_frame(struct wl_listener *listener, void *data)
{ {
UNUSED(data); UNUSED(data);
struct timespec now; struct timespec now;
absn_output *output = wl_container_of(listener, output, frame); absn_output *output = wl_container_of(listener, output, frame);
struct wlr_scene *scene = output->server->scene; struct wlr_scene *scene = output->server->scene;
struct wlr_scene_output *scene_output = struct wlr_scene_output *scene_output = wlr_scene_get_scene_output(scene, output->wlr);
wlr_scene_get_scene_output(scene, output->wlr);
absn_toplevel *toplevel; absn_toplevel *toplevel;
wl_list_for_each(toplevel, &output->server->toplevels, link) wl_list_for_each(toplevel, &output->server->toplevels, link)
{ {
if (toplevel->resizing && toplevel->output == output) if (toplevel->resizing && toplevel->output == output)
goto skip; goto skip;
} }
wlr_scene_output_commit(scene_output, NULL); wlr_scene_output_commit(scene_output, NULL);
skip: skip:
clock_gettime(CLOCK_MONOTONIC, &now); clock_gettime(CLOCK_MONOTONIC, &now);
wlr_scene_output_send_frame_done(scene_output, &now); wlr_scene_output_send_frame_done(scene_output, &now);
} }
void void output_request_state(struct wl_listener *listener, void *data)
output_request_state(struct wl_listener *listener, void *data)
{ {
struct absn_output *output = wl_container_of(listener, output, struct absn_output *output = wl_container_of(listener, output, request_state);
request_state); const struct wlr_output_event_request_state *event = data;
const struct wlr_output_event_request_state *event = data; wlr_output_commit_state(output->wlr, event->state);
wlr_output_commit_state(output->wlr, event->state);
} }
void void output_destroy(struct wl_listener *listener, void *data)
output_destroy(struct wl_listener *listener, void *data)
{ {
UNUSED(data); UNUSED(data);
struct absn_output *output = wl_container_of(listener, output, struct absn_output *output = wl_container_of(listener, output, request_state);
request_state);
wl_list_remove(&output->frame.link); wl_list_remove(&output->frame.link);
wl_list_remove(&output->request_state.link); wl_list_remove(&output->request_state.link);
wl_list_remove(&output->destroy.link); wl_list_remove(&output->destroy.link);
wl_list_remove(&output->link); wl_list_remove(&output->link);
free(output); free(output);
} }
void void output_layout_change(struct wl_listener *listener, void *data)
output_layout_change(struct wl_listener *listener, void *data)
{ {
UNUSED(data); UNUSED(data);
absn_server *server = wl_container_of(listener, server, layout_change); absn_server *server = wl_container_of(listener, server, layout_change);
struct wlr_output_configuration_v1 *config = struct wlr_output_configuration_v1 *config = wlr_output_configuration_v1_create();
wlr_output_configuration_v1_create();
absn_toplevel *toplevel = NULL; absn_toplevel *toplevel = NULL;
absn_output *output; absn_output *output;
struct wlr_output_configuration_head_v1 *config_head; struct wlr_output_configuration_head_v1 *config_head;
wl_list_for_each(output, &server->outputs, link) wl_list_for_each(output, &server->outputs, link)
{ {
if (output->wlr->enabled) if (output->wlr->enabled)
continue; continue;
config_head = wlr_output_configuration_head_v1_create(config, config_head = wlr_output_configuration_head_v1_create(config, output->wlr);
output->wlr); config_head->state.enabled = 0;
config_head->state.enabled = 0; wlr_output_layout_remove(server->output_layout, output->wlr);
wlr_output_layout_remove(server->output_layout, output->wlr);
// closemon(m); // closemon(m);
// m->m = m->w = (struct wlr_box){0}; // m->m = m->w = (struct wlr_box){0};
} }
wl_list_for_each(output, &server->outputs, link) wl_list_for_each(output, &server->outputs, link)
{ {
if (output->wlr->enabled && if (output->wlr->enabled && !wlr_output_layout_get(server->output_layout, output->wlr))
!wlr_output_layout_get(server->output_layout, output->wlr)) wlr_output_layout_add_auto(server->output_layout, toplevel->output->wlr);
wlr_output_layout_add_auto(server->output_layout, }
toplevel->output->wlr);
}
struct wlr_box layout_geom; struct wlr_box layout_geom;
wlr_output_layout_get_box(server->output_layout, NULL, &layout_geom); wlr_output_layout_get_box(server->output_layout, NULL, &layout_geom);
wlr_scene_node_set_position(&server->bg->node, layout_geom.x, wlr_scene_node_set_position(&server->bg->node, layout_geom.x, layout_geom.y);
layout_geom.y); wlr_scene_rect_set_size(server->bg, layout_geom.width, layout_geom.height);
wlr_scene_rect_set_size(server->bg, layout_geom.width,
layout_geom.height);
wl_list_for_each(output, &server->outputs, link) wl_list_for_each(output, &server->outputs, link)
{ {
if (!output->wlr->enabled) if (!output->wlr->enabled)
continue; continue;
config_head = wlr_output_configuration_head_v1_create(config, config_head = wlr_output_configuration_head_v1_create(config, output->wlr);
output->wlr);
wlr_output_layout_get_box(server->output_layout, output->wlr, wlr_output_layout_get_box(server->output_layout, output->wlr, &output->geom);
&output->geom);
if ((toplevel = focus_get_topmost(server)) && if ((toplevel = focus_get_topmost(server)) && toplevel->fullscreen)
toplevel->fullscreen) toplevel_set_size(toplevel, output->geom.width, output->geom.height);
toplevel_set_size(toplevel, output->geom.width,
output->geom.height);
config_head->state.x = output->geom.x; config_head->state.x = output->geom.x;
config_head->state.y = output->geom.y; config_head->state.y = output->geom.y;
if (!server->focused_output) if (!server->focused_output)
server->focused_output = output; server->focused_output = output;
} }
if (server->focused_output && server->focused_output->wlr->enabled) { if (server->focused_output && server->focused_output->wlr->enabled) {
wl_list_for_each(toplevel, &server->toplevels, link) wl_list_for_each(toplevel, &server->toplevels, link)
{ {
if (!toplevel->output) { if (!toplevel->output) {
toplevel->output = server->focused_output; toplevel->output = server->focused_output;
} }
} }
layout_arrange(server->focused_output); layout_arrange(server->focused_output);
} }
focus_toplevel(focus_get_topmost(server)); focus_toplevel(focus_get_topmost(server));
wlr_cursor_move(server->cursor, NULL, 0, 0); wlr_cursor_move(server->cursor, NULL, 0, 0);
wlr_output_manager_v1_set_configuration(server->output_mgr, config); wlr_output_manager_v1_set_configuration(server->output_mgr, config);
} }
void void update_focused_output(absn_server *server)
update_focused_output(absn_server *server)
{ {
absn_output *output; absn_output *output;
int32_t cursor_x = server->cursor->x; int32_t cursor_x = server->cursor->x;
int32_t cursor_y = server->cursor->y; int32_t cursor_y = server->cursor->y;
wl_list_for_each(output, &server->outputs, link) wl_list_for_each(output, &server->outputs, link)
{ {
bool cursor_in_output_x = cursor_x >= output->geom.x && bool cursor_in_output_x = cursor_x >= output->geom.x && cursor_x <= output->geom.x + output->geom.width;
cursor_x <= output->geom.x + output->geom.width; bool cursor_in_output_y = cursor_y >= output->geom.y && cursor_y <= output->geom.y + output->geom.height;
bool cursor_in_output_y = cursor_y >= output->geom.y && if (cursor_in_output_x && cursor_in_output_y) {
cursor_y <= output->geom.y + output->geom.height; server->focused_output = output;
if (cursor_in_output_x && cursor_in_output_y) { break;
server->focused_output = output; }
break; }
}
}
} }
src/seat.c
+15 -23
View File
@@ -3,37 +3,29 @@
#include "types.h" #include "types.h"
void void request_cursor(struct wl_listener *listener, void *data)
request_cursor(struct wl_listener *listener, void *data)
{ {
absn_server *server = wl_container_of(listener, server, request_cursor); absn_server *server = wl_container_of(listener, server, request_cursor);
struct wlr_seat_pointer_request_set_cursor_event *event = data; struct wlr_seat_pointer_request_set_cursor_event *event = data;
struct wlr_seat_client *client = struct wlr_seat_client *client = server->seat->pointer_state.focused_client;
server->seat->pointer_state.focused_client;
if (client == event->seat_client) if (client == event->seat_client)
wlr_cursor_set_surface(server->cursor, event->surface, wlr_cursor_set_surface(server->cursor, event->surface, event->hotspot_x, event->hotspot_y);
event->hotspot_x, event->hotspot_y);
} }
void void pointer_focus_change(struct wl_listener *listener, void *data)
pointer_focus_change(struct wl_listener *listener, void *data)
{ {
absn_server *server = wl_container_of(listener, server, absn_server *server = wl_container_of(listener, server, pointer_focus_change);
pointer_focus_change); struct wlr_seat_pointer_focus_change_event *event = data;
struct wlr_seat_pointer_focus_change_event *event = data;
if (!event->new_surface) if (!event->new_surface)
wlr_cursor_set_xcursor(server->cursor, server->cursor_mgr, wlr_cursor_set_xcursor(server->cursor, server->cursor_mgr, "default");
"default");
} }
void void request_set_selection(struct wl_listener *listener, void *data)
request_set_selection(struct wl_listener *listener, void *data)
{ {
absn_server *server = wl_container_of(listener, server, absn_server *server = wl_container_of(listener, server, request_set_selection);
request_set_selection); struct wlr_seat_request_set_selection_event *event = data;
struct wlr_seat_request_set_selection_event *event = data;
wlr_seat_set_selection(server->seat, event->source, event->serial); wlr_seat_set_selection(server->seat, event->source, event->serial);
} }
src/server.c
+227 -301
View File
@@ -23,396 +23,322 @@
#include "xwayland.h" #include "xwayland.h"
#endif #endif
void void new_output(struct wl_listener *listener, void *data)
new_output(struct wl_listener *listener, void *data)
{ {
absn_server *server = wl_container_of(listener, server, new_output); absn_server *server = wl_container_of(listener, server, new_output);
struct wlr_output *wlr_output = data; struct wlr_output *wlr_output = data;
wlr_output_init_render(wlr_output, server->allocator, server->renderer); wlr_output_init_render(wlr_output, server->allocator, server->renderer);
struct wlr_output_state state; struct wlr_output_state state;
wlr_output_state_init(&state); wlr_output_state_init(&state);
wlr_output_state_set_enabled(&state, true); wlr_output_state_set_enabled(&state, true);
struct wlr_output_mode *mode = wlr_output_preferred_mode(wlr_output); struct wlr_output_mode *mode = wlr_output_preferred_mode(wlr_output);
if (mode) if (mode)
wlr_output_state_set_mode(&state, mode); wlr_output_state_set_mode(&state, mode);
wlr_output_commit_state(wlr_output, &state); wlr_output_commit_state(wlr_output, &state);
wlr_output_state_finish(&state); wlr_output_state_finish(&state);
struct absn_output *output = calloc(1, sizeof(*output)); struct absn_output *output = calloc(1, sizeof(*output));
output->wlr = wlr_output; output->wlr = wlr_output;
output->server = server; output->server = server;
for (int i = 0; i < server->workspaces_count; ++i) { for (int i = 0; i < server->workspaces_count; ++i) {
if (!server->workspaces[i].output) { if (!server->workspaces[i].output) {
server->workspaces[i].output = output; server->workspaces[i].output = output;
output->workspace = &server->workspaces[i]; output->workspace = &server->workspaces[i];
break; break;
} }
} }
LISTEN(output->frame, output_frame, wlr_output->events.frame); LISTEN(output->frame, output_frame, wlr_output->events.frame);
LISTEN(output->request_state, output_request_state, LISTEN(output->request_state, output_request_state, wlr_output->events.request_state);
wlr_output->events.request_state); LISTEN(output->destroy, output_destroy, wlr_output->events.destroy);
LISTEN(output->destroy, output_destroy, wlr_output->events.destroy);
wl_list_insert(&server->outputs, &output->link); wl_list_insert(&server->outputs, &output->link);
for (int i = 0; i < 4; ++i) for (int i = 0; i < 4; ++i)
wl_list_init(&output->layers[i]); wl_list_init(&output->layers[i]);
struct wlr_output_layout_output *l_layout = struct wlr_output_layout_output *l_layout = wlr_output_layout_add_auto(server->output_layout, output->wlr);
wlr_output_layout_add_auto(server->output_layout, output->wlr); struct wlr_scene_output *scene_output = wlr_scene_output_create(server->scene, wlr_output);
struct wlr_scene_output *scene_output = wlr_scene_output_layout_add_output(server->scene_layout, l_layout, scene_output);
wlr_scene_output_create(server->scene, wlr_output); wlr_output_layout_get_box(server->output_layout, output->wlr, &output->geom);
wlr_scene_output_layout_add_output(server->scene_layout, l_layout,
scene_output);
wlr_output_layout_get_box(server->output_layout, output->wlr,
&output->geom);
} }
void void new_xdg_toplevel(struct wl_listener *listener, void *data)
new_xdg_toplevel(struct wl_listener *listener, void *data)
{ {
absn_server *server = wl_container_of(listener, server, absn_server *server = wl_container_of(listener, server, new_xdg_toplevel);
new_xdg_toplevel); struct wlr_xdg_toplevel *xdg_toplevel = data;
struct wlr_xdg_toplevel *xdg_toplevel = data;
absn_toplevel *toplevel = calloc(1, sizeof(*toplevel)); absn_toplevel *toplevel = calloc(1, sizeof(*toplevel));
toplevel->type = TOPLEVEL_XDG; toplevel->type = TOPLEVEL_XDG;
toplevel->server = server; toplevel->server = server;
toplevel->xdg = xdg_toplevel; toplevel->xdg = xdg_toplevel;
toplevel->xdg->base->data = toplevel; toplevel->xdg->base->data = toplevel;
toplevel->xdg->base->surface->data = toplevel; toplevel->xdg->base->surface->data = toplevel;
wlr_surface_set_preferred_buffer_scale(toplevel->xdg->base->surface, 1); wlr_surface_set_preferred_buffer_scale(toplevel->xdg->base->surface, 1);
LISTEN(toplevel->commit, toplevel_commit, LISTEN(toplevel->commit, toplevel_commit, xdg_toplevel->base->surface->events.commit);
xdg_toplevel->base->surface->events.commit); LISTEN(toplevel->map, toplevel_map, xdg_toplevel->base->surface->events.map);
LISTEN(toplevel->map, toplevel_map, LISTEN(toplevel->unmap, toplevel_unmap, xdg_toplevel->base->surface->events.unmap);
xdg_toplevel->base->surface->events.map); LISTEN(toplevel->destroy, toplevel_destroy, xdg_toplevel->events.destroy);
LISTEN(toplevel->unmap, toplevel_unmap, LISTEN(toplevel->request_move, toplevel_request_move, xdg_toplevel->events.request_move);
xdg_toplevel->base->surface->events.unmap); LISTEN(toplevel->request_resize, toplevel_request_resize, xdg_toplevel->events.request_resize);
LISTEN(toplevel->destroy, toplevel_destroy, LISTEN(toplevel->request_maximize, toplevel_request_maximize, xdg_toplevel->events.request_maximize);
xdg_toplevel->events.destroy); LISTEN(toplevel->request_fullscreen, toplevel_request_fullscreen, xdg_toplevel->events.request_fullscreen);
LISTEN(toplevel->request_move, toplevel_request_move,
xdg_toplevel->events.request_move);
LISTEN(toplevel->request_resize, toplevel_request_resize,
xdg_toplevel->events.request_resize);
LISTEN(toplevel->request_maximize, toplevel_request_maximize,
xdg_toplevel->events.request_maximize);
LISTEN(toplevel->request_fullscreen, toplevel_request_fullscreen,
xdg_toplevel->events.request_fullscreen);
} }
void void new_xdg_popup(struct wl_listener *listener, void *data)
new_xdg_popup(struct wl_listener *listener, void *data)
{ {
absn_server *server = wl_container_of(listener, server, new_xdg_popup); absn_server *server = wl_container_of(listener, server, new_xdg_popup);
struct wlr_xdg_popup *xdg_popup = data; struct wlr_xdg_popup *xdg_popup = data;
absn_popup *popup = calloc(1, sizeof(*popup)); absn_popup *popup = calloc(1, sizeof(*popup));
popup->wlr = xdg_popup; popup->wlr = xdg_popup;
struct wlr_xdg_surface *parent = wlr_xdg_surface_try_from_wlr_surface( struct wlr_xdg_surface *parent = wlr_xdg_surface_try_from_wlr_surface(xdg_popup->parent);
xdg_popup->parent); absn_toplevel *parent_toplevel = parent->data;
absn_toplevel *parent_toplevel = parent->data; struct wlr_scene_tree *parent_tree = parent_toplevel->scene_tree;
struct wlr_scene_tree *parent_tree = parent_toplevel->scene_tree; xdg_popup->base->data = wlr_scene_xdg_surface_create(parent_tree, xdg_popup->base);
xdg_popup->base->data = wlr_scene_xdg_surface_create(parent_tree,
xdg_popup->base);
LISTEN(popup->commit, xdg_popup_commit, LISTEN(popup->commit, xdg_popup_commit, xdg_popup->base->surface->events.commit);
xdg_popup->base->surface->events.commit); LISTEN(popup->destroy, xdg_popup_destroy, xdg_popup->base->surface->events.destroy);
LISTEN(popup->destroy, xdg_popup_destroy,
xdg_popup->base->surface->events.destroy);
} }
void void new_xdg_decoration(struct wl_listener *listener, void *data)
new_xdg_decoration(struct wl_listener *listener, void *data)
{ {
UNUSED(listener); UNUSED(listener);
struct wlr_xdg_toplevel_decoration_v1 *deco = data; struct wlr_xdg_toplevel_decoration_v1 *deco = data;
absn_toplevel *toplevel = deco->toplevel->base->data; absn_toplevel *toplevel = deco->toplevel->base->data;
toplevel->deco = deco; toplevel->deco = deco;
LISTEN(toplevel->deco_request_mode, deco_request_mode, LISTEN(toplevel->deco_request_mode, deco_request_mode, deco->events.request_mode);
deco->events.request_mode); LISTEN(toplevel->deco_destroy, deco_destroy, deco->events.destroy);
LISTEN(toplevel->deco_destroy, deco_destroy, deco->events.destroy);
/* Forse server side decoration mode */ /* Forse server side decoration mode */
deco_request_mode(&toplevel->deco_request_mode, toplevel->deco); deco_request_mode(&toplevel->deco_request_mode, toplevel->deco);
} }
void void new_layer_surface(struct wl_listener *listener, void *data)
new_layer_surface(struct wl_listener *listener, void *data)
{ {
absn_server *server = wl_container_of(listener, server, absn_server *server = wl_container_of(listener, server, new_layer_surface);
new_layer_surface); struct wlr_layer_surface_v1 *surface = data;
struct wlr_layer_surface_v1 *surface = data;
if (!surface->output && if (!surface->output && !(surface->output = server->focused_output->wlr)) {
!(surface->output = server->focused_output->wlr)) { wlr_layer_surface_v1_destroy(surface);
wlr_layer_surface_v1_destroy(surface); return;
return; }
}
absn_layer_surface *layer_surface = calloc(1, sizeof(*layer_surface)); absn_layer_surface *layer_surface = calloc(1, sizeof(*layer_surface));
LISTEN(layer_surface->map, layer_surface_map, LISTEN(layer_surface->map, layer_surface_map, surface->surface->events.map);
surface->surface->events.map); LISTEN(layer_surface->unmap, layer_surface_unmap, surface->surface->events.unmap);
LISTEN(layer_surface->unmap, layer_surface_unmap, LISTEN(layer_surface->commit, layer_surface_commit, surface->surface->events.commit);
surface->surface->events.unmap); LISTEN(layer_surface->new_popup, layer_surface_new_popup, surface->events.new_popup);
LISTEN(layer_surface->commit, layer_surface_commit, LISTEN(layer_surface->destroy, layer_surface_destroy, surface->surface->events.destroy);
surface->surface->events.commit);
LISTEN(layer_surface->new_popup, layer_surface_new_popup,
surface->events.new_popup);
LISTEN(layer_surface->destroy, layer_surface_destroy,
surface->surface->events.destroy);
layer_surface->wlr = surface; layer_surface->wlr = surface;
layer_surface->output = surface->output->data; layer_surface->output = surface->output->data;
struct wlr_scene_tree *scene_layer = struct wlr_scene_tree *scene_layer = server->layers[layermap[surface->pending.layer]];
server->layers[layermap[surface->pending.layer]]; layer_surface->scene_layer = wlr_scene_layer_surface_v1_create(scene_layer, surface);
layer_surface->scene_layer = layer_surface->scene_tree = layer_surface->scene_layer->tree;
wlr_scene_layer_surface_v1_create(scene_layer, surface);
layer_surface->scene_tree = layer_surface->scene_layer->tree;
wl_list_insert(&layer_surface->output->layers[surface->pending.layer], wl_list_insert(&layer_surface->output->layers[surface->pending.layer], &layer_surface->link);
&layer_surface->link); wlr_surface_send_enter(surface->surface, surface->output);
wlr_surface_send_enter(surface->surface, surface->output);
} }
#ifdef XWAYLAND #ifdef XWAYLAND
void void xwayland_ready(struct wl_listener *listener, void *data)
xwayland_ready(struct wl_listener *listener, void *data)
{ {
UNUSED(data); UNUSED(data);
absn_server *server = wl_container_of(listener, server, xw_ready); absn_server *server = wl_container_of(listener, server, xw_ready);
wlr_xwayland_set_seat(server->xwayland, server->seat); wlr_xwayland_set_seat(server->xwayland, server->seat);
struct wlr_xcursor *xcursor; struct wlr_xcursor *xcursor;
if ((xcursor = wlr_xcursor_manager_get_xcursor(server->cursor_mgr, if ((xcursor = wlr_xcursor_manager_get_xcursor(server->cursor_mgr, "default", 1))) {
"default", 1))) { struct wlr_buffer *buffer = wlr_xcursor_image_get_buffer(xcursor->images[0]);
struct wlr_buffer *buffer = wlr_xcursor_image_get_buffer( wlr_xwayland_set_cursor(server->xwayland, buffer, xcursor->images[0]->hotspot_x, xcursor->images[0]->hotspot_y);
xcursor->images[0]); }
wlr_xwayland_set_cursor(server->xwayland, buffer,
xcursor->images[0]->hotspot_x,
xcursor->images[0]->hotspot_y);
}
} }
void void xwayland_new_surface(struct wl_listener *listener, void *data)
xwayland_new_surface(struct wl_listener *listener, void *data)
{ {
absn_server *server = wl_container_of(listener, server, xw_new_surface); absn_server *server = wl_container_of(listener, server, xw_new_surface);
struct wlr_xwayland_surface *surface = data; struct wlr_xwayland_surface *surface = data;
absn_toplevel *toplevel = calloc(1, sizeof(*toplevel)); absn_toplevel *toplevel = calloc(1, sizeof(*toplevel));
toplevel->type = TOPLEVEL_X11; toplevel->type = TOPLEVEL_X11;
toplevel->server = server; toplevel->server = server;
toplevel->xw = surface; toplevel->xw = surface;
toplevel->bw = toplevel_is_unmanaged(toplevel) ? 0 : TOPLEVEL_BW; toplevel->bw = toplevel_is_unmanaged(toplevel) ? 0 : TOPLEVEL_BW;
surface->data = toplevel; surface->data = toplevel;
LISTEN(toplevel->destroy, toplevel_destroy, surface->events.destroy); LISTEN(toplevel->destroy, toplevel_destroy, surface->events.destroy);
LISTEN(toplevel->request_maximize, toplevel_request_maximize, LISTEN(toplevel->request_maximize, toplevel_request_maximize, surface->events.request_maximize);
surface->events.request_maximize); LISTEN(toplevel->request_fullscreen, toplevel_request_fullscreen, surface->events.request_fullscreen);
LISTEN(toplevel->request_fullscreen, toplevel_request_fullscreen,
surface->events.request_fullscreen);
LISTEN(toplevel->xw_activate, xwayland_activate, LISTEN(toplevel->xw_activate, xwayland_activate, surface->events.request_activate);
surface->events.request_activate); LISTEN(toplevel->xw_associate, xwayland_associate, surface->events.associate);
LISTEN(toplevel->xw_associate, xwayland_associate, LISTEN(toplevel->xw_dissociate, xwayland_dissociate, surface->events.dissociate);
surface->events.associate); LISTEN(toplevel->xw_configure, xwayland_configure, surface->events.request_configure);
LISTEN(toplevel->xw_dissociate, xwayland_dissociate, LISTEN(toplevel->xw_set_hints, xwayland_set_hints, surface->events.set_hints);
surface->events.dissociate);
LISTEN(toplevel->xw_configure, xwayland_configure,
surface->events.request_configure);
LISTEN(toplevel->xw_set_hints, xwayland_set_hints,
surface->events.set_hints);
} }
#endif #endif
void void cursor_motion(struct wl_listener *listener, void *data)
cursor_motion(struct wl_listener *listener, void *data)
{ {
absn_server *server = wl_container_of(listener, server, cursor_motion); absn_server *server = wl_container_of(listener, server, cursor_motion);
struct wlr_pointer_motion_event *event = data; struct wlr_pointer_motion_event *event = data;
update_focused_output(server); update_focused_output(server);
wlr_cursor_move(server->cursor, &event->pointer->base, event->delta_x, wlr_cursor_move(server->cursor, &event->pointer->base, event->delta_x, event->delta_y);
event->delta_y); process_cursor_motion(server, event->time_msec);
process_cursor_motion(server, event->time_msec);
} }
void void cursor_motion_abs(struct wl_listener *listener, void *data)
cursor_motion_abs(struct wl_listener *listener, void *data)
{ {
absn_server *server = wl_container_of(listener, server, absn_server *server = wl_container_of(listener, server, cursor_motion_abs);
cursor_motion_abs); struct wlr_pointer_motion_absolute_event *event = data;
struct wlr_pointer_motion_absolute_event *event = data; update_focused_output(server);
update_focused_output(server); wlr_cursor_warp_absolute(server->cursor, &event->pointer->base, event->x, event->y);
wlr_cursor_warp_absolute(server->cursor, &event->pointer->base, process_cursor_motion(server, event->time_msec);
event->x, event->y);
process_cursor_motion(server, event->time_msec);
} }
void void cursor_button(struct wl_listener *listener, void *data)
cursor_button(struct wl_listener *listener, void *data)
{ {
absn_server *server = wl_container_of(listener, server, cursor_button); absn_server *server = wl_container_of(listener, server, cursor_button);
struct wlr_pointer_button_event *event = data; struct wlr_pointer_button_event *event = data;
bool handled = false; bool handled = false;
if (event->state == WL_POINTER_BUTTON_STATE_RELEASED) { if (event->state == WL_POINTER_BUTTON_STATE_RELEASED) {
reset_cursor_mode(server); reset_cursor_mode(server);
} else { } else {
double sx, sy; double sx, sy;
struct wlr_surface *surface = NULL; struct wlr_surface *surface = NULL;
absn_toplevel *toplevel = toplevel_at(server, server->cursor->x, absn_toplevel *toplevel = toplevel_at(server, server->cursor->x, server->cursor->y, &surface, &sx, &sy);
server->cursor->y, &surface, &sx, &sy);
if (!toplevel) if (!toplevel)
goto handle; goto handle;
struct wlr_keyboard *keyboard = wlr_seat_get_keyboard( struct wlr_keyboard *keyboard = wlr_seat_get_keyboard(server->seat);
server->seat); uint32_t mods = wlr_keyboard_get_modifiers(keyboard);
uint32_t mods = wlr_keyboard_get_modifiers(keyboard); if (mods & CURSOR_MOD) {
if (mods & CURSOR_MOD) { if (event->button == CURSOR_MOVE_BUTTON) {
if (event->button == CURSOR_MOVE_BUTTON) { server->cursor_mode = CURSOR_MOVE;
server->cursor_mode = CURSOR_MOVE; wlr_cursor_set_xcursor(server->cursor, server->cursor_mgr, "all-scroll");
wlr_cursor_set_xcursor(server->cursor, handled = true;
server->cursor_mgr, "all-scroll"); } else if (event->button == CURSOR_RESIZE_BUTTON) {
handled = true; server->cursor_mode = CURSOR_RESIZE;
} else if (event->button == CURSOR_RESIZE_BUTTON) { handled = true;
server->cursor_mode = CURSOR_RESIZE; }
handled = true; }
}
}
focus_toplevel(toplevel); focus_toplevel(toplevel);
server->grab_x = server->cursor->x; server->grab_x = server->cursor->x;
server->grab_y = server->cursor->y; server->grab_y = server->cursor->y;
int32_t lx, ly; int32_t lx, ly;
wlr_scene_node_coords(&toplevel->scene_tree->node, &lx, &ly); wlr_scene_node_coords(&toplevel->scene_tree->node, &lx, &ly);
server->grab_geom.x = lx; server->grab_geom.x = lx;
server->grab_geom.y = ly; server->grab_geom.y = ly;
server->grab_geom.width = toplevel->geom.width; server->grab_geom.width = toplevel->geom.width;
server->grab_geom.height = toplevel->geom.height; server->grab_geom.height = toplevel->geom.height;
if (server->cursor_mode != CURSOR_RESIZE) if (server->cursor_mode != CURSOR_RESIZE)
goto handle; goto handle;
int32_t width = toplevel->xdg->base->geometry.width; int32_t width = toplevel->xdg->base->geometry.width;
int32_t height = toplevel->xdg->base->geometry.height; int32_t height = toplevel->xdg->base->geometry.height;
if (server->grab_x > (lx + width / 2) && if (server->grab_x > (lx + width / 2) && server->grab_y > (ly + height / 2)) {
server->grab_y > (ly + height / 2)) { server->resize_corner = BOTTOM_RIGHT;
server->resize_corner = BOTTOM_RIGHT; wlr_cursor_set_xcursor(server->cursor, server->cursor_mgr, "se-resize");
wlr_cursor_set_xcursor(server->cursor, } else if (server->grab_x < (lx + width / 2) && server->grab_y > (ly + height / 2)) {
server->cursor_mgr, "se-resize"); server->resize_corner = BOTTOM_LEFT;
} else if (server->grab_x < (lx + width / 2) && wlr_cursor_set_xcursor(server->cursor, server->cursor_mgr, "sw-resize");
server->grab_y > (ly + height / 2)) { } else if (server->grab_x > (lx + width / 2) && server->grab_y < (ly + height / 2)) {
server->resize_corner = BOTTOM_LEFT; server->resize_corner = TOP_RIGHT;
wlr_cursor_set_xcursor(server->cursor, wlr_cursor_set_xcursor(server->cursor, server->cursor_mgr, "ne-resize");
server->cursor_mgr, "sw-resize"); } else {
} else if (server->grab_x > (lx + width / 2) && server->resize_corner = TOP_LEFT;
server->grab_y < (ly + height / 2)) { wlr_cursor_set_xcursor(server->cursor, server->cursor_mgr, "nw-resize");
server->resize_corner = TOP_RIGHT; }
wlr_cursor_set_xcursor(server->cursor,
server->cursor_mgr, "ne-resize");
} else {
server->resize_corner = TOP_LEFT;
wlr_cursor_set_xcursor(server->cursor,
server->cursor_mgr, "nw-resize");
}
wlr_xdg_toplevel_set_resizing(toplevel->xdg, true); wlr_xdg_toplevel_set_resizing(toplevel->xdg, true);
} }
handle: handle:
if (!handled) { if (!handled) {
wlr_seat_pointer_notify_button(server->seat, event->time_msec, wlr_seat_pointer_notify_button(server->seat, event->time_msec, event->button, event->state);
event->button, event->state); }
}
} }
void void cursor_axis(struct wl_listener *listener, void *data)
cursor_axis(struct wl_listener *listener, void *data)
{ {
absn_server *server = wl_container_of(listener, server, cursor_axis); absn_server *server = wl_container_of(listener, server, cursor_axis);
struct wlr_pointer_axis_event *event = data; struct wlr_pointer_axis_event *event = data;
wlr_seat_pointer_notify_axis(server->seat, event->time_msec, wlr_seat_pointer_notify_axis(server->seat, event->time_msec, event->orientation, event->delta,
event->orientation, event->delta, event->delta_discrete, event->delta_discrete, event->source, event->relative_direction);
event->source, event->relative_direction);
} }
void void cursor_frame(struct wl_listener *listener, void *data)
cursor_frame(struct wl_listener *listener, void *data)
{ {
UNUSED(data); UNUSED(data);
absn_server *server = wl_container_of(listener, server, cursor_frame); absn_server *server = wl_container_of(listener, server, cursor_frame);
wlr_seat_pointer_notify_frame(server->seat); wlr_seat_pointer_notify_frame(server->seat);
} }
static void static void new_keyboard(absn_server *server, struct wlr_input_device *device)
new_keyboard(absn_server *server, struct wlr_input_device *device)
{ {
struct wlr_keyboard *wlr_keyboard = wlr_keyboard_from_input_device( struct wlr_keyboard *wlr_keyboard = wlr_keyboard_from_input_device(device);
device); absn_keyboard *keyboard = calloc(1, sizeof(*keyboard));
absn_keyboard *keyboard = calloc(1, sizeof(*keyboard)); keyboard->server = server;
keyboard->server = server; keyboard->wlr = wlr_keyboard;
keyboard->wlr = wlr_keyboard;
struct xkb_context *context = xkb_context_new(XKB_CONTEXT_NO_FLAGS); struct xkb_context *context = xkb_context_new(XKB_CONTEXT_NO_FLAGS);
struct xkb_keymap *keymap = xkb_keymap_new_from_names(context, NULL, struct xkb_keymap *keymap = xkb_keymap_new_from_names(context, NULL, XKB_KEYMAP_COMPILE_NO_FLAGS);
XKB_KEYMAP_COMPILE_NO_FLAGS);
wlr_keyboard_set_keymap(wlr_keyboard, keymap); wlr_keyboard_set_keymap(wlr_keyboard, keymap);
xkb_keymap_unref(keymap); xkb_keymap_unref(keymap);
xkb_context_unref(context); xkb_context_unref(context);
wlr_keyboard_set_repeat_info(wlr_keyboard, 25, 600); wlr_keyboard_set_repeat_info(wlr_keyboard, 25, 600);
LISTEN(keyboard->modifiers, handle_modifiers, LISTEN(keyboard->modifiers, handle_modifiers, wlr_keyboard->events.modifiers);
wlr_keyboard->events.modifiers); LISTEN(keyboard->key, handle_key, wlr_keyboard->events.key);
LISTEN(keyboard->key, handle_key, wlr_keyboard->events.key); LISTEN(keyboard->destroy, handle_destroy, wlr_keyboard->base.events.destroy);
LISTEN(keyboard->destroy, handle_destroy,
wlr_keyboard->base.events.destroy);
wlr_seat_set_keyboard(server->seat, wlr_keyboard); wlr_seat_set_keyboard(server->seat, wlr_keyboard);
wl_list_insert(&server->keyboards, &keyboard->link); wl_list_insert(&server->keyboards, &keyboard->link);
} }
static void static void new_pointer(absn_server *server, struct wlr_input_device *device)
new_pointer(absn_server *server, struct wlr_input_device *device)
{ {
wlr_cursor_attach_input_device(server->cursor, device); wlr_cursor_attach_input_device(server->cursor, device);
} }
void void new_input(struct wl_listener *listener, void *data)
new_input(struct wl_listener *listener, void *data)
{ {
absn_server *server = wl_container_of(listener, server, new_input); absn_server *server = wl_container_of(listener, server, new_input);
struct wlr_input_device *device = data; struct wlr_input_device *device = data;
switch (device->type) { switch (device->type) {
case WLR_INPUT_DEVICE_KEYBOARD: case WLR_INPUT_DEVICE_KEYBOARD:
new_keyboard(server, device); new_keyboard(server, device);
break; break;
case WLR_INPUT_DEVICE_POINTER: case WLR_INPUT_DEVICE_POINTER:
new_pointer(server, device); new_pointer(server, device);
default: default:
break; break;
} }
uint32_t caps = WL_SEAT_CAPABILITY_POINTER; uint32_t caps = WL_SEAT_CAPABILITY_POINTER;
if (!wl_list_empty(&server->keyboards)) { if (!wl_list_empty(&server->keyboards)) {
caps |= WL_SEAT_CAPABILITY_KEYBOARD; caps |= WL_SEAT_CAPABILITY_KEYBOARD;
} }
wlr_seat_set_capabilities(server->seat, caps); wlr_seat_set_capabilities(server->seat, caps);
} }
src/toplevel-handlers.c
+87 -106
View File
@@ -7,149 +7,130 @@
#include "output.h" #include "output.h"
#include "toplevel.h" #include "toplevel.h"
void void toplevel_map(struct wl_listener *listener, void *data)
toplevel_map(struct wl_listener *listener, void *data)
{ {
UNUSED(data); UNUSED(data);
absn_toplevel *toplevel = wl_container_of(listener, toplevel, map); absn_toplevel *toplevel = wl_container_of(listener, toplevel, map);
absn_server *server = toplevel->server; absn_server *server = toplevel->server;
toplevel->scene_tree = wlr_scene_tree_create( toplevel->scene_tree = wlr_scene_tree_create(server->layers[LAYER_TILE]);
server->layers[LAYER_TILE]); toplevel->scene_tree->node.data = toplevel;
toplevel->scene_tree->node.data = toplevel; wlr_scene_node_set_enabled(&toplevel->scene_tree->node, toplevel_is_unmanaged(toplevel));
wlr_scene_node_set_enabled(&toplevel->scene_tree->node,
toplevel_is_unmanaged(toplevel));
if (toplevel->type != TOPLEVEL_X11 && if (toplevel->type != TOPLEVEL_X11 &&
wl_resource_get_version(toplevel->xdg->resource) >= wl_resource_get_version(toplevel->xdg->resource) >= XDG_TOPLEVEL_STATE_TILED_RIGHT_SINCE_VERSION) {
XDG_TOPLEVEL_STATE_TILED_RIGHT_SINCE_VERSION) { wlr_xdg_toplevel_set_tiled(toplevel->xdg, WLR_EDGE_TOP | WLR_EDGE_BOTTOM | WLR_EDGE_LEFT | WLR_EDGE_RIGHT);
wlr_xdg_toplevel_set_tiled(toplevel->xdg, } else {
WLR_EDGE_TOP | WLR_EDGE_BOTTOM | WLR_EDGE_LEFT | wlr_xdg_toplevel_set_maximized(toplevel->xdg, true);
WLR_EDGE_RIGHT); }
} else {
wlr_xdg_toplevel_set_maximized(toplevel->xdg, true);
}
toplevel->bw = toplevel_is_unmanaged(toplevel) ? 0 : TOPLEVEL_BW; toplevel->bw = toplevel_is_unmanaged(toplevel) ? 0 : TOPLEVEL_BW;
#ifdef XWAYLAND #ifdef XWAYLAND
if (toplevel->type == TOPLEVEL_X11) { if (toplevel->type == TOPLEVEL_X11) {
toplevel->scene_surface = wlr_scene_subsurface_tree_create( toplevel->scene_surface = wlr_scene_subsurface_tree_create(toplevel->scene_tree, toplevel->xw->surface);
toplevel->scene_tree, toplevel->xw->surface); } else
} else
#endif #endif
{ {
toplevel->scene_surface = wlr_scene_xdg_surface_create( toplevel->scene_surface = wlr_scene_xdg_surface_create(toplevel->scene_tree, toplevel->xdg->base);
toplevel->scene_tree, toplevel->xdg->base); }
} toplevel->scene_surface->node.data = toplevel;
toplevel->scene_surface->node.data = toplevel;
toplevel_get_geom(toplevel); toplevel_get_geom(toplevel);
toplevel->bw = toplevel_is_unmanaged(toplevel) ? 0 : TOPLEVEL_BW; toplevel->bw = toplevel_is_unmanaged(toplevel) ? 0 : TOPLEVEL_BW;
for (int i = 0; i < 4; ++i) { for (int i = 0; i < 4; ++i) {
toplevel->border[i] = wlr_scene_rect_create( toplevel->border[i] = wlr_scene_rect_create(toplevel->scene_tree, 0, 0, unfocused_bc);
toplevel->scene_tree, 0, 0, unfocused_bc); toplevel->border[i]->node.data = toplevel;
toplevel->border[i]->node.data = toplevel; }
}
update_focused_output(toplevel->server); update_focused_output(toplevel->server);
toplevel->output = toplevel->server->focused_output; toplevel->output = toplevel->server->focused_output;
toplevel->workspace = toplevel->output->workspace; toplevel->workspace = toplevel->output->workspace;
toplevel->fullscreen = false; toplevel->fullscreen = false;
wl_list_insert(&toplevel->server->toplevels, &toplevel->link); wl_list_insert(&toplevel->server->toplevels, &toplevel->link);
wl_list_insert(&toplevel->server->focus_stack, &toplevel->flink); wl_list_insert(&toplevel->server->focus_stack, &toplevel->flink);
layout_arrange(toplevel->output); layout_arrange(toplevel->output);
focus_toplevel(focus_get_topmost(toplevel->server)); focus_toplevel(focus_get_topmost(toplevel->server));
} }
void void toplevel_unmap(struct wl_listener *listener, void *data)
toplevel_unmap(struct wl_listener *listener, void *data)
{ {
UNUSED(data); UNUSED(data);
absn_toplevel *toplevel = wl_container_of(listener, toplevel, unmap); absn_toplevel *toplevel = wl_container_of(listener, toplevel, unmap);
if (toplevel == toplevel->server->focused_toplevel) { if (toplevel == toplevel->server->focused_toplevel) {
toplevel->server->focused_toplevel = NULL; toplevel->server->focused_toplevel = NULL;
toplevel->server->seat->keyboard_state.focused_surface = NULL; toplevel->server->seat->keyboard_state.focused_surface = NULL;
} }
wl_list_remove(&toplevel->link); wl_list_remove(&toplevel->link);
wl_list_remove(&toplevel->flink); wl_list_remove(&toplevel->flink);
layout_arrange(toplevel->output); layout_arrange(toplevel->output);
focus_toplevel(focus_get_topmost(toplevel->server)); focus_toplevel(focus_get_topmost(toplevel->server));
wlr_scene_node_destroy(&toplevel->scene_tree->node); wlr_scene_node_destroy(&toplevel->scene_tree->node);
} }
void void toplevel_destroy(struct wl_listener *listener, void *data)
toplevel_destroy(struct wl_listener *listener, void *data)
{ {
UNUSED(data); UNUSED(data);
absn_toplevel *toplevel = wl_container_of(listener, toplevel, destroy); absn_toplevel *toplevel = wl_container_of(listener, toplevel, destroy);
#ifdef XWAYLAND #ifdef XWAYLAND
if (toplevel->type == TOPLEVEL_X11) { if (toplevel->type == TOPLEVEL_X11) {
wl_list_remove(&toplevel->xw_activate.link); wl_list_remove(&toplevel->xw_activate.link);
wl_list_remove(&toplevel->xw_associate.link); wl_list_remove(&toplevel->xw_associate.link);
wl_list_remove(&toplevel->xw_dissociate.link); wl_list_remove(&toplevel->xw_dissociate.link);
wl_list_remove(&toplevel->xw_configure.link); wl_list_remove(&toplevel->xw_configure.link);
wl_list_remove(&toplevel->xw_set_hints.link); wl_list_remove(&toplevel->xw_set_hints.link);
} else } else
#endif #endif
{ {
wl_list_remove(&toplevel->map.link); wl_list_remove(&toplevel->map.link);
wl_list_remove(&toplevel->unmap.link); wl_list_remove(&toplevel->unmap.link);
wl_list_remove(&toplevel->commit.link); wl_list_remove(&toplevel->commit.link);
wl_list_remove(&toplevel->request_move.link); wl_list_remove(&toplevel->request_move.link);
wl_list_remove(&toplevel->request_resize.link); wl_list_remove(&toplevel->request_resize.link);
} }
wl_list_remove(&toplevel->destroy.link); wl_list_remove(&toplevel->destroy.link);
wl_list_remove(&toplevel->request_maximize.link); wl_list_remove(&toplevel->request_maximize.link);
wl_list_remove(&toplevel->request_fullscreen.link); wl_list_remove(&toplevel->request_fullscreen.link);
free(toplevel); free(toplevel);
} }
void void toplevel_request_move(struct wl_listener *listener, void *data)
toplevel_request_move(struct wl_listener *listener, void *data)
{ {
UNUSED(data); UNUSED(data);
absn_toplevel *toplevel = wl_container_of(listener, toplevel, absn_toplevel *toplevel = wl_container_of(listener, toplevel, request_move);
request_move); if (toplevel->xdg->base->initialized)
if (toplevel->xdg->base->initialized) wlr_xdg_surface_schedule_configure(toplevel->xdg->base);
wlr_xdg_surface_schedule_configure(toplevel->xdg->base);
} }
void void toplevel_request_resize(struct wl_listener *listener, void *data)
toplevel_request_resize(struct wl_listener *listener, void *data)
{ {
UNUSED(data); UNUSED(data);
absn_toplevel *toplevel = wl_container_of(listener, toplevel, absn_toplevel *toplevel = wl_container_of(listener, toplevel, request_resize);
request_resize); if (toplevel->xdg->base->initialized)
if (toplevel->xdg->base->initialized) wlr_xdg_surface_schedule_configure(toplevel->xdg->base);
wlr_xdg_surface_schedule_configure(toplevel->xdg->base);
} }
void void toplevel_request_maximize(struct wl_listener *listener, void *data)
toplevel_request_maximize(struct wl_listener *listener, void *data)
{ {
UNUSED(data); UNUSED(data);
absn_toplevel *toplevel = wl_container_of(listener, toplevel, absn_toplevel *toplevel = wl_container_of(listener, toplevel, request_maximize);
request_maximize); if (toplevel->xdg->base->initialized)
if (toplevel->xdg->base->initialized) wlr_xdg_surface_schedule_configure(toplevel->xdg->base);
wlr_xdg_surface_schedule_configure(toplevel->xdg->base);
} }
void void toplevel_request_fullscreen(struct wl_listener *listener, void *data)
toplevel_request_fullscreen(struct wl_listener *listener, void *data)
{ {
UNUSED(data); UNUSED(data);
absn_toplevel *toplevel = wl_container_of(listener, toplevel, absn_toplevel *toplevel = wl_container_of(listener, toplevel, request_fullscreen);
request_fullscreen); toplevel_set_fullscreen(toplevel, toplevel->xdg->requested.fullscreen);
toplevel_set_fullscreen(toplevel, toplevel->xdg->requested.fullscreen);
} }
src/toplevel.c
+125 -152
View File
@@ -12,40 +12,38 @@
* its surface and coordinates inside of it * its surface and coordinates inside of it
* to process input event * to process input event
*/ */
absn_toplevel * absn_toplevel *toplevel_at(absn_server *server, double lx, double ly, struct wlr_surface **surface, double *sx,
toplevel_at(absn_server *server, double lx, double ly, double *sy)
struct wlr_surface **surface, double *sx, double *sy)
{ {
struct wlr_scene_node *node = struct wlr_scene_node *node = wlr_scene_node_at(&server->scene->tree.node, lx, ly, sx, sy);
wlr_scene_node_at(&server->scene->tree.node, lx, ly, sx, sy); if (!node) {
if (!node) { return NULL;
return NULL; }
}
struct wlr_scene_buffer *scene_buffer = NULL; struct wlr_scene_buffer *scene_buffer = NULL;
struct wlr_scene_surface *scene_surface = NULL; struct wlr_scene_surface *scene_surface = NULL;
switch (node->type) { switch (node->type) {
case WLR_SCENE_NODE_BUFFER: case WLR_SCENE_NODE_BUFFER:
scene_buffer = wlr_scene_buffer_from_node(node); scene_buffer = wlr_scene_buffer_from_node(node);
scene_surface = wlr_scene_surface_try_from_buffer(scene_buffer); scene_surface = wlr_scene_surface_try_from_buffer(scene_buffer);
if (!scene_surface) { if (!scene_surface) {
return NULL; return NULL;
} }
*surface = scene_surface->surface; *surface = scene_surface->surface;
struct wlr_scene_tree *tree = node->parent; struct wlr_scene_tree *tree = node->parent;
while (tree != NULL && tree->node.data == NULL) { while (tree != NULL && tree->node.data == NULL) {
tree = tree->node.parent; tree = tree->node.parent;
} }
return tree->node.data; return tree->node.data;
break; break;
case WLR_SCENE_NODE_RECT: case WLR_SCENE_NODE_RECT:
return node->data; return node->data;
break; break;
default: default:
return NULL; return NULL;
} }
} }
/* /*
@@ -53,174 +51,149 @@ toplevel_at(absn_server *server, double lx, double ly,
* move or resize it and just draw it * move or resize it and just draw it
* where it wants * where it wants
*/ */
bool bool toplevel_is_unmanaged(absn_toplevel *toplevel)
toplevel_is_unmanaged(absn_toplevel *toplevel)
{ {
#ifdef XWAYLAND #ifdef XWAYLAND
if (toplevel->type == TOPLEVEL_X11) if (toplevel->type == TOPLEVEL_X11)
return toplevel->xw->override_redirect; return toplevel->xw->override_redirect;
#endif #endif
return false; return false;
} }
/* used only to get initial window size */ /* used only to get initial window size */
void void toplevel_get_geom(absn_toplevel *toplevel)
toplevel_get_geom(absn_toplevel *toplevel)
{ {
#ifdef XWAYLAND #ifdef XWAYLAND
if (toplevel->type == TOPLEVEL_X11) { if (toplevel->type == TOPLEVEL_X11) {
toplevel->geom.x = toplevel->xw->x; toplevel->geom.x = toplevel->xw->x;
toplevel->geom.y = toplevel->xw->y; toplevel->geom.y = toplevel->xw->y;
toplevel->geom.width = toplevel->xw->width; toplevel->geom.width = toplevel->xw->width;
toplevel->geom.height = toplevel->xw->height; toplevel->geom.height = toplevel->xw->height;
} else } else
#endif #endif
{ {
toplevel->geom = toplevel->xdg->base->geometry; toplevel->geom = toplevel->xdg->base->geometry;
} }
} }
static void static void toplevel_update_borders_geom(absn_toplevel *toplevel)
toplevel_update_borders_geom(absn_toplevel *toplevel)
{ {
int32_t bw = toplevel->bw; int32_t bw = toplevel->bw;
if (toplevel->geom.width - 2 * bw < 0 || if (toplevel->geom.width - 2 * bw < 0 || toplevel->geom.height - 2 * bw < 0)
toplevel->geom.height - 2 * bw < 0) return;
return;
wlr_scene_node_set_position(&toplevel->scene_tree->node, wlr_scene_node_set_position(&toplevel->scene_tree->node, toplevel->geom.x, toplevel->geom.y);
toplevel->geom.x, toplevel->geom.y); wlr_scene_node_set_position(&toplevel->scene_surface->node, bw, bw);
wlr_scene_node_set_position(&toplevel->scene_surface->node, bw, bw);
wlr_scene_rect_set_size(toplevel->border[0], wlr_scene_rect_set_size(toplevel->border[0], toplevel->geom.width - 2 * bw, bw);
toplevel->geom.width - 2 * bw, bw); wlr_scene_rect_set_size(toplevel->border[1], toplevel->geom.width - 2 * bw, bw);
wlr_scene_rect_set_size(toplevel->border[1], wlr_scene_rect_set_size(toplevel->border[2], bw, toplevel->geom.height);
toplevel->geom.width - 2 * bw, bw); wlr_scene_rect_set_size(toplevel->border[3], bw, toplevel->geom.height);
wlr_scene_rect_set_size(toplevel->border[2], bw, toplevel->geom.height);
wlr_scene_rect_set_size(toplevel->border[3], bw, toplevel->geom.height);
wlr_scene_node_set_position(&toplevel->border[0]->node, bw, 0); wlr_scene_node_set_position(&toplevel->border[0]->node, bw, 0);
wlr_scene_node_set_position(&toplevel->border[1]->node, bw, wlr_scene_node_set_position(&toplevel->border[1]->node, bw, toplevel->geom.height - bw);
toplevel->geom.height - bw); wlr_scene_node_set_position(&toplevel->border[2]->node, 0, 0);
wlr_scene_node_set_position(&toplevel->border[2]->node, 0, 0); wlr_scene_node_set_position(&toplevel->border[3]->node, toplevel->geom.width - bw, 0);
wlr_scene_node_set_position(&toplevel->border[3]->node,
toplevel->geom.width - bw, 0);
} }
void void toplevel_set_pos(absn_toplevel *toplevel, int32_t x, int32_t y)
toplevel_set_pos(absn_toplevel *toplevel, int32_t x, int32_t y)
{ {
toplevel->geom.x = x; toplevel->geom.x = x;
toplevel->geom.y = y; toplevel->geom.y = y;
wlr_scene_node_set_position(&toplevel->scene_tree->node, x, y); wlr_scene_node_set_position(&toplevel->scene_tree->node, x, y);
} }
void void toplevel_set_size(absn_toplevel *toplevel, int32_t width, int32_t height)
toplevel_set_size(absn_toplevel *toplevel, int32_t width, int32_t height)
{ {
if (width <= 2 * toplevel->bw || height <= 2 * toplevel->bw || if (width <= 2 * toplevel->bw || height <= 2 * toplevel->bw ||
(width == toplevel->geom.width && height == toplevel->geom.height)) (width == toplevel->geom.width && height == toplevel->geom.height))
return; return;
toplevel->geom.width = width; toplevel->geom.width = width;
toplevel->geom.height = height; toplevel->geom.height = height;
toplevel_update_borders_geom(toplevel); toplevel_update_borders_geom(toplevel);
struct wlr_box clip = { struct wlr_box clip = {
.x = 0, .x = 0,
.y = 0, .y = 0,
.width = width - toplevel->bw, .width = width - toplevel->bw,
.height = height - toplevel->bw, .height = height - toplevel->bw,
}; };
if (toplevel->type == TOPLEVEL_XDG) { if (toplevel->type == TOPLEVEL_XDG) {
if (wl_resource_get_version(toplevel->xdg->resource) >= if (wl_resource_get_version(toplevel->xdg->resource) >= XDG_TOPLEVEL_CONFIGURE_BOUNDS_SINCE_VERSION)
XDG_TOPLEVEL_CONFIGURE_BOUNDS_SINCE_VERSION) wlr_xdg_toplevel_set_bounds(toplevel->xdg, width, height);
wlr_xdg_toplevel_set_bounds(toplevel->xdg, width, toplevel->resizing =
height); wlr_xdg_toplevel_set_size(toplevel->xdg, width - 2 * toplevel->bw, height - 2 * toplevel->bw);
toplevel->resizing = wlr_xdg_toplevel_set_size(toplevel->xdg, }
width - 2 * toplevel->bw, height - 2 * toplevel->bw);
}
#ifdef XWAYLAND #ifdef XWAYLAND
else if (toplevel->type == TOPLEVEL_X11) { else if (toplevel->type == TOPLEVEL_X11) {
wlr_xwayland_surface_configure(toplevel->xw, toplevel->geom.x, wlr_xwayland_surface_configure(toplevel->xw, toplevel->geom.x, toplevel->geom.y, width - 2 * toplevel->bw,
toplevel->geom.y, width - 2 * toplevel->bw, height - 2 * toplevel->bw);
height - 2 * toplevel->bw); /* manually update position */
/* manually update position */ toplevel_set_pos(toplevel, toplevel->geom.x, toplevel->geom.y);
toplevel_set_pos(toplevel, toplevel->geom.x, toplevel->geom.y); }
}
#endif #endif
wlr_scene_subsurface_tree_set_clip(&toplevel->scene_surface->node, wlr_scene_subsurface_tree_set_clip(&toplevel->scene_surface->node, &clip);
&clip);
} }
void void toplevel_set_geom(absn_toplevel *toplevel, struct wlr_box *geom)
toplevel_set_geom(absn_toplevel *toplevel, struct wlr_box *geom)
{ {
toplevel_set_pos(toplevel, geom->x, geom->y); toplevel_set_pos(toplevel, geom->x, geom->y);
toplevel_set_size(toplevel, geom->width, geom->height); toplevel_set_size(toplevel, geom->width, geom->height);
} }
void void toplevel_set_floating(absn_toplevel *toplevel, bool floating)
toplevel_set_floating(absn_toplevel *toplevel, bool floating)
{ {
if (!toplevel || toplevel->floating == floating) if (!toplevel || toplevel->floating == floating)
return; return;
toplevel->floating = floating; toplevel->floating = floating;
if (floating) if (floating)
wlr_scene_node_reparent(&toplevel->scene_tree->node, wlr_scene_node_reparent(&toplevel->scene_tree->node, toplevel->server->layers[LAYER_FLOAT]);
toplevel->server->layers[LAYER_FLOAT]); else
else wlr_scene_node_reparent(&toplevel->scene_tree->node, toplevel->server->layers[LAYER_TILE]);
wlr_scene_node_reparent(&toplevel->scene_tree->node,
toplevel->server->layers[LAYER_TILE]);
layout_arrange(toplevel->output); layout_arrange(toplevel->output);
} }
void void toplevel_set_fullscreen(absn_toplevel *toplevel, bool fullscreen)
toplevel_set_fullscreen(absn_toplevel *toplevel, bool fullscreen)
{ {
if (!toplevel || toplevel->fullscreen == fullscreen) if (!toplevel || toplevel->fullscreen == fullscreen)
return; return;
absn_output *output = toplevel->server->focused_output; absn_output *output = toplevel->server->focused_output;
toplevel->fullscreen = fullscreen; toplevel->fullscreen = fullscreen;
wlr_xdg_toplevel_set_fullscreen(toplevel->xdg, fullscreen); wlr_xdg_toplevel_set_fullscreen(toplevel->xdg, fullscreen);
if (fullscreen) { if (fullscreen) {
toplevel->prev_geom = toplevel->geom; toplevel->prev_geom = toplevel->geom;
toplevel->bw = 0; toplevel->bw = 0;
toplevel_set_geom(toplevel, &output->geom); toplevel_set_geom(toplevel, &output->geom);
wlr_scene_node_reparent(&toplevel->scene_tree->node, wlr_scene_node_reparent(&toplevel->scene_tree->node, toplevel->server->layers[LAYER_FULLSCREEN]);
toplevel->server->layers[LAYER_FULLSCREEN]); } else {
} else { toplevel->bw = toplevel_is_unmanaged(toplevel) ? 0 : TOPLEVEL_BW;
toplevel->bw = toplevel_is_unmanaged(toplevel) ? 0 : toplevel_set_geom(toplevel, &toplevel->prev_geom);
TOPLEVEL_BW; if (toplevel->floating)
toplevel_set_geom(toplevel, &toplevel->prev_geom); wlr_scene_node_reparent(&toplevel->scene_tree->node, toplevel->server->layers[LAYER_FLOAT]);
if (toplevel->floating) else
wlr_scene_node_reparent(&toplevel->scene_tree->node, wlr_scene_node_reparent(&toplevel->scene_tree->node, toplevel->server->layers[LAYER_TILE]);
toplevel->server->layers[LAYER_FLOAT]); }
else
wlr_scene_node_reparent(&toplevel->scene_tree->node,
toplevel->server->layers[LAYER_TILE]);
}
toplevel_update_borders_geom(toplevel); toplevel_update_borders_geom(toplevel);
layout_arrange(toplevel->output); layout_arrange(toplevel->output);
} }
void void toplevel_set_border_color(absn_toplevel *toplevel, const float color[4])
toplevel_set_border_color(absn_toplevel *toplevel, const float color[4])
{ {
if (!toplevel) if (!toplevel)
return; return;
for (int i = 0; i < 4; ++i) { for (int i = 0; i < 4; ++i) {
wlr_scene_rect_set_color(toplevel->border[i], color); wlr_scene_rect_set_color(toplevel->border[i], color);
} }
} }
src/xdg-decoration.c
+10 -15
View File
@@ -2,24 +2,19 @@
#include "types.h" #include "types.h"
void void deco_request_mode(struct wl_listener *listener, void *data)
deco_request_mode(struct wl_listener *listener, void *data)
{ {
UNUSED(data); UNUSED(data);
absn_toplevel *toplevel = wl_container_of(listener, toplevel, absn_toplevel *toplevel = wl_container_of(listener, toplevel, deco_request_mode);
deco_request_mode); if (toplevel->xdg->base->initialized)
if (toplevel->xdg->base->initialized) wlr_xdg_toplevel_decoration_v1_set_mode(toplevel->deco, WLR_XDG_TOPLEVEL_DECORATION_V1_MODE_SERVER_SIDE);
wlr_xdg_toplevel_decoration_v1_set_mode(toplevel->deco,
WLR_XDG_TOPLEVEL_DECORATION_V1_MODE_SERVER_SIDE);
} }
void void deco_destroy(struct wl_listener *listener, void *data)
deco_destroy(struct wl_listener *listener, void *data)
{ {
UNUSED(data); UNUSED(data);
absn_toplevel *toplevel = wl_container_of(listener, toplevel, absn_toplevel *toplevel = wl_container_of(listener, toplevel, deco_destroy);
deco_destroy);
wl_list_remove(&toplevel->deco_request_mode.link); wl_list_remove(&toplevel->deco_request_mode.link);
wl_list_remove(&toplevel->deco_destroy.link); wl_list_remove(&toplevel->deco_destroy.link);
} }
src/xdg-popup.c
+11 -13
View File
@@ -3,24 +3,22 @@
#include "types.h" #include "types.h"
void void xdg_popup_commit(struct wl_listener *listener, void *data)
xdg_popup_commit(struct wl_listener *listener, void *data)
{ {
UNUSED(data); UNUSED(data);
absn_popup *popup = wl_container_of(listener, popup, commit); absn_popup *popup = wl_container_of(listener, popup, commit);
if (popup->wlr->base->initial_commit) if (popup->wlr->base->initial_commit)
wlr_xdg_surface_schedule_configure(popup->wlr->base); wlr_xdg_surface_schedule_configure(popup->wlr->base);
} }
void void xdg_popup_destroy(struct wl_listener *listener, void *data)
xdg_popup_destroy(struct wl_listener *listener, void *data)
{ {
UNUSED(data); UNUSED(data);
absn_popup *popup = wl_container_of(listener, popup, destroy); absn_popup *popup = wl_container_of(listener, popup, destroy);
wl_list_remove(&popup->commit.link); wl_list_remove(&popup->commit.link);
wl_list_remove(&popup->destroy.link); wl_list_remove(&popup->destroy.link);
free(popup); free(popup);
} }
src/xdg-toplevel.c
+23 -28
View File
@@ -5,38 +5,33 @@
#include "types.h" #include "types.h"
#include "xdg-decoration.h" #include "xdg-decoration.h"
void void toplevel_commit(struct wl_listener *listener, void *data)
toplevel_commit(struct wl_listener *listener, void *data)
{ {
UNUSED(data); UNUSED(data);
absn_toplevel *toplevel = wl_container_of(listener, toplevel, commit); absn_toplevel *toplevel = wl_container_of(listener, toplevel, commit);
if (toplevel->xdg->base->initial_commit) { if (toplevel->xdg->base->initial_commit) {
wlr_xdg_toplevel_set_activated(toplevel->xdg, false); wlr_xdg_toplevel_set_activated(toplevel->xdg, false);
/* forse server side decoration mode */ /* forse server side decoration mode */
if (toplevel->deco) if (toplevel->deco)
deco_request_mode(&toplevel->deco_request_mode, deco_request_mode(&toplevel->deco_request_mode, toplevel->deco);
toplevel->deco); /* let client set initial size */
/* let client set initial size */ toplevel->resizing = wlr_xdg_toplevel_set_size(toplevel->xdg, 0, 0);
toplevel->resizing = wlr_xdg_toplevel_set_size(toplevel->xdg, 0, return;
0); }
return;
}
bool resizing = toplevel->resizing && bool resizing = toplevel->resizing && toplevel->resizing <= toplevel->xdg->base->current.configure_serial;
toplevel->resizing <= toplevel->xdg->base->current.configure_serial;
/* remove pending resize */ /* remove pending resize */
if (resizing) if (resizing)
toplevel->resizing = 0; toplevel->resizing = 0;
struct wlr_box clip = { struct wlr_box clip = {
.x = toplevel->xdg->base->geometry.x, .x = toplevel->xdg->base->geometry.x,
.y = toplevel->xdg->base->geometry.y, .y = toplevel->xdg->base->geometry.y,
.width = toplevel->geom.width - toplevel->bw, .width = toplevel->geom.width - toplevel->bw,
.height = toplevel->geom.height - toplevel->bw, .height = toplevel->geom.height - toplevel->bw,
}; };
wlr_scene_subsurface_tree_set_clip(&toplevel->scene_surface->node, wlr_scene_subsurface_tree_set_clip(&toplevel->scene_surface->node, &clip);
&clip);
} }
src/xwayland.c
+32 -45
View File
@@ -1,71 +1,58 @@
#ifdef XWAYLAND #ifdef XWAYLAND
#include "xwayland.h"
#include "toplevel-handlers.h" #include "toplevel-handlers.h"
#include "toplevel.h" #include "toplevel.h"
#include "types.h" #include "types.h"
#include "xwayland.h"
void void xwayland_activate(struct wl_listener *listener, void *data)
xwayland_activate(struct wl_listener *listener, void *data)
{ {
UNUSED(data); UNUSED(data);
absn_toplevel *toplevel = wl_container_of(listener, toplevel, absn_toplevel *toplevel = wl_container_of(listener, toplevel, xw_activate);
xw_activate);
if (!toplevel_is_unmanaged(toplevel)) if (!toplevel_is_unmanaged(toplevel))
wlr_xwayland_surface_activate(toplevel->xw, 1); wlr_xwayland_surface_activate(toplevel->xw, 1);
} }
void void xwayland_associate(struct wl_listener *listener, void *data)
xwayland_associate(struct wl_listener *listener, void *data)
{ {
UNUSED(data); UNUSED(data);
absn_toplevel *toplevel = wl_container_of(listener, toplevel, absn_toplevel *toplevel = wl_container_of(listener, toplevel, xw_associate);
xw_associate);
LISTEN(toplevel->map, toplevel_map, toplevel->xw->surface->events.map); LISTEN(toplevel->map, toplevel_map, toplevel->xw->surface->events.map);
LISTEN(toplevel->unmap, toplevel_unmap, LISTEN(toplevel->unmap, toplevel_unmap, toplevel->xw->surface->events.unmap);
toplevel->xw->surface->events.unmap);
} }
void void xwayland_dissociate(struct wl_listener *listener, void *data)
xwayland_dissociate(struct wl_listener *listener, void *data)
{ {
UNUSED(data); UNUSED(data);
absn_toplevel *toplevel = wl_container_of(listener, toplevel, absn_toplevel *toplevel = wl_container_of(listener, toplevel, xw_dissociate);
xw_dissociate);
wl_list_remove(&toplevel->map.link); wl_list_remove(&toplevel->map.link);
wl_list_remove(&toplevel->unmap.link); wl_list_remove(&toplevel->unmap.link);
} }
void void xwayland_configure(struct wl_listener *listener, void *data)
xwayland_configure(struct wl_listener *listener, void *data)
{ {
UNUSED(data); UNUSED(data);
absn_toplevel *toplevel = wl_container_of(listener, toplevel, absn_toplevel *toplevel = wl_container_of(listener, toplevel, xw_configure);
xw_configure); struct wlr_xwayland_surface_configure_event *event = data;
struct wlr_xwayland_surface_configure_event *event = data;
if (!toplevel->xw->surface || !toplevel->xw->surface->mapped) { if (!toplevel->xw->surface || !toplevel->xw->surface->mapped) {
wlr_xwayland_surface_configure(toplevel->xw, event->x, event->y, wlr_xwayland_surface_configure(toplevel->xw, event->x, event->y, event->width, event->height);
event->width, event->height); return;
return; }
}
if (toplevel_is_unmanaged(toplevel)) { if (toplevel_is_unmanaged(toplevel)) {
wlr_scene_node_set_position(&toplevel->scene_tree->node, wlr_scene_node_set_position(&toplevel->scene_tree->node, event->x, event->y);
event->x, event->y); wlr_xwayland_surface_configure(toplevel->xw, event->x, event->y, event->width, event->height);
wlr_xwayland_surface_configure(toplevel->xw, event->x, event->y, return;
event->width, event->height); }
return;
}
} }
void void xwayland_set_hints(struct wl_listener *listener, void *data)
xwayland_set_hints(struct wl_listener *listener, void *data)
{ {
UNUSED(listener); UNUSED(listener);
UNUSED(data); UNUSED(data);
} }
#endif #endif