From 2a017bb89521209ba973d2e66fda63d875f14bbe Mon Sep 17 00:00:00 2001 From: Your Name Date: Sat, 28 Oct 2023 18:14:49 +0300 Subject: [PATCH] first --- LICENSE | 13 + Makefile | 18 + config.h | 10 + include/die.h | 9 + include/server.h | 67 ++++ include/structs.h | 13 + protocols/wlr-layer-shell-unstable-v1.xml | 390 ++++++++++++++++++++++ src/die.c | 10 + src/main.c | 33 ++ src/server.c | 50 +++ 10 files changed, 613 insertions(+) create mode 100644 LICENSE create mode 100644 Makefile create mode 100644 config.h create mode 100644 include/die.h create mode 100644 include/server.h create mode 100644 include/structs.h create mode 100644 protocols/wlr-layer-shell-unstable-v1.xml create mode 100644 src/die.c create mode 100644 src/main.c create mode 100644 src/server.c diff --git a/LICENSE b/LICENSE new file mode 100644 index 0000000..456c488 --- /dev/null +++ b/LICENSE @@ -0,0 +1,13 @@ + DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE + Version 2, December 2004 + + Copyright (C) 2004 Sam Hocevar + + Everyone is permitted to copy and distribute verbatim or modified + copies of this license document, and changing it is allowed as long + as the name is changed. + + DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE + TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION + + 0. You just DO WHAT THE FUCK YOU WANT TO. diff --git a/Makefile b/Makefile new file mode 100644 index 0000000..dd4e700 --- /dev/null +++ b/Makefile @@ -0,0 +1,18 @@ +CFLAGS:=-s -O0 -pedantic -Wall -Wextra -DWLR_USE_UNSTABLE +LDFLAGS:=$(shell pkg-config --libs wlroots wayland-server libinput) +CC:=cc + +WAYLAND_SCANNER:=$(shell pkg-config --variable=wayland_scanner wayland-scanner) +WAYLAND_PROTOCOLS:=$(shell pkg-config --variable=pkgdatadir wayland-protocols) + +all: xdg-shell-protocol.h wlr-layer-shell-unstable-v1-protocol.h + $(CC) $(CFLAGS) $(LDFLAGS) src/*.c -Iinclude/ -I. -o micro-wm + +xdg-shell-protocol.h: + $(WAYLAND_SCANNER) server-header $(WAYLAND_PROTOCOLS)/stable/xdg-shell/xdg-shell.xml $@ + +wlr-layer-shell-unstable-v1-protocol.h: + $(WAYLAND_SCANNER) server-header protocols/wlr-layer-shell-unstable-v1.xml $@ + +clean: + rm micro-wm *-protocol.h diff --git a/config.h b/config.h new file mode 100644 index 0000000..ca22e24 --- /dev/null +++ b/config.h @@ -0,0 +1,10 @@ +#ifndef _CONFIG_H +#define _CONFIG_H + +#define LOG_LEVEL WLR_ERROR +static const MonitorRule monrules[] = { + /* [monitor name] [workspace id] [x] [y] [resolution x] [resolution y]*/ + {"VGA-1", 1, -1, -1, 1440, 900} +}; + +#endif diff --git a/include/die.h b/include/die.h new file mode 100644 index 0000000..2bc358d --- /dev/null +++ b/include/die.h @@ -0,0 +1,9 @@ +#ifndef _DIE_H +#define _DIE_H +#include +#include +#include +#include + +void die(const char *msg, int flag); +#endif diff --git a/include/server.h b/include/server.h new file mode 100644 index 0000000..3382c58 --- /dev/null +++ b/include/server.h @@ -0,0 +1,67 @@ +#ifndef _SERVER_H +#define _SERVER_H +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "structs.h" +#include "config.h" +#include "die.h" + +struct server { + struct wl_display *wl_display; + struct wl_event_loop *wl_event_loop; + struct wlr_allocator *alloc; + + struct wlr_backend *backend; + struct wlr_compositor *compositor; + struct wlr_renderer *renderer; + + /* Monitors */ + struct wl_list outputs; +}; + + +void createmon(struct wl_listener *listener, void *data); +static struct wl_listener new_output = {.notify = createmon}; + +void server_init(struct server *server); +#endif diff --git a/include/structs.h b/include/structs.h new file mode 100644 index 0000000..58218dc --- /dev/null +++ b/include/structs.h @@ -0,0 +1,13 @@ +#ifndef _STRUCTS_H +#define _STRUCTS_H + +typedef struct { + const char *name; + int id; + int x; + int y; + int res_x; + int res_y; +} MonitorRule; + +#endif diff --git a/protocols/wlr-layer-shell-unstable-v1.xml b/protocols/wlr-layer-shell-unstable-v1.xml new file mode 100644 index 0000000..d62fd51 --- /dev/null +++ b/protocols/wlr-layer-shell-unstable-v1.xml @@ -0,0 +1,390 @@ + + + + Copyright © 2017 Drew DeVault + + Permission to use, copy, modify, distribute, and sell this + software and its documentation for any purpose is hereby granted + without fee, provided that the above copyright notice appear in + all copies and that both that copyright notice and this permission + notice appear in supporting documentation, and that the name of + the copyright holders not be used in advertising or publicity + pertaining to distribution of the software without specific, + written prior permission. The copyright holders make no + representations about the suitability of this software for any + purpose. It is provided "as is" without express or implied + warranty. + + THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS + SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND + FITNESS, IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY + SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN + AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, + ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF + THIS SOFTWARE. + + + + + Clients can use this interface to assign the surface_layer role to + wl_surfaces. Such surfaces are assigned to a "layer" of the output and + rendered with a defined z-depth respective to each other. They may also be + anchored to the edges and corners of a screen and specify input handling + semantics. This interface should be suitable for the implementation of + many desktop shell components, and a broad number of other applications + that interact with the desktop. + + + + + Create a layer surface for an existing surface. This assigns the role of + layer_surface, or raises a protocol error if another role is already + assigned. + + Creating a layer surface from a wl_surface which has a buffer attached + or committed is a client error, and any attempts by a client to attach + or manipulate a buffer prior to the first layer_surface.configure call + must also be treated as errors. + + After creating a layer_surface object and setting it up, the client + must perform an initial commit without any buffer attached. + The compositor will reply with a layer_surface.configure event. + The client must acknowledge it and is then allowed to attach a buffer + to map the surface. + + You may pass NULL for output to allow the compositor to decide which + output to use. Generally this will be the one that the user most + recently interacted with. + + Clients can specify a namespace that defines the purpose of the layer + surface. + + + + + + + + + + + + + + + + + These values indicate which layers a surface can be rendered in. They + are ordered by z depth, bottom-most first. Traditional shell surfaces + will typically be rendered between the bottom and top layers. + Fullscreen shell surfaces are typically rendered at the top layer. + Multiple surfaces can share a single layer, and ordering within a + single layer is undefined. + + + + + + + + + + + + + This request indicates that the client will not use the layer_shell + object any more. Objects that have been created through this instance + are not affected. + + + + + + + An interface that may be implemented by a wl_surface, for surfaces that + are designed to be rendered as a layer of a stacked desktop-like + environment. + + Layer surface state (layer, size, anchor, exclusive zone, + margin, interactivity) is double-buffered, and will be applied at the + time wl_surface.commit of the corresponding wl_surface is called. + + Attaching a null buffer to a layer surface unmaps it. + + Unmapping a layer_surface means that the surface cannot be shown by the + compositor until it is explicitly mapped again. The layer_surface + returns to the state it had right after layer_shell.get_layer_surface. + The client can re-map the surface by performing a commit without any + buffer attached, waiting for a configure event and handling it as usual. + + + + + Sets the size of the surface in surface-local coordinates. The + compositor will display the surface centered with respect to its + anchors. + + If you pass 0 for either value, the compositor will assign it and + inform you of the assignment in the configure event. You must set your + anchor to opposite edges in the dimensions you omit; not doing so is a + protocol error. Both values are 0 by default. + + Size is double-buffered, see wl_surface.commit. + + + + + + + + Requests that the compositor anchor the surface to the specified edges + and corners. If two orthogonal edges are specified (e.g. 'top' and + 'left'), then the anchor point will be the intersection of the edges + (e.g. the top left corner of the output); otherwise the anchor point + will be centered on that edge, or in the center if none is specified. + + Anchor is double-buffered, see wl_surface.commit. + + + + + + + Requests that the compositor avoids occluding an area with other + surfaces. The compositor's use of this information is + implementation-dependent - do not assume that this region will not + actually be occluded. + + A positive value is only meaningful if the surface is anchored to one + edge or an edge and both perpendicular edges. If the surface is not + anchored, anchored to only two perpendicular edges (a corner), anchored + to only two parallel edges or anchored to all edges, a positive value + will be treated the same as zero. + + A positive zone is the distance from the edge in surface-local + coordinates to consider exclusive. + + Surfaces that do not wish to have an exclusive zone may instead specify + how they should interact with surfaces that do. If set to zero, the + surface indicates that it would like to be moved to avoid occluding + surfaces with a positive exclusive zone. If set to -1, the surface + indicates that it would not like to be moved to accommodate for other + surfaces, and the compositor should extend it all the way to the edges + it is anchored to. + + For example, a panel might set its exclusive zone to 10, so that + maximized shell surfaces are not shown on top of it. A notification + might set its exclusive zone to 0, so that it is moved to avoid + occluding the panel, but shell surfaces are shown underneath it. A + wallpaper or lock screen might set their exclusive zone to -1, so that + they stretch below or over the panel. + + The default value is 0. + + Exclusive zone is double-buffered, see wl_surface.commit. + + + + + + + Requests that the surface be placed some distance away from the anchor + point on the output, in surface-local coordinates. Setting this value + for edges you are not anchored to has no effect. + + The exclusive zone includes the margin. + + Margin is double-buffered, see wl_surface.commit. + + + + + + + + + + Types of keyboard interaction possible for layer shell surfaces. The + rationale for this is twofold: (1) some applications are not interested + in keyboard events and not allowing them to be focused can improve the + desktop experience; (2) some applications will want to take exclusive + keyboard focus. + + + + + This value indicates that this surface is not interested in keyboard + events and the compositor should never assign it the keyboard focus. + + This is the default value, set for newly created layer shell surfaces. + + This is useful for e.g. desktop widgets that display information or + only have interaction with non-keyboard input devices. + + + + + Request exclusive keyboard focus if this surface is above the shell surface layer. + + For the top and overlay layers, the seat will always give + exclusive keyboard focus to the top-most layer which has keyboard + interactivity set to exclusive. If this layer contains multiple + surfaces with keyboard interactivity set to exclusive, the compositor + determines the one receiving keyboard events in an implementation- + defined manner. In this case, no guarantee is made when this surface + will receive keyboard focus (if ever). + + For the bottom and background layers, the compositor is allowed to use + normal focus semantics. + + This setting is mainly intended for applications that need to ensure + they receive all keyboard events, such as a lock screen or a password + prompt. + + + + + This requests the compositor to allow this surface to be focused and + unfocused by the user in an implementation-defined manner. The user + should be able to unfocus this surface even regardless of the layer + it is on. + + Typically, the compositor will want to use its normal mechanism to + manage keyboard focus between layer shell surfaces with this setting + and regular toplevels on the desktop layer (e.g. click to focus). + Nevertheless, it is possible for a compositor to require a special + interaction to focus or unfocus layer shell surfaces (e.g. requiring + a click even if focus follows the mouse normally, or providing a + keybinding to switch focus between layers). + + This setting is mainly intended for desktop shell components (e.g. + panels) that allow keyboard interaction. Using this option can allow + implementing a desktop shell that can be fully usable without the + mouse. + + + + + + + Set how keyboard events are delivered to this surface. By default, + layer shell surfaces do not receive keyboard events; this request can + be used to change this. + + This setting is inherited by child surfaces set by the get_popup + request. + + Layer surfaces receive pointer, touch, and tablet events normally. If + you do not want to receive them, set the input region on your surface + to an empty region. + + Keyboard interactivity is double-buffered, see wl_surface.commit. + + + + + + + This assigns an xdg_popup's parent to this layer_surface. This popup + should have been created via xdg_surface::get_popup with the parent set + to NULL, and this request must be invoked before committing the popup's + initial state. + + See the documentation of xdg_popup for more details about what an + xdg_popup is and how it is used. + + + + + + + When a configure event is received, if a client commits the + surface in response to the configure event, then the client + must make an ack_configure request sometime before the commit + request, passing along the serial of the configure event. + + If the client receives multiple configure events before it + can respond to one, it only has to ack the last configure event. + + A client is not required to commit immediately after sending + an ack_configure request - it may even ack_configure several times + before its next surface commit. + + A client may send multiple ack_configure requests before committing, but + only the last request sent before a commit indicates which configure + event the client really is responding to. + + + + + + + This request destroys the layer surface. + + + + + + The configure event asks the client to resize its surface. + + Clients should arrange their surface for the new states, and then send + an ack_configure request with the serial sent in this configure event at + some point before committing the new surface. + + The client is free to dismiss all but the last configure event it + received. + + The width and height arguments specify the size of the window in + surface-local coordinates. + + The size is a hint, in the sense that the client is free to ignore it if + it doesn't resize, pick a smaller size (to satisfy aspect ratio or + resize in steps of NxM pixels). If the client picks a smaller size and + is anchored to two opposite anchors (e.g. 'top' and 'bottom'), the + surface will be centered on this axis. + + If the width or height arguments are zero, it means the client should + decide its own window dimension. + + + + + + + + + The closed event is sent by the compositor when the surface will no + longer be shown. The output may have been destroyed or the user may + have asked for it to be removed. Further changes to the surface will be + ignored. The client should destroy the resource after receiving this + event, and create a new surface if they so choose. + + + + + + + + + + + + + + + + + + + + + + Change the layer that the surface is rendered on. + + Layer is double-buffered, see wl_surface.commit. + + + + + diff --git a/src/die.c b/src/die.c new file mode 100644 index 0000000..cc6190f --- /dev/null +++ b/src/die.c @@ -0,0 +1,10 @@ +#include "die.h" + +void die(const char *msg, int flag) { + if (flag) + fprintf(stderr, "%s: %s\n", msg, strerror(errno)); + else + puts(msg); + + exit(1); +} diff --git a/src/main.c b/src/main.c new file mode 100644 index 0000000..d6e62ee --- /dev/null +++ b/src/main.c @@ -0,0 +1,33 @@ +#include +#include +#include +#include +#include +#include +#include +#include "server.h" +#include "die.h" + +void destroy(struct server *server) { + wlr_backend_destroy(server->backend); + wl_display_destroy(server->wl_display); +} + +int main(void) { + if (!getenv("XDG_RUNTIME_DIR")) + die("XDG_RUNTIME_DIR must be set", 0); + + int sig[] = {SIGCHLD, SIGINT, SIGTERM, SIGPIPE}; + for (size_t i = 0; i < sizeof(sig) / sizeof(sig[0]); i++) + signal(sig[i], NULL); + + wlr_log_init(LOG_LEVEL, NULL); + + struct server server; + server_init(&server); + + wl_display_run(server.wl_display); + destroy(&server); + + return 0; +} diff --git a/src/server.c b/src/server.c new file mode 100644 index 0000000..53c3e28 --- /dev/null +++ b/src/server.c @@ -0,0 +1,50 @@ +#include "server.h" + +void createmon(struct wl_listener *listener, void *data) { + +} + +void server_init(struct server *server) { + server->wl_display = wl_display_create(); + assert(server->wl_display); + + server->wl_event_loop = wl_display_get_event_loop(server->wl_display); + assert(server->wl_event_loop); + + server->backend = wlr_backend_autocreate(server->wl_display); + assert(server->backend); + + server->renderer = wlr_renderer_autocreate(server->backend); + assert(server->renderer); + + wlr_renderer_init_wl_display(server->renderer, server->wl_display); + + server->alloc = wlr_allocator_autocreate(server->backend, server->renderer); + assert(server->alloc); + + server->compositor = wlr_compositor_create(server->wl_display, server->renderer); + wlr_export_dmabuf_manager_v1_create(server->wl_display); + wlr_screencopy_manager_v1_create(server->wl_display); + wlr_data_control_manager_v1_create(server->wl_display); + wlr_data_device_manager_create(server->wl_display); + wlr_gamma_control_manager_v1_create(server->wl_display); + wlr_primary_selection_v1_device_manager_create(server->wl_display); + wlr_viewporter_create(server->wl_display); + wlr_single_pixel_buffer_manager_v1_create(server->wl_display); + wlr_subcompositor_create(server->wl_display); + + wl_list_init(&server->outputs); + wl_signal_add(&server->backend->events.new_output, &new_output); + + const char *socket = wl_display_add_socket_auto(server->wl_display); + assert(socket); + + printf("Running compositor on wayland display '%s'\n", socket); + setenv("WAYLAND_DISPLAY", socket, 1); + + if (!wlr_backend_start(server->backend)) { + wl_display_destroy(server->wl_display); + die("wlr_backend_start", 1); + } + +}