summaryrefslogtreecommitdiff
path: root/src/drivers/Wayland
diff options
context:
space:
mode:
Diffstat (limited to 'src/drivers/Wayland')
-rw-r--r--src/drivers/Wayland/Fl_Wayland_Copy_Surface_Driver.H34
-rw-r--r--src/drivers/Wayland/Fl_Wayland_Copy_Surface_Driver.cxx60
-rw-r--r--src/drivers/Wayland/Fl_Wayland_Gl_Window_Driver.H62
-rw-r--r--src/drivers/Wayland/Fl_Wayland_Gl_Window_Driver.cxx486
-rw-r--r--src/drivers/Wayland/Fl_Wayland_Graphics_Driver.H72
-rw-r--r--src/drivers/Wayland/Fl_Wayland_Graphics_Driver.cxx310
-rw-r--r--src/drivers/Wayland/Fl_Wayland_Image_Surface_Driver.H40
-rw-r--r--src/drivers/Wayland/Fl_Wayland_Image_Surface_Driver.cxx185
-rw-r--r--src/drivers/Wayland/Fl_Wayland_Screen_Driver.H193
-rw-r--r--src/drivers/Wayland/Fl_Wayland_Screen_Driver.cxx2204
-rw-r--r--src/drivers/Wayland/Fl_Wayland_Window_Driver.H185
-rw-r--r--src/drivers/Wayland/Fl_Wayland_Window_Driver.cxx2191
-rw-r--r--src/drivers/Wayland/fl_wayland_clipboard_dnd.cxx741
-rw-r--r--src/drivers/Wayland/fl_wayland_platform_init.cxx157
14 files changed, 0 insertions, 6920 deletions
diff --git a/src/drivers/Wayland/Fl_Wayland_Copy_Surface_Driver.H b/src/drivers/Wayland/Fl_Wayland_Copy_Surface_Driver.H
deleted file mode 100644
index e10a801ce..000000000
--- a/src/drivers/Wayland/Fl_Wayland_Copy_Surface_Driver.H
+++ /dev/null
@@ -1,34 +0,0 @@
-//
-// Copy-to-clipboard code for the Fast Light Tool Kit (FLTK).
-//
-// Copyright 2022 by Bill Spitzak and others.
-//
-// This library is free software. Distribution and use rights are outlined in
-// the file "COPYING" which should have been included with this file. If this
-// file is missing or damaged, see the license at:
-//
-// https://www.fltk.org/COPYING.php
-//
-// Please see the following page on how to report bugs and issues:
-//
-// https://www.fltk.org/bugs.php
-//
-
-#ifndef FL_WAYLAND_COPY_SURFACE_DRIVER_H
-#define FL_WAYLAND_COPY_SURFACE_DRIVER_H
-
-#include <FL/Fl_Copy_Surface.H>
-#include <FL/Fl_Image_Surface.H>
-
-class Fl_Wayland_Copy_Surface_Driver : public Fl_Copy_Surface_Driver {
- friend class Fl_Copy_Surface_Driver;
- Fl_Image_Surface *img_surf;
-protected:
- Fl_Wayland_Copy_Surface_Driver(int w, int h);
- ~Fl_Wayland_Copy_Surface_Driver();
- void set_current() FL_OVERRIDE;
- void translate(int x, int y) FL_OVERRIDE;
- void untranslate() FL_OVERRIDE;
-};
-
-#endif // FL_WAYLAND_COPY_SURFACE_DRIVER_H
diff --git a/src/drivers/Wayland/Fl_Wayland_Copy_Surface_Driver.cxx b/src/drivers/Wayland/Fl_Wayland_Copy_Surface_Driver.cxx
deleted file mode 100644
index 043114781..000000000
--- a/src/drivers/Wayland/Fl_Wayland_Copy_Surface_Driver.cxx
+++ /dev/null
@@ -1,60 +0,0 @@
-//
-// Copy-to-clipboard code for the Fast Light Tool Kit (FLTK).
-//
-// Copyright 1998-2023 by Bill Spitzak and others.
-//
-// This library is free software. Distribution and use rights are outlined in
-// the file "COPYING" which should have been included with this file. If this
-// file is missing or damaged, see the license at:
-//
-// https://www.fltk.org/COPYING.php
-//
-// Please see the following page on how to report bugs and issues:
-//
-// https://www.fltk.org/bugs.php
-//
-
-#include "Fl_Wayland_Copy_Surface_Driver.H"
-#include <FL/Fl_Image_Surface.H>
-#include "Fl_Wayland_Graphics_Driver.H"
-#include "Fl_Wayland_Screen_Driver.H"
-#include "Fl_Wayland_Window_Driver.H"
-
-
-Fl_Wayland_Copy_Surface_Driver::Fl_Wayland_Copy_Surface_Driver(int w, int h) : Fl_Copy_Surface_Driver(w, h) {
- float os_scale = Fl_Graphics_Driver::default_driver().scale();
- int d = 1;
- if (Fl::first_window()) {
- d = Fl_Wayland_Window_Driver::driver(Fl::first_window())->wld_scale();
- }
- img_surf = new Fl_Image_Surface(int(w * os_scale) * d, int(h * os_scale) * d);
- driver(img_surf->driver());
- driver()->scale(d * os_scale);
-}
-
-
-Fl_Wayland_Copy_Surface_Driver::~Fl_Wayland_Copy_Surface_Driver() {
- Fl_RGB_Image *rgb = img_surf->image();
- Fl_Wayland_Screen_Driver *scr_driver = (Fl_Wayland_Screen_Driver*)Fl::screen_driver();
- scr_driver->copy_image(rgb->array, rgb->data_w(), rgb->data_h());
- delete rgb;
- delete img_surf;
- driver(NULL);
-}
-
-
-void Fl_Wayland_Copy_Surface_Driver::set_current() {
- Fl_Surface_Device::set_current();
- Fl_Cairo_Graphics_Driver *dr = (Fl_Cairo_Graphics_Driver*)driver();
- if (!dr->cr()) dr->set_cairo((cairo_t*)img_surf->offscreen());
-}
-
-
-void Fl_Wayland_Copy_Surface_Driver::translate(int x, int y) {
- ((Fl_Wayland_Graphics_Driver*)driver())->ps_translate(x, y);
-}
-
-
-void Fl_Wayland_Copy_Surface_Driver::untranslate() {
- ((Fl_Wayland_Graphics_Driver*)driver())->ps_untranslate();
-}
diff --git a/src/drivers/Wayland/Fl_Wayland_Gl_Window_Driver.H b/src/drivers/Wayland/Fl_Wayland_Gl_Window_Driver.H
deleted file mode 100644
index ad67c01bf..000000000
--- a/src/drivers/Wayland/Fl_Wayland_Gl_Window_Driver.H
+++ /dev/null
@@ -1,62 +0,0 @@
-//
-// Class Fl_Wayland_Gl_Window_Driver for the Fast Light Tool Kit (FLTK).
-//
-// Copyright 2021-2023 by Bill Spitzak and others.
-//
-// This library is free software. Distribution and use rights are outlined in
-// the file "COPYING" which should have been included with this file. If this
-// file is missing or damaged, see the license at:
-//
-// https://www.fltk.org/COPYING.php
-//
-// Please see the following page on how to report bugs and issues:
-//
-// https://www.fltk.org/bugs.php
-//
-
-#ifndef FL_WAYLAND_GL_WINDOW_DRIVER_H
-#define FL_WAYLAND_GL_WINDOW_DRIVER_H
-
-#include <config.h>
-#if HAVE_GL
-#include "../../Fl_Gl_Window_Driver.H"
-#include <wayland-egl.h>
-#include <EGL/egl.h>
-#include <FL/gl.h>
-
-
-class Fl_Wayland_Gl_Window_Driver : public Fl_Gl_Window_Driver {
- friend Fl_Gl_Window_Driver* Fl_Gl_Window_Driver::newGlWindowDriver(Fl_Gl_Window *);
- friend class Fl_Wayland_Gl_Plugin;
-private:
- static EGLDisplay egl_display;
- struct wl_egl_window *egl_window;
- EGLSurface egl_surface;
- bool need_swap;
- Fl_Wayland_Gl_Window_Driver(Fl_Gl_Window *win);
- float pixels_per_unit() FL_OVERRIDE;
- void make_current_before() FL_OVERRIDE;
- int mode_(int m, const int *a) FL_OVERRIDE;
- void swap_buffers() FL_OVERRIDE;
- void resize(int is_a_resize, int w, int h) FL_OVERRIDE;
- char swap_type() FL_OVERRIDE;
- void swap_interval(int) FL_OVERRIDE;
- int swap_interval() const FL_OVERRIDE;
- Fl_Gl_Choice *find(int m, const int *alistp) FL_OVERRIDE;
- GLContext create_gl_context(Fl_Window* window, const Fl_Gl_Choice* g) FL_OVERRIDE;
- void set_gl_context(Fl_Window* w, GLContext context) FL_OVERRIDE;
- void delete_gl_context(GLContext) FL_OVERRIDE;
- void make_overlay_current() FL_OVERRIDE;
- void redraw_overlay() FL_OVERRIDE;
- void gl_start() FL_OVERRIDE;
- void gl_visual(Fl_Gl_Choice *c) FL_OVERRIDE;
- void init();
- void* GetProcAddress(const char *procName) FL_OVERRIDE;
-public:
- static void surface_frame_done(void *data, struct wl_callback *cb, uint32_t time);
- //virtual bool need_scissor() { return true; } // CONTROL_LEAKING_SUB_GL_WINDOWS
- //void apply_scissor(); // CONTROL_LEAKING_SUB_GL_WINDOWS
-};
-
-#endif // HAVE_GL
-#endif // FL_WAYLAND_GL_WINDOW_DRIVER_H
diff --git a/src/drivers/Wayland/Fl_Wayland_Gl_Window_Driver.cxx b/src/drivers/Wayland/Fl_Wayland_Gl_Window_Driver.cxx
deleted file mode 100644
index d20b941b7..000000000
--- a/src/drivers/Wayland/Fl_Wayland_Gl_Window_Driver.cxx
+++ /dev/null
@@ -1,486 +0,0 @@
-//
-// Class Fl_Wayland_Gl_Window_Driver for the Fast Light Tool Kit (FLTK).
-//
-// Copyright 2021-2023 by Bill Spitzak and others.
-//
-// This library is free software. Distribution and use rights are outlined in
-// the file "COPYING" which should have been included with this file. If this
-// file is missing or damaged, see the license at:
-//
-// https://www.fltk.org/COPYING.php
-//
-// Please see the following page on how to report bugs and issues:
-//
-// https://www.fltk.org/bugs.php
-//
-
-#include <config.h>
-#if HAVE_GL
-#include <FL/platform.H>
-#include <FL/Fl_Image_Surface.H>
-#include "../../Fl_Gl_Choice.H"
-#include "Fl_Wayland_Window_Driver.H"
-#include "Fl_Wayland_Graphics_Driver.H"
-#include "Fl_Wayland_Gl_Window_Driver.H"
-#include "../Posix/Fl_Posix_System_Driver.H"
-#ifdef FLTK_USE_X11
-# include "../X11/Fl_X11_Gl_Window_Driver.H"
-#endif
-#include <wayland-egl.h>
-#include <EGL/egl.h>
-#include <FL/gl.h>
-
-/* Implementation notes about OpenGL drawing on the Wayland platform
-
-* After eglCreateWindowSurface() with attributes {EGL_RENDER_BUFFER, EGL_SINGLE_BUFFER, EGL_NONE},
-eglQueryContext() reports that EGL_RENDER_BUFFER equals EGL_BACK_BUFFER.
-This experiment suggests that the platform only supports double-buffer drawing.
-Consequently, FL_DOUBLE is enforced in all Fl_Gl_Window::mode_ values under Wayland.
-
-* Commented out code marked with CONTROL_LEAKING_SUB_GL_WINDOWS aims to prevent
- sub GL windows from leaking out from their parent by making leaking parts fully transparent.
- This code is commented out because it requires the FL_ALPHA flag to be on
- which not all client applications do.
-*/
-
-// Describes crap needed to create a GLContext.
-class Fl_Wayland_Gl_Choice : public Fl_Gl_Choice {
- friend class Fl_Wayland_Gl_Window_Driver;
-private:
- EGLConfig egl_conf;
-public:
- Fl_Wayland_Gl_Choice(int m, const int *alistp, Fl_Gl_Choice *n) : Fl_Gl_Choice(m, alistp, n) {
- egl_conf = 0;
- }
-};
-
-
-struct gl_start_support { // to support use of gl_start / gl_finish
- struct wl_surface *surface;
- struct wl_subsurface *subsurface;
- struct wl_egl_window *egl_window;
- EGLSurface egl_surface;
-};
-
-
-static EGLConfig wld_egl_conf = NULL;
-static EGLint swap_interval_ = 1;
-static EGLint max_swap_interval = 1000;
-static EGLint min_swap_interval = 0;
-
-
-EGLDisplay Fl_Wayland_Gl_Window_Driver::egl_display = EGL_NO_DISPLAY;
-
-
-Fl_Wayland_Gl_Window_Driver::Fl_Wayland_Gl_Window_Driver(Fl_Gl_Window *win) :
- Fl_Gl_Window_Driver(win) {
- if (egl_display == EGL_NO_DISPLAY) init();
- egl_window = NULL;
- egl_surface = NULL;
- need_swap = false;
-}
-
-
-Fl_Gl_Window_Driver *Fl_Gl_Window_Driver::newGlWindowDriver(Fl_Gl_Window *w)
-{
-#ifdef FLTK_USE_X11
- if (!Fl_Wayland_Screen_Driver::wl_display) return new Fl_X11_Gl_Window_Driver(w);
-#endif
- return new Fl_Wayland_Gl_Window_Driver(w);
-}
-
-
-void Fl_Wayland_Gl_Window_Driver::init() {
- EGLint major, minor;
-
- if (!fl_wl_display()) fl_open_display();
- egl_display = eglGetDisplay((EGLNativeDisplayType) fl_wl_display());
- if (egl_display == EGL_NO_DISPLAY) {
- Fl::fatal("Can't create egl display\n");
- }
-
- if (eglInitialize(egl_display, &major, &minor) != EGL_TRUE) {
- Fl::fatal("Can't initialise egl display\n");
- }
- //printf("EGL major: %d, minor %d\n", major, minor);
- //eglGetConfigs(egl_display, NULL, 0, &configs_count);
- //printf("EGL has %d configs\n", configs_count);
- eglBindAPI(EGL_OPENGL_API);
-}
-
-
-Fl_Gl_Choice *Fl_Wayland_Gl_Window_Driver::find(int m, const int *alistp)
-{
- m |= FL_DOUBLE;
- //if (pWindow->parent()) m |= FL_ALPHA; // CONTROL_LEAKING_SUB_GL_WINDOWS
- Fl_Wayland_Gl_Choice *g = (Fl_Wayland_Gl_Choice*)Fl_Gl_Window_Driver::find_begin(
- m, alistp);
- if (g) return g;
-
- EGLint n;
- EGLint config_attribs[] = {
- EGL_SURFACE_TYPE, EGL_WINDOW_BIT,
- EGL_RED_SIZE, 8,
- EGL_GREEN_SIZE, 8,
- EGL_BLUE_SIZE, 8,
- EGL_RENDERABLE_TYPE, EGL_OPENGL_BIT,
- EGL_DEPTH_SIZE, 0, // set at 11
- EGL_SAMPLE_BUFFERS, 0, // set at 13
- EGL_STENCIL_SIZE, 0, // set at 15
- EGL_ALPHA_SIZE, 0, // set at 17
- EGL_NONE
- };
-
- if (m & FL_DEPTH32)
- config_attribs[11] = 32; // request at least 32 bits
- else if (m & FL_DEPTH)
- config_attribs[11] = 1; // accept any size
-
- if (m & FL_MULTISAMPLE) config_attribs[13] = 1;
- if (m & FL_STENCIL) config_attribs[15] = 1;
- if (m & FL_ALPHA) config_attribs[17] = (m & FL_RGB8) ? 8 : 1;
-
- g = new Fl_Wayland_Gl_Choice(m, alistp, first);
- eglChooseConfig(egl_display, config_attribs, &(g->egl_conf), 1, &n);
- if (n == 0 && (m & FL_MULTISAMPLE)) {
- config_attribs[13] = 0;
- eglChooseConfig(egl_display, config_attribs, &(g->egl_conf), 1, &n);
- }
- if (n == 0) {
- Fl::fatal("failed to choose an EGL config\n");
- }
-
- eglGetConfigAttrib(egl_display, g->egl_conf, EGL_MAX_SWAP_INTERVAL, &max_swap_interval);
- eglGetConfigAttrib(egl_display, g->egl_conf, EGL_MIN_SWAP_INTERVAL, &min_swap_interval);
-
- first = g;
- return g;
-}
-
-
-GLContext Fl_Wayland_Gl_Window_Driver::create_gl_context(Fl_Window* window,
- const Fl_Gl_Choice* g) {
- GLContext shared_ctx = 0;
- if (context_list && nContext) shared_ctx = context_list[0];
-
- static const EGLint context_attribs[] = { EGL_CONTEXT_CLIENT_VERSION, 2, EGL_NONE };
- GLContext ctx = (GLContext)eglCreateContext(egl_display,
- ((Fl_Wayland_Gl_Choice*)g)->egl_conf,
- (shared_ctx ? (EGLContext)shared_ctx : EGL_NO_CONTEXT),
- context_attribs);
-//fprintf(stderr, "eglCreateContext=%p shared_ctx=%p\n", ctx, shared_ctx);
- if (ctx) {
- add_context(ctx);
- /* CONTROL_LEAKING_SUB_GL_WINDOWS
- if (egl_surface) {
- eglMakeCurrent(egl_display, egl_surface, egl_surface, (EGLContext)ctx);
- glClearColor(0., 0., 0., 1.); // set opaque black as starting background color
- apply_scissor();
- }*/
- }
- return ctx;
-}
-
-
-void Fl_Wayland_Gl_Window_Driver::set_gl_context(Fl_Window* w, GLContext context) {
- struct wld_window *win = fl_wl_xid(w);
- if (!win) return;
- Fl_Wayland_Window_Driver *dr = Fl_Wayland_Window_Driver::driver(w);
- EGLSurface target_egl_surface = NULL;
- if (egl_surface) target_egl_surface = egl_surface;
- else if (dr->gl_start_support_) target_egl_surface = dr->gl_start_support_->egl_surface;
- if (!target_egl_surface) { // useful for gl_start()
- dr->gl_start_support_ = new struct gl_start_support;
- float s = Fl::screen_scale(w->screen_num());
- Fl_Wayland_Screen_Driver *scr_driver = (Fl_Wayland_Screen_Driver*)Fl::screen_driver();
- // the GL scene will be a transparent subsurface above the cairo-drawn surface
- dr->gl_start_support_->surface =
- wl_compositor_create_surface(scr_driver->wl_compositor);
- dr->gl_start_support_->subsurface = wl_subcompositor_get_subsurface(
- scr_driver->wl_subcompositor, dr->gl_start_support_->surface, win->wl_surface);
- wl_subsurface_set_position(dr->gl_start_support_->subsurface, w->x() * s, w->y() * s);
- wl_subsurface_place_above(dr->gl_start_support_->subsurface, win->wl_surface);
- dr->gl_start_support_->egl_window = wl_egl_window_create(
- dr->gl_start_support_->surface, w->w() * s, w->h() * s);
- target_egl_surface = dr->gl_start_support_->egl_surface = eglCreateWindowSurface(
- egl_display, wld_egl_conf, dr->gl_start_support_->egl_window, NULL);
- }
- GLContext current_context = eglGetCurrentContext();
- if (context != current_context || w != cached_window) {
- cached_window = w;
- if (eglMakeCurrent(egl_display, target_egl_surface, target_egl_surface,
- (EGLContext)context)) {
-//fprintf(stderr, "EGLContext %p made current\n", context);
- } else {
- Fl::error("eglMakeCurrent() failed\n");
- }
- }
- if (!(mode() & FL_ALPHA)) { // useful at least for Linux on MacBook hardware
- GLfloat vals[4];
- glGetFloatv(GL_COLOR_CLEAR_VALUE, vals);
- if (vals[3] == 0.) glClearColor(vals[0], vals[1], vals[2], 1.);
- }
-}
-
-/* CONTROL_LEAKING_SUB_GL_WINDOWS
-void Fl_Wayland_Gl_Window_Driver::apply_scissor() {
- cairo_rectangle_int_t *extents = Fl_Wayland_Window_Driver::driver(pWindow)->subRect();
- if (extents) {
- glDisable(GL_SCISSOR_TEST);
- GLdouble vals[4];
- glGetDoublev(GL_COLOR_CLEAR_VALUE, vals);
- glClearColor(0., 0., 0., 0.);
- glClear(GL_COLOR_BUFFER_BIT);
- glClearColor(vals[0], vals[1], vals[2], vals[3]);
- float s = pWindow->pixels_per_unit();
- glScissor(s*extents->x, s*extents->y, s*extents->width, s*extents->height);
-//printf("apply_scissor %dx%d %dx%d\n",extents->x, extents->y, extents->width, extents->height);
- glEnable(GL_SCISSOR_TEST);
- }
-}*/
-
-
-void Fl_Wayland_Gl_Window_Driver::delete_gl_context(GLContext context) {
- GLContext current_context = eglGetCurrentContext();
- if (current_context == context) {
- cached_window = 0;
- }
- if (current_context == (EGLContext)context) {
- eglMakeCurrent(egl_display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
- }
- eglDestroyContext(egl_display, (EGLContext)context);
- eglDestroySurface(egl_display, egl_surface);
- egl_surface = NULL;
- wl_egl_window_destroy(egl_window);
- egl_window = NULL;
- del_context(context);
-}
-
-
-void Fl_Wayland_Gl_Window_Driver::make_overlay_current() {
- glDrawBuffer(GL_FRONT);
-}
-
-
-void Fl_Wayland_Gl_Window_Driver::redraw_overlay() {
- pWindow->redraw();
-}
-
-
-void Fl_Wayland_Gl_Window_Driver::make_current_before() {
- if (!egl_window) {
- struct wld_window *win = fl_wl_xid(pWindow);
- struct wl_surface *surface = win->wl_surface;
- int W = pWindow->pixel_w();
- int H = pWindow->pixel_h();
- int scale = Fl_Wayland_Window_Driver::driver(pWindow)->wld_scale();
- egl_window = wl_egl_window_create(surface, (W/scale)*scale, (H/scale)*scale);
- if (egl_window == EGL_NO_SURFACE) {
- Fl::fatal("Can't create egl window with wl_egl_window_create()\n");
- }
- Fl_Wayland_Gl_Choice *g = (Fl_Wayland_Gl_Choice*)this->g();
- egl_surface = eglCreateWindowSurface(egl_display, g->egl_conf, egl_window, NULL);
- wl_surface_set_buffer_scale(surface, scale);
- if (mode() & FL_ALPHA) wl_surface_set_opaque_region(surface, NULL);
- // Tested apps: shape, glpuzzle, cube, fractals, gl_overlay, fullscreen, unittests,
- // OpenGL3-glut-test, OpenGL3test.
- // Tested wayland compositors: mutter, kde-plasma, weston, sway on FreeBSD.
- if (pWindow->parent()) win = fl_wl_xid(pWindow->top_window());
- while (wl_list_empty(&win->outputs)) wl_display_dispatch(fl_wl_display());
- }
-}
-
-
-float Fl_Wayland_Gl_Window_Driver::pixels_per_unit()
-{
- int ns = pWindow->screen_num();
- int wld_scale = (pWindow->shown() ?
- Fl_Wayland_Window_Driver::driver(pWindow)->wld_scale() : 1);
- return wld_scale * Fl::screen_driver()->scale(ns);
-}
-
-
-int Fl_Wayland_Gl_Window_Driver::mode_(int m, const int *a) {
- mode(m | FL_DOUBLE);
- return 1;
-}
-
-
-void Fl_Wayland_Gl_Window_Driver::surface_frame_done(void *data, struct wl_callback *cb, uint32_t time) {
- Fl_Wayland_Gl_Window_Driver *gl_dr = (Fl_Wayland_Gl_Window_Driver *)data;
- wl_callback_destroy(cb);
- struct wld_window *window = fl_wl_xid(gl_dr->pWindow);
- window->frame_cb = NULL;
- if (gl_dr->need_swap) {
- eglSwapBuffers(Fl_Wayland_Gl_Window_Driver::egl_display, gl_dr->egl_surface);
- gl_dr->need_swap = false;
- }
-}
-
-
-static const struct wl_callback_listener surface_frame_listener = {
- .done = Fl_Wayland_Gl_Window_Driver::surface_frame_done,
-};
-
-
-void Fl_Wayland_Gl_Window_Driver::swap_buffers() {
- if (overlay()) {
- static bool overlay_buffer = true;
- int wo = pWindow->pixel_w(), ho = pWindow->pixel_h();
- GLint matrixmode;
- GLfloat pos[4];
- glGetIntegerv(GL_MATRIX_MODE, &matrixmode);
- glGetFloatv(GL_CURRENT_RASTER_POSITION, pos); // save original glRasterPos
- glMatrixMode(GL_PROJECTION); // save proj/model matrices
- glPushMatrix();
- glLoadIdentity();
- glMatrixMode(GL_MODELVIEW);
- glPushMatrix();
- glLoadIdentity();
- glScalef(2.0f/wo, 2.0f/ho, 1.0f);
- glTranslatef(-wo/2.0f, -ho/2.0f, 0.0f); // set transform so 0,0 is bottom/left of window
- glRasterPos2i(0,0); // set glRasterPos to bottom left corner
- {
- // Emulate overlay by doing copypixels
- glReadBuffer(overlay_buffer?GL_BACK:GL_FRONT);
- glDrawBuffer(overlay_buffer?GL_FRONT:GL_BACK);
- overlay_buffer = ! overlay_buffer;
- glCopyPixels(0, 0, wo, ho, GL_COLOR);
- }
- glPopMatrix(); // GL_MODELVIEW // restore model/proj matrices
- glMatrixMode(GL_PROJECTION);
- glPopMatrix();
- glMatrixMode(matrixmode);
- glRasterPos3f(pos[0], pos[1], pos[2]); // restore original glRasterPos
- if (!overlay_buffer) return; // don't call eglSwapBuffers until overlay has been drawn
- }
-
- if (egl_surface) {
- Fl_Window *parent = pWindow->parent() ? pWindow->window() : NULL;
- struct wld_window *parent_xid = parent ? fl_wl_xid(parent) : NULL;
- if (parent_xid) { // issue #967
- struct wld_window *xid = fl_wl_xid(pWindow);
- if (xid->frame_cb) {
- need_swap = true;
- return;
- }
- if (!parent_xid->frame_cb) {
- xid->frame_cb = wl_surface_frame(xid->wl_surface);
- wl_callback_add_listener(xid->frame_cb, &surface_frame_listener, this);
- }
- }
- eglSwapBuffers(Fl_Wayland_Gl_Window_Driver::egl_display, egl_surface);
- need_swap = false;
- }
-}
-
-
-class Fl_Wayland_Gl_Plugin : public Fl_Wayland_Plugin {
-public:
- Fl_Wayland_Gl_Plugin() : Fl_Wayland_Plugin(name()) { }
- const char *name() FL_OVERRIDE { return "gl.wayland.fltk.org"; }
- void do_swap(Fl_Window *w) FL_OVERRIDE {
- Fl_Gl_Window_Driver *gldr = Fl_Gl_Window_Driver::driver(w->as_gl_window());
- if (gldr->overlay() == w) gldr->swap_buffers();
- }
- void invalidate(Fl_Window *w) FL_OVERRIDE {
- w->as_gl_window()->valid(0);
- }
- void terminate() FL_OVERRIDE {
- if (Fl_Wayland_Gl_Window_Driver::egl_display != EGL_NO_DISPLAY) {
- eglTerminate(Fl_Wayland_Gl_Window_Driver::egl_display);
- }
- }
- void destroy(struct gl_start_support *gl_start_support_) FL_OVERRIDE {
- eglDestroySurface(Fl_Wayland_Gl_Window_Driver::egl_display,
- gl_start_support_->egl_surface);
- wl_egl_window_destroy(gl_start_support_->egl_window);
- wl_subsurface_destroy(gl_start_support_->subsurface);
- wl_surface_destroy(gl_start_support_->surface);
- delete gl_start_support_;
- }
-};
-
-
-static Fl_Wayland_Gl_Plugin Gl_Overlay_Plugin;
-
-
-/* CONTROL_LEAKING_SUB_GL_WINDOWS
-static void delayed_scissor(Fl_Wayland_Gl_Window_Driver *dr) {
- dr->apply_scissor();
-}*/
-
-
-void Fl_Wayland_Gl_Window_Driver::resize(int is_a_resize, int W, int H) {
- if (!egl_window) return;
- float f = Fl::screen_scale(pWindow->screen_num());
- int s = Fl_Wayland_Window_Driver::driver(pWindow)->wld_scale();
- W = int(W * f) * s; // W, H must be multiples of int s
- H = int(H * f) * s;
- int W2, H2;
- wl_egl_window_get_attached_size(egl_window, &W2, &H2);
- if (W2 != W || H2 != H) {
- struct wld_window *xid = fl_wl_xid(pWindow);
- if (xid->kind == Fl_Wayland_Window_Driver::DECORATED && !xid->frame_cb) {
- xid->frame_cb = wl_surface_frame(xid->wl_surface);
- wl_callback_add_listener(xid->frame_cb,
- Fl_Wayland_Graphics_Driver::p_surface_frame_listener, xid);
- }
- wl_egl_window_resize(egl_window, W, H, 0, 0);
- wl_surface_set_buffer_scale(xid->wl_surface, s);
- }
- /* CONTROL_LEAKING_SUB_GL_WINDOWS
- if (Fl_Wayland_Window_Driver::driver(pWindow)->subRect()) {
- pWindow->redraw();
- Fl::add_timeout(0.01, (Fl_Timeout_Handler)delayed_scissor, this);
- }*/
-}
-
-
-char Fl_Wayland_Gl_Window_Driver::swap_type() {
- return copy;
-}
-
-
-void Fl_Wayland_Gl_Window_Driver::gl_visual(Fl_Gl_Choice *c) {
- Fl_Gl_Window_Driver::gl_visual(c);
- wld_egl_conf = ((Fl_Wayland_Gl_Choice*)c)->egl_conf;
-}
-
-
-void Fl_Wayland_Gl_Window_Driver::gl_start() {
- float f = Fl::screen_scale(Fl_Window::current()->screen_num());
- int W = Fl_Window::current()->w() * f;
- int H = Fl_Window::current()->h() * f;
- int W2, H2;
- Fl_Wayland_Window_Driver *dr = Fl_Wayland_Window_Driver::driver(Fl_Window::current());
- wl_egl_window_get_attached_size(dr->gl_start_support_->egl_window, &W2, &H2);
- if (W2 != W || H2 != H) {
- wl_egl_window_resize(dr->gl_start_support_->egl_window, W, H, 0, 0);
- }
- glClearColor(0., 0., 0., 0.);
- glClear(GL_COLOR_BUFFER_BIT);
-}
-
-void Fl_Wayland_Gl_Window_Driver::swap_interval(int interval) {
- if (interval < min_swap_interval) interval = min_swap_interval;
- if (interval > max_swap_interval) interval = max_swap_interval;
- if (egl_display && eglSwapInterval(egl_display, interval))
- swap_interval_ = interval;
- // printf("swap_interval_=%d\n",swap_interval_);
-}
-
-
-int Fl_Wayland_Gl_Window_Driver::swap_interval() const {
- return swap_interval_;
-}
-
-
-void* Fl_Wayland_Gl_Window_Driver::GetProcAddress(const char *procName) {
- return Fl_Posix_System_Driver::dlopen_or_dlsym(NULL, procName);
-}
-
-
-FL_EXPORT EGLContext fl_wl_glcontext(GLContext rc) { return (EGLContext)rc; }
-
-#endif // HAVE_GL
diff --git a/src/drivers/Wayland/Fl_Wayland_Graphics_Driver.H b/src/drivers/Wayland/Fl_Wayland_Graphics_Driver.H
deleted file mode 100644
index ac8786a47..000000000
--- a/src/drivers/Wayland/Fl_Wayland_Graphics_Driver.H
+++ /dev/null
@@ -1,72 +0,0 @@
-//
-// Definition of class Fl_Wayland_Graphics_Driver.
-//
-// Copyright 2021-2023 by Bill Spitzak and others.
-//
-// This library is free software. Distribution and use rights are outlined in
-// the file "COPYING" which should have been included with this file. If this
-// file is missing or damaged, see the license at:
-//
-// https://www.fltk.org/COPYING.php
-//
-// Please see the following page on how to report bugs and issues:
-//
-// https://www.fltk.org/bugs.php
-//
-
-/**
- \file Fl_Wayland_Graphics_Driver.H
- \brief Definition of Wayland graphics driver.
- */
-
-#ifndef FL_WAYLAND_GRAPHICS_DRIVER_H
-#define FL_WAYLAND_GRAPHICS_DRIVER_H
-
-#include "../Cairo/Fl_Cairo_Graphics_Driver.H"
-#include <stdint.h> // for uint32_t
-#include <wayland-client.h> // for wl_list
-
-
-class Fl_Wayland_Graphics_Driver : public Fl_Cairo_Graphics_Driver {
-public:
- struct draw_buffer {
- unsigned char *buffer;
- cairo_t *cairo_;
- size_t data_size; // of wl_buffer and buffer
- int stride;
- int width;
- };
- struct wld_buffer {
- struct draw_buffer draw_buffer;
- struct wl_list link; // links all buffers from the same wl_shm_pool
- struct wl_buffer *wl_buffer;
- void *data;
- struct wl_shm_pool *shm_pool;
- bool draw_buffer_needs_commit;
- bool in_use; // true while being committed
- bool released; // true after buffer_release() was called
- };
- struct wld_shm_pool_data { // one record attached to each wl_shm_pool object
- char *pool_memory; // start of mmap'ed memory encapsulated by the wl_shm_pool
- size_t pool_size; // size of encapsulated memory
- struct wl_list buffers; // to list of fl_wld_buffer's from this pool
- };
- static const uint32_t wld_format;
- static struct wl_shm_pool *current_pool;
- static FL_EXPORT const struct wl_callback_listener *p_surface_frame_listener;
- void copy_offscreen(int x, int y, int w, int h, Fl_Offscreen osrc,
- int srcx, int srcy) FL_OVERRIDE;
- void cache_size(Fl_Image *img, int &width, int &height) FL_OVERRIDE;
- static struct wld_buffer *create_wld_buffer(int width, int height, bool with_shm = true);
- static void create_shm_buffer(wld_buffer *buffer);
- static void buffer_release(struct wld_window *window);
- static void buffer_commit(struct wld_window *window, cairo_region_t *r = NULL);
- static void cairo_init(struct draw_buffer *buffer, int width, int height, int stride,
- cairo_format_t format);
- // used by class Fl_Wayland_Gl_Window_Driver
- static FL_EXPORT struct draw_buffer *offscreen_buffer(Fl_Offscreen);
- static const cairo_user_data_key_t key;
- static Fl_Image_Surface *custom_offscreen(int w, int h, struct wld_buffer **buffer);
-};
-
-#endif // FL_WAYLAND_GRAPHICS_DRIVER_H
diff --git a/src/drivers/Wayland/Fl_Wayland_Graphics_Driver.cxx b/src/drivers/Wayland/Fl_Wayland_Graphics_Driver.cxx
deleted file mode 100644
index 5c9539a8c..000000000
--- a/src/drivers/Wayland/Fl_Wayland_Graphics_Driver.cxx
+++ /dev/null
@@ -1,310 +0,0 @@
-//
-// Implementation of the Wayland graphics driver.
-//
-// Copyright 2021-2023 by Bill Spitzak and others.
-//
-// This library is free software. Distribution and use rights are outlined in
-// the file "COPYING" which should have been included with this file. If this
-// file is missing or damaged, see the license at:
-//
-// https://www.fltk.org/COPYING.php
-//
-// Please see the following page on how to report bugs and issues:
-//
-// https://www.fltk.org/bugs.php
-//
-
-#include "Fl_Wayland_Graphics_Driver.H"
-#include "Fl_Wayland_Screen_Driver.H"
-#include "Fl_Wayland_Window_Driver.H"
-#include <FL/Fl_Image_Surface.H>
-#include <sys/mman.h>
-#include <unistd.h> // for close()
-#include <errno.h>
-#include <string.h> // for strerror()
-#include <cairo/cairo.h>
-
-extern "C" {
-# include "../../../libdecor/src/os-compatibility.h" // for libdecor_os_create_anonymous_file()
-}
-
-// used by create_shm_buffer and do_buffer_release
-struct wl_shm_pool *Fl_Wayland_Graphics_Driver::current_pool = NULL;
-
-
-static void do_buffer_release(struct Fl_Wayland_Graphics_Driver::wld_buffer *);
-
-
-static void buffer_release_listener(void *user_data, struct wl_buffer *wl_buffer)
-{
- struct Fl_Wayland_Graphics_Driver::wld_buffer *buffer =
- (struct Fl_Wayland_Graphics_Driver::wld_buffer*)user_data;
- buffer->in_use = false;
- if (buffer->released) do_buffer_release(buffer);
-}
-
-
-static const struct wl_buffer_listener buffer_listener = {
- buffer_release_listener
-};
-
-
-void Fl_Wayland_Graphics_Driver::create_shm_buffer(Fl_Wayland_Graphics_Driver::wld_buffer *buffer) {
- int width = buffer->draw_buffer.width;
- int stride = buffer->draw_buffer.stride;
- int height = buffer->draw_buffer.data_size / stride;
- const size_t default_pool_size = 10000000; // larger pools are possible if needed
- int chunk_offset = 0; // offset to start of available memory in pool
- struct wld_shm_pool_data *pool_data = current_pool ? // data record attached to current pool
- (struct wld_shm_pool_data *)wl_shm_pool_get_user_data(current_pool) : NULL;
- size_t pool_size = current_pool ? pool_data->pool_size : default_pool_size; // current pool size
- if (current_pool && !wl_list_empty(&pool_data->buffers)) {
- // last wld_buffer created from current pool
- struct wld_buffer *record = wl_container_of(pool_data->buffers.next, record, link);
- chunk_offset = ((char*)record->data - pool_data->pool_memory) +
- record->draw_buffer.data_size;
- }
- if (!current_pool || chunk_offset + buffer->draw_buffer.data_size > pool_size) {
- // if true, a new pool is needed
- if (current_pool && wl_list_empty(&pool_data->buffers)) {
- wl_shm_pool_destroy(current_pool);
- /*int err = */munmap(pool_data->pool_memory, pool_data->pool_size);
-// printf("create_shm_buffer munmap(%p)->%d\n", pool_data->pool_memory, err);
- free(pool_data);
- }
- chunk_offset = 0;
- pool_size = default_pool_size;
- if (buffer->draw_buffer.data_size > pool_size)
- pool_size = 2 * buffer->draw_buffer.data_size; // a larger pool is needed
- int fd = libdecor_os_create_anonymous_file(pool_size);
- if (fd < 0) {
- Fl::fatal("libdecor_os_create_anonymous_file failed: %s\n", strerror(errno));
- }
- pool_data = (struct wld_shm_pool_data*)calloc(1, sizeof(struct wld_shm_pool_data));
- pool_data->pool_memory = (char*)mmap(NULL, pool_size, PROT_READ | PROT_WRITE,
- MAP_SHARED, fd, 0);
- if (pool_data->pool_memory == MAP_FAILED) {
- close(fd);
- Fl::fatal("mmap failed: %s\n", strerror(errno));
- }
- Fl_Wayland_Screen_Driver *scr_driver = (Fl_Wayland_Screen_Driver*)Fl::screen_driver();
- current_pool = wl_shm_create_pool(scr_driver->wl_shm, fd, (int32_t)pool_size);
- close(fd); // does not prevent the mmap'ed memory from being used
- //printf("wl_shm_create_pool %p size=%lu\n",pool_data->pool_memory , pool_size);
- pool_data->pool_size = pool_size;
- wl_list_init(&pool_data->buffers);
- wl_shm_pool_set_user_data(current_pool, pool_data);
- }
- buffer->wl_buffer = wl_shm_pool_create_buffer(current_pool, chunk_offset,
- width, height, stride, wld_format);
- wl_buffer_add_listener(buffer->wl_buffer, &buffer_listener, buffer);
- // add this buffer to head of list of current pool's buffers
- wl_list_insert(&pool_data->buffers, &buffer->link);
- buffer->shm_pool = current_pool;
- buffer->data = (void*)(pool_data->pool_memory + chunk_offset);
-//fprintf(stderr, "last=%p chunk_offset=%d ", pool_data->buffers.next, chunk_offset);
-//fprintf(stderr, "create_shm_buffer: %dx%d = %d\n", width, height, size);
-}
-
-
-struct Fl_Wayland_Graphics_Driver::wld_buffer *
- Fl_Wayland_Graphics_Driver::create_wld_buffer(int width, int height, bool with_shm) {
- struct wld_buffer *buffer = (struct wld_buffer*)calloc(1, sizeof(struct wld_buffer));
- int stride = cairo_format_stride_for_width(cairo_format, width);
- cairo_init(&buffer->draw_buffer, width, height, stride, cairo_format);
- buffer->draw_buffer_needs_commit = true;
- if (with_shm) create_shm_buffer(buffer);
- return buffer;
-}
-
-
-// used to support both normal and progressive drawing and for top-level GL windows
-static void surface_frame_done(void *data, struct wl_callback *cb, uint32_t time) {
- struct wld_window *window = (struct wld_window *)data;
- wl_callback_destroy(cb);
- window->frame_cb = NULL;
- if (window->buffer && window->buffer->draw_buffer_needs_commit) {
- Fl_Wayland_Graphics_Driver::buffer_commit(window);
- }
-}
-
-
-static const struct wl_callback_listener surface_frame_listener = {
- .done = surface_frame_done,
-};
-
-
-const struct wl_callback_listener *Fl_Wayland_Graphics_Driver::p_surface_frame_listener =
- &surface_frame_listener;
-
-
-// copy pixels in region r from the Cairo surface to the Wayland buffer
-static void copy_region(struct wld_window *window, cairo_region_t *r) {
- struct Fl_Wayland_Graphics_Driver::wld_buffer *buffer = window->buffer;
- float f = Fl::screen_scale(window->fl_win->screen_num());
- int d = Fl_Wayland_Window_Driver::driver(window->fl_win)->wld_scale();
- int count = cairo_region_num_rectangles(r);
- cairo_rectangle_int_t rect;
- for (int i = 0; i < count; i++) {
- cairo_region_get_rectangle(r, i, &rect);
- int left = d * int(rect.x * f);
- int top = d * int(rect.y * f);
- int right = d * ceil((rect.x + rect.width) * f);
- if (right > d * int(window->fl_win->w() * f)) right = d * int(window->fl_win->w() * f);
- int width = right - left;
- int bottom = d * ceil((rect.y + rect.height) * f);
- if (bottom > d * int(window->fl_win->h() * f)) bottom = d * int(window->fl_win->h() * f);
- int height = bottom - top;
- int offset = top * buffer->draw_buffer.stride + 4 * left;
- int W4 = 4 * width;
- for (int l = 0; l < height; l++) {
- if (offset + W4 >= (int)buffer->draw_buffer.data_size) {
- W4 = buffer->draw_buffer.data_size - offset;
- if (W4 <= 0) break;
- }
- memcpy((uchar*)buffer->data + offset, buffer->draw_buffer.buffer + offset, W4);
- offset += buffer->draw_buffer.stride;
- }
- wl_surface_damage_buffer(window->wl_surface, left, top, width, height);
- }
-}
-
-
-void Fl_Wayland_Graphics_Driver::buffer_commit(struct wld_window *window, cairo_region_t *r)
-{
- if (!window->buffer->wl_buffer) create_shm_buffer(window->buffer);
- cairo_surface_t *surf = cairo_get_target(window->buffer->draw_buffer.cairo_);
- cairo_surface_flush(surf);
- if (r) copy_region(window, r);
- else {
- memcpy(window->buffer->data, window->buffer->draw_buffer.buffer,
- window->buffer->draw_buffer.data_size);
- wl_surface_damage_buffer(window->wl_surface, 0, 0, 1000000, 1000000);
- }
- window->buffer->in_use = true;
- wl_surface_attach(window->wl_surface, window->buffer->wl_buffer, 0, 0);
- wl_surface_set_buffer_scale( window->wl_surface,
- Fl_Wayland_Window_Driver::driver(window->fl_win)->wld_scale() );
- if (!window->covered) { // see issue #878
- window->frame_cb = wl_surface_frame(window->wl_surface);
- wl_callback_add_listener(window->frame_cb, p_surface_frame_listener, window);
- }
- wl_surface_commit(window->wl_surface);
- window->buffer->draw_buffer_needs_commit = false;
-}
-
-
-void Fl_Wayland_Graphics_Driver::cairo_init(struct Fl_Wayland_Graphics_Driver::draw_buffer *buffer,
- int width, int height, int stride,
- cairo_format_t format) {
- buffer->data_size = stride * height;
- buffer->stride = stride;
- buffer->buffer = new uchar[buffer->data_size];
- buffer->width = width;
- cairo_surface_t *surf = cairo_image_surface_create_for_data(buffer->buffer, format,
- width, height, stride);
- if (cairo_surface_status(surf) != CAIRO_STATUS_SUCCESS) {
- Fl::fatal("Can't create Cairo surface with cairo_image_surface_create_for_data()\n");
- return;
- }
- buffer->cairo_ = cairo_create(surf);
- cairo_status_t err;
- if ((err = cairo_status(buffer->cairo_)) != CAIRO_STATUS_SUCCESS) {
- Fl::fatal("Cairo error during cairo_create() %s\n", cairo_status_to_string(err));
- return;
- }
- cairo_surface_destroy(surf);
- memset(buffer->buffer, 0, buffer->data_size); // useful for transparent windows
- cairo_set_source_rgba(buffer->cairo_, .0, .0, .0, 1.0); // Black default color
- cairo_save(buffer->cairo_);
-}
-
-
-// runs when buffer->in_use is false and buffer->released is true
-static void do_buffer_release(struct Fl_Wayland_Graphics_Driver::wld_buffer *buffer) {
- struct wl_shm_pool *my_pool = buffer->shm_pool;
- if (buffer->wl_buffer) {
- struct Fl_Wayland_Graphics_Driver::wld_shm_pool_data *pool_data =
- (struct Fl_Wayland_Graphics_Driver::wld_shm_pool_data*)
- wl_shm_pool_get_user_data(my_pool);
- wl_buffer_destroy(buffer->wl_buffer);
- // remove wld_buffer from list of pool's buffers
- wl_list_remove(&buffer->link);
- if (wl_list_empty(&pool_data->buffers) && my_pool != Fl_Wayland_Graphics_Driver::current_pool) {
- // all buffers from pool are gone
- wl_shm_pool_destroy(my_pool);
- /*int err = */munmap(pool_data->pool_memory, pool_data->pool_size);
- //printf("do_buffer_release munmap(%p)->%d\n", pool_data->pool_memory, err);
- free(pool_data);
- }
- }
- free(buffer);
-}
-
-
-void Fl_Wayland_Graphics_Driver::buffer_release(struct wld_window *window)
-{
- if (window->buffer && !window->buffer->released) {
- window->buffer->released = true;
- if (window->frame_cb) { wl_callback_destroy(window->frame_cb); window->frame_cb = NULL; }
- delete[] window->buffer->draw_buffer.buffer;
- window->buffer->draw_buffer.buffer = NULL;
- cairo_destroy(window->buffer->draw_buffer.cairo_);
- if (!window->buffer->in_use) do_buffer_release(window->buffer);
- window->buffer = NULL;
- }
-}
-
-
-// this refers to the same memory layout for pixel data as does CAIRO_FORMAT_ARGB32
-const uint32_t Fl_Wayland_Graphics_Driver::wld_format = WL_SHM_FORMAT_ARGB8888;
-
-
-void Fl_Wayland_Graphics_Driver::copy_offscreen(int x, int y, int w, int h,
- Fl_Offscreen src, int srcx, int srcy) {
- // draw portion srcx,srcy,w,h of osrc to position x,y (top-left) of
- // the graphics driver's surface
- cairo_matrix_t matrix;
- cairo_get_matrix(cairo_, &matrix);
- double s = matrix.xx;
- cairo_save(cairo_);
- cairo_rectangle(cairo_, x - 0.5, y - 0.5, w, h);
- cairo_set_antialias(cairo_, CAIRO_ANTIALIAS_NONE);
- cairo_clip(cairo_);
- cairo_set_antialias(cairo_, CAIRO_ANTIALIAS_DEFAULT);
- cairo_surface_t *surf = cairo_get_target((cairo_t *)src);
- cairo_pattern_t *pat = cairo_pattern_create_for_surface(surf);
- cairo_set_source(cairo_, pat);
- cairo_matrix_init_scale(&matrix, s, s);
- cairo_matrix_translate(&matrix, -(x - srcx), -(y - srcy));
- cairo_pattern_set_matrix(pat, &matrix);
- cairo_paint(cairo_);
- cairo_pattern_destroy(pat);
- cairo_restore(cairo_);
- surface_needs_commit();
-}
-
-
-const cairo_user_data_key_t Fl_Wayland_Graphics_Driver::key = {};
-
-
-struct Fl_Wayland_Graphics_Driver::draw_buffer*
-Fl_Wayland_Graphics_Driver::offscreen_buffer(Fl_Offscreen offscreen) {
- return (struct draw_buffer*)cairo_get_user_data((cairo_t*)offscreen, &key);
-}
-
-
-Fl_Image_Surface *Fl_Wayland_Graphics_Driver::custom_offscreen(int w, int h,
- struct Fl_Wayland_Graphics_Driver::wld_buffer **p_off) {
- struct wld_buffer *off = create_wld_buffer(w, h);
- *p_off = off;
- cairo_set_user_data(off->draw_buffer.cairo_, &key, &off->draw_buffer, NULL);
- return new Fl_Image_Surface(w, h, 0, (Fl_Offscreen)off->draw_buffer.cairo_);
-}
-
-
-void Fl_Wayland_Graphics_Driver::cache_size(Fl_Image *img, int &width, int &height) {
- Fl_Graphics_Driver::cache_size(img, width, height);
- width *= wld_scale;
- height *= wld_scale;
-}
diff --git a/src/drivers/Wayland/Fl_Wayland_Image_Surface_Driver.H b/src/drivers/Wayland/Fl_Wayland_Image_Surface_Driver.H
deleted file mode 100644
index ae32ac3df..000000000
--- a/src/drivers/Wayland/Fl_Wayland_Image_Surface_Driver.H
+++ /dev/null
@@ -1,40 +0,0 @@
-//
-// Draw-to-image code for the Fast Light Tool Kit (FLTK).
-//
-// Copyright 1998-2022 by Bill Spitzak and others.
-//
-// This library is free software. Distribution and use rights are outlined in
-// the file "COPYING" which should have been included with this file. If this
-// file is missing or damaged, see the license at:
-//
-// https://www.fltk.org/COPYING.php
-//
-// Please see the following page on how to report bugs and issues:
-//
-// https://www.fltk.org/bugs.php
-//
-
-#ifndef FL_WAYLAND_IMAGE_SURFACE_DRIVER_H
-#define FL_WAYLAND_IMAGE_SURFACE_DRIVER_H
-
-#include <FL/Fl_Image_Surface.H>
-
-class Fl_Wayland_Image_Surface_Driver : public Fl_Image_Surface_Driver {
- void end_current() FL_OVERRIDE;
- struct wld_window *pre_window;
-public:
- Fl_Wayland_Image_Surface_Driver(int w, int h, int high_res, Fl_Offscreen off);
- ~Fl_Wayland_Image_Surface_Driver();
- void mask(const Fl_RGB_Image *) FL_OVERRIDE;
- struct shape_data_type {
- double scale;
- cairo_pattern_t *mask_pattern_;
- cairo_t *bg_cr;
- } *shape_data_;
- void set_current() FL_OVERRIDE;
- void translate(int x, int y) FL_OVERRIDE;
- void untranslate() FL_OVERRIDE;
- Fl_RGB_Image *image() FL_OVERRIDE;
-};
-
-#endif // FL_WAYLAND_IMAGE_SURFACE_DRIVER_H
diff --git a/src/drivers/Wayland/Fl_Wayland_Image_Surface_Driver.cxx b/src/drivers/Wayland/Fl_Wayland_Image_Surface_Driver.cxx
deleted file mode 100644
index ec9c56cb7..000000000
--- a/src/drivers/Wayland/Fl_Wayland_Image_Surface_Driver.cxx
+++ /dev/null
@@ -1,185 +0,0 @@
-//
-// Draw-to-image code for the Fast Light Tool Kit (FLTK).
-//
-// Copyright 1998-2023 by Bill Spitzak and others.
-//
-// This library is free software. Distribution and use rights are outlined in
-// the file "COPYING" which should have been included with this file. If this
-// file is missing or damaged, see the license at:
-//
-// https://www.fltk.org/COPYING.php
-//
-// Please see the following page on how to report bugs and issues:
-//
-// https://www.fltk.org/bugs.php
-//
-
-#include <FL/platform.H>
-#include "Fl_Wayland_Graphics_Driver.H"
-#include "Fl_Wayland_Window_Driver.H"
-#include "Fl_Wayland_Image_Surface_Driver.H"
-
-
-Fl_Wayland_Image_Surface_Driver::Fl_Wayland_Image_Surface_Driver(int w, int h,
- int high_res, Fl_Offscreen off) : Fl_Image_Surface_Driver(w, h, high_res, off) {
- shape_data_ = NULL;
- float s = 1;
- int d = 1;
- if (!off) {
- fl_open_display();
- if (Fl::first_window()) {
- d = Fl_Wayland_Window_Driver::driver(Fl::first_window())->wld_scale();
- }
- s = Fl_Graphics_Driver::default_driver().scale();
- if (d*s != 1 && high_res) {
- w = int(w * s) * d;
- h = int(h * s) * d;
- }
- struct Fl_Wayland_Graphics_Driver::draw_buffer *off_ =
- (struct Fl_Wayland_Graphics_Driver::draw_buffer*)calloc(1,
- sizeof(struct Fl_Wayland_Graphics_Driver::draw_buffer));
- Fl_Wayland_Graphics_Driver::cairo_init(off_, w, h,
- cairo_format_stride_for_width(CAIRO_FORMAT_RGB24, w), CAIRO_FORMAT_RGB24);
- offscreen = (Fl_Offscreen)off_->cairo_;
- cairo_set_user_data(off_->cairo_, &Fl_Wayland_Graphics_Driver::key, off_, NULL);
- if (d*s != 1 && high_res) cairo_scale((cairo_t*)offscreen, d*s, d*s);
- }
- driver(new Fl_Wayland_Graphics_Driver());
- if (d*s != 1 && high_res) driver()->scale(d*s);
-}
-
-
-Fl_Wayland_Image_Surface_Driver::~Fl_Wayland_Image_Surface_Driver() {
- if (shape_data_) {
- cairo_surface_t *surf;
- cairo_pattern_get_surface(shape_data_->mask_pattern_, &surf);
- unsigned char *bits = cairo_image_surface_get_data(surf);
- cairo_pattern_destroy(shape_data_->mask_pattern_);
- delete[] bits;
- struct Fl_Wayland_Graphics_Driver::draw_buffer *off_ =
- Fl_Wayland_Graphics_Driver::offscreen_buffer((Fl_Offscreen)shape_data_->bg_cr);
- delete[] off_->buffer;
- free(off_);
- cairo_destroy(shape_data_->bg_cr);
- free(shape_data_);
- }
- if (offscreen && !external_offscreen) {
- struct Fl_Wayland_Graphics_Driver::draw_buffer *buffer =
- Fl_Wayland_Graphics_Driver::offscreen_buffer(offscreen);
- cairo_destroy((cairo_t *)offscreen);
- delete[] buffer->buffer;
- free(buffer);
- }
- delete driver();
-}
-
-
-void Fl_Wayland_Image_Surface_Driver::set_current() {
- Fl_Surface_Device::set_current();
- Fl_Cairo_Graphics_Driver *dr = (Fl_Cairo_Graphics_Driver*)driver();
- if (!dr->cr()) dr->set_cairo((cairo_t*)offscreen);
- pre_window = Fl_Wayland_Window_Driver::wld_window;
- Fl_Wayland_Window_Driver::wld_window = NULL;
- fl_window = 0;
-}
-
-
-void Fl_Wayland_Image_Surface_Driver::end_current() {
- cairo_surface_t *surf = cairo_get_target((cairo_t*)offscreen);
- cairo_surface_flush(surf);
- Fl_Wayland_Window_Driver::wld_window = pre_window;
- fl_window = (Window)pre_window;
- Fl_Surface_Device::end_current();
-}
-
-
-void Fl_Wayland_Image_Surface_Driver::translate(int x, int y) {
- ((Fl_Wayland_Graphics_Driver*)driver())->ps_translate(x, y);
-}
-
-
-void Fl_Wayland_Image_Surface_Driver::untranslate() {
- ((Fl_Wayland_Graphics_Driver*)driver())->ps_untranslate();
-}
-
-
-Fl_RGB_Image* Fl_Wayland_Image_Surface_Driver::image() {
- if (shape_data_ && shape_data_->mask_pattern_) {
- // draw above the secondary offscreen the main offscreen masked by mask_pattern_
- cairo_t *c = ((Fl_Cairo_Graphics_Driver*)driver())->cr();
- cairo_pattern_t *paint_pattern = cairo_pattern_create_for_surface(cairo_get_target(c));
- cairo_set_source(shape_data_->bg_cr, paint_pattern);
- cairo_mask(shape_data_->bg_cr, shape_data_->mask_pattern_);
- cairo_pattern_destroy(paint_pattern);
- // copy secondary offscreen to the main offscreen
- cairo_pattern_t *pat = cairo_pattern_create_for_surface(cairo_get_target(shape_data_->bg_cr));
- cairo_scale(c, shape_data_->scale, shape_data_->scale);
- cairo_set_source(c, pat),
- cairo_paint(c);
- cairo_pattern_destroy(pat);
- // delete secondary offscreen
- cairo_surface_t *surf;
- cairo_pattern_get_surface(shape_data_->mask_pattern_, &surf);
- unsigned char *bits = cairo_image_surface_get_data(surf);
- cairo_pattern_destroy(shape_data_->mask_pattern_);
- delete[] bits;
- struct Fl_Wayland_Graphics_Driver::draw_buffer *off_ =
- Fl_Wayland_Graphics_Driver::offscreen_buffer((Fl_Offscreen)shape_data_->bg_cr);
- delete[] off_->buffer;
- free(off_);
- cairo_destroy(shape_data_->bg_cr);
- free(shape_data_);
- shape_data_ = NULL;
- }
-
- // Convert depth-4 image in draw_buffer to a depth-3 image while exchanging R and B colors
- struct Fl_Wayland_Graphics_Driver::draw_buffer *off_buf =
- Fl_Wayland_Graphics_Driver::offscreen_buffer(offscreen);
- int height = int(off_buf->data_size / off_buf->stride);
- uchar *rgb = new uchar[off_buf->width * height * 3];
- uchar *p = rgb;
- uchar *q;
- for (int j = 0; j < height; j++) {
- q = off_buf->buffer + j*off_buf->stride;
- for (int i = 0; i < off_buf->width; i++) { // exchange R and B colors, transmit G
- *p = *(q+2);
- *(p+1) = *(q+1);
- *(p+2) = *q;
- p += 3; q += 4;
- }
- }
- Fl_RGB_Image *image = new Fl_RGB_Image(rgb, off_buf->width, height, 3);
- image->alloc_array = 1;
- return image;
-}
-
-
-void Fl_Wayland_Image_Surface_Driver::mask(const Fl_RGB_Image *mask) {
- bool using_copy = false;
- shape_data_ = (struct shape_data_type*)calloc(1, sizeof(struct shape_data_type));
- int W, H;
- struct Fl_Wayland_Graphics_Driver::draw_buffer *off_buf =
- Fl_Wayland_Graphics_Driver::offscreen_buffer(offscreen);
- W = off_buf->width;
- H = (int)(off_buf->data_size / off_buf->stride);
- if (W != mask->data_w() || H != mask->data_h()) {
- Fl_RGB_Image *copy = (Fl_RGB_Image*)mask->copy(W, H);
- mask = copy;
- using_copy = true;
- }
- shape_data_->mask_pattern_ = Fl_Cairo_Graphics_Driver::calc_cairo_mask(mask);
- //duplicate current offscreen content to new cairo_t* shape_data_->bg_cr
- int width, height;
- printable_rect(&width, &height);
- struct Fl_Wayland_Graphics_Driver::draw_buffer *off_ =
- (struct Fl_Wayland_Graphics_Driver::draw_buffer*)calloc(1,
- sizeof(struct Fl_Wayland_Graphics_Driver::draw_buffer));
- Fl_Wayland_Graphics_Driver::cairo_init(off_, W, H,
- cairo_format_stride_for_width(CAIRO_FORMAT_RGB24, W),
- CAIRO_FORMAT_RGB24);
- cairo_set_user_data(off_->cairo_, &Fl_Wayland_Graphics_Driver::key, off_, NULL);
- shape_data_->bg_cr = off_->cairo_;
- memcpy(off_->buffer, off_buf->buffer, off_buf->data_size);
- shape_data_->scale = double(width) / W;
- if (using_copy) delete mask;
-}
diff --git a/src/drivers/Wayland/Fl_Wayland_Screen_Driver.H b/src/drivers/Wayland/Fl_Wayland_Screen_Driver.H
deleted file mode 100644
index 83efd79a3..000000000
--- a/src/drivers/Wayland/Fl_Wayland_Screen_Driver.H
+++ /dev/null
@@ -1,193 +0,0 @@
-//
-// Definition of the Wayland Screen interface
-// for the Fast Light Tool Kit (FLTK).
-//
-// Copyright 2010-2026 by Bill Spitzak and others.
-//
-// This library is free software. Distribution and use rights are outlined in
-// the file "COPYING" which should have been included with this file. If this
-// file is missing or damaged, see the license at:
-//
-// https://www.fltk.org/COPYING.php
-//
-// Please see the following page on how to report bugs and issues:
-//
-// https://www.fltk.org/bugs.php
-//
-
-/**
- \file Fl_Wayland_Screen_Driver.H
- \brief Definition of Wayland Screen interface
- */
-
-#ifndef FL_WAYLAND_SCREEN_DRIVER_H
-#define FL_WAYLAND_SCREEN_DRIVER_H
-
-#include <config.h>
-#include "../Unix/Fl_Unix_Screen_Driver.H"
-#include <wayland-client.h>
-
-class Fl_Window;
-
-class Fl_Wayland_Screen_Driver : public Fl_Unix_Screen_Driver
-{
-private:
- static int insertion_point_x;
- static int insertion_point_y;
- static int insertion_point_width;
- static int insertion_point_height;
- static bool insertion_point_location_is_valid;
-public:
-// type definitions
- typedef enum {unspecified, MUTTER, WESTON, KWIN, OWL, WAYFIRE} compositor_name;
- struct seat {
- struct wl_seat *wl_seat;
- struct wl_pointer *wl_pointer;
- struct wl_keyboard *wl_keyboard;
- uint32_t keyboard_enter_serial;
- struct wl_surface *keyboard_surface;
- struct wl_list pointer_outputs;
- struct wl_cursor_theme *cursor_theme;
- struct wl_cursor *default_cursor;
- struct wl_surface *cursor_surface;
- struct wl_surface *pointer_focus;
- int pointer_scale;
- uint32_t serial;
- uint32_t pointer_enter_serial;
- struct wl_data_device_manager *data_device_manager;
- struct wl_data_device *data_device;
- struct wl_data_source *data_source;
- struct xkb_state *xkb_state;
- struct xkb_context *xkb_context;
- struct xkb_keymap *xkb_keymap;
- struct xkb_compose_state *xkb_compose_state;
- char *name;
- struct zwp_text_input_v3 *text_input;
- struct gtk_shell1 *gtk_shell;
- };
- struct output { // one record for each screen
- uint32_t id;
- int x, y; // logical position of screen
- int pixel_width; // in pixels
- int pixel_height; // in pixels
- int width; // in pixels, account for fractional scaling
- int height; // in pixels, account for fractional scaling
- float dpi;
- struct wl_output *wl_output;
- int wld_scale; // Wayland scale factor
- float gui_scale; // FLTK scale factor
- bool done;
- struct wl_list link;
- };
- enum cursor_shapes {arrow = 0, wait, insert, hand, help, cross, move,
- north, south, west, east, north_south, west_east, south_west, south_east, north_east, north_west, nesw, nwse};
- static const int cursor_count = nwse + 1; // nber of elements of 'enum cursor_shapes'
-
-// static member variables
- static FL_EXPORT struct wl_display *wl_display;
- static const struct wl_data_device_listener *p_data_device_listener;
- // next length of marked text after current marked text will have been replaced
- static int next_marked_length;
- static compositor_name compositor; // identifies the used Wayland compositor
-
-// static member functions
- static void insertion_point_location(int x, int y, int height);
- static bool insertion_point_location(int *px, int *py, int *pwidth, int *pheight);
- static bool own_output(struct wl_output *output);
- static void do_set_cursor(struct Fl_Wayland_Screen_Driver::seat *,
- struct wl_cursor *wl_cursor = NULL, Fl_Cursor c = FL_CURSOR_NONE);
-// member variables
- struct wl_cursor *xc_cursor[cursor_count]; // one for each element of enum cursor_shapes
- struct wl_registry *wl_registry;
- struct wl_compositor *wl_compositor;
- struct wl_subcompositor *wl_subcompositor;
- struct wl_shm *wl_shm;
- struct seat *seat;
- struct wl_list outputs; // linked list of struct output records for all screens in system
- struct libdecor *libdecor_context;
- struct xdg_wm_base *xdg_wm_base;
- struct zwp_text_input_manager_v3 *text_input_base;
-#if HAVE_XDG_DIALOG
- struct xdg_wm_dialog_v1 *xdg_wm_dialog;
-#endif
-#if HAVE_CURSOR_SHAPE
- struct wp_cursor_shape_manager_v1 *wp_cursor_shape_manager;
- struct wp_cursor_shape_device_v1 *wp_cursor_shape_device;
-#endif
-
-// constructor
- Fl_Wayland_Screen_Driver();
-
-// overridden functions from parent class Fl_Screen_Driver
- APP_SCALING_CAPABILITY rescalable() FL_OVERRIDE { return PER_SCREEN_APP_SCALING; }
- float scale(int n) FL_OVERRIDE;
- void scale(int n, float f) FL_OVERRIDE;
- // --- screen configuration
- void init() FL_OVERRIDE;
- int x() FL_OVERRIDE;
- int y() FL_OVERRIDE;
- int w() FL_OVERRIDE;
- int h() FL_OVERRIDE;
- void screen_xywh(int &X, int &Y, int &W, int &H, int n) FL_OVERRIDE;
- void screen_dpi(float &h, float &v, int n=0) FL_OVERRIDE;
- void screen_work_area(int &X, int &Y, int &W, int &H, int n) FL_OVERRIDE;
- // --- audible output
- void beep(int type) FL_OVERRIDE;
- // --- global events
- void flush() FL_OVERRIDE;
- void grab(Fl_Window* win) FL_OVERRIDE;
- // --- global colors
- void get_system_colors() FL_OVERRIDE;
- // this one is in fl_wayland_clipboard_dnd.cxx
- int dnd(int unused) FL_OVERRIDE;
- int compose(int &del) FL_OVERRIDE;
- void compose_reset() FL_OVERRIDE;
- Fl_RGB_Image *read_win_rectangle(int X, int Y, int w, int h, Fl_Window *win,
- bool may_capture_subwins, bool *did_capture_subwins) FL_OVERRIDE;
- int get_mouse(int &x, int &y) FL_OVERRIDE;
- void open_display_platform() FL_OVERRIDE;
- void close_display() FL_OVERRIDE;
- void display(const char *d) FL_OVERRIDE;
- // --- compute dimensions of an Fl_Offscreen
- void offscreen_size(Fl_Offscreen o, int &width, int &height) FL_OVERRIDE;
- int has_marked_text() const FL_OVERRIDE;
- // --- clipboard operations
- // this one is in fl_wayland_clipboard_dnd.cxx
- void copy(const char *stuff, int len, int clipboard, const char *type) FL_OVERRIDE;
- // this one is in fl_wayland_clipboard_dnd.cxx
- void paste(Fl_Widget &receiver, int clipboard, const char *type) FL_OVERRIDE;
- // this one is in fl_wayland_clipboard_dnd.cxx
- int clipboard_contains(const char *type) FL_OVERRIDE;
- void set_spot(int font, int height, int x, int y, int w, int h, Fl_Window *win) FL_OVERRIDE;
- void reset_spot() FL_OVERRIDE;
- void *control_maximize_button(void *data) FL_OVERRIDE;
- int event_key(int k) FL_OVERRIDE;
- int get_key(int k) FL_OVERRIDE;
- void enable_im() FL_OVERRIDE;
- void disable_im() FL_OVERRIDE;
- bool screen_boundaries_known() FL_OVERRIDE { return false; }
- float base_scale(int numscreen) FL_OVERRIDE;
-
- // overridden functions from parent class Fl_Unix_Screen_Driver
- int poll_or_select_with_delay(double time_to_wait) FL_OVERRIDE;
- int poll_or_select() FL_OVERRIDE;
-
-// Wayland-specific member functions
- void screen_count_set(int count) {num_screens = count;}
- int screen_count_get() {return num_screens;}
- void reset_cursor();
- // this one is in fl_wayland_clipboard_dnd.cxx
- void copy_image(const unsigned char* data, int W, int H);
- void init_workarea();
- void set_cursor();
- struct wl_cursor *default_cursor();
- void default_cursor(struct wl_cursor *cursor);
- struct wl_cursor *cache_cursor(const char *cursor_name);
- uint32_t get_serial();
- struct wl_seat *get_wl_seat();
- char *get_seat_name();
- struct xkb_keymap *get_xkb_keymap();
-};
-
-
-#endif // FL_WAYLAND_SCREEN_DRIVER_H
diff --git a/src/drivers/Wayland/Fl_Wayland_Screen_Driver.cxx b/src/drivers/Wayland/Fl_Wayland_Screen_Driver.cxx
deleted file mode 100644
index 9199f3a5f..000000000
--- a/src/drivers/Wayland/Fl_Wayland_Screen_Driver.cxx
+++ /dev/null
@@ -1,2204 +0,0 @@
-//
-// Implementation of Wayland Screen interface
-//
-// Copyright 1998-2026 by Bill Spitzak and others.
-//
-// This library is free software. Distribution and use rights are outlined in
-// the file "COPYING" which should have been included with this file. If this
-// file is missing or damaged, see the license at:
-//
-// https://www.fltk.org/COPYING.php
-//
-// Please see the following page on how to report bugs and issues:
-//
-// https://www.fltk.org/bugs.php
-//
-
-#include "Fl_Wayland_Screen_Driver.H"
-#include "Fl_Wayland_Window_Driver.H"
-#include "Fl_Wayland_Graphics_Driver.H"
-#include "../../Fl_Scalable_Graphics_Driver.H"
-#include <wayland-cursor.h>
-#include "../../../libdecor/build/fl_libdecor.h"
-#include "xdg-shell-client-protocol.h"
-#include "../Posix/Fl_Posix_System_Driver.H"
-#include <FL/Fl.H>
-#include <FL/Fl_Image_Surface.H>
-#include <FL/platform.H>
-#include <FL/fl_ask.H>
-#include <FL/filename.H>
-#include <vector>
-#include "../../print_button.h"
-#include <dlfcn.h>
-#include <linux/input.h>
-#include <stdlib.h>
-#include <xkbcommon/xkbcommon.h>
-#include <xkbcommon/xkbcommon-compose.h>
-#include "text-input-client-protocol.h"
-#include "gtk-shell-client-protocol.h"
-#if HAVE_XDG_DIALOG
-# include "xdg-dialog-client-protocol.h"
-#endif
-#if HAVE_CURSOR_SHAPE
-# include "cursor-shape-client-protocol.h"
-#endif
-#include <assert.h>
-#include <sys/mman.h>
-#include <poll.h>
-#include <errno.h>
-#include <string.h> // for strerror()
-#include <map>
-extern "C" {
- bool libdecor_get_cursor_settings(char **theme, int *size);
- bool fl_is_surface_from_GTK_titlebar (struct wl_surface *surface, struct libdecor_frame *frame,
- bool *using_GTK);
-}
-
-// set this to 1 for keyboard debug output, 0 for no debug output
-#define DEBUG_KEYBOARD 0
-
-#define fl_max(a,b) ((a) > (b) ? (a) : (b))
-#define fl_min(a,b) ((a) < (b) ? (a) : (b))
-
-struct pointer_output {
- Fl_Wayland_Screen_Driver::output* output;
- struct wl_list link;
-};
-
-/* Implementation note:
-
-- About CSD and SSD :
- * Mutter and Weston use CSD (client-side decoration) which means that libdecor.so draws all window
- titlebars and responds to resize, minimization and maximization events.
- * KWin uses SSD (server-side decoration) which means the OS draws titlebars according to its own rules
- and triggers resize, minimization and maximization events.
-
-- Function registry_handle_global() runs within fl_open_display() and sets public static variable
- Fl_Wayland_Screen_Driver::compositor to either Fl_Wayland_Screen_Driver::MUTTER, ::WESTON, or ::KWIN.
-
-- Specific operations for WESTON:
- * When a libdecor-framed window is minimized under Weston, the frame remains on display. To avoid
- that, function libdecor_frame_set_minimized() is modified so it turns off the frame's visibility, with
- function libdecor_frame_set_visibility(), when the window is minimized. That's implemented in file
- libdecor/build/fl_libdecor.c. The modified libdecor_frame_set_minimized() function, part of libdecor.so,
- needs access to variable Fl_Wayland_Screen_Driver::compositor, part of libfltk.a. This is achieved
- calling FLTK function fl_libdecor_using_weston() which returns whether the running compositor
- is Weston. This Weston bug has been corrected in Weston version 10. Thus, this special processing
- is not performed when Weston version is ≥ 10.
-
-- Support of Fl_Window::border(int) :
- FLTK uses libdecor_frame_set_visibility() to show or hide a toplevel window's frame. This doesn't work
- with KWin which uses Server-Side Decoration. In that case, FLTK hides and re-shows the window to toggle
- between presence and absence of a window's frame.
-*/
-
-
-static std::vector<int> key_vector; // used by Fl_Wayland_Screen_Driver::event_key()
-static struct wl_surface *gtk_shell_surface = NULL;
-
-Fl_Wayland_Screen_Driver::compositor_name Fl_Wayland_Screen_Driver::compositor =
- Fl_Wayland_Screen_Driver::unspecified;
-
-
-extern "C" {
- bool fl_libdecor_using_weston(void) {
- return Fl_Wayland_Screen_Driver::compositor == Fl_Wayland_Screen_Driver::WESTON;
- }
-}
-
-
-static void xdg_wm_base_ping(void *data, struct xdg_wm_base *xdg_wm_base, uint32_t serial)
-{
- xdg_wm_base_pong(xdg_wm_base, serial);
-}
-
-
-static const struct xdg_wm_base_listener xdg_wm_base_listener = {
- .ping = xdg_wm_base_ping,
-};
-
-
-// these are set by Fl::args() and override any system colors: from Fl_get_system_colors.cxx
-extern const char *fl_fg;
-extern const char *fl_bg;
-extern const char *fl_bg2;
-// end of extern additions workaround
-
-
-void Fl_Wayland_Screen_Driver::do_set_cursor(
- struct Fl_Wayland_Screen_Driver::seat *seat, struct wl_cursor *wl_cursor, Fl_Cursor cursor) {
- /*
- wl_cursor: when non-NULL means a custom cursor;
- when NULL:
- - with "Cursor shape" protocol, cursor is meaningful if != FL_CURSOR_NONE;
- - with old-school cursors, seat->default_cursor gives the desired cursor.
- cursor: used with "Cursor shape" protocol for enumerated cursor shape, otherwise equal to FL_CURSOR_NONE
- */
- struct wl_cursor_image *image;
- struct wl_buffer *buffer;
- const int scale = seat->pointer_scale;
-
-#if HAVE_CURSOR_SHAPE
- static std::map<int, int> cursor_shape_map = {
- {FL_CURSOR_DEFAULT, WP_CURSOR_SHAPE_DEVICE_V1_SHAPE_DEFAULT },
- {FL_CURSOR_ARROW, WP_CURSOR_SHAPE_DEVICE_V1_SHAPE_DEFAULT },
- {FL_CURSOR_CROSS, WP_CURSOR_SHAPE_DEVICE_V1_SHAPE_CROSSHAIR },
- {FL_CURSOR_WAIT, WP_CURSOR_SHAPE_DEVICE_V1_SHAPE_WAIT },
- {FL_CURSOR_INSERT, WP_CURSOR_SHAPE_DEVICE_V1_SHAPE_TEXT },
- {FL_CURSOR_HAND, WP_CURSOR_SHAPE_DEVICE_V1_SHAPE_GRAB },
- {FL_CURSOR_HELP, WP_CURSOR_SHAPE_DEVICE_V1_SHAPE_HELP },
- {FL_CURSOR_MOVE, WP_CURSOR_SHAPE_DEVICE_V1_SHAPE_MOVE },
- {FL_CURSOR_N, WP_CURSOR_SHAPE_DEVICE_V1_SHAPE_N_RESIZE },
- {FL_CURSOR_E, WP_CURSOR_SHAPE_DEVICE_V1_SHAPE_E_RESIZE },
- {FL_CURSOR_W, WP_CURSOR_SHAPE_DEVICE_V1_SHAPE_W_RESIZE },
- {FL_CURSOR_S, WP_CURSOR_SHAPE_DEVICE_V1_SHAPE_S_RESIZE },
- {FL_CURSOR_NS, WP_CURSOR_SHAPE_DEVICE_V1_SHAPE_NS_RESIZE },
- {FL_CURSOR_WE, WP_CURSOR_SHAPE_DEVICE_V1_SHAPE_EW_RESIZE },
- {FL_CURSOR_SW, WP_CURSOR_SHAPE_DEVICE_V1_SHAPE_SW_RESIZE },
- {FL_CURSOR_SE, WP_CURSOR_SHAPE_DEVICE_V1_SHAPE_SE_RESIZE },
- {FL_CURSOR_NE, WP_CURSOR_SHAPE_DEVICE_V1_SHAPE_NE_RESIZE },
- {FL_CURSOR_NW, WP_CURSOR_SHAPE_DEVICE_V1_SHAPE_NW_RESIZE },
- {FL_CURSOR_NESW, WP_CURSOR_SHAPE_DEVICE_V1_SHAPE_NESW_RESIZE },
- {FL_CURSOR_NWSE, WP_CURSOR_SHAPE_DEVICE_V1_SHAPE_NWSE_RESIZE }
- };
- Fl_Wayland_Screen_Driver *scr_driver = (Fl_Wayland_Screen_Driver*)Fl::screen_driver();
- if (scr_driver->wp_cursor_shape_device && !wl_cursor) {
- if (cursor != FL_CURSOR_NONE) wp_cursor_shape_device_v1_set_shape(
- scr_driver->wp_cursor_shape_device, seat->pointer_enter_serial, cursor_shape_map[cursor]);
- return;
- }
-#endif
-
- if ((!seat->cursor_theme && !wl_cursor) || !seat->wl_pointer)
- return;
-
- if (!wl_cursor) wl_cursor = seat->default_cursor;
- image = wl_cursor->images[0];
- buffer = wl_cursor_image_get_buffer(image);
- wl_pointer_set_cursor(seat->wl_pointer, seat->pointer_enter_serial,
- seat->cursor_surface,
- image->hotspot_x / scale,
- image->hotspot_y / scale);
- wl_surface_attach(seat->cursor_surface, buffer, 0, 0);
- wl_surface_set_buffer_scale(seat->cursor_surface, scale);
- wl_surface_damage_buffer(seat->cursor_surface, 0, 0,
- image->width, image->height);
- wl_surface_commit(seat->cursor_surface);
-}
-
-
-static uint32_t ptime;
-static uint32_t wld_event_time;
-static int px, py;
-
-
-static void set_event_xy(Fl_Window *win) {
- // turn off is_click if enough time or mouse movement has passed:
- if (abs(Fl::e_x_root-px)+abs(Fl::e_y_root-py) > 3 ||
- wld_event_time >= ptime+1000) {
- Fl::e_is_click = 0;
-//fprintf(stderr, "Fl::e_is_click = 0\n");
- }
-}
-
-
-// if this is same event as last && is_click, increment click count:
-static inline void checkdouble() {
- if (Fl::e_is_click == Fl::e_keysym) {
- Fl::e_clicks++;
-//fprintf(stderr, "Fl::e_clicks = %d\n", Fl::e_clicks);
- } else {
- Fl::e_clicks = 0;
- Fl::e_is_click = Fl::e_keysym;
-//fprintf(stderr, "Fl::e_is_click = %d\n", Fl::e_is_click);
- }
- px = Fl::e_x_root;
- py = Fl::e_y_root;
- ptime = wld_event_time;
-}
-
-
-struct wl_display *Fl_Wayland_Screen_Driver::wl_display = NULL;
-
-
-static Fl_Window *event_coords_from_surface(struct wl_surface *surface,
- wl_fixed_t surface_x, wl_fixed_t surface_y) {
- Fl_Window *win = Fl_Wayland_Window_Driver::surface_to_window(surface);
- if (!win) return NULL;
- int delta_x = 0, delta_y = 0;
- while (win->parent()) {
- delta_x += win->x();
- delta_y += win->y();
- win = win->window();
- }
- float f = Fl::screen_scale(win->screen_num());
- Fl::e_x = wl_fixed_to_int(surface_x) / f + delta_x;
- Fl::e_x_root = Fl::e_x + win->x();
- Fl::e_y = wl_fixed_to_int(surface_y) / f + delta_y;
- int *poffset = Fl_Window_Driver::menu_offset_y(win);
- if (poffset) Fl::e_y -= *poffset;
- Fl::e_y_root = Fl::e_y + win->y();
- return win;
-}
-
-static Fl_Window *need_leave = NULL;
-
-static void pointer_enter(void *data, struct wl_pointer *wl_pointer, uint32_t serial,
- struct wl_surface *surface, wl_fixed_t surface_x, wl_fixed_t surface_y) {
- struct Fl_Wayland_Screen_Driver::seat *seat = (struct Fl_Wayland_Screen_Driver::seat*)data;
- Fl_Window *win = event_coords_from_surface(surface, surface_x, surface_y);
- static bool using_GTK = seat->gtk_shell &&
- (gtk_shell1_get_version(seat->gtk_shell) >= GTK_SURFACE1_TITLEBAR_GESTURE_SINCE_VERSION);
- if (!win && using_GTK) {
- // check whether surface is the headerbar of a GTK-decorated window
- Fl_X *xp = Fl_X::first;
- while (xp && using_GTK) { // all mapped windows
- struct wld_window *xid = (struct wld_window*)xp->xid;
- if (xid->kind == Fl_Wayland_Window_Driver::DECORATED &&
- fl_is_surface_from_GTK_titlebar(surface, xid->frame, &using_GTK)) {
- gtk_shell_surface = surface;
- break;
- }
- xp = xp->next;
- }
- }
- if (!win) return;
- //fprintf(stderr, "pointer_enter window=%p\n", Fl_Wayland_Window_Driver::surface_to_window(surface));
- seat->pointer_focus = surface;
- // use custom cursor if present
- struct wl_cursor *cursor =
- fl_wl_xid(win)->custom_cursor ? fl_wl_xid(win)->custom_cursor->wl_cursor : NULL;
- seat->serial = serial;
- seat->pointer_enter_serial = serial;
- Fl_Wayland_Screen_Driver::do_set_cursor(seat, cursor, Fl_Wayland_Window_Driver::driver(win)->standard_cursor());
- set_event_xy(win);
- need_leave = NULL;
- win = Fl_Wayland_Window_Driver::surface_to_window(surface);
- // Caution: with an Fl_Tooltip this call can hide the window being entered (#1317)
- if (!win->parent()) Fl::handle(FL_ENTER, win);
-}
-
-
-static void pointer_leave(void *data, struct wl_pointer *wl_pointer,
- uint32_t serial, struct wl_surface *surface) {
- struct Fl_Wayland_Screen_Driver::seat *seat = (struct Fl_Wayland_Screen_Driver::seat*)data;
- if (seat->pointer_focus == surface) seat->pointer_focus = NULL;
- Fl_Window *win = Fl_Wayland_Window_Driver::surface_to_window(surface);
- gtk_shell_surface = NULL;
- if (win) {
- //fprintf(stderr, "pointer_leave window=%p [%s]\n", win, (win->parent()?"sub":"top"));
- set_event_xy(win);
- need_leave = win->top_window(); // we leave a sub or toplevel window
- wl_display_roundtrip(fl_wl_display()); // pointer_enter to other win, if applicable, will run
- if (need_leave) { // we really left the sub-or-top win and did not enter another
- extern Fl_Window *fl_xmousewin;
- fl_xmousewin = 0;
- Fl::handle(FL_LEAVE, need_leave);
- }
- }
-}
-
-
-static void pointer_motion(void *data, struct wl_pointer *wl_pointer,
- uint32_t time, wl_fixed_t surface_x, wl_fixed_t surface_y) {
- struct Fl_Wayland_Screen_Driver::seat *seat =
- (struct Fl_Wayland_Screen_Driver::seat*)data;
- Fl_Window *win = event_coords_from_surface(seat->pointer_focus, surface_x, surface_y);
- if (!win) return;
- if (Fl::grab() && !Fl::grab()->menu_window() && Fl::grab() != win) {
- // If there's an active, non-menu grab() and the pointer is in a window other than
- // the grab(), make e_x_root too large to be in any window
- Fl::e_x_root = 1000000;
- }
- else if (Fl_Window_Driver::menu_parent(NULL) && // any kind of menu is active now, and
- !win->menu_window() && // we enter a non-menu window
- win != Fl_Window_Driver::menu_parent(NULL) // that's not the window below the menu
- ) {
- Fl::e_x_root = 1000000; // make it too large to be in any window
- }
-//fprintf(stderr, "FL_MOVE on win=%p to x:%dx%d root:%dx%d\n", win, Fl::e_x, Fl::e_y, Fl::e_x_root, Fl::e_y_root);
- wld_event_time = time;
- set_event_xy(win);
- Fl::handle(FL_MOVE, win);
-}
-
-
-//#include <FL/names.h>
-static void pointer_button(void *data,
- struct wl_pointer *wl_pointer,
- uint32_t serial,
- uint32_t time,
- uint32_t button,
- uint32_t state)
-{
- struct Fl_Wayland_Screen_Driver::seat *seat =
- (struct Fl_Wayland_Screen_Driver::seat*)data;
- if (gtk_shell_surface && state == WL_POINTER_BUTTON_STATE_PRESSED &&
- button == BTN_MIDDLE) {
- struct gtk_surface1 *gtk_surface = gtk_shell1_get_gtk_surface(seat->gtk_shell,gtk_shell_surface);
- gtk_surface1_titlebar_gesture(gtk_surface, serial, seat->wl_seat,
- GTK_SURFACE1_GESTURE_MIDDLE_CLICK);
- gtk_surface1_release(gtk_surface); // very necessary
- return;
- }
- seat->serial = serial;
- int event = 0;
- Fl_Window *win = Fl_Wayland_Window_Driver::surface_to_window(seat->pointer_focus);
- if (!win) return;
- win = win->top_window();
- wld_event_time = time;
- int b = 0;
- // Fl::e_state &= ~FL_BUTTONS; // DO NOT reset the mouse button state!
- if (state == WL_POINTER_BUTTON_STATE_PRESSED) {
- if (button == BTN_LEFT) { Fl::e_state |= FL_BUTTON1; b = 1; }
- else if (button == BTN_RIGHT) { Fl::e_state |= FL_BUTTON3; b = 3; }
- else if (button == BTN_MIDDLE) { Fl::e_state |= FL_BUTTON2; b = 2; }
- else if (button == BTN_BACK) { Fl::e_state |= FL_BUTTON4; b = 4; } // ?
- else if (button == BTN_SIDE) { Fl::e_state |= FL_BUTTON4; b = 4; } // OK: Debian 12
- else if (button == BTN_FORWARD) { Fl::e_state |= FL_BUTTON5; b = 5; } // ?
- else if (button == BTN_EXTRA) { Fl::e_state |= FL_BUTTON5; b = 5; } // OK: Debian 12
- } else { // must be WL_POINTER_BUTTON_STATE_RELEASED
- if (button == BTN_LEFT) { Fl::e_state &= ~FL_BUTTON1; b = 1; }
- else if (button == BTN_RIGHT) { Fl::e_state &= ~FL_BUTTON3; b = 3; }
- else if (button == BTN_MIDDLE) { Fl::e_state &= ~FL_BUTTON2; b = 2; }
- else if (button == BTN_BACK) { Fl::e_state &= ~FL_BUTTON4; b = 4; } // ?
- else if (button == BTN_SIDE) { Fl::e_state &= ~FL_BUTTON4; b = 4; } // OK: Debian 12
- else if (button == BTN_FORWARD) { Fl::e_state &= ~FL_BUTTON5; b = 5; } // ?
- else if (button == BTN_EXTRA) { Fl::e_state &= ~FL_BUTTON5; b = 5; } // OK: Debian 12
- }
- Fl::e_keysym = FL_Button + b;
- Fl::e_dx = Fl::e_dy = 0;
-
- set_event_xy(win);
- if (state == WL_POINTER_BUTTON_STATE_PRESSED) {
- event = FL_PUSH;
- checkdouble();
- } else if (state == WL_POINTER_BUTTON_STATE_RELEASED) {
- event = FL_RELEASE;
- }
- // fprintf(stderr, "%s %s\n", fl_eventnames[event], win->label() ? win->label():"[]");
- Fl::handle(event, win);
-}
-
-
-static void pointer_axis(void *data, struct wl_pointer *wl_pointer,
- uint32_t time, uint32_t axis, wl_fixed_t value) {
- struct Fl_Wayland_Screen_Driver::seat *seat = (struct Fl_Wayland_Screen_Driver::seat*)data;
- Fl_Window *win = Fl_Wayland_Window_Driver::surface_to_window(seat->pointer_focus);
- if (!win) return;
- wld_event_time = time;
- int delta = wl_fixed_to_int(value);
- if (abs(delta) >= 10) delta /= 10;
- // fprintf(stderr, "FL_MOUSEWHEEL: %c delta=%d\n", axis==WL_POINTER_AXIS_HORIZONTAL_SCROLL?'H':'V', delta);
- // allow both horizontal and vertical movements to be processed by the widget
- if (axis == WL_POINTER_AXIS_HORIZONTAL_SCROLL) {
- if (Fl::event_shift()) { // shift key pressed: send vertical mousewheel event
- Fl::e_dx = 0;
- Fl::e_dy = delta;
- } else { // shift key not pressed (normal behavior): send horizontal mousewheel event
- Fl::e_dx = delta;
- Fl::e_dy = 0;
- }
- Fl::handle(FL_MOUSEWHEEL, win->top_window());
- }
- if (axis == WL_POINTER_AXIS_VERTICAL_SCROLL) {
- if (Fl::event_shift()) { // shift key pressed: send horizontal mousewheel event
- Fl::e_dx = delta;
- Fl::e_dy = 0;
- } else {// shift key not pressed (normal behavior): send vertical mousewheel event
- Fl::e_dx = 0;
- Fl::e_dy = delta;
- }
- Fl::handle(FL_MOUSEWHEEL, win->top_window());
- }
-}
-
-
-static struct wl_pointer_listener pointer_listener = {
- pointer_enter,
- pointer_leave,
- pointer_motion,
- pointer_button,
- pointer_axis
-};
-
-
-static const char *proxy_tag = "FLTK for Wayland";
-
-
-bool Fl_Wayland_Screen_Driver::own_output(struct wl_output *output)
-{
- return wl_proxy_get_tag((struct wl_proxy *)output) == &proxy_tag;
-}
-
-
-static void init_cursors(struct Fl_Wayland_Screen_Driver::seat *seat);
-
-
-static void try_update_cursor(struct Fl_Wayland_Screen_Driver::seat *seat) {
- if (wl_list_empty(&seat->pointer_outputs)) return;
- struct pointer_output *pointer_output;
- int scale = 1;
-
- wl_list_for_each(pointer_output, &seat->pointer_outputs, link) {
- scale = fl_max(scale, pointer_output->output->wld_scale);
- }
-
- if (scale != seat->pointer_scale) {
- seat->pointer_scale = scale;
- init_cursors(seat);
- Fl_Wayland_Screen_Driver::do_set_cursor(seat);
- }
-}
-
-
-static void output_scale(void *data, struct wl_output *wl_output, int32_t factor);
-
-
-static void cursor_surface_enter(void *data,
- struct wl_surface *wl_surface, struct wl_output *wl_output) {
- // Runs when the seat's cursor_surface enters a display
- struct Fl_Wayland_Screen_Driver::seat *seat =
- (struct Fl_Wayland_Screen_Driver::seat*)data;
- struct pointer_output *pointer_output;
-
- if (!Fl_Wayland_Screen_Driver::own_output(wl_output))
- return;
-
- pointer_output = (struct pointer_output *)calloc(1, sizeof(struct pointer_output));
- pointer_output->output =
- (Fl_Wayland_Screen_Driver::output *)wl_output_get_user_data(wl_output);
-//fprintf(stderr, "cursor_surface_enter: wl_output_get_user_data(%p)=%p\n", wl_output, pointer_output->output);
- wl_list_insert(&seat->pointer_outputs, &pointer_output->link);
- try_update_cursor(seat);
- Fl_Wayland_Screen_Driver::output *output =
- (Fl_Wayland_Screen_Driver::output*)wl_output_get_user_data(wl_output);
- output_scale(output, wl_output, output->wld_scale); // rescale custom cursors
- // maintain custom or standard window cursor
- Fl_Window *win = Fl::first_window();
- if (win) {
- Fl_Wayland_Window_Driver *driver = Fl_Wayland_Window_Driver::driver(win);
- struct wld_window *xid = fl_wl_xid(win);
- if (xid->custom_cursor) Fl_Wayland_Screen_Driver::do_set_cursor(seat, xid->custom_cursor->wl_cursor);
- else if (driver->cursor_default()) driver->set_cursor(driver->cursor_default());
- else win->cursor(driver->standard_cursor());
- }
-}
-
-
-static void cursor_surface_leave(void *data, struct wl_surface *wl_surface,
- struct wl_output *wl_output) {
- struct Fl_Wayland_Screen_Driver::seat *seat =
- (struct Fl_Wayland_Screen_Driver::seat*)data;
- struct pointer_output *pointer_output, *tmp;
- wl_list_for_each_safe(pointer_output, tmp, &seat->pointer_outputs, link) {
- if (pointer_output->output->wl_output == wl_output) {
- wl_list_remove(&pointer_output->link);
- free(pointer_output);
- }
- }
- try_update_cursor(seat);
- // maintain custom window cursor
- Fl_Window *win = Fl::first_window();
- if (win) {
- struct wld_window *xid = fl_wl_xid(win);
- if (xid->custom_cursor) Fl_Wayland_Screen_Driver::do_set_cursor(seat, xid->custom_cursor->wl_cursor);
- }
-}
-
-
-static struct wl_surface_listener cursor_surface_listener = {
- cursor_surface_enter,
- cursor_surface_leave,
-};
-
-
-static void init_cursors(struct Fl_Wayland_Screen_Driver::seat *seat) {
- Fl_Wayland_Screen_Driver *scr_driver = (Fl_Wayland_Screen_Driver*)Fl::screen_driver();
- if (!seat->cursor_surface) {
- seat->cursor_surface = wl_compositor_create_surface(scr_driver->wl_compositor);
- wl_surface_add_listener(seat->cursor_surface, &cursor_surface_listener, seat);
- }
-#if HAVE_CURSOR_SHAPE
- if (scr_driver->wp_cursor_shape_manager) return;
-#endif
-
- char *name;
- int size;
- struct wl_cursor_theme *theme;
-
- if (!libdecor_get_cursor_settings(&name, &size)) {
- name = NULL;
- size = 24;
- }
- size *= seat->pointer_scale;
- theme = wl_cursor_theme_load(name, size, scr_driver->wl_shm);
- free(name);
- if (theme != NULL) {
- if (seat->cursor_theme) {
- // caution to destroy theme because Fl_Wayland_Window_Driver::set_cursor(Fl_Cursor) caches used cursors
- scr_driver->reset_cursor();
- wl_cursor_theme_destroy(seat->cursor_theme);
- }
- seat->cursor_theme = theme;
- }
- if (seat->cursor_theme) {
- seat->default_cursor = scr_driver->xc_cursor[Fl_Wayland_Screen_Driver::arrow] =
- wl_cursor_theme_get_cursor(seat->cursor_theme, "left_ptr");
- }
-}
-
-
-static void wl_keyboard_keymap(void *data, struct wl_keyboard *wl_keyboard,
- uint32_t format, int32_t fd, uint32_t size) {
- struct Fl_Wayland_Screen_Driver::seat *seat =
- (struct Fl_Wayland_Screen_Driver::seat*)data;
- assert(format == WL_KEYBOARD_KEYMAP_FORMAT_XKB_V1);
-
- char *map_shm = (char*)mmap(NULL, size, PROT_READ,
- wl_keyboard_get_version(wl_keyboard) >= 7 ? MAP_PRIVATE : MAP_SHARED, fd, 0);
- assert(map_shm != MAP_FAILED);
-
- struct xkb_keymap *xkb_keymap = xkb_keymap_new_from_string(seat->xkb_context, map_shm,
- XKB_KEYMAP_FORMAT_TEXT_V1, XKB_KEYMAP_COMPILE_NO_FLAGS);
- munmap(map_shm, size);
- close(fd);
- if (xkb_keymap) {
- struct xkb_state *xkb_state = xkb_state_new(xkb_keymap);
- xkb_keymap_unref(seat->xkb_keymap);
- if (seat->xkb_state) xkb_state_unref(seat->xkb_state);
- seat->xkb_keymap = xkb_keymap;
- seat->xkb_state = xkb_state;
- }
-}
-
-
-static int search_int_vector(std::vector<int>& v, int val) {
- for (unsigned pos = 0; pos < v.size(); pos++) {
- if (v[pos] == val) return pos;
- }
- return -1;
-}
-
-
-static void remove_int_vector(std::vector<int>& v, int val) {
- int pos = search_int_vector(v, val);
- if (pos < 0) return;
- v.erase(v.begin()+pos);
-}
-
-
-static int process_wld_key(struct xkb_state *xkb_state, uint32_t key,
- uint32_t *p_keycode, xkb_keysym_t *p_sym) {
- uint32_t keycode = key + 8;
- xkb_keysym_t sym = xkb_state_key_get_one_sym(xkb_state, keycode);
- if (sym == 0xfe20) sym = FL_Tab;
- if (sym == 0xffeb) sym = FL_Meta_L; // repair value libxkb gives for FL_Meta_L
- if (sym == 0xffec) sym = FL_Meta_R; // repair value libxkb gives for FL_Meta_R
- if (sym >= 'A' && sym <= 'Z') sym += 32; // replace uppercase by lowercase letter
- int for_key_vector = sym; // for support of Fl::event_key(int)
- // special processing for number keys == keycodes 10-19 :
- if (keycode >= 10 && keycode <= 18) {
- for_key_vector = '1' + (keycode - 10);
- } else if (keycode == 19) {
- for_key_vector = '0';
- }
- if (p_keycode) *p_keycode = keycode;
- if (p_sym) *p_sym = sym;
- return for_key_vector;
-}
-
-
-static uint32_t last_keydown_serial = 0; // serial of last keydown event
-
-
-static void wl_keyboard_enter(void *data, struct wl_keyboard *wl_keyboard,
- uint32_t serial, struct wl_surface *surface, struct wl_array *keys) {
- struct Fl_Wayland_Screen_Driver::seat *seat =
- (struct Fl_Wayland_Screen_Driver::seat*)data;
-//fprintf(stderr, "keyboard enter fl_win=%p; keys pressed are: ", Fl_Wayland_Window_Driver::surface_to_window(surface));
- key_vector.clear();
- // Replace wl_array_for_each(p, keys) rejected by C++
- for (uint32_t *p = (uint32_t *)(keys)->data;
- (const char *) p < ((const char *) (keys)->data + (keys)->size);
- (p)++) {
- int for_key_vector = process_wld_key(seat->xkb_state, *p, NULL, NULL);
-//fprintf(stderr, "%d ", for_key_vector);
- if (search_int_vector(key_vector, for_key_vector) < 0) {
- key_vector.push_back(for_key_vector);
- }
- }
-//fprintf(stderr, "\n");
- seat->keyboard_surface = surface;
- seat->keyboard_enter_serial = serial;
- last_keydown_serial = 0;
- Fl_Window *win = Fl_Wayland_Window_Driver::surface_to_window(surface);
- if (win) {
- Fl::handle(FL_FOCUS, win);
- fl_wl_find(fl_wl_xid(win));
- }
-}
-
-
-struct key_repeat_data_t {
- uint32_t serial;
- Fl_Window *window;
-};
-
-#define KEY_REPEAT_DELAY 0.5 // sec
-#define KEY_REPEAT_INTERVAL 0.05 // sec
-
-
-static void key_repeat_timer_cb(key_repeat_data_t *key_repeat_data) {
- if (last_keydown_serial == key_repeat_data->serial) {
- Fl::handle(FL_KEYDOWN, key_repeat_data->window);
- Fl::add_timeout(KEY_REPEAT_INTERVAL, (Fl_Timeout_Handler)key_repeat_timer_cb, key_repeat_data);
- }
- else delete key_repeat_data;
-}
-
-
-int Fl_Wayland_Screen_Driver::next_marked_length = 0;
-
-
-int Fl_Wayland_Screen_Driver::has_marked_text() const {
- return 1;
-}
-
-
-int Fl_Wayland_Screen_Driver::insertion_point_x = 0;
-int Fl_Wayland_Screen_Driver::insertion_point_y = 0;
-int Fl_Wayland_Screen_Driver::insertion_point_width = 0;
-int Fl_Wayland_Screen_Driver::insertion_point_height = 0;
-bool Fl_Wayland_Screen_Driver::insertion_point_location_is_valid = false;
-
-static int previous_cursor_x = 0, previous_cursor_y = 0, previous_cursor_h = 0;
-static uint32_t commit_serial = 0;
-static char *current_pre_edit = NULL;
-static char *pending_pre_edit = NULL;
-static char *pending_commit = NULL;
-
-
-static void send_commit(struct zwp_text_input_v3 *zwp_text_input_v3) {
- zwp_text_input_v3_commit(zwp_text_input_v3);
- commit_serial++;
-}
-
-
-// inform TIM about location of the insertion point, and memorize this info.
-void Fl_Wayland_Screen_Driver::insertion_point_location(int x, int y, int height) {
-//printf("insertion_point_location %dx%d\n",x,y);
- Fl_Wayland_Screen_Driver *scr_driver = (Fl_Wayland_Screen_Driver*)Fl::screen_driver();
- if (scr_driver->seat->text_input /*&& !current_pre_edit*/ &&
- (x != previous_cursor_x || y != previous_cursor_y || height != previous_cursor_h)) {
- previous_cursor_x = x;
- previous_cursor_y = y;
- previous_cursor_h = height;
- if (Fl::focus()) {
- Fl_Widget *focuswin = Fl::focus()->window();
- while (focuswin && focuswin->parent()) {
- x += focuswin->x(); y += focuswin->y();
- focuswin = focuswin->window();
- }
- }
- float s = fl_graphics_driver->scale();
- insertion_point_location_is_valid = true;
- insertion_point_x = s*x;
- insertion_point_y = s*(y-height);
- insertion_point_width = s*5;
- insertion_point_height = s*height;
- if (zwp_text_input_v3_get_user_data(scr_driver->seat->text_input) ) {
- zwp_text_input_v3_set_cursor_rectangle(scr_driver->seat->text_input,
- insertion_point_x, insertion_point_y,
- insertion_point_width, insertion_point_height);
- send_commit(scr_driver->seat->text_input);
- }
- }
-}
-
-
-// computes window coordinates & size of insertion point
-bool Fl_Wayland_Screen_Driver::insertion_point_location(int *px, int *py,
- int *pwidth, int *pheight) {
- // return true if the current coordinates and size of the insertion point are available
- if ( ! insertion_point_location_is_valid ) return false;
- *px = insertion_point_x;
- *py = insertion_point_y;
- *pwidth = insertion_point_width;
- *pheight = insertion_point_height;
- return true;
-}
-
-
-int Fl_Wayland_Screen_Driver::compose(int& del) {
- unsigned char ascii = (unsigned char)Fl::e_text[0];
- // letter+modifier key
- int condition = (Fl::e_state & (FL_ALT | FL_META | FL_CTRL)) && ascii < 128 ;
- // pressing modifier key
- // FL_Shift_L, FL_Shift_R, FL_Control_L, FL_Control_R, FL_Caps_Lock
- // FL_Meta_L, FL_Meta_R, FL_Alt_L, FL_Alt_R
- condition |= ((Fl::e_keysym >= FL_Shift_L && Fl::e_keysym <= FL_Alt_R) ||
- Fl::e_keysym == FL_Alt_Gr);
- // FL_Home FL_Left FL_Up FL_Right FL_Down FL_Page_Up FL_Page_Down FL_End
- // FL_Print FL_Insert FL_Menu FL_Help and more
- condition |= (Fl::e_keysym >= FL_Home && Fl::e_keysym <= FL_Num_Lock);
- condition |= (Fl::e_keysym >= FL_F && Fl::e_keysym <= FL_F_Last);
- condition |= Fl::e_keysym == FL_Tab || Fl::e_keysym == FL_Scroll_Lock || Fl::e_keysym == FL_Pause;
-//fprintf(stderr, "compose: condition=%d e_state=%x ascii=%d\n", condition, Fl::e_state, ascii);
- if (condition) { del = 0; return 0;}
-//fprintf(stderr, "compose: del=%d compose_state=%d next_marked_length=%d \n", del, Fl::compose_state, next_marked_length);
- del = Fl::compose_state;
- Fl::compose_state = next_marked_length;
- // no-underlined-text && (ascii non-printable || ascii == delete)
- if (ascii && (!Fl::compose_state) && (ascii <= 31 || ascii == 127)) { del = 0; return 0; }
- return 1;
-}
-
-
-void Fl_Wayland_Screen_Driver::compose_reset() {
- if (!Fl_Wayland_Screen_Driver::wl_registry) open_display();
- Fl::compose_state = 0;
- next_marked_length = 0;
- if (seat->xkb_compose_state) xkb_compose_state_reset(seat->xkb_compose_state);
-}
-
-
-struct dead_key_struct {
- xkb_keysym_t keysym; // the keysym obtained when hitting a dead key
- const char *marked_text; // the temporary text to display for that dead key
-};
-
-
-static dead_key_struct dead_keys[] = {
- {XKB_KEY_dead_grave, "`"},
- {XKB_KEY_dead_acute, "´"},
- {XKB_KEY_dead_circumflex, "^"},
- {XKB_KEY_dead_tilde, "~"},
- {XKB_KEY_dead_macron, "¯"},
- {XKB_KEY_dead_breve, "˘"},
- {XKB_KEY_dead_abovedot, "˙"},
- {XKB_KEY_dead_diaeresis, "¨"},
- {XKB_KEY_dead_abovering, "˚"},
- {XKB_KEY_dead_doubleacute, "˝"},
- {XKB_KEY_dead_caron, "ˇ"},
- {XKB_KEY_dead_cedilla, "¸"},
- {XKB_KEY_dead_ogonek, "˛"},
- {XKB_KEY_dead_iota, "ι"},
- {XKB_KEY_dead_doublegrave, " ̏"},
-};
-
-
-const int dead_key_count = sizeof(dead_keys)/sizeof(struct dead_key_struct);
-
-static void wl_keyboard_key(void *data, struct wl_keyboard *wl_keyboard,
- uint32_t serial, uint32_t time, uint32_t key, uint32_t state) {
- struct Fl_Wayland_Screen_Driver::seat *seat =
- (struct Fl_Wayland_Screen_Driver::seat*)data;
- seat->serial = serial;
- static char buf[128];
- uint32_t keycode;
- xkb_keysym_t sym;
- int for_key_vector = process_wld_key(seat->xkb_state, key, &keycode, &sym);
-#if (DEBUG_KEYBOARD)
- xkb_keysym_get_name(sym, buf, sizeof(buf));
- const char *action = (state == WL_KEYBOARD_KEY_STATE_PRESSED ? "press" : "release");
- fprintf(stderr, "wl_keyboard_key: key %s: sym: %-12s(%d) code:%u fl_win=%p, ",
- action, buf, sym, keycode,
- Fl_Wayland_Window_Driver::surface_to_window(seat->keyboard_surface));
-#endif
- xkb_state_key_get_utf8(seat->xkb_state, keycode, buf, sizeof(buf));
-#if (DEBUG_KEYBOARD)
- fprintf(stderr, "utf8: '%s' e_length=%d [%d]\n", buf, (int)strlen(buf), *buf);
-#endif
- Fl::e_keysym = Fl::e_original_keysym = for_key_vector;
- if (!(Fl::e_state & FL_NUM_LOCK) && sym >= XKB_KEY_KP_Home && sym <= XKB_KEY_KP_Delete) {
- // compute e_keysym and e_original_keysym for keypad number keys and '.|,' when NumLock is off
- static const int table[11] = {FL_Home /* 7 */, FL_Left /* 4 */, FL_Up /* 8 */,
- FL_Right /* 6 */, FL_Down /* 2 */, FL_Page_Up /* 9 */,
- FL_Page_Down /* 3 */, FL_End /* 1 */, 0xff0b /* 5 */,
- FL_Insert /* 0 */, FL_Delete /* .|, */};
- static const int table_original[11] = {0xffb7 /* 7 */, 0xffb4 /* 4 */, 0xffb8 /* 8 */,
- 0xffb6 /* 6 */, 0xffb2 /* 2 */, 0xffb9 /* 9 */,
- 0xffb3 /* 3 */, 0xffb1 /* 1 */, 0xffb5 /* 5 */,
- 0xffb0 /* 0 */, 0xffac /* .|, */};
- Fl::e_keysym = table[sym - XKB_KEY_KP_Home];
- Fl::e_original_keysym = table_original[sym - XKB_KEY_KP_Home];
- for_key_vector = Fl::e_original_keysym;
- }
-#if (DEBUG_KEYBOARD)
- fprintf(stderr, "wl_keyboard_key: e_keysym=%x e_original_keysym=%x\n", Fl::e_keysym, Fl::e_original_keysym);
-#endif
- if (state == WL_KEYBOARD_KEY_STATE_PRESSED) {
- if (search_int_vector(key_vector, for_key_vector) < 0) {
- key_vector.push_back(for_key_vector);
- }
- } else {
- last_keydown_serial = 0;
- remove_int_vector(key_vector, for_key_vector);
- }
- Fl::e_text = buf;
- Fl::e_length = (int)strlen(buf);
- // Process dead keys and compose sequences :
- enum xkb_compose_status status = XKB_COMPOSE_NOTHING;
- // This part is useful only if the compositor doesn't support protocol text-input-unstable-v3
- if (seat->xkb_compose_state && state == WL_KEYBOARD_KEY_STATE_PRESSED &&
- !(sym >= FL_Shift_L && sym <= FL_Alt_R) && sym != XKB_KEY_ISO_Level3_Shift) {
- xkb_compose_state_feed(seat->xkb_compose_state, sym);
- status = xkb_compose_state_get_status(seat->xkb_compose_state);
- if (status == XKB_COMPOSE_COMPOSING) {
- if (Fl::e_length == 0) { // dead keys produce e_length = 0
- int i;
- for (i = 0; i < dead_key_count; i++) {
- if (dead_keys[i].keysym == sym) break;
- }
- if (i < dead_key_count) strcpy(buf, dead_keys[i].marked_text);
- else buf[0] = 0;
- Fl::e_length = (int)strlen(buf);
- Fl::compose_state = 0;
- }
- Fl_Wayland_Screen_Driver::next_marked_length = Fl::e_length;
- } else if (status == XKB_COMPOSE_COMPOSED) {
- Fl::e_length = xkb_compose_state_get_utf8(seat->xkb_compose_state, buf, sizeof(buf));
- Fl::compose_state = Fl_Wayland_Screen_Driver::next_marked_length;
- Fl_Wayland_Screen_Driver::next_marked_length = 0;
- } else if (status == XKB_COMPOSE_CANCELLED) {
- Fl::e_length = 0;
- Fl::compose_state = Fl_Wayland_Screen_Driver::next_marked_length;
- Fl_Wayland_Screen_Driver::next_marked_length = 0;
- }
-//fprintf(stderr, "xkb_compose_status=%d ctxt=%p state=%p l=%d[%s]\n", status, seat->xkb_context, seat->xkb_compose_state, Fl::e_length, buf);
- }
- // end of part used only without text-input-unstable-v3
-
- wld_event_time = time;
- int event = (state == WL_KEYBOARD_KEY_STATE_PRESSED ? FL_KEYDOWN : FL_KEYUP);
- // Send event to focus-containing top window as defined by FLTK,
- // otherwise send it to Wayland-defined focus window
- Fl_Window *win = ( Fl::focus() ? Fl::focus()->top_window() :
- Fl_Wayland_Window_Driver::surface_to_window(seat->keyboard_surface) );
- if (win) {
- set_event_xy(win);
- Fl::e_is_click = 0;
- Fl::handle(event, win);
- }
- if (event == FL_KEYDOWN && status == XKB_COMPOSE_NOTHING &&
- !(sym >= FL_Shift_L && sym <= FL_Alt_R)) {
- // Handling of key repeats :
- // Use serial argument rather than time to detect repeated keys because
- // serial value changes at each key up or down in all tested OS and compositors,
- // whereas time value changes in Ubuntu24.04 KDE/Plasma 5.27.11 and Ubuntu22.04 KDE/Plasma 5.24.7
- // but not in Debian-testing KDE/Plasma 5.27.10.
- // Unexplained difference in behaviors of KDE/Plasma compositor:
- // Consider KDE settings -> input -> keyboard -> when a key is held: repeat/do nothing.
- // This setting (repeat) has key-down wayland events repeated when key is held under Debian/KDE
- // but not under Ubuntu/KDE !
- key_repeat_data_t *key_repeat_data = new key_repeat_data_t;
- key_repeat_data->serial = serial;
- key_repeat_data->window = win;
- last_keydown_serial = serial;
- Fl::add_timeout(KEY_REPEAT_DELAY, (Fl_Timeout_Handler)key_repeat_timer_cb,
- key_repeat_data);
- }
-}
-
-
-static void wl_keyboard_leave(void *data, struct wl_keyboard *wl_keyboard,
- uint32_t serial, struct wl_surface *surface) {
- struct Fl_Wayland_Screen_Driver::seat *seat = (struct Fl_Wayland_Screen_Driver::seat*)data;
-//fprintf(stderr, "keyboard leave fl_win=%p\n", Fl_Wayland_Window_Driver::surface_to_window(surface));
- seat->keyboard_surface = NULL;
- last_keydown_serial = 0;
- Fl_Window *win = Fl_Wayland_Window_Driver::surface_to_window(surface);
- if (!win && Fl::focus()) win = Fl::focus()->top_window();
- if (win) Fl::handle(FL_UNFOCUS, win);
- key_vector.clear();
-}
-
-
-static void wl_keyboard_modifiers(void *data, struct wl_keyboard *wl_keyboard,
- uint32_t serial, uint32_t mods_depressed,
- uint32_t mods_latched, uint32_t mods_locked,
- uint32_t group) {
- struct Fl_Wayland_Screen_Driver::seat *seat =
- (struct Fl_Wayland_Screen_Driver::seat*)data;
- xkb_state_update_mask(seat->xkb_state, mods_depressed, mods_latched, mods_locked,
- 0, 0, group);
- Fl::e_state &= ~(FL_SHIFT+FL_CTRL+FL_ALT+FL_META+FL_CAPS_LOCK+FL_NUM_LOCK);
- if (xkb_state_mod_name_is_active(seat->xkb_state, XKB_MOD_NAME_SHIFT,
- XKB_STATE_MODS_DEPRESSED)) Fl::e_state |= FL_SHIFT;
- if (xkb_state_mod_name_is_active(seat->xkb_state, XKB_MOD_NAME_CTRL,
- XKB_STATE_MODS_DEPRESSED)) Fl::e_state |= FL_CTRL;
- if (xkb_state_mod_name_is_active(seat->xkb_state, XKB_MOD_NAME_ALT,
- XKB_STATE_MODS_DEPRESSED)) Fl::e_state |= FL_ALT;
- if (xkb_state_mod_name_is_active(seat->xkb_state, XKB_MOD_NAME_LOGO,
- XKB_STATE_MODS_DEPRESSED)) Fl::e_state |= FL_META;
- if (xkb_state_mod_name_is_active(seat->xkb_state, XKB_MOD_NAME_CAPS,
- XKB_STATE_MODS_LOCKED)) Fl::e_state |= FL_CAPS_LOCK;
- if (xkb_state_mod_name_is_active(seat->xkb_state, XKB_MOD_NAME_NUM,
- XKB_STATE_MODS_LOCKED)) Fl::e_state |= FL_NUM_LOCK;
-//fprintf(stderr, "mods_depressed=%u Fl::e_state=%X\n", mods_depressed, Fl::e_state);
-}
-
-
-static void wl_keyboard_repeat_info(void *data, struct wl_keyboard *wl_keyboard, int32_t rate, int32_t delay)
-{
- // wl_keyboard is version 3 under Debian, but that event isn't sent until version 4
-}
-
-
-static const struct wl_keyboard_listener wl_keyboard_listener = {
- .keymap = wl_keyboard_keymap,
- .enter = wl_keyboard_enter,
- .leave = wl_keyboard_leave,
- .key = wl_keyboard_key,
- .modifiers = wl_keyboard_modifiers,
- .repeat_info = wl_keyboard_repeat_info,
-};
-
-
-void text_input_enter(void *data, struct zwp_text_input_v3 *zwp_text_input_v3,
- struct wl_surface *surface) {
-//puts("text_input_enter");
- zwp_text_input_v3_set_user_data(zwp_text_input_v3, surface);
- zwp_text_input_v3_enable(zwp_text_input_v3);
- zwp_text_input_v3_set_content_type(zwp_text_input_v3, ZWP_TEXT_INPUT_V3_CONTENT_HINT_NONE, ZWP_TEXT_INPUT_V3_CONTENT_PURPOSE_NORMAL);
- int x, y, width, height;
- if (Fl_Wayland_Screen_Driver::insertion_point_location(&x, &y, &width, &height)) {
- zwp_text_input_v3_set_cursor_rectangle(zwp_text_input_v3, x, y, width, height);
- }
- send_commit(zwp_text_input_v3);
-}
-
-
-void text_input_leave(void *data, struct zwp_text_input_v3 *zwp_text_input_v3,
- struct wl_surface *surface) {
-//puts("text_input_leave");
- zwp_text_input_v3_disable(zwp_text_input_v3);
- zwp_text_input_v3_set_user_data(zwp_text_input_v3, NULL);
- send_commit(zwp_text_input_v3);
- free(pending_pre_edit); pending_pre_edit = NULL;
- free(current_pre_edit); current_pre_edit = NULL;
- free(pending_commit); pending_commit = NULL;
-}
-
-
-static void send_text_to_fltk(const char *text, bool is_marked, struct wl_surface *current_surface) {
-//printf("send_text_to_fltk(%s, %d)\n",text,is_marked);
- Fl_Window *win = Fl_Wayland_Window_Driver::surface_to_window(current_surface);
- Fl::e_text = text ? (char*)text : (char*)"";
- Fl::e_length = text ? (int)strlen(text) : 0;
- Fl::e_keysym = 'a'; // fake a simple key
- set_event_xy(win);
- Fl::e_is_click = 0;
- if (is_marked) { // goes to widget as marked text
- Fl_Wayland_Screen_Driver::next_marked_length = Fl::e_length;
- Fl::handle(FL_KEYDOWN, win);
- } else if (text) {
- Fl_Wayland_Screen_Driver::next_marked_length = 0;
- Fl::handle(FL_KEYDOWN, win);
- Fl::compose_state = 0;
- } else {
- Fl_Wayland_Screen_Driver::next_marked_length = 0;
- Fl::handle(FL_KEYDOWN, win);
- }
-}
-
-
-void text_input_preedit_string(void *data, struct zwp_text_input_v3 *zwp_text_input_v3,
- const char *text, int32_t cursor_begin, int32_t cursor_end) {
-//printf("text_input_preedit_string %s cursor_begin=%d cursor_end=%d\n",text, cursor_begin, cursor_end);
- free(pending_pre_edit);
- pending_pre_edit = text ? strdup(text) : NULL;
-}
-
-
-void text_input_commit_string(void *data, struct zwp_text_input_v3 *zwp_text_input_v3,
- const char *text) {
-//printf("text_input_commit_string %s\n",text);
- free(pending_commit);
- pending_commit = (text ? strdup(text) : NULL);
-}
-
-
-void text_input_delete_surrounding_text(void *data,
- struct zwp_text_input_v3 *zwp_text_input_v3,
- uint32_t before_length, uint32_t after_length) {
- fprintf(stderr, "delete_surrounding_text before=%d adfter=%d\n",
- before_length,after_length);
-}
-
-
-void text_input_done(void *data, struct zwp_text_input_v3 *zwp_text_input_v3,
- uint32_t serial) {
-//puts("text_input_done");
- struct wl_surface *current_surface = (struct wl_surface*)data;
- const bool bad_event = (serial != commit_serial);
- if ((pending_pre_edit == NULL && current_pre_edit == NULL) ||
- (pending_pre_edit && current_pre_edit && strcmp(pending_pre_edit, current_pre_edit) == 0)) {
- free(pending_pre_edit); pending_pre_edit = NULL;
- } else {
- free(current_pre_edit);
- current_pre_edit = pending_pre_edit;
- pending_pre_edit = NULL;
- if (current_pre_edit) {
- send_text_to_fltk(current_pre_edit, !bad_event, current_surface);
- } else {
- send_text_to_fltk(NULL, false, current_surface);
- }
- }
- if (pending_commit) {
- send_text_to_fltk(pending_commit, false, current_surface);
- free(pending_commit); pending_commit = NULL;
- }
-}
-
-
-static const struct zwp_text_input_v3_listener text_input_listener = {
- .enter = text_input_enter,
- .leave = text_input_leave,
- .preedit_string = text_input_preedit_string,
- .commit_string = text_input_commit_string,
- .delete_surrounding_text = text_input_delete_surrounding_text,
- .done = text_input_done,
-};
-
-
-void Fl_Wayland_Screen_Driver::enable_im() {
- if (text_input_base && !seat->text_input) {
- seat->text_input = zwp_text_input_manager_v3_get_text_input(text_input_base,
- seat->wl_seat);
- //printf("seat->text_input=%p\n",seat->text_input);
- zwp_text_input_v3_add_listener(seat->text_input, &text_input_listener, NULL);
- }
-}
-
-
-void Fl_Wayland_Screen_Driver::disable_im() {
- if (seat->text_input) {
- zwp_text_input_v3_disable(seat->text_input);
- zwp_text_input_v3_commit(seat->text_input);
- zwp_text_input_v3_destroy(seat->text_input);
- seat->text_input = NULL;
- free(pending_pre_edit); pending_pre_edit = NULL;
- free(current_pre_edit); current_pre_edit = NULL;
- free(pending_commit); pending_commit = NULL;
- }
-}
-
-
-static void seat_capabilities(void *data, struct wl_seat *wl_seat, uint32_t capabilities)
-{
- Fl_Wayland_Screen_Driver *scr_driver = (Fl_Wayland_Screen_Driver*)Fl::screen_driver();
- struct Fl_Wayland_Screen_Driver::seat *seat =
- (struct Fl_Wayland_Screen_Driver::seat*)data;
- if ((capabilities & WL_SEAT_CAPABILITY_POINTER) && !seat->wl_pointer) {
- seat->wl_pointer = wl_seat_get_pointer(wl_seat);
- wl_pointer_add_listener(seat->wl_pointer, &pointer_listener, seat);
- seat->pointer_scale = 1;
-#if HAVE_CURSOR_SHAPE
- if (scr_driver->wp_cursor_shape_manager) {
- scr_driver->wp_cursor_shape_device =
- wp_cursor_shape_manager_v1_get_pointer(scr_driver->wp_cursor_shape_manager, seat->wl_pointer);
- }
-#endif // HAVE_CURSOR_SHAPE
- init_cursors(seat);
- } else if (!(capabilities & WL_SEAT_CAPABILITY_POINTER) && seat->wl_pointer) {
- wl_pointer_release(seat->wl_pointer);
- seat->wl_pointer = NULL;
- }
-
- bool have_keyboard = seat->xkb_context && (capabilities & WL_SEAT_CAPABILITY_KEYBOARD);
- if (have_keyboard && seat->wl_keyboard == NULL) {
- seat->wl_keyboard = wl_seat_get_keyboard(wl_seat);
- wl_keyboard_add_listener(seat->wl_keyboard,
- &wl_keyboard_listener, seat);
-//fprintf(stderr, "wl_keyboard version=%d\n", wl_keyboard_get_version(seat->wl_keyboard));
-
- } else if (!have_keyboard && seat->wl_keyboard != NULL) {
- wl_keyboard_release(seat->wl_keyboard);
- seat->wl_keyboard = NULL;
- }
- scr_driver->enable_im();
-}
-
-
-static void seat_name(void *data, struct wl_seat *wl_seat, const char *name) {
- struct Fl_Wayland_Screen_Driver::seat *seat = (struct Fl_Wayland_Screen_Driver::seat*)data;
- seat->name = strdup(name);
-}
-
-
-static struct wl_seat_listener seat_listener = {
- seat_capabilities,
- seat_name
-};
-
-
-static void output_geometry(void *data,
- struct wl_output *wl_output,
- int32_t x,
- int32_t y,
- int32_t physical_width,
- int32_t physical_height,
- int32_t subpixel,
- const char *make,
- const char *model,
- int32_t transform)
-{
- //fprintf(stderr, "output_geometry: x=%d y=%d physical=%dx%d\n",x,y,physical_width,physical_height);
- Fl_Wayland_Screen_Driver::output *output = (Fl_Wayland_Screen_Driver::output*)data;
- output->x = int(x);
- output->y = int(y);
- output->dpi = 96; // to elaborate
-}
-
-
-static void output_mode(void *data, struct wl_output *wl_output, uint32_t flags,
- int32_t width, int32_t height, int32_t refresh)
-{
- Fl_Wayland_Screen_Driver::output *output = (Fl_Wayland_Screen_Driver::output*)data;
- output->pixel_width = int(width);
- output->pixel_height = int(height);
- output->width = output->pixel_width; // until further notice
- output->height = output->pixel_height;
-//fprintf(stderr, "output_mode: [%p]=%dx%d\n",output->wl_output,width,height);
-}
-
-
-static void output_done(void *data, struct wl_output *wl_output)
-{
- // Runs at startup and when desktop scale factor is changed or screen added
- Fl_Wayland_Screen_Driver::output *output = (Fl_Wayland_Screen_Driver::output*)data;
-//fprintf(stderr, "output_done output=%p\n",output);
- Fl_X *xp = Fl_X::first;
- while (xp) { // all mapped windows
- struct wld_window *win = (struct wld_window*)xp->xid;
- Fl_Window *W = win->fl_win;
- if (win->buffer || W->as_gl_window()) {
- if (W->as_gl_window()) {
- wl_surface_set_buffer_scale(win->wl_surface, output->wld_scale);
- Fl_Window_Driver::driver(W)->is_a_rescale(true);
- W->resize(W->x(), W->y(), W->w(), W->h());
- Fl_Window_Driver::driver(W)->is_a_rescale(false);
- } else {
- Fl_Wayland_Graphics_Driver::buffer_release(win);
- }
- W->redraw();
- Fl_Window_Driver::driver(W)->flush();
- }
- xp = xp->next;
- }
- output->done = true;
-
- Fl_Wayland_Screen_Driver *scr_driver = (Fl_Wayland_Screen_Driver*)Fl::screen_driver();
- if (scr_driver->screen_count_get() > 0) { // true when output_done runs after initial screen dectection
- scr_driver->screen_count_set( wl_list_length(&(scr_driver->outputs)) );
- scr_driver->init_workarea();
- }
-}
-
-
-static void output_scale(void *data, struct wl_output *wl_output, int32_t factor) {
- Fl_Wayland_Screen_Driver::output *output = (Fl_Wayland_Screen_Driver::output*)data;
- output->wld_scale = factor;
-//fprintf(stderr,"output_scale: wl_output=%p factor=%d\n",wl_output, factor);
- // rescale cursors of windows that map here and have a custom cursor
- Fl_Window *win = Fl::first_window();
- while (win) {
- struct wld_window *xid = fl_wl_xid(win);
- struct Fl_Wayland_Window_Driver::surface_output *s_output;
- // get 1st screen where window appears
- s_output = wl_container_of(xid->outputs.next, s_output, link);
- if (xid->custom_cursor && output == s_output->output) {
- Fl_Wayland_Window_Driver *driver = Fl_Wayland_Window_Driver::driver(win);
- driver->set_cursor_4args(xid->custom_cursor->rgb,
- xid->custom_cursor->hotx, xid->custom_cursor->hoty, false);
- };
- win = Fl::next_window(win);
- }
-}
-
-
-static struct wl_output_listener output_listener = {
- output_geometry,
- output_mode,
- output_done,
- output_scale
-};
-
-
-struct pair_bool {
- bool found_gtk_shell;
- bool found_wf_shell;
-};
-
-
-// Notice: adding use of unstable protocol "XDG output" would allow FLTK to be notified
-// in real time of changes to the relative location of multiple displays;
-// with the present code, that information is received at startup only.
-static void registry_handle_global(void *user_data, struct wl_registry *wl_registry,
- uint32_t id, const char *interface, uint32_t version) {
-//fprintf(stderr, "interface=%s version=%u\n", interface, version);
- Fl_Wayland_Screen_Driver *scr_driver = (Fl_Wayland_Screen_Driver*)Fl::screen_driver();
- if (strcmp(interface, "wl_compositor") == 0) {
- if (version < 4) {
- Fl::fatal("wl_compositor version >= 4 required");
- }
- scr_driver->wl_compositor = (struct wl_compositor*)wl_registry_bind(wl_registry,
- id, &wl_compositor_interface, 4);
-
- } else if (strcmp(interface, "wl_subcompositor") == 0) {
- scr_driver->wl_subcompositor = (struct wl_subcompositor*)wl_registry_bind(wl_registry,
- id, &wl_subcompositor_interface, 1);
-
- } else if (strcmp(interface, "wl_shm") == 0) {
- scr_driver->wl_shm = (struct wl_shm*)wl_registry_bind(wl_registry,
- id, &wl_shm_interface, 1);
-
- } else if (strcmp(interface, "wl_seat") == 0) {
- if (version < 3) {
- Fl::fatal("%s version 3 required but only version %i is available\n",
- interface, version);
- }
- if (!scr_driver->seat) scr_driver->seat =
- (struct Fl_Wayland_Screen_Driver::seat*)calloc(1,
- sizeof(struct Fl_Wayland_Screen_Driver::seat));
-//fprintf(stderr, "registry_handle_global: seat=%p\n", scr_driver->seat);
- wl_list_init(&scr_driver->seat->pointer_outputs);
- scr_driver->seat->wl_seat = (wl_seat*)wl_registry_bind(wl_registry, id,
- &wl_seat_interface, 3);
- scr_driver->seat->xkb_context = xkb_context_new(XKB_CONTEXT_NO_FLAGS);
- if (scr_driver->seat->xkb_context) {
- const char *locale = getenv("LC_ALL");
- if (!locale || !*locale)
- locale = getenv("LC_CTYPE");
- if (!locale || !*locale)
- locale = getenv("LANG");
- if (!locale || !*locale)
- locale = "C";
- struct xkb_compose_table *table =
- xkb_compose_table_new_from_locale(scr_driver->seat->xkb_context, locale,
- XKB_COMPOSE_COMPILE_NO_FLAGS);
- if (table) {
- scr_driver->seat->xkb_compose_state =
- xkb_compose_state_new(table, XKB_COMPOSE_STATE_NO_FLAGS);
- }
- }
- wl_seat_add_listener(scr_driver->seat->wl_seat, &seat_listener, scr_driver->seat);
- if (scr_driver->seat->data_device_manager) {
- scr_driver->seat->data_device =
- wl_data_device_manager_get_data_device(scr_driver->seat->data_device_manager,
- scr_driver->seat->wl_seat);
- wl_data_device_add_listener(scr_driver->seat->data_device,
- Fl_Wayland_Screen_Driver::p_data_device_listener, NULL);
- }
-
- } else if (strcmp(interface, wl_data_device_manager_interface.name) == 0) {
- if (!scr_driver->seat) scr_driver->seat =
- (struct Fl_Wayland_Screen_Driver::seat*)calloc(1,
- sizeof(struct Fl_Wayland_Screen_Driver::seat));
- scr_driver->seat->data_device_manager =
- (struct wl_data_device_manager*)wl_registry_bind(wl_registry, id,
- &wl_data_device_manager_interface,
- fl_min(version, 3));
- if (scr_driver->seat->wl_seat) {
- scr_driver->seat->data_device =
- wl_data_device_manager_get_data_device(scr_driver->seat->data_device_manager,
- scr_driver->seat->wl_seat);
- wl_data_device_add_listener(scr_driver->seat->data_device,
- Fl_Wayland_Screen_Driver::p_data_device_listener, NULL);
- }
-//fprintf(stderr, "registry_handle_global: %s\n", interface);
-
- } else if (strcmp(interface, "wl_output") == 0) {
- if (version < 2) {
- Fl::fatal("%s version 2 required but only version %i is available\n",
- interface, version);
- }
- Fl_Wayland_Screen_Driver::output *output =
- (Fl_Wayland_Screen_Driver::output*)calloc(1, sizeof *output);
- output->id = id;
- output->wld_scale = 1;
-#ifdef WL_OUTPUT_RELEASE_SINCE_VERSION
- const int used_version = WL_OUTPUT_RELEASE_SINCE_VERSION;
-#else
- const int used_version = 2;
-#endif
- output->wl_output = (struct wl_output*)wl_registry_bind(wl_registry,
- id, &wl_output_interface, fl_min(used_version, version));
- output->gui_scale = 1.f;
- wl_proxy_set_tag((struct wl_proxy *) output->wl_output, &proxy_tag);
- wl_output_add_listener(output->wl_output, &output_listener, output);
- // Put new screen in list of screens, but make sure it's not in list already
- // which may occur after having removed a screen.
- bool found = false;
- Fl_Wayland_Screen_Driver::output *elt;
- wl_list_for_each(elt, &scr_driver->outputs, link) {
- if (elt == output) found = true;
- }
- if (!found) { // add to end of the linked list of displays
- struct wl_list *e = &scr_driver->outputs;
- while (e->next != &scr_driver->outputs) e = e->next; // move e to end of linked list
- wl_list_insert(e, &output->link);
- }
-//fprintf(stderr, "wl_output: id=%d wl_output=%p \n", id, output->wl_output);
-
- } else if (strcmp(interface, xdg_wm_base_interface.name) == 0) {
-//fprintf(stderr, "registry_handle_global interface=%s\n", interface);
- scr_driver->xdg_wm_base = (struct xdg_wm_base *)wl_registry_bind(wl_registry, id,
- &xdg_wm_base_interface, 1);
- xdg_wm_base_add_listener(scr_driver->xdg_wm_base, &xdg_wm_base_listener, NULL);
- } else if (strstr(interface, "wf_shell_manager")) {
- ((pair_bool*)user_data)->found_wf_shell = true;
- } else if (strcmp(interface, "gtk_shell1") == 0) {
- ((pair_bool*)user_data)->found_gtk_shell = true;
- //fprintf(stderr, "Running the Mutter compositor\n");
- scr_driver->seat->gtk_shell = (struct gtk_shell1*)wl_registry_bind(wl_registry, id,
- &gtk_shell1_interface, version);
- } else if (strcmp(interface, "weston_desktop_shell") == 0) {
- Fl_Wayland_Screen_Driver::compositor = Fl_Wayland_Screen_Driver::WESTON;
- //fprintf(stderr, "Running the Weston compositor\n");
- } else if (strcmp(interface, "org_kde_plasma_shell") == 0) {
- Fl_Wayland_Screen_Driver::compositor = Fl_Wayland_Screen_Driver::KWIN;
- //fprintf(stderr, "Running the KWin compositor\n");
- } else if (strncmp(interface, "zowl_mach_ipc", 13) == 0) {
- Fl_Wayland_Screen_Driver::compositor = Fl_Wayland_Screen_Driver::OWL;
- //fprintf(stderr, "Running the Owl compositor\n");
- if (wl_list_length(&scr_driver->outputs) == 0) {
- Fl_Wayland_Screen_Driver::output *output =
- (Fl_Wayland_Screen_Driver::output*)calloc(1, sizeof *output);
- output->id = 1;
- output->wld_scale = 1;
- output->gui_scale = 1.f;
- output->width = 1440; output->height = 900;
- output->pixel_width = 1440; output->pixel_height = 900;
- output->done = true;
- wl_list_insert(&(scr_driver->outputs), &output->link);
- scr_driver->screen_count_set(1);
- }
- } else if (strcmp(interface, zwp_text_input_manager_v3_interface.name) == 0) {
- scr_driver->text_input_base = (struct zwp_text_input_manager_v3 *)
- wl_registry_bind(wl_registry, id, &zwp_text_input_manager_v3_interface, 1);
-//printf("scr_driver->text_input_base=%p version=%d\n",scr_driver->text_input_base,version);
-#if HAVE_XDG_DIALOG
- } else if (strcmp(interface, xdg_wm_dialog_v1_interface.name) == 0) {
- scr_driver->xdg_wm_dialog = (struct xdg_wm_dialog_v1 *)
- wl_registry_bind(wl_registry, id, &xdg_wm_dialog_v1_interface, 1);
-#endif // HAVE_XDG_DIALOG
-#if HAVE_CURSOR_SHAPE
- } else if (strcmp(interface, wp_cursor_shape_manager_v1_interface.name) == 0) {
- scr_driver->wp_cursor_shape_manager = (struct wp_cursor_shape_manager_v1 *)
- wl_registry_bind(wl_registry, id, &wp_cursor_shape_manager_v1_interface, 1);
-#endif // HAVE_CURSOR_SHAPE
- }
-}
-
-
-static void registry_handle_global_remove(void *data, struct wl_registry *registry, uint32_t name) {
- Fl_Wayland_Screen_Driver::output *output;
-//fprintf(stderr, "registry_handle_global_remove data=%p id=%u\n", data, name);
- Fl_Wayland_Screen_Driver *scr_driver = (Fl_Wayland_Screen_Driver*)Fl::screen_driver();
- bool has_removed_screen = false;
- wl_list_for_each(output, &(scr_driver->outputs), link) { // all screens
- if (output->id == name) { // the screen being removed
- wl_list_remove(&output->link);
- wl_output_destroy(output->wl_output);
- free(output);
- has_removed_screen = true;
- break;
- }
- }
- if (has_removed_screen) {
- scr_driver->screen_count_set( wl_list_length(&(scr_driver->outputs)) );
- scr_driver->init_workarea();
- }
-}
-
-
-static const struct wl_registry_listener registry_listener = {
- registry_handle_global,
- registry_handle_global_remove
-};
-
-
-static void wayland_socket_callback(int fd, struct wl_display *display)
-{
- if (wl_display_prepare_read(display) == -1) {
- wl_display_dispatch_pending(display);
- return;
- }
- wl_display_flush(display);
- struct pollfd fds = (struct pollfd) { fd, POLLIN, 0 };
- if (poll(&fds, 1, 0) <= 0) {
- wl_display_cancel_read(display);
- return;
- }
- if (fds.revents & (POLLERR | POLLHUP)) {
- wl_display_cancel_read(display);
- goto fatal;
- }
- if (wl_display_read_events(display) == -1)
- goto fatal;
- if (wl_display_dispatch_pending(display) == -1)
- goto fatal;
- return;
-fatal:
- if (wl_display_get_error(display) == EPROTO) {
- const struct wl_interface *interface;
- int code = wl_display_get_protocol_error(display, &interface, NULL);
- Fl::fatal("Fatal error %d in Wayland protocol: %s",
- code, (interface ? interface->name : "unknown") );
- } else {
- Fl::fatal("Fatal error while communicating with Wayland server: %s",
- strerror(errno));
- }
-}
-
-
-Fl_Wayland_Screen_Driver::Fl_Wayland_Screen_Driver() : Fl_Unix_Screen_Driver() {
- libdecor_context = NULL;
- seat = NULL;
- text_input_base = NULL;
- reset_cursor();
- wl_registry = NULL;
-#if HAVE_XDG_DIALOG
- xdg_wm_dialog = NULL;
-#endif
-#if HAVE_CURSOR_SHAPE
- wp_cursor_shape_manager = NULL;
- wp_cursor_shape_device = NULL;
-#endif
-}
-
-
-static void sync_done(void *data, struct wl_callback *cb, uint32_t time) {
- // runs after all calls to registry_handle_global()
- *(struct wl_callback **)data = NULL;
- wl_callback_destroy(cb);
- // keep processing until output_done() has run for each screen
- Fl_Wayland_Screen_Driver *scr_driver = (Fl_Wayland_Screen_Driver*)Fl::screen_driver();
- Fl_Wayland_Screen_Driver::output *output;
- wl_list_for_each(output, &scr_driver->outputs, link) { // each screen of the system
- while (!output->done) wl_display_dispatch(Fl_Wayland_Screen_Driver::wl_display);
- }
- // Now all screens have been initialized
- scr_driver->screen_count_set( wl_list_length(&(scr_driver->outputs)) );
- struct pair_bool *pair = (struct pair_bool*)wl_registry_get_user_data(scr_driver->wl_registry);
- if (pair->found_gtk_shell || pair->found_wf_shell) {
- Fl_Wayland_Screen_Driver::compositor = (pair->found_wf_shell ?
- Fl_Wayland_Screen_Driver::WAYFIRE : Fl_Wayland_Screen_Driver::MUTTER);
- }
- if (scr_driver->seat) {
-#if HAVE_CURSOR_SHAPE
- if (!scr_driver->wp_cursor_shape_manager)
-#endif
- try_update_cursor(scr_driver->seat);
- }
- if (Fl_Wayland_Screen_Driver::compositor != Fl_Wayland_Screen_Driver::OWL) scr_driver->init_workarea();
-}
-
-
-static const struct wl_callback_listener sync_listener = {
- sync_done
-};
-
-
-static void do_atexit() {
- if (Fl_Wayland_Screen_Driver::wl_display) {
- wl_display_roundtrip(Fl_Wayland_Screen_Driver::wl_display);
- }
-}
-
-
-void Fl_Wayland_Screen_Driver::open_display_platform() {
- static bool beenHereDoneThat = false;
- if (beenHereDoneThat)
- return;
-
- beenHereDoneThat = true;
-
- if (!wl_display) {
- wl_display = wl_display_connect(NULL);
- if (!wl_display) {
- Fl::fatal("No Wayland connection\n");
- }
- }
- //puts("Using Wayland backend");
- wl_list_init(&outputs);
-
- wl_registry = wl_display_get_registry(wl_display);
- struct pair_bool pair = {false, false};
- wl_registry_add_listener(wl_registry, &registry_listener, &pair);
- struct wl_callback *registry_cb = wl_display_sync(wl_display);
- wl_callback_add_listener(registry_cb, &sync_listener, &registry_cb);
- while (registry_cb) wl_display_dispatch(wl_display);
- Fl::add_fd(wl_display_get_fd(wl_display), FL_READ, (Fl_FD_Handler)wayland_socket_callback,
- wl_display);
- fl_create_print_window();
- /* This is useful to avoid crash of the Wayland compositor after
- FLTK apps terminate in certain situations:
- - gnome-shell version < 44 (e.g. version 42.9)
- - focus set to "follow-mouse"
- See issue #821 for details.
- */
- atexit(do_atexit);
-}
-
-
-void Fl_Wayland_Screen_Driver::close_display() {
- if (!Fl_Wayland_Screen_Driver::wl_display) return;
- wl_display_roundtrip(Fl_Wayland_Screen_Driver::wl_display);
- if (text_input_base) {
- disable_im();
- zwp_text_input_manager_v3_destroy(text_input_base);
- text_input_base = NULL;
- }
- while (wl_list_length(&outputs) > 0) {
- Fl_Wayland_Screen_Driver::output *output;
- wl_list_for_each(output, &outputs, link) {
- wl_list_remove(&output->link);
- screen_count_set( wl_list_length(&outputs) );
- if (output->wl_output) {
-#ifdef WL_OUTPUT_RELEASE_SINCE_VERSION
- if (wl_output_get_version(output->wl_output) >= WL_OUTPUT_RELEASE_SINCE_VERSION)
- wl_output_release(output->wl_output);
- else
-#endif
- wl_output_destroy(output->wl_output);
- }
- free(output);
- break;
- }
- }
- wl_subcompositor_destroy(wl_subcompositor); wl_subcompositor = NULL;
- wl_surface_destroy(seat->cursor_surface); seat->cursor_surface = NULL;
- if (seat->cursor_theme) {
- wl_cursor_theme_destroy(seat->cursor_theme);
- seat->cursor_theme = NULL;
- }
- wl_compositor_destroy(wl_compositor); wl_compositor = NULL;
- // wl_shm-related data
- if (Fl_Wayland_Graphics_Driver::current_pool) {
- struct Fl_Wayland_Graphics_Driver::wld_shm_pool_data *pool_data =
- (struct Fl_Wayland_Graphics_Driver::wld_shm_pool_data*)
- wl_shm_pool_get_user_data(Fl_Wayland_Graphics_Driver::current_pool);
- wl_shm_pool_destroy(Fl_Wayland_Graphics_Driver::current_pool);
- Fl_Wayland_Graphics_Driver::current_pool = NULL;
- /*int err = */munmap(pool_data->pool_memory, pool_data->pool_size);
- //printf("close_display munmap(%p)->%d\n", pool_data->pool_memory, err);
- free(pool_data);
- }
- wl_shm_destroy(wl_shm); wl_shm = NULL;
- if (seat->wl_keyboard) {
- if (seat->xkb_state) {
- xkb_state_unref(seat->xkb_state);
- seat->xkb_state = NULL;
- }
- if (seat->xkb_keymap) {
- xkb_keymap_unref(seat->xkb_keymap);
- seat->xkb_keymap = NULL;
- }
- wl_keyboard_destroy(seat->wl_keyboard);
- seat->wl_keyboard = NULL;
- }
- wl_pointer_destroy(seat->wl_pointer); seat->wl_pointer = NULL;
- if (seat->xkb_compose_state) {
- xkb_compose_state_unref(seat->xkb_compose_state);
- seat->xkb_compose_state = NULL;
- }
- if (seat->xkb_context) {
- xkb_context_unref(seat->xkb_context);
- seat->xkb_context = NULL;
- }
- if (seat->data_source) {
- wl_data_source_destroy(seat->data_source);
- seat->data_source = NULL;
- }
- wl_data_device_destroy(seat->data_device); seat->data_device = NULL;
- wl_data_device_manager_destroy(seat->data_device_manager);
- seat->data_device_manager = NULL;
- wl_seat_destroy(seat->wl_seat); seat->wl_seat = NULL;
- if (seat->name) free(seat->name);
- free(seat); seat = NULL;
- if (libdecor_context) {
- libdecor_unref(libdecor_context);
- libdecor_context = NULL;
- }
- xdg_wm_base_destroy(xdg_wm_base); xdg_wm_base = NULL;
- Fl_Wayland_Plugin *plugin = Fl_Wayland_Window_Driver::gl_plugin();
- if (plugin) plugin->terminate();
-#if HAVE_XDG_DIALOG
- if (xdg_wm_dialog) {
- xdg_wm_dialog_v1_destroy(xdg_wm_dialog);
- xdg_wm_dialog = NULL;
- }
-#endif // HAVE_XDG_DIALOG
-#if HAVE_CURSOR_SHAPE
- if (wp_cursor_shape_device ) {
- wp_cursor_shape_device_v1_destroy(wp_cursor_shape_device);
- wp_cursor_shape_device = NULL;
- }
- if (wp_cursor_shape_manager ) {
- wp_cursor_shape_manager_v1_destroy(wp_cursor_shape_manager);
- wp_cursor_shape_manager = NULL;
- }
-#endif // HAVE_CURSOR_SHAPE
-
- Fl::remove_fd(wl_display_get_fd(Fl_Wayland_Screen_Driver::wl_display));
- wl_registry_destroy(wl_registry); wl_registry = NULL;
- wl_display_disconnect(Fl_Wayland_Screen_Driver::wl_display);
- Fl_Wayland_Screen_Driver::wl_display = NULL;
- delete Fl_Display_Device::display_device()->driver();
- delete Fl_Display_Device::display_device();
- delete Fl::system_driver();
- delete this;
-}
-
-
-struct configure_s { int W, H; uint32_t state; };
-
-static void xdg_toplevel_configure(void *v, struct xdg_toplevel *xdg_toplevel,
- int32_t width, int32_t height, struct wl_array *states)
-{
- struct configure_s *data = (struct configure_s*)v;
- data->W = width;
- data->H = height;
- data->state = (width && height && states ? *(uint32_t *)(states->data) : 0);
-}
-
-static const struct xdg_toplevel_listener xdg_toplevel_listener = {
- .configure = xdg_toplevel_configure,
-};
-
-
-static bool compute_full_and_maximized_areas(Fl_Wayland_Screen_Driver::output *output,
- int& Wfullscreen, int& Hfullscreen,
- int& Wworkarea, int& Hworkarea) {
- if (Fl_Wayland_Screen_Driver::compositor == Fl_Wayland_Screen_Driver::unspecified) {
- Wfullscreen = 0;
- return false;
- }
- bool found_workarea = false;
- Fl_Wayland_Screen_Driver *scr_driver = (Fl_Wayland_Screen_Driver*)Fl::screen_driver();
- struct wl_surface *wl_surface = wl_compositor_create_surface(scr_driver->wl_compositor);
- wl_surface_set_opaque_region(wl_surface, NULL);
- struct xdg_surface *xdg_surface = xdg_wm_base_get_xdg_surface(scr_driver->xdg_wm_base, wl_surface);
- struct xdg_toplevel *xdg_toplevel = xdg_surface_get_toplevel(xdg_surface);
- struct configure_s data = {0, 0, 0};
- xdg_toplevel_add_listener(xdg_toplevel, &xdg_toplevel_listener, &data);
- xdg_toplevel_set_fullscreen(xdg_toplevel, output->wl_output);
- wl_surface_commit(wl_surface); // necessary under KWin
- while (data.state != XDG_TOPLEVEL_STATE_FULLSCREEN)
- wl_display_dispatch(Fl_Wayland_Screen_Driver::wl_display);
- Wfullscreen = data.W;
- Hfullscreen = data.H;
- if (Wfullscreen && Hfullscreen && wl_list_length(&scr_driver->outputs) == 1) {
- struct wl_surface *wl_surface2 = wl_compositor_create_surface(scr_driver->wl_compositor);
- struct xdg_surface *xdg_surface2 = xdg_wm_base_get_xdg_surface(scr_driver->xdg_wm_base, wl_surface2);
- struct xdg_toplevel *xdg_toplevel2 = xdg_surface_get_toplevel(xdg_surface2);
- struct configure_s data2 = {0, 0, 0};
- xdg_toplevel_add_listener(xdg_toplevel2, &xdg_toplevel_listener, &data2);
- xdg_toplevel_set_parent(xdg_toplevel2, xdg_toplevel);
- xdg_toplevel_set_maximized(xdg_toplevel2);
- wl_surface_commit(wl_surface2); // necessary under KWin
- while (data2.state != XDG_TOPLEVEL_STATE_MAXIMIZED)
- wl_display_dispatch(Fl_Wayland_Screen_Driver::wl_display);
- Wworkarea = data2.W;
- Hworkarea = data2.H;
- xdg_toplevel_destroy(xdg_toplevel2);
- xdg_surface_destroy(xdg_surface2);
- wl_surface_destroy(wl_surface2);
- if (Wworkarea == Wfullscreen && Hworkarea < Hfullscreen && Hworkarea > Hfullscreen - 80)
- found_workarea = true;
- if (Hworkarea == Hfullscreen && Wworkarea < Wfullscreen && Wworkarea > Wfullscreen - 80)
- found_workarea = true;
- } else {
- Wworkarea = Wfullscreen;
- Hworkarea = Hfullscreen;
- }
- xdg_toplevel_destroy(xdg_toplevel);
- xdg_surface_destroy(xdg_surface);
- wl_surface_destroy(wl_surface);
- /*int fractional_scale = int(100 * (output->pixel_width / float(Wfullscreen)));
- printf("fullscreen=%dx%d workarea=%dx%d fractional_scale=%d%% wld_s=%d\n",
- Wfullscreen,Hfullscreen,Wworkarea,Hworkarea,fractional_scale,output->wld_scale);*/
- return found_workarea;
-}
-
-static int workarea_xywh[4] = { -1, -1, -1, -1 };
-
-
-/* Implementation note about computing work area and about handling fractional scaling.
-
- FLTK computes 2 pairs of (WxH) values for each display:
- 1) (pixel_width x pixel_height) gives the size in pixel of a display. It's unchanged by
- any scaling applied by the compositor; it's assigned by function output_mode().
- 2) (width x height) gives the size in pixels of a buffer that would fully cover the display.
- When the active scaling is non-fractional, these equations hold:
- pixel_width = width = wld_scale * configured-width-of-fullscreen-window
- pixel_height = height = wld_scale * configured-height-of-fullscreen-window
-
- When fractional scaling is active, buffers received from client are scaled down
- by the compositor and mapped to screen. These equations hold:
- pixel_width < width = wld_scale * configured-width-of-fullscreen-window
- pixel_height < height = wld_scale * configured-height-of-fullscreen-window
-
- One way for a client to discover that fractional scaling is active on a given display
- is to ask for a fullscreen window on that display, get its configured size and compare
- it to that display's pixel size. That's what function compute_full_and_maximized_areas() does.
-
- One way for a client to discover the work area size of a display is to get the configured size
- of a maximized window on that display. FLTK didn't find a way to control in general
- on what display the compositor puts a maximized window. Therefore, FLTK computes an exact
- work area size only when the system contains a single display. We create first a fullscreen
- window on the display and then we create a maximized window made a child of the
- fullscreen one and record its configured size. That's also done by function
- compute_full_and_maximized_areas().
- */
-
-void Fl_Wayland_Screen_Driver::init_workarea()
-{
- wl_display_roundtrip(Fl_Wayland_Screen_Driver::wl_display); // important after screen removal
- bool need_init_workarea = true;
- Fl_Wayland_Screen_Driver::output *output;
- wl_list_for_each(output, &outputs, link) {
- int Wfullscreen, Hfullscreen, Wworkarea, Hworkarea;
- bool found_workarea = compute_full_and_maximized_areas(output, Wfullscreen, Hfullscreen, Wworkarea, Hworkarea);
- if (Wfullscreen && Hfullscreen) { // skip sway which puts 0 there
- output->width = Wfullscreen * output->wld_scale; // pixels
- output->height = Hfullscreen * output->wld_scale; // pixels
- if (found_workarea) {
- workarea_xywh[0] = output->x; // pixels
- workarea_xywh[1] = output->y; // pixels
- workarea_xywh[2] = Wworkarea * output->wld_scale; // pixels
- workarea_xywh[3] = Hworkarea * output->wld_scale; // pixels
- need_init_workarea = false;
- }
- }
- }
- if (need_init_workarea) {
- screen_xywh(workarea_xywh[0], workarea_xywh[1], workarea_xywh[2], workarea_xywh[3], 0);
- }
- Fl::handle(FL_SCREEN_CONFIGURATION_CHANGED, NULL);
-}
-
-
-int Fl_Wayland_Screen_Driver::x() {
- if (!Fl_Wayland_Screen_Driver::wl_registry) open_display();
- Fl_Wayland_Screen_Driver::output *output;
- wl_list_for_each(output, &outputs, link) {
- break;
- }
- return workarea_xywh[0] / (output->gui_scale * output->wld_scale);
-}
-
-
-int Fl_Wayland_Screen_Driver::y() {
- if (!Fl_Wayland_Screen_Driver::wl_registry) open_display();
- Fl_Wayland_Screen_Driver::output *output;
- wl_list_for_each(output, &outputs, link) {
- break;
- }
- return workarea_xywh[1] / (output->gui_scale * output->wld_scale);
-}
-
-
-int Fl_Wayland_Screen_Driver::w() {
- if (!Fl_Wayland_Screen_Driver::wl_registry) open_display();
- Fl_Wayland_Screen_Driver::output *output;
- wl_list_for_each(output, &outputs, link) {
- break;
- }
- return workarea_xywh[2] / (output->gui_scale * output->wld_scale);
-}
-
-
-int Fl_Wayland_Screen_Driver::h() {
- if (!Fl_Wayland_Screen_Driver::wl_registry) open_display();
- Fl_Wayland_Screen_Driver::output *output;
- wl_list_for_each(output, &outputs, link) {
- break;
- }
- return workarea_xywh[3] / (output->gui_scale * output->wld_scale);
-}
-
-
-void Fl_Wayland_Screen_Driver::init() {
- if (!Fl_Wayland_Screen_Driver::wl_registry) open_display();
-}
-
-
-void Fl_Wayland_Screen_Driver::screen_work_area(int &X, int &Y, int &W, int &H, int n)
-{
- if (num_screens < 0) init();
- if (n < 0 || n >= num_screens) n = 0;
- if (n == 0) { // for the main screen, these return the work area
- X = Fl::x();
- Y = Fl::y();
- W = Fl::w();
- H = Fl::h();
- } else { // for other screens, work area is full screen,
- screen_xywh(X, Y, W, H, n);
- }
-}
-
-
-void Fl_Wayland_Screen_Driver::screen_xywh(int &X, int &Y, int &W, int &H, int n)
-{
- if (num_screens < 0) init();
-
- if ((n < 0) || (n >= num_screens))
- n = 0;
-
- if (num_screens > 0) {
- Fl_Wayland_Screen_Driver::output *output;
- int i = 0;
- wl_list_for_each(output, &outputs, link) {
- if (i++ == n) { // n'th screen of the system
- float s = output->gui_scale * output->wld_scale;
- X = output->x / s;
- Y = output->y / s;
- W = output->width / s;
- H = output->height / s;
- break;
- }
- }
- }
-}
-
-
-void Fl_Wayland_Screen_Driver::screen_dpi(float &h, float &v, int n)
-{
- if (num_screens < 0) init();
- h = v = 0.0f;
-
- if (n >= 0 && n < num_screens) {
- Fl_Wayland_Screen_Driver::output *output;
- int i = 0;
- wl_list_for_each(output, &outputs, link) {
- if (i++ == n) { // n'th screen of the system
- h = output->dpi;
- v = output->dpi;
- break;
- }
- }
- }
-}
-
-
-// Implements fl_beep(). See documentation in src/fl_ask.cxx.
-void Fl_Wayland_Screen_Driver::beep(int type)
-{
- fprintf(stderr, "\007");
-}
-
-
-void Fl_Wayland_Screen_Driver::flush()
-{
- if (Fl_Wayland_Screen_Driver::wl_display) {
- wl_display_flush(Fl_Wayland_Screen_Driver::wl_display);
- }
-}
-
-
-extern void fl_fix_focus(); // in Fl.cxx
-
-
-void Fl_Wayland_Screen_Driver::grab(Fl_Window* win)
-{
- if (win) {
- if (!Fl::grab()) {
- }
- Fl::grab_ = win; // FIXME: Fl::grab_ "should be private", but we need
- // a way to *set* the variable from the driver!
- } else {
- if (Fl::grab()) {
- // We must keep the grab in the non-EWMH fullscreen case
- Fl::grab_ = 0; // FIXME: Fl::grab_ "should be private", but we need
- // a way to *set* the variable from the driver!
- fl_fix_focus();
- }
- }
-}
-
-
-static void set_selection_color(uchar r, uchar g, uchar b)
-{
- Fl::set_color(FL_SELECTION_COLOR,r,g,b);
-}
-
-
-static void getsyscolor(const char *key1, const char* key2, const char *arg,
- const char *defarg, void (*func)(uchar,uchar,uchar)) {
- uchar r, g, b;
- if (!arg) arg = defarg;
- if (!Fl::screen_driver()->parse_color(arg, r, g, b))
- Fl::error("Unknown color: %s", arg);
- else
- func(r, g, b);
-}
-
-
-void Fl_Wayland_Screen_Driver::get_system_colors()
-{
- open_display();
- const char* key1 = 0;
- if (Fl::first_window()) key1 = Fl::first_window()->xclass();
- if (!key1) key1 = "fltk";
- if (!bg2_set)
- getsyscolor("Text","background", fl_bg2, "#ffffff", Fl::background2);
- if (!fg_set)
- getsyscolor(key1, "foreground", fl_fg, "#000000", Fl::foreground);
- if (!bg_set)
- getsyscolor(key1, "background", fl_bg, "#c0c0c0", Fl::background);
- getsyscolor("Text", "selectBackground", 0, "#000080", set_selection_color);
-}
-
-
-Fl_RGB_Image *Fl_Wayland_Screen_Driver::read_win_rectangle(int X, int Y, int w, int h,
- Fl_Window *win,
- bool ignore, bool *p_ignore) {
- struct wld_window* xid = win ? fl_wl_xid(win) : NULL;
- if (win && (!xid || !xid->buffer)) return NULL;
- struct Fl_Wayland_Graphics_Driver::draw_buffer *buffer;
- if (win) buffer = &xid->buffer->draw_buffer;
- else {
- Fl_Image_Surface_Driver *dr = (Fl_Image_Surface_Driver*)Fl_Surface_Device::surface();
- buffer = Fl_Wayland_Graphics_Driver::offscreen_buffer(
- dr->image_surface()->offscreen());
- }
- float s = win ?
- Fl_Wayland_Window_Driver::driver(win)->wld_scale() * scale(win->screen_num()) :
- Fl_Surface_Device::surface()->driver()->scale();
- int Xs, Ys, ws, hs;
- if (s == 1) {
- Xs = X; Ys = Y; ws = w; hs = h;
- } else {
- Xs = Fl_Scalable_Graphics_Driver::floor(X, s);
- Ys = Fl_Scalable_Graphics_Driver::floor(Y, s);
- ws = Fl_Scalable_Graphics_Driver::floor(X+w, s) - Xs;
- hs = Fl_Scalable_Graphics_Driver::floor(Y+h, s) - Ys;
- }
- if (ws == 0 || hs == 0) return NULL;
- uchar *data = new uchar[ws * hs * 3];
- uchar *p = data, *q;
- for (int j = 0; j < hs; j++) {
- q = buffer->buffer + (j+Ys) * buffer->stride + 4 * Xs;
- for (int i = 0; i < ws; i++) {
- *p++ = *(q+2); // R
- *p++ = *(q+1); // G
- *p++ = *q; // B
- q += 4;
- }
- }
- Fl_RGB_Image *rgb = new Fl_RGB_Image(data, ws, hs, 3);
- rgb->alloc_array = 1;
- return rgb;
-}
-
-
-void Fl_Wayland_Screen_Driver::offscreen_size(Fl_Offscreen off_, int &width, int &height)
-{
- struct Fl_Wayland_Graphics_Driver::draw_buffer *off = Fl_Wayland_Graphics_Driver::offscreen_buffer(off_);
- width = off->width;
- height = off->data_size / off->stride;
-}
-
-
-float Fl_Wayland_Screen_Driver::scale(int n) {
- Fl_Wayland_Screen_Driver::output *output;
- int i = 0;
- wl_list_for_each(output, &outputs, link) {
- if (i++ == n) break;
- }
- return output->gui_scale;
-}
-
-
-void Fl_Wayland_Screen_Driver::scale(int n, float f) {
- Fl_Wayland_Screen_Driver::output *output;
- int i = 0;
- wl_list_for_each(output, &outputs, link) {
- if (i++ == n) {
- output->gui_scale = f;
- return;
- }
- }
-}
-
-
-void Fl_Wayland_Screen_Driver::set_cursor() {
- do_set_cursor(seat);
-}
-
-
-struct wl_cursor *Fl_Wayland_Screen_Driver::default_cursor() {
- return seat->default_cursor;
-}
-
-
-void Fl_Wayland_Screen_Driver::default_cursor(struct wl_cursor *cursor) {
- seat->default_cursor = cursor;
- do_set_cursor(seat);
-}
-
-
-struct wl_cursor *Fl_Wayland_Screen_Driver::cache_cursor(const char *cursor_name) {
- return wl_cursor_theme_get_cursor(seat->cursor_theme, cursor_name);
-}
-
-
-void Fl_Wayland_Screen_Driver::reset_cursor() {
- for (int i = 0; i < cursor_count; i++) xc_cursor[i] = NULL;
-}
-
-
-uint32_t Fl_Wayland_Screen_Driver::get_serial() {
- return seat->serial;
-}
-
-
-struct wl_seat*Fl_Wayland_Screen_Driver::get_wl_seat() {
- return seat->wl_seat;
-}
-
-
-char *Fl_Wayland_Screen_Driver::get_seat_name() {
- return seat->name;
-}
-
-
-struct xkb_keymap *Fl_Wayland_Screen_Driver::get_xkb_keymap() {
- return seat->xkb_keymap;
-}
-
-
-int Fl_Wayland_Screen_Driver::get_mouse(int &xx, int &yy) {
- open_display();
- xx = Fl::e_x_root; yy = Fl::e_y_root;
- if (!seat->pointer_focus) return 0;
- Fl_Window *win = Fl_Wayland_Window_Driver::surface_to_window(seat->pointer_focus);
- if (!win) return 0;
- int snum = Fl_Window_Driver::driver(win)->screen_num();
-//printf("get_mouse(%dx%d)->%d\n", xx, yy, snum);
- return snum;
-}
-
-
-void Fl_Wayland_Screen_Driver::set_spot(int font, int height, int x, int y, int w, int h, Fl_Window *win) {
- Fl_Wayland_Screen_Driver::insertion_point_location(x, y, height);
-}
-
-
-void Fl_Wayland_Screen_Driver::reset_spot() {
- Fl::compose_state = 0;
- Fl_Wayland_Screen_Driver::next_marked_length = 0;
- Fl_Wayland_Screen_Driver::insertion_point_location_is_valid = false;
-}
-
-
-void Fl_Wayland_Screen_Driver::display(const char *d)
-{
- if (d && !wl_registry) { // if display was opened, it's too late
- if (wl_display) {
- // only the wl_display_connect() call was done, redo it because the target
- // Wayland compositor may be different
- wl_display_disconnect(wl_display);
- }
- wl_display = wl_display_connect(d);
- if (!wl_display) {
- fprintf(stderr, "Error: '%s' is not an active Wayland socket\n", d);
- exit(1);
- }
- }
-}
-
-
-void *Fl_Wayland_Screen_Driver::control_maximize_button(void *data) {
- // The code below aims at removing the calling window's fullscreen button
- // while dialog runs. Unfortunately, it doesn't work with some X11 window managers
- // (e.g., KDE, xfce) because the button goes away but doesn't come back,
- // so we move this code to a virtual member function.
- // Noticeably, this code works OK under Wayland.
- struct win_dims {
- Fl_Widget_Tracker *tracker;
- int minw, minh, maxw, maxh;
- struct win_dims *next;
- };
-
- if (!data) { // this call turns each decorated window's maximize button off
- struct win_dims *first_dim = NULL;
- // consider all bordered, top-level FLTK windows
- Fl_Window *win = Fl::first_window();
- while (win) {
- if (!win->parent() && win->border() &&
- !( ((struct wld_window*)Fl_X::flx(win)->xid)->state &
- LIBDECOR_WINDOW_STATE_MAXIMIZED) ) {
- win_dims *dim = new win_dims;
- dim->tracker = new Fl_Widget_Tracker(win);
- win->get_size_range(&dim->minw, &dim->minh, &dim->maxw, &dim->maxh, NULL, NULL, NULL);
- //make win un-resizable
- win->size_range(win->w(), win->h(), win->w(), win->h());
- dim->next = first_dim;
- first_dim = dim;
- }
- win = Fl::next_window(win);
- }
- return first_dim;
- } else { // this call returns each decorated window's maximize button to its previous state
- win_dims *first_dim = (win_dims *)data;
- while (first_dim) {
- win_dims *dim = first_dim;
- //give back win its resizing parameters
- if (dim->tracker->exists()) {
- Fl_Window *win = (Fl_Window*)dim->tracker->widget();
- win->size_range(dim->minw, dim->minh, dim->maxw, dim->maxh);
- }
- first_dim = dim->next;
- delete dim->tracker;
- delete dim;
- }
- return NULL;
- }
-}
-
-
-int Fl_Wayland_Screen_Driver::poll_or_select_with_delay(double time_to_wait) {
- if (wl_display_dispatch_pending(wl_display) > 0) return 1;
- return Fl_Unix_Screen_Driver::poll_or_select_with_delay(time_to_wait);
-}
-
-
-// like Fl_Wayland_Screen_Driver::poll_or_select_with_delay(0.0) except no callbacks are done:
-int Fl_Wayland_Screen_Driver::poll_or_select() {
- int ret = wl_display_prepare_read(wl_display);
- if (ret == 0) wl_display_cancel_read(wl_display);
- else return 1;
- return Fl_Unix_Screen_Driver::poll_or_select();
-}
-
-
-int Fl_Wayland_Screen_Driver::event_key(int k) {
- if (k >= 'A' && k <= 'Z') k += 32;
- return (search_int_vector(key_vector, k) >= 0);
-}
-
-
-int Fl_Wayland_Screen_Driver::get_key(int k) {
- return event_key(k);
-}
-
-
-float Fl_Wayland_Screen_Driver::base_scale(int numscreen) {
- const char *p;
- float factor = 1;
- if ((p = fl_getenv("FLTK_SCALING_FACTOR"))) {
- sscanf(p, "%f", &factor);
- }
- return factor;
-}
-
-
-struct wl_display *fl_wl_display() {
- return Fl_Wayland_Screen_Driver::wl_display;
-}
diff --git a/src/drivers/Wayland/Fl_Wayland_Window_Driver.H b/src/drivers/Wayland/Fl_Wayland_Window_Driver.H
deleted file mode 100644
index c5c1bee50..000000000
--- a/src/drivers/Wayland/Fl_Wayland_Window_Driver.H
+++ /dev/null
@@ -1,185 +0,0 @@
-//
-// Definition of Wayland window driver for the Fast Light Tool Kit (FLTK).
-//
-// Copyright 2010-2025 by Bill Spitzak and others.
-//
-// This library is free software. Distribution and use rights are outlined in
-// the file "COPYING" which should have been included with this file. If this
-// file is missing or damaged, see the license at:
-//
-// https://www.fltk.org/COPYING.php
-//
-// Please see the following page on how to report bugs and issues:
-//
-// https://www.fltk.org/bugs.php
-//
-
-/**
- \file Fl_Wayland_Window_Driver.H
- \brief Definition of Wayland window driver.
- */
-
-#ifndef FL_WAYLAND_WINDOW_DRIVER_H
-#define FL_WAYLAND_WINDOW_DRIVER_H
-
-#include <config.h>
-#include "../../Fl_Window_Driver.H"
-#include <FL/Fl_Plugin.H>
-#include "Fl_Wayland_Screen_Driver.H"
-#include "Fl_Wayland_Graphics_Driver.H"
-
-
-/*
- Move everything here that manages the native window interface.
-
- There is one window driver for each Fl_Window. Window drivers manage window
- actions such as resizing, events, decoration, fullscreen modes, etc. . All
- drawing and rendering is managed by the Surface device and the associated
- graphics driver.
-
- - window specific event handling
- - window types and styles, depth, etc.
- - decorations
- */
-
-typedef struct _cairo_pattern cairo_pattern_t;
-typedef struct _cairo_rectangle_int cairo_rectangle_int_t;
-class Fl_Wayland_Plugin;
-
-
-class Fl_Wayland_Window_Driver : public Fl_Window_Driver
-{
- friend class Fl_Wayland_Gl_Window_Driver;
-private:
- struct shape_data_type {
- int lw_; ///< width of shape image
- int lh_; ///< height of shape image
- Fl_Image* shape_; ///< shape image
- cairo_pattern_t *mask_pattern_;
- } *shape_data_;
- bool can_expand_outside_parent_; // specially to allow window docking (#987)
- cairo_rectangle_int_t *subRect_; // makes sure subwindow remains inside its parent window
- static bool in_flush_; // useful for progressive window drawing
- Fl_Cursor standard_cursor_; // window's standard custom kind
- struct gl_start_support *gl_start_support_; // for support of gl_start/gl_finish
- bool is_popup_window_;
-public:
- inline Fl_Cursor standard_cursor() { return standard_cursor_; }
- bool in_handle_configure; // distinguish OS and user window resize
-
- struct surface_output { // for linked list of displays where a surface maps
- struct Fl_Wayland_Screen_Driver::output *output;
- struct wl_list link;
- };
- struct custom_cursor {
- struct wl_cursor *wl_cursor;
- const Fl_RGB_Image *rgb;
- int hotx, hoty;
- };
- static void delete_cursor(struct custom_cursor *custom, bool delete_rgb = true);
- void decorated_win_size(int &w, int &h);
- void shape_bitmap_(Fl_Image* b);
- void shape_alpha_(Fl_Image* img, int offset) override;
- FL_EXPORT int wld_scale(); // used by class Fl_Wayland_Gl_Window_Driver
- cairo_rectangle_int_t *subRect() { return subRect_; } // getter
- void subRect(cairo_rectangle_int_t *r); // setter
- void checkSubwindowFrame();
- enum kind {DECORATED, SUBWINDOW, POPUP, UNFRAMED};
- struct xdg_toplevel *xdg_toplevel();
- Fl_Wayland_Window_Driver(Fl_Window*);
- virtual ~Fl_Wayland_Window_Driver();
- static struct wld_window *wld_window;
- static Fl_Window *surface_to_window(struct wl_surface *);
-
- static inline Fl_Wayland_Window_Driver* driver(const Fl_Window *w) {
- return (Fl_Wayland_Window_Driver*)Fl_Window_Driver::driver(w);
- }
- static Fl_Wayland_Plugin *gl_plugin();
-
- // --- window data
- int decorated_w() override;
- int decorated_h() override;
- const Fl_Image* shape() override;
-
- // --- window management
- void makeWindow() override;
- void take_focus() override;
- void flush() override;
- void flush_overlay() override;
- void draw_end() override;
- void make_current() override;
- void show() override;
- void resize(int X,int Y,int W,int H) override;
- void label(const char *name, const char *mininame) override;
- void hide() override;
- void map() override;
- void unmap() override;
- void fullscreen_on() override;
- void fullscreen_off(int X, int Y, int W, int H) override;
- void maximize() override;
- void un_maximize() override;
- void use_border() override;
- void size_range() override;
- void iconize() override;
- void decoration_sizes(int *top, int *left, int *right, int *bottom) override;
- // --- window cursor stuff
- int set_cursor(Fl_Cursor) override;
- int set_cursor(const Fl_RGB_Image*, int, int) override;
- int set_cursor_4args(const Fl_RGB_Image*, int, int, bool);
-
- void shape(const Fl_Image* img) override;
- void capture_titlebar_and_borders(Fl_RGB_Image*& top, Fl_RGB_Image*& left,
- Fl_RGB_Image*& bottom, Fl_RGB_Image*& right) override;
- int scroll(int src_x, int src_y, int src_w, int src_h, int dest_x, int dest_y,
- void (*draw_area)(void*, int,int,int,int), void* data) override;
- void wait_for_expose() override;
- // menu-related stuff
- void reposition_menu_window(int x, int y) override;
- void menu_window_area(int &X, int &Y, int &W, int &H, int nscreen = -1) override;
- static bool new_popup; // to support tall menu buttons
- bool process_menu_or_tooltip(struct wld_window *);
- static Fl_Window *previous_floatingtitle; // to support floating menuwindow w/ title
- void allow_expand_outside_parent() override { can_expand_outside_parent_ = true; }
-};
-
-
-struct wld_window {
- Fl_Window *fl_win;
- struct wl_list outputs; // linked list of displays where part or whole of window maps
- struct wl_surface *wl_surface;
- struct wl_callback *frame_cb;
- struct Fl_Wayland_Graphics_Driver::wld_buffer *buffer;
- struct xdg_surface *xdg_surface;
- union { // for each value of kind
- struct libdecor_frame *frame;
- struct wl_subsurface *subsurface;
- struct xdg_popup *xdg_popup;
- struct xdg_toplevel *xdg_toplevel;
- };
- // non-null when using custom cursor
- struct Fl_Wayland_Window_Driver::custom_cursor *custom_cursor;
-#if HAVE_XDG_DIALOG
- struct xdg_dialog_v1 *xdg_dialog;
-#endif
- enum Fl_Wayland_Window_Driver::kind kind;
- int configured_width;
- int configured_height;
- int floating_width;
- int floating_height;
- int state;
- bool covered; // specially for Mutter and issue #878
-};
-
-
-class Fl_Wayland_Plugin : public Fl_Plugin {
-public:
- Fl_Wayland_Plugin(const char *pluginName) : Fl_Plugin(klass(), pluginName) { }
- virtual const char *klass() { return "wayland.fltk.org"; }
- virtual const char *name() = 0;
- virtual void do_swap(Fl_Window*) = 0;
- virtual void invalidate(Fl_Window*) = 0;
- virtual void terminate() = 0;
- virtual void destroy(struct gl_start_support *) = 0;
-};
-
-#endif // FL_WAYLAND_WINDOW_DRIVER_H
diff --git a/src/drivers/Wayland/Fl_Wayland_Window_Driver.cxx b/src/drivers/Wayland/Fl_Wayland_Window_Driver.cxx
deleted file mode 100644
index 0495fb7bc..000000000
--- a/src/drivers/Wayland/Fl_Wayland_Window_Driver.cxx
+++ /dev/null
@@ -1,2191 +0,0 @@
-//
-// Implementation of the Wayland window driver.
-//
-// Copyright 1998-2026 by Bill Spitzak and others.
-//
-// This library is free software. Distribution and use rights are outlined in
-// the file "COPYING" which should have been included with this file. If this
-// file is missing or damaged, see the license at:
-//
-// https://www.fltk.org/COPYING.php
-//
-// Please see the following page on how to report bugs and issues:
-//
-// https://www.fltk.org/bugs.php
-//
-
-#include <FL/platform.H>
-#include "Fl_Wayland_Window_Driver.H"
-#include "Fl_Wayland_Screen_Driver.H"
-#include "Fl_Wayland_Graphics_Driver.H"
-#include <FL/filename.H>
-#include <wayland-cursor.h>
-#include "../../../libdecor/build/fl_libdecor.h"
-#include "xdg-shell-client-protocol.h"
-#include "gtk-shell-client-protocol.h"
-#if HAVE_XDG_DIALOG
-# include "xdg-dialog-client-protocol.h"
-#endif
-#include <pango/pangocairo.h>
-#include <FL/Fl_Overlay_Window.H>
-#include <FL/Fl_Tooltip.H>
-#include <FL/fl_draw.H>
-#include <FL/fl_ask.H>
-#include <FL/Fl.H>
-#include <FL/Fl_Image_Surface.H>
-#include <FL/Fl_Menu_Button.H>
-#include <string.h>
-#include <math.h> // for ceil()
-#include <sys/types.h> // for pid_t
-#include <unistd.h> // for getpid()
-
-struct cursor_image { // as in wayland-cursor.c of the Wayland project source code
- struct wl_cursor_image image;
- struct wl_cursor_theme *theme;
- struct wl_buffer *buffer;
- int offset; /* data offset of this image in the shm pool */
-};
-
-extern "C" {
-# include "../../../libdecor/src/libdecor-plugin.h"
- uchar *fl_libdecor_titlebar_buffer(struct libdecor_frame *frame, int *w, int *h, int *stride);
-}
-
-#define fl_max(a,b) ((a) > (b) ? (a) : (b))
-#define fl_min(a,b) ((a) < (b) ? (a) : (b))
-
-#if !defined(FLTK_USE_X11)
-Window fl_window = 0;
-#endif
-
-
-struct wld_window *Fl_Wayland_Window_Driver::wld_window = NULL;
-bool Fl_Wayland_Window_Driver::new_popup = false; // to support tall menu buttons
-// A menutitle to be mapped later as the child of a menuwindow
-Fl_Window *Fl_Wayland_Window_Driver::previous_floatingtitle = NULL;
-
-
-Fl_Wayland_Window_Driver::Fl_Wayland_Window_Driver(Fl_Window *win) : Fl_Window_Driver(win)
-{
- shape_data_ = NULL;
- standard_cursor_ = FL_CURSOR_DEFAULT;
- in_handle_configure = false;
- screen_num_ = -1;
- gl_start_support_ = NULL;
- subRect_ = NULL;
- is_popup_window_ = false;
- can_expand_outside_parent_ = false;
-}
-
-
-void Fl_Wayland_Window_Driver::delete_cursor(
- struct Fl_Wayland_Window_Driver::custom_cursor *custom, bool delete_rgb) {
- struct wl_cursor *wl_cursor = custom->wl_cursor;
- struct cursor_image *new_image = (struct cursor_image*)wl_cursor->images[0];
- struct Fl_Wayland_Graphics_Driver::wld_buffer *offscreen =
- (struct Fl_Wayland_Graphics_Driver::wld_buffer *)
- wl_buffer_get_user_data(new_image->buffer);
- struct wld_window fake_xid;
- memset(&fake_xid, 0, sizeof(fake_xid));
- fake_xid.buffer = offscreen;
- Fl_Wayland_Graphics_Driver::buffer_release(&fake_xid);
- free(new_image);
- free(wl_cursor->images);
- free(wl_cursor->name);
- free(wl_cursor);
- Fl_Wayland_Screen_Driver *scr_driver = (Fl_Wayland_Screen_Driver*)Fl::screen_driver();
- if (scr_driver->default_cursor() == wl_cursor) {
- scr_driver->default_cursor(scr_driver->xc_cursor[Fl_Wayland_Screen_Driver::arrow]);
- }
- if (delete_rgb) delete custom->rgb;
- delete custom;
-}
-
-
-Fl_Wayland_Window_Driver::~Fl_Wayland_Window_Driver()
-{
- if (shape_data_) {
- cairo_surface_t *surface;
- cairo_pattern_get_surface(shape_data_->mask_pattern_, &surface);
- uchar *data = cairo_image_surface_get_data(surface);
- cairo_pattern_destroy(shape_data_->mask_pattern_);
- delete[] data;
- delete shape_data_;
- }
- if (subRect_) delete subRect_;
- if (gl_start_support_) { // occurs only if gl_start/gl_finish was used
- gl_plugin()->destroy(gl_start_support_);
- }
-}
-
-
-void Fl_Wayland_Window_Driver::decorated_win_size(int &w, int &h)
-{
- Fl_Window *win = pWindow;
- w = win->w();
- h = win->h();
- if (!win->shown() || win->parent() || !win->border() || !win->visible()) return;
- int X, titlebar_height;
- libdecor_frame_translate_coordinate(fl_wl_xid(win)->frame, 0, 0, &X, &titlebar_height);
-//printf("titlebar_height=%d\n",titlebar_height);
- h = win->h() + ceil(titlebar_height / Fl::screen_scale(win->screen_num()));
-}
-
-
-int Fl_Wayland_Window_Driver::decorated_h()
-{
- int w, h;
- decorated_win_size(w, h);
- return h;
-}
-
-
-int Fl_Wayland_Window_Driver::decorated_w()
-{
- int w, h;
- decorated_win_size(w, h);
- return w;
-}
-
-
-struct xdg_toplevel *Fl_Wayland_Window_Driver::xdg_toplevel() {
- struct wld_window * w = fl_wl_xid(pWindow);
- struct xdg_toplevel *top = NULL;
- if (w->kind == DECORATED) top = libdecor_frame_get_xdg_toplevel(w->frame);
- else if (w->kind == UNFRAMED) top = w->xdg_toplevel;
- return top;
-}
-
-
-void Fl_Wayland_Window_Driver::take_focus()
-{
- struct wld_window *w = fl_wl_xid(pWindow);
- if (w) {
- Fl_Window *old_first = Fl::first_window();
- struct wld_window *first_xid = (old_first ? fl_wl_xid(old_first->top_window()) : NULL);
- if (first_xid && first_xid != w && xdg_toplevel()) {
- // this will move the target window to the front
- Fl_Wayland_Window_Driver *top_dr =
- Fl_Wayland_Window_Driver::driver(old_first->top_window());
- xdg_toplevel_set_parent(xdg_toplevel(), top_dr->xdg_toplevel());
- // this will remove the parent-child relationship
- xdg_toplevel_set_parent(xdg_toplevel(), NULL);
- wl_display_roundtrip(Fl_Wayland_Screen_Driver::wl_display);
- }
- // this sets the first window
- fl_wl_find(w);
- }
-}
-
-
-void Fl_Wayland_Window_Driver::flush_overlay()
-{
- if (!shown()) return;
- Fl_Overlay_Window *oWindow = pWindow->as_overlay_window();
- int erase_overlay = (pWindow->damage()&FL_DAMAGE_OVERLAY) | (overlay() == oWindow);
- pWindow->clear_damage((uchar)(pWindow->damage()&~FL_DAMAGE_OVERLAY));
- pWindow->make_current();
- if (!other_xid) {
- other_xid = new Fl_Image_Surface(oWindow->w(), oWindow->h(), 1);
- oWindow->clear_damage(FL_DAMAGE_ALL);
- }
- if (oWindow->damage() & ~FL_DAMAGE_EXPOSE) {
- Fl_X *myi = Fl_X::flx(pWindow);
- fl_clip_region(myi->region); myi->region = 0;
- Fl_Surface_Device::push_current(other_xid);
- draw();
- Fl_Surface_Device::pop_current();
- }
- if (erase_overlay) fl_clip_region(0);
- if (other_xid) {
- struct Fl_Wayland_Graphics_Driver::draw_buffer *buffer =
- Fl_Wayland_Graphics_Driver::offscreen_buffer(other_xid->offscreen());
- struct wld_window *xid = fl_wl_xid(pWindow);
- struct Fl_Wayland_Graphics_Driver::wld_buffer *wbuffer = xid->buffer;
- if (wbuffer->draw_buffer.data_size != buffer->data_size) {
- fl_copy_offscreen(0, 0, oWindow->w(), oWindow->h(), other_xid->offscreen(), 0, 0);
- } else {
- memcpy(wbuffer->draw_buffer.buffer, buffer->buffer, wbuffer->draw_buffer.data_size);
- }
- }
- if (overlay() == oWindow) oWindow->draw_overlay();
-}
-
-
-const Fl_Image* Fl_Wayland_Window_Driver::shape() {
- return shape_data_ ? shape_data_->shape_ : NULL;
-}
-
-
-void Fl_Wayland_Window_Driver::shape_bitmap_(Fl_Image* b) {
- shape_data_->mask_pattern_ = Fl_Cairo_Graphics_Driver::bitmap_to_pattern(
- (Fl_Bitmap*)b, true, NULL);
- shape_data_->shape_ = b;
- shape_data_->lw_ = b->data_w();
- shape_data_->lh_ = b->data_h();
-}
-
-
-void Fl_Wayland_Window_Driver::shape_alpha_(Fl_Image* img, int offset) {
- int i, j, d = img->d(), w = img->data_w(), h = img->data_h();
- int bytesperrow = cairo_format_stride_for_width(CAIRO_FORMAT_A1, w);
- unsigned u;
- uchar byte, onebit;
- // build a CAIRO_FORMAT_A1 surface covering the non-fully transparent/black part of the image
- uchar* bits = new uchar[h*bytesperrow]; // to store the surface data
- const uchar* alpha = (const uchar*)*img->data() + offset; // points to alpha value of pixels
- for (i = 0; i < h; i++) {
- uchar *p = (uchar*)bits + i * bytesperrow;
- byte = 0;
- onebit = 1;
- for (j = 0; j < w; j++) {
- if (d == 3) {
- u = *alpha;
- u += *(alpha+1);
- u += *(alpha+2);
- }
- else u = *alpha;
- if (u > 0) { // if the pixel is not fully transparent/black
- byte |= onebit; // turn on the corresponding bit of the bitmap
- }
- onebit = onebit << 1; // move the single set bit one position to the left
- if (onebit == 0 || j == w-1) {
- onebit = 1;
- *p++ = ~byte; // store in bitmap one pack of bits, complemented
- byte = 0;
- }
- alpha += d; // point to alpha value of next img pixel
- }
- }
- cairo_surface_t *mask_surf = cairo_image_surface_create_for_data(bits, CAIRO_FORMAT_A1,
- w, h, bytesperrow);
- shape_data_->mask_pattern_ = cairo_pattern_create_for_surface(mask_surf);
- cairo_surface_destroy(mask_surf);
- shape_data_->shape_ = img;
- shape_data_->lw_ = w;
- shape_data_->lh_ = h;
-}
-
-
-void Fl_Wayland_Window_Driver::shape(const Fl_Image* img) {
- if (shape_data_) {
- if (shape_data_->mask_pattern_) {
- cairo_surface_t *surface;
- cairo_pattern_get_surface(shape_data_->mask_pattern_, &surface);
- uchar *data = cairo_image_surface_get_data(surface);
- cairo_pattern_destroy(shape_data_->mask_pattern_);
- delete[] data;
- }
- }
- else {
- shape_data_ = new shape_data_type;
- }
- memset(shape_data_, 0, sizeof(shape_data_type));
- pWindow->border(false);
- int d = img->d();
- if (d && img->count() >= 2) {
- shape_pixmap_((Fl_Image*)img);
- shape_data_->shape_ = (Fl_Image*)img;
- }
- else if (d == 0) shape_bitmap_((Fl_Image*)img);
- else if (d == 2 || d == 4) shape_alpha_((Fl_Image*)img, d - 1);
- else if ((d == 1 || d == 3) && img->count() == 1) shape_alpha_((Fl_Image*)img, 0);
-}
-
-
-void Fl_Wayland_Window_Driver::draw_end()
-{
- if (shape_data_ && shape_data_->mask_pattern_) {
- Fl_Wayland_Graphics_Driver *gr_dr = (Fl_Wayland_Graphics_Driver*)fl_graphics_driver;
- cairo_t *cr = gr_dr->cr();
- cairo_matrix_t matrix;
- cairo_matrix_init_scale(&matrix, double(shape_data_->lw_) / (pWindow->w() + 1),
- double(shape_data_->lh_) / (pWindow->h() + 1) );
- cairo_matrix_translate(&matrix, 1, 1);
- cairo_pattern_set_matrix(shape_data_->mask_pattern_, &matrix);
- cairo_set_operator(cr, CAIRO_OPERATOR_CLEAR);
- cairo_mask(cr, shape_data_->mask_pattern_);
- cairo_set_operator(cr, CAIRO_OPERATOR_OVER);
- }
-}
-
-
-/* Returns images of the captures of the window title-bar, and the left, bottom and right window borders
- (or NULL if a particular border is absent).
- Returned images can be deleted after use. Their depth and size may be platform-dependent.
- The top and bottom images extend from left of the left border to right of the right border.
- */
-void Fl_Wayland_Window_Driver::capture_titlebar_and_borders(Fl_RGB_Image*& top,
- Fl_RGB_Image*& left, Fl_RGB_Image*& bottom, Fl_RGB_Image*& right)
-{
- top = left = bottom = right = NULL;
- if (pWindow->decorated_h() == h()) return;
- int htop = pWindow->decorated_h() - pWindow->h();
- struct wld_window *wwin = fl_wl_xid(pWindow);
- int width, height, stride;
- uchar *cairo_data = fl_libdecor_titlebar_buffer(wwin->frame, &width, &height, &stride);
- if (!cairo_data) return;
- uchar *data = new uchar[width * height * 4];
- uchar *p = data;
- for (int j = 0; j < height; j++) {
- uchar *q = cairo_data + j * stride;
- for (int i = 0; i < width; i++) {
- *p++ = *(q+2); // R
- *p++ = *(q+1); // G
- *p++ = *q; // B
- *p++ = *(q+3); // A
- q += 4;
- }
- }
- top = new Fl_RGB_Image(data, width, height, 4);
- top->alloc_array = 1;
- top->scale(pWindow->w(), htop);
-}
-
-
-// make drawing go into this window (called by subclass flush() impl.)
-void Fl_Wayland_Window_Driver::make_current() {
- if (!shown()) {
- static const char err_message[] = "Fl_Window::make_current(), but window is not shown().";
- fl_alert(err_message);
- Fl::fatal(err_message);
- }
-
- struct wld_window *window = fl_wl_xid(pWindow);
- if (window->buffer) {
- ((Fl_Cairo_Graphics_Driver*)fl_graphics_driver)->needs_commit_tag(
- &window->buffer->draw_buffer_needs_commit);
- }
-
- // to support progressive drawing
- if ( (!Fl_Wayland_Window_Driver::in_flush_) && window->buffer && (!window->frame_cb) &&
- (!wait_for_expose_value) ) {
- Fl_Wayland_Graphics_Driver::buffer_commit(window);
- }
-
- Fl_Wayland_Window_Driver::wld_window = window;
- fl_window = (Window)window;
- float f = Fl::screen_scale(pWindow->screen_num());
- int wld_s = wld_scale();
- if (!window->buffer) {
- window->buffer = Fl_Wayland_Graphics_Driver::create_wld_buffer(
- int(pWindow->w() * f) * wld_s, int(pWindow->h() * f) * wld_s, false);
- ((Fl_Cairo_Graphics_Driver*)fl_graphics_driver)->needs_commit_tag(
- &window->buffer->draw_buffer_needs_commit);
- }
- ((Fl_Wayland_Graphics_Driver*)fl_graphics_driver)->set_cairo(
- window->buffer->draw_buffer.cairo_, f * wld_s);
- ((Fl_Cairo_Graphics_Driver*)fl_graphics_driver)->wld_scale = wld_s;
- int *poffset = Fl_Window_Driver::menu_offset_y(pWindow);
- if (poffset) { // for tall menu windows under KWIN to offset drawing inside window
- cairo_translate(window->buffer->draw_buffer.cairo_, 0, *poffset);
- }
- cairo_rectangle_int_t *extents = subRect();
- if (extents) { // make damage-to-buffer not to leak outside parent
- Fl_Region clip_region = fl_graphics_driver->XRectangleRegion(extents->x, extents->y,
- extents->width, extents->height);
-//printf("make_current: %dx%d %dx%d\n",extents->x, extents->y, extents->width, extents->height);
- Fl_X::flx(pWindow)->region = clip_region;
- }
- else fl_graphics_driver->clip_region(0);
-
-#ifdef FLTK_HAVE_CAIROEXT
- // update the cairo_t context
- if (Fl::cairo_autolink_context()) Fl::cairo_make_current(pWindow);
-#endif
-}
-
-
-void Fl_Wayland_Window_Driver::flush() {
- if (!pWindow->damage()) return;
- if (pWindow->as_gl_window()) {
- int W = pWindow->w();
- int H = pWindow->h();
- float scale = fl_graphics_driver->scale();
- Fl_Wayland_Window_Driver::in_flush_ = true;
- Fl_Window_Driver::flush();
- Fl_Wayland_Window_Driver::in_flush_ = false;
- gl_plugin()->do_swap(pWindow); // useful only for GL win with overlay
- if (scale != fl_graphics_driver->scale() || W != pWindow->w() || H != pWindow->h()) {
- gl_plugin()->invalidate(pWindow);
- }
- return;
- }
- struct wld_window *window = fl_wl_xid(pWindow);
- if (!window || !window->configured_width) return;
-
- Fl_X *ip = Fl_X::flx(pWindow);
- cairo_region_t* r = (cairo_region_t*)ip->region;
- if (!window->buffer || pWindow->as_overlay_window()) r = NULL;
-
- Fl_Wayland_Window_Driver::in_flush_ = true;
- Fl_Window_Driver::flush();
- Fl_Wayland_Window_Driver::in_flush_ = false;
- if (!window->frame_cb) Fl_Wayland_Graphics_Driver::buffer_commit(window, r);
-}
-
-
-void Fl_Wayland_Window_Driver::show() {
- if (!shown()) {
- fl_open_display();
- makeWindow();
- } else {
- // Wayland itself gives no way to programmatically unminimize a minimized window
- Fl::handle(FL_SHOW, pWindow);
- }
-}
-
-
-static void popup_done(void *data, struct xdg_popup *xdg_popup);
-
-
-static void destroy_surface_caution_pointer_focus(struct wl_surface *surface,
- struct Fl_Wayland_Screen_Driver::seat *seat) {
- if (seat->pointer_focus == surface) seat->pointer_focus = NULL;
- if (seat->keyboard_surface == surface) seat->keyboard_surface = NULL;
- wl_surface_destroy(surface);
-}
-
-
-void Fl_Wayland_Window_Driver::hide() {
- if (pWindow == Fl_Screen_Driver::transient_scale_parent) {
- // Delete also the running transient scale window
- // because the transient is a popup and MUST be deleted
- // before its parent.
- Fl::remove_timeout(Fl_Screen_Driver::del_transient_window);
- Fl_Screen_Driver::del_transient_window(NULL);
- }
- Fl_X* ip = Fl_X::flx(pWindow);
- if (hide_common()) return;
- if (ip->region) {
- Fl_Graphics_Driver::default_driver().XDestroyRegion(ip->region);
- ip->region = 0;
- }
- screen_num_ = -1;
- struct wld_window *wld_win = (struct wld_window*)ip->xid;
- if (wld_win) { // this test makes sure ip->xid has not been destroyed already
- Fl_Wayland_Graphics_Driver::buffer_release(wld_win);
- if (wld_win->kind == SUBWINDOW && wld_win->subsurface) {
- wl_subsurface_destroy(wld_win->subsurface);
- wld_win->subsurface = NULL;
- }
-#if HAVE_XDG_DIALOG
- if (wld_win->xdg_dialog) {
- xdg_dialog_v1_destroy(wld_win->xdg_dialog);
- wld_win->xdg_dialog = NULL;
- }
-#endif
- if (wld_win->kind == DECORATED) {
- libdecor_frame_unref(wld_win->frame);
- wld_win->frame = NULL;
- wld_win->xdg_surface = NULL;
- } else {
- if (wld_win->kind == POPUP && wld_win->xdg_popup) {
- popup_done(xdg_popup_get_user_data(wld_win->xdg_popup), wld_win->xdg_popup);
- wld_win->xdg_popup = NULL;
- }
- if (wld_win->kind == UNFRAMED && wld_win->xdg_toplevel) {
- xdg_toplevel_destroy(wld_win->xdg_toplevel);
- wld_win->xdg_toplevel = NULL;
- }
- if (wld_win->xdg_surface) {
- xdg_surface_destroy(wld_win->xdg_surface);
- wld_win->xdg_surface = NULL;
- }
- }
- if (wld_win->custom_cursor) delete_cursor(wld_win->custom_cursor);
- if (wld_win->wl_surface) {
- Fl_Wayland_Screen_Driver *scr_driver = (Fl_Wayland_Screen_Driver*)Fl::screen_driver();
- destroy_surface_caution_pointer_focus(wld_win->wl_surface, scr_driver->seat);
- wld_win->wl_surface = NULL;
- }
- while (!wl_list_empty(&wld_win->outputs)) { // remove from screens where it belongs
- struct surface_output *s_output;
- s_output = wl_container_of(wld_win->outputs.next, s_output, link);
- wl_list_remove(&s_output->link);
- free(s_output);
- }
- if (Fl_Wayland_Window_Driver::wld_window == wld_win) {
- Fl_Wayland_Window_Driver::wld_window = NULL;
- }
- if (wld_win->frame_cb) wl_callback_destroy(wld_win->frame_cb); // useful for GL subwins
- free(wld_win);
- }
- delete ip;
-}
-
-
-void Fl_Wayland_Window_Driver::map() {
- Fl_X* ip = Fl_X::flx(pWindow);
- struct wld_window *wl_win = (struct wld_window*)ip->xid;
- if (wl_win->kind == SUBWINDOW && !wl_win->subsurface) {
- struct wld_window *parent = fl_wl_xid(pWindow->window());
- if (parent) {
- Fl_Wayland_Screen_Driver *scr_driver = (Fl_Wayland_Screen_Driver*)Fl::screen_driver();
- wl_win->subsurface = wl_subcompositor_get_subsurface(scr_driver->wl_subcompositor,
- wl_win->wl_surface, parent->wl_surface);
- float f = Fl::screen_scale(pWindow->top_window()->screen_num());
- wl_subsurface_set_position(wl_win->subsurface, pWindow->x() * f, pWindow->y() * f);
- wl_subsurface_set_desync(wl_win->subsurface); // important
- wl_subsurface_place_above(wl_win->subsurface, parent->wl_surface);
- wl_win->configured_width = pWindow->w();
- wl_win->configured_height = pWindow->h();
- wait_for_expose_value = 0;
- pWindow->redraw();
- }
- }
-}
-
-
-void Fl_Wayland_Window_Driver::unmap() {
- Fl_X* ip = Fl_X::flx(pWindow);
- struct wld_window *wl_win = (struct wld_window*)ip->xid;
- if (wl_win->kind == SUBWINDOW && wl_win->wl_surface) {
- wl_surface_attach(wl_win->wl_surface, NULL, 0, 0);
- Fl_Wayland_Graphics_Driver::buffer_release(wl_win);
- wl_subsurface_destroy(wl_win->subsurface);
- wl_win->subsurface = NULL;
- }
-}
-
-
-void Fl_Wayland_Window_Driver::size_range() {
- if (shown()) {
- Fl_X* ip = Fl_X::flx(pWindow);
- struct wld_window *wl_win = (struct wld_window*)ip->xid;
- float f = Fl::screen_scale(pWindow->screen_num());
- int minw, minh, maxw, maxh;
- pWindow->get_size_range(&minw, &minh, &maxw, &maxh, NULL, NULL, NULL);
- if (wl_win->kind == DECORATED && wl_win->frame) {
- int X,Y,W,H;
- Fl::screen_work_area(X,Y,W,H, Fl::screen_num(x(),y(),w(),h()));
- if (maxw && maxw < W && maxh && maxh < H) {
- libdecor_frame_unset_capabilities(wl_win->frame, LIBDECOR_ACTION_FULLSCREEN);
- } else {
- libdecor_frame_set_capabilities(wl_win->frame, LIBDECOR_ACTION_FULLSCREEN);
- }
- if (maxw && maxh && (minw >= maxw || minh >= maxh)) {
- libdecor_frame_unset_capabilities(wl_win->frame, LIBDECOR_ACTION_RESIZE);
- } else {
- libdecor_frame_set_capabilities(wl_win->frame, LIBDECOR_ACTION_RESIZE);
- }
- libdecor_frame_set_min_content_size(wl_win->frame, minw*f, minh*f);
- libdecor_frame_set_max_content_size(wl_win->frame, maxw*f, maxh*f);
- if (xdg_toplevel()) {
- struct libdecor_state *state = libdecor_state_new(int(w() * f), int(h() * f));
- libdecor_frame_commit(wl_win->frame, state, NULL);
- libdecor_state_free(state);
- }
- } else if (wl_win->kind == UNFRAMED && wl_win->xdg_toplevel) {
- xdg_toplevel_set_min_size(wl_win->xdg_toplevel, minw*f, minh*f);
- if (maxw && maxh)
- xdg_toplevel_set_max_size(wl_win->xdg_toplevel, maxw*f, maxh*f);
- }
- }
-}
-
-
-void Fl_Wayland_Window_Driver::iconize() {
- Fl_X* ip = Fl_X::flx(pWindow);
- struct wld_window *wl_win = (struct wld_window*)ip->xid;
- if (wl_win->kind == DECORATED) {
- libdecor_frame_set_minimized(wl_win->frame);
- if (xdg_toplevel_get_version(xdg_toplevel()) < 6) {
- Fl::handle(FL_HIDE, pWindow);
- }
- }
- else if (wl_win->kind == UNFRAMED && wl_win->xdg_toplevel) xdg_toplevel_set_minimized(wl_win->xdg_toplevel);
-}
-
-
-void Fl_Wayland_Window_Driver::decoration_sizes(int *top, int *left, int *right, int *bottom)
-{
- struct wld_window *xid = (struct wld_window*)fl_xid(pWindow);
- if (xid && xid->kind == DECORATED) {
- libdecor_frame_translate_coordinate(xid->frame, 0, 0, left, top);
- *right = *left;
- *bottom = 0;
- } else {
- Fl_Window_Driver::decoration_sizes(top, left, right, bottom);
- }
-}
-
-
-int Fl_Wayland_Window_Driver::scroll(int src_x, int src_y, int src_w, int src_h,
- int dest_x, int dest_y,
- void (*draw_area)(void*, int,int,int,int), void* data)
-{
- struct wld_window * xid = fl_wl_xid(pWindow);
- struct Fl_Wayland_Graphics_Driver::wld_buffer *buffer = xid->buffer;
- float s = wld_scale() * fl_graphics_driver->scale();
- if (s != 1) {
- src_x = src_x * s;
- src_y = src_y * s;
- src_w = src_w * s;
- src_h = src_h * s;
- dest_x = dest_x * s;
- dest_y = dest_y * s;
- }
- if (src_x == dest_x) { // vertical scroll
- int i, to, step;
- if (src_y > dest_y) {
- i = 0; to = src_h; step = 1;
- } else {
- i = src_h - 1; to = -1; step = -1;
- }
- while (i != to) {
- memcpy(
- buffer->draw_buffer.buffer + (dest_y + i) * buffer->draw_buffer.stride + 4 * dest_x,
- buffer->draw_buffer.buffer + (src_y + i) * buffer->draw_buffer.stride + 4 * src_x,
- 4 * src_w);
- i += step;
- }
- } else { // horizontal scroll
- int i, to, step;
- if (src_x > dest_x) {
- i = 0; to = src_h; step = 1;
- } else {
- i = src_h - 1; to = -1; step = -1;
- }
- while (i != to) {
- memmove(
- buffer->draw_buffer.buffer + (src_y + i) * buffer->draw_buffer.stride + 4 * dest_x,
- buffer->draw_buffer.buffer + (src_y + i) * buffer->draw_buffer.stride + 4 * src_x,
- 4 * src_w);
- i += step;
- }
- }
- return 0;
-}
-
-
-static void handle_error(struct libdecor *libdecor_context, enum libdecor_error error, const char *message)
-{
- Fl::fatal("Caught error (%d): %s\n", error, message);
-}
-
-
-static struct libdecor_interface libdecor_iface = {
- .error = handle_error,
-};
-
-
-
-static void delayed_rescale(Fl_Window *win) {
- Fl_Window_Driver::driver(win)->is_a_rescale(true);
- win->size(win->w(), win->h());
- Fl_Window_Driver::driver(win)->is_a_rescale(false);
-}
-
-
-void change_scale(Fl_Wayland_Screen_Driver::output *output, struct wld_window *window,
- float pre_scale) {
- Fl_Wayland_Window_Driver *win_driver = Fl_Wayland_Window_Driver::driver(window->fl_win);
- if (!window->fl_win->parent()) {
- // for top-level, set its screen number when the 1st screen for this surface changes
- Fl_Wayland_Screen_Driver::output *running_output;
- Fl_Wayland_Screen_Driver *scr_dr = (Fl_Wayland_Screen_Driver*)Fl::screen_driver();
- int i = 0;
- wl_list_for_each(running_output, &scr_dr->outputs, link) { // each screen of the system
- if (running_output == output) { // we've found our screen of the system
- win_driver->screen_num(i);
- break;
- }
- i++;
- }
- }
- float post_scale = Fl::screen_scale(win_driver->screen_num()) * output->wld_scale;
-//printf("pre_scale=%.1f post_scale=%.1f\n", pre_scale, post_scale);
- if (post_scale != pre_scale) {
- if (window->kind == Fl_Wayland_Window_Driver::POPUP) {
- Fl_Wayland_Graphics_Driver::buffer_release(window);
- window->fl_win->redraw();
- } else {
- // delaying the rescaling is necessary to set first the window's size_range according to the new screen
- Fl::add_timeout(0, (Fl_Timeout_Handler)delayed_rescale, window->fl_win);
- }
- }
-}
-
-
-static void surface_enter(void *data, struct wl_surface *wl_surface,
- struct wl_output *wl_output) {
- struct wld_window *window = (struct wld_window*)data;
-
- if (!Fl_Wayland_Screen_Driver::own_output(wl_output))
- return;
-
- Fl_Wayland_Screen_Driver::output *output =
- (Fl_Wayland_Screen_Driver::output*)wl_output_get_user_data(wl_output);
- if (output == NULL)
- return;
-
- bool list_was_empty = wl_list_empty(&window->outputs);
- struct Fl_Wayland_Window_Driver::surface_output *surface_output =
- (struct Fl_Wayland_Window_Driver::surface_output*)malloc(
- sizeof(struct Fl_Wayland_Window_Driver::surface_output));
- surface_output->output = output;
- // add to end of the linked list of displays of this surface
- struct wl_list *e = &window->outputs;
- while (e->next != &window->outputs) e = e->next; // move e to end of linked list
- wl_list_insert(e, &surface_output->link);
-//printf("window %p enters screen id=%d length=%d\n", window->fl_win, output->id, wl_list_length(&window->outputs));
- if (list_was_empty && !window->fl_win->parent()) {
- change_scale(output, window, 0);
- }
-}
-
-
-static void surface_leave(void *data, struct wl_surface *wl_surface,
- struct wl_output *wl_output) {
- if (!Fl_Wayland_Screen_Driver::own_output(wl_output))
- return;
- struct wld_window *window = (struct wld_window*)data;
- Fl_Wayland_Screen_Driver::output *output =
- (Fl_Wayland_Screen_Driver::output*)wl_output_get_user_data(wl_output);
- Fl_Wayland_Window_Driver *win_driver = Fl_Wayland_Window_Driver::driver(window->fl_win);
- float pre_scale = Fl::screen_scale(win_driver->screen_num()) * win_driver->wld_scale();
- struct Fl_Wayland_Window_Driver::surface_output *s_output;
- int count = 0;
- wl_list_for_each(s_output, &window->outputs, link) {
- count++;
- if (s_output->output == output) {
- wl_list_remove(&s_output->link);
- free(s_output);
-//printf("window %p leaves screen id=%d length=%d\n", window->fl_win, output->id, wl_list_length(&window->outputs));
- break;
- }
- }
- if (count == 1 && !wl_list_empty(&window->outputs) && !window->fl_win->parent()) {
- s_output = wl_container_of(window->outputs.next, s_output, link);
- change_scale(s_output->output, window, pre_scale);
- }
-}
-
-
-static struct wl_surface_listener surface_listener = {
- surface_enter,
- surface_leave,
-};
-
-
-Fl_Window *Fl_Wayland_Window_Driver::surface_to_window(struct wl_surface *surface) {
- if (surface) {
- if (wl_proxy_get_listener((struct wl_proxy *)surface) == &surface_listener) {
- return ((struct wld_window *)wl_surface_get_user_data(surface))->fl_win;
- }
- }
- return NULL;
-}
-
-
-static struct Fl_Wayland_Screen_Driver::output *screen_num_to_output(int num_screen) {
- Fl_Wayland_Screen_Driver *scr_driver = (Fl_Wayland_Screen_Driver*)Fl::screen_driver();
- int i = 0;
- Fl_Wayland_Screen_Driver::output *output;
- wl_list_for_each(output, &(scr_driver->outputs), link) { // all screens of the system
- if (i++ == num_screen) return output;
- }
- return NULL;
-}
-
-
-#define LIBDECOR_MR131 1 // this means libdecor does not include MR!131 yet
-
-#ifdef LIBDECOR_MR131
-/* === Beginning of hack that would become un-needed if libdecor accepted MR!131 === */
-
-// true while the GUI is interactively resizing a decorated window
-static bool in_decorated_window_resizing = false;
-
-
-// libdecor's configure cb function for xdg_toplevel objects
-static void (*decor_xdg_toplevel_configure)(void*, struct xdg_toplevel *, int32_t,
- int32_t, struct wl_array *);
-
-
-static void fltk_xdg_toplevel_configure(void *user_data, struct xdg_toplevel *xdg_toplevel,
- int32_t width, int32_t height,
- struct wl_array *states) {
- uint32_t *p;
- in_decorated_window_resizing = false;
- // Replace wl_array_for_each(p, states) rejected by C++
- for (p = (uint32_t *)(states)->data;
- (const char *) p < ((const char *) (states)->data + (states)->size);
- (p)++) {
- if (*p == XDG_TOPLEVEL_STATE_RESIZING) {
- in_decorated_window_resizing = true;
- break;
- }
- }
- decor_xdg_toplevel_configure(user_data, xdg_toplevel, width, height, states);
-}
-
-
-struct wl_object { // copied from wayland-private.h
- const struct wl_interface *interface;
- const void *implementation;
- uint32_t id;
-};
-
-
-// replace libdecor's toplevel configure cb by FLTK's
-static void use_FLTK_toplevel_configure_cb(struct libdecor_frame *frame) {
- struct wl_object *object = (struct wl_object *)libdecor_frame_get_xdg_toplevel(frame);
- static struct xdg_toplevel_listener *fltk_listener = NULL;
- if (!fltk_listener) {
- struct xdg_toplevel_listener *decor_listener = (struct xdg_toplevel_listener*)
- object->implementation;
- fltk_listener = (struct xdg_toplevel_listener*)
- malloc(sizeof(struct xdg_toplevel_listener));
- // initialize FLTK's listener with libdecor's values
- *fltk_listener = *decor_listener;
- // memorize libdecor's toplevel configure cb
- decor_xdg_toplevel_configure = decor_listener->configure;
- // replace libdecor's toplevel configure cb by FLTK's
- fltk_listener->configure = fltk_xdg_toplevel_configure;
- }
- // replace the toplevel listener by a copy whose configure member is FLTK's
- object->implementation = fltk_listener;
-}
-
-/* === End of hack that would become un-needed if libdecor accepted MR!131 === */
-#endif // LIBDECOR_MR131
-
-
-// does win entirely cover its parent ?
-static void does_window_cover_parent(Fl_Window *win) {
- Fl_Window *parent = win->window();
- fl_wl_xid(parent)->covered = (win->x() <= 0 && win->y() <= 0 &&
- win->w() >= parent->w() && win->h() >= parent->h());
-}
-
-
-// recursively explore all shown subwindows in a window and call f for each
-static void scan_subwindows(Fl_Group *g, void (*f)(Fl_Window *)) {
- for (int i = 0; i < g->children(); i++) {
- Fl_Widget *o = g->child(i);
- if (o->as_window()) {
- if (!o->as_window()->shown()) continue;
- f(o->as_window());
- }
- if (o->as_group()) scan_subwindows(o->as_group(), f);
- }
-}
-
-// Generate FL_APP_ACTIVATE and FL_APP_DEACTIVATE events
-static bool app_has_active_window = false;
-
-// If a window is deactivated, check after a short delay if any other window has
-// become active. If not, send an FL_APP_DEACTIVATE event.
-static void deferred_check_app_deactivate(void*) {
- if (!app_has_active_window) return;
- app_has_active_window = false;
- // Check all FLTK windows to see if any are still active
- for (Fl_Window *w = Fl::first_window(); w; w = Fl::next_window(w)) {
- if (w->visible_r()) {
- struct wld_window* xid = fl_wl_xid(w);
- if (xid && (xid->state & LIBDECOR_WINDOW_STATE_ACTIVE)) {
- app_has_active_window = true;
- break;
- }
- }
- }
- if (!app_has_active_window) Fl::handle(FL_APP_DEACTIVATE, nullptr);
-}
-
-static void handle_configure(struct libdecor_frame *frame,
- struct libdecor_configuration *configuration, void *user_data)
-{
- struct wld_window *window = (struct wld_window*)user_data;
- if (!window->wl_surface) return;
- int width, height;
- enum libdecor_window_state window_state;
- struct libdecor_state *state;
- Fl_Wayland_Window_Driver *driver = Fl_Wayland_Window_Driver::driver(window->fl_win);
- // true exactly for the 1st run of handle_configure() for this window
- bool is_1st_run = (window->xdg_surface == 0);
- // true exactly for the 2nd run of handle_configure() for this window
- bool is_2nd_run = (window->xdg_surface != 0 && driver->wait_for_expose_value);
- float f = Fl::screen_scale(window->fl_win->screen_num());
-
- if (!window->xdg_surface) window->xdg_surface = libdecor_frame_get_xdg_surface(frame);
-
-#ifdef LIBDECOR_MR131
- if (is_1st_run) use_FLTK_toplevel_configure_cb(frame);
-#endif
- struct wl_output *wl_output = NULL;
- if (window->fl_win->fullscreen_active()) {
- if (!(window->state & LIBDECOR_WINDOW_STATE_FULLSCREEN)) {
- if (Fl_Window_Driver::driver(window->fl_win)->force_position()) {
- struct Fl_Wayland_Screen_Driver::output *output =
- screen_num_to_output(window->fl_win->screen_num());
- if (output) wl_output = output->wl_output;
- }
- libdecor_frame_set_fullscreen(window->frame, wl_output);
- }
- } else if (driver->show_iconic()) {
- libdecor_frame_set_minimized(window->frame);
- driver->show_iconic(0);
- }
- if (!libdecor_configuration_get_window_state(configuration, &window_state))
- window_state = LIBDECOR_WINDOW_STATE_NONE;
- if ((window->state & LIBDECOR_WINDOW_STATE_FULLSCREEN) &&
- !(window_state & LIBDECOR_WINDOW_STATE_FULLSCREEN) && !window->fl_win->border()) {
- // necessary so Mutter correctly positions borderless window back from fullscreen
- window->fl_win->redraw();
- }
- window->state = window_state;
-
- // Weston, KWin, and some old versions of Mutter, on purpose, don't set the
- // window width x height when xdg_toplevel_configure runs twice
- // during resizable window creation
- // (see https://gitlab.freedesktop.org/wayland/wayland-protocols/-/issues/6).
- // Consequently, libdecor_configuration_get_content_size() may return false twice.
- // Weston and KWin, at least, don't change the window size asked by the client application
- // which is available here in floating_{width,height}.
- if (!libdecor_configuration_get_content_size(configuration, frame, &width, &height)) {
- if (is_2nd_run) {
- width = window->floating_width;
- height = window->floating_height;
- if (!driver->is_resizable()) {
- libdecor_frame_set_min_content_size(frame, width, height);
- libdecor_frame_set_max_content_size(frame, width, height);
- }
- } else { width = height = 0; }
- }
- if (is_2nd_run && Fl_Wayland_Screen_Driver::compositor == Fl_Wayland_Screen_Driver::MUTTER) {
- scan_subwindows(window->fl_win, does_window_cover_parent); // issue #878
- }
-
- if (window->fl_win->fullscreen_active() &&
- Fl_Window_Driver::driver(window->fl_win)->force_position()) {
- int X, Y, W, H;
- Fl::screen_xywh(X, Y, W, H, window->fl_win->screen_num());
- width = W * f; height = H * f;
- }
-
- if (width == 0) {
- width = window->floating_width;
- height = window->floating_height;
- //fprintf(stderr,"handle_configure: using floating %dx%d\n",width,height);
- }
-
-#ifndef LIBDECOR_MR131
- bool in_decorated_window_resizing = (window->state & LIBDECOR_WINDOW_STATE_RESIZING);
-#endif
- bool condition = in_decorated_window_resizing;
- if (condition) { // see issue #878
- condition = (window->covered ? (window->buffer && window->buffer->in_use) : (window->frame_cb != NULL));
- }
- if (condition) {
- // Skip resizing & redrawing. The last resize request won't be skipped because
- // LIBDECOR_WINDOW_STATE_RESIZING will be off or cb will be NULL then.
- return;
- }
-
- driver->in_handle_configure = true;
- window->fl_win->resize(0, 0, ceil(width / f), ceil(height / f));
- driver->in_handle_configure = false;
- if (wl_output) window->fl_win->redraw();
- window->configured_width = ceil(width / f);
- window->configured_height = ceil(height / f);
- if (is_2nd_run) driver->wait_for_expose_value = 0;
-//fprintf(stderr, "handle_configure fl_win=%p size:%dx%d state=%x wait_for_expose_value=%d is_2nd_run=%d\n", window->fl_win, width,height,window_state,driver->wait_for_expose_value, is_2nd_run);
-
- // When no window is active, and one window gets activated, generate an FL_APP_ACTIVATE event
- if (window_state & LIBDECOR_WINDOW_STATE_ACTIVE) {
- if (!app_has_active_window) {
- app_has_active_window = true;
- Fl::handle(FL_APP_ACTIVATE, nullptr);
- }
-
- if (Fl_Wayland_Screen_Driver::compositor == Fl_Wayland_Screen_Driver::WESTON) {
- // After click on titlebar, weston calls wl_keyboard_enter() for a
- // titlebar-related surface that FLTK can't identify, so we send FL_FOCUS here.
- Fl::handle(FL_FOCUS, window->fl_win);
- }
- if (!window->fl_win->border()) libdecor_frame_set_visibility(window->frame, false);
- else if (!libdecor_frame_is_visible(window->frame)) {
- libdecor_frame_set_visibility(window->frame, true);
- } else if (!window->fl_win->visible()) {
- Fl::handle(FL_SHOW, window->fl_win); // useful when un-minimizing
- }
- } else if (window_state & LIBDECOR_WINDOW_STATE_SUSPENDED) { // window is minimized
- Fl::handle(FL_HIDE, window->fl_win);
- }
-
- // When a window gets deactivated and there are no other active windows,
- // generate an FL_APP_DEACTIVATE event
- if ( ((window_state & LIBDECOR_WINDOW_STATE_ACTIVE) == 0) && app_has_active_window) {
- Fl::add_timeout(0.1, deferred_check_app_deactivate, nullptr);
- }
-
- if (window->fl_win->border())
- driver->is_maximized(window_state & LIBDECOR_WINDOW_STATE_MAXIMIZED);
- if (window_state & LIBDECOR_WINDOW_STATE_MAXIMIZED) state = libdecor_state_new(width,
- height);
- else state = libdecor_state_new(int(ceil(width/f)*f), int(ceil(height/f)*f));
- libdecor_frame_commit(frame, state, configuration);
- if (libdecor_frame_is_floating(frame)) { // store floating dimensions
- window->floating_width = int(ceil(width/f)*f);
- window->floating_height = int(ceil(height/f)*f);
- //fprintf(stderr,"set floating_width+height %dx%d\n",width,height);
- }
- libdecor_state_free(state);
-
- driver->flush();
- if (Fl_Wayland_Screen_Driver::compositor != Fl_Wayland_Screen_Driver::WESTON || !is_1st_run) {
- window->fl_win->clear_damage();
- }
-}
-
-
-void Fl_Wayland_Window_Driver::wait_for_expose()
-{
- Fl_Window_Driver::wait_for_expose();
- struct wld_window * xid = fl_wl_xid(pWindow);
- if (!xid) return;
- if (pWindow->fullscreen_active()) {
- if (xid->kind == DECORATED) {
- while (!(xid->state & LIBDECOR_WINDOW_STATE_FULLSCREEN) ||
- !(xid->state & LIBDECOR_WINDOW_STATE_ACTIVE)) {
- wl_display_dispatch(Fl_Wayland_Screen_Driver::wl_display);
- }
- } else if (xid->kind == UNFRAMED) {
- wl_display_roundtrip(Fl_Wayland_Screen_Driver::wl_display);
- }
- } else if (xid->kind == DECORATED) {
- // necessary for the windowfocus demo program with recent Wayland versions
- if (!(xid->state & LIBDECOR_WINDOW_STATE_ACTIVE)) {
- wl_display_dispatch(Fl_Wayland_Screen_Driver::wl_display);
- }
- }
-}
-
-
-static void delayed_close(Fl_Window *win) {
- Fl::remove_check((Fl_Timeout_Handler)delayed_close, win);
- Fl::handle(FL_CLOSE, win);
-}
-
-
-static void handle_close(struct libdecor_frame *frame, void *user_data)
-{ // runs when the close button of a window titlebar is pushed
- // or after "Quit" of the application menu
- // or after the Kill command of Sway
- Fl_Window* win = ((struct wld_window*)user_data)->fl_win;
- int X, Y;
- libdecor_frame_translate_coordinate(frame, 0, 0, &X, &Y);
- if (Y == 0) Fl::handle(FL_CLOSE, win);
- else {
- // the close window attempt is delayed because libdecor
- // uses the frame after return from this function
- Fl::add_check((Fl_Timeout_Handler)delayed_close, win);
- }
-}
-
-
-static void handle_commit(struct libdecor_frame *frame, void *user_data)
-{
- struct wld_window* wl_win = (struct wld_window*)user_data;
- if (wl_win->wl_surface) wl_surface_commit(wl_win->wl_surface);
-}
-
-
-static void handle_dismiss_popup(struct libdecor_frame *frame, const char *seat_name, void *user_data)
-{
-}
-
-
-static struct libdecor_frame_interface libdecor_frame_iface = {
- handle_configure,
- handle_close,
- handle_commit,
- handle_dismiss_popup,
-};
-
-
-static void xdg_surface_configure(void *data, struct xdg_surface *xdg_surface, uint32_t serial)
-{
- // runs for borderless windows and popup (menu,tooltip) windows
- struct wld_window *window = (struct wld_window*)data;
- xdg_surface_ack_configure(xdg_surface, serial);
-//fprintf(stderr, "xdg_surface_configure: surface=%p\n", window->wl_surface);
-
- if (window->fl_win->w() != window->configured_width ||
- window->fl_win->h() != window->configured_height) {
- if (window->buffer) {
- Fl_Wayland_Graphics_Driver::buffer_release(window);
- }
- }
- window->configured_width = window->fl_win->w();
- window->configured_height = window->fl_win->h();
- Fl_Window_Driver::driver(window->fl_win)->flush();
- window->fl_win->clear_damage();
-}
-
-
-static const struct xdg_surface_listener xdg_surface_listener = {
- .configure = xdg_surface_configure,
-};
-
-
-static bool parse_states_fullscreen(struct wl_array *states)
-{
- uint32_t *p;
- // Replace wl_array_for_each(p, states) rejected by C++
- for (p = (uint32_t *)(states)->data;
- (const char *) p < ((const char *) (states)->data + (states)->size);
- (p)++) {
- if (*p == XDG_TOPLEVEL_STATE_FULLSCREEN) return true;
- }
- return false;
-}
-
-
-static void xdg_toplevel_configure(void *data, struct xdg_toplevel *xdg_toplevel,
- int32_t width, int32_t height, struct wl_array *states)
-{
- // runs for borderless top-level windows
- // under Weston: width & height are 0 during both calls, except if fullscreen
- struct wld_window *window = (struct wld_window*)data;
-//fprintf(stderr, "xdg_toplevel_configure: surface=%p size: %dx%d\n", window->wl_surface, width, height);
- if (window->fl_win->fullscreen_active() && !parse_states_fullscreen(states)) {
- struct wl_output *wl_output = NULL;
- if (Fl_Window_Driver::driver(window->fl_win)->force_position()) {
- struct Fl_Wayland_Screen_Driver::output *output =
- screen_num_to_output(window->fl_win->screen_num());
- if (output) wl_output = output->wl_output;
- }
- xdg_toplevel_set_fullscreen(xdg_toplevel, wl_output);
- if (wl_output) {
- int X, Y;
- Fl::screen_xywh(X, Y, width, height, window->fl_win->screen_num());
- }
- }
- if (window->configured_width) {
- Fl_Window_Driver::driver(window->fl_win)->wait_for_expose_value = 0;
- }
- float f = Fl::screen_scale(window->fl_win->screen_num());
- if (width == 0 || height == 0) {
- width = window->fl_win->w() * f;
- height = window->fl_win->h() * f;
- }
- window->fl_win->size(ceil(width / f), ceil(height / f));
- if (window->buffer && (ceil(width / f) != window->configured_width ||
- ceil(height / f) != window->configured_height)) {
- Fl_Wayland_Graphics_Driver::buffer_release(window);
- }
- window->configured_width = ceil(width / f);
- window->configured_height = ceil(height / f);
-}
-
-
-static void xdg_toplevel_close(void *data, struct xdg_toplevel *toplevel)
-{
-}
-
-
-static const struct xdg_toplevel_listener xdg_toplevel_listener = {
- .configure = xdg_toplevel_configure,
- .close = xdg_toplevel_close,
-};
-
-
-struct win_positioner {
- struct wld_window *window;
- int x, y;
- Fl_Window *child_popup;
-};
-
-
-static void popup_configure(void *data, struct xdg_popup *xdg_popup, int32_t x, int32_t y,
- int32_t width, int32_t height) {
- struct win_positioner *win_pos = (struct win_positioner *)data;
- struct wld_window *window = win_pos->window;
-//printf("popup_configure %p asked:%dx%d got:%dx%d\n",window->fl_win, win_pos->x,win_pos->y, x,y);
- Fl_Window_Driver::driver(window->fl_win)->wait_for_expose_value = 0;
- int HH;
- Fl_Window_Driver::menu_parent(&HH);
- if (window->fl_win->h() > HH && y != win_pos->y) { // A menu taller than the display
- // Under KWin, height is set to the display height or less: we ignore that.
- window->state = (y - win_pos->y);
- // make selected item visible, if there's one
- Fl_Window_Driver::scroll_to_selected_item(window->fl_win);
- }
- if (Fl_Window_Driver::current_menu_button && !Fl_Window_Driver::menu_leftorigin(window->fl_win)) {
- int X, Y;
- Fl_Window_Driver::current_menu_button->top_window_offset(X, Y);
- if (y < Y) {
- Fl_Window *win = window->fl_win;
- win->Fl_Widget::resize(win->x(), Y - win->h(), win->w(), win->h());
- }
- }
-}
-
-
-static struct xdg_popup *mem_grabbing_popup = NULL;
-
-
-static void popup_done(void *data, struct xdg_popup *xdg_popup) {
- struct win_positioner *win_pos = (struct win_positioner *)data;
- struct wld_window *window = win_pos->window;
-//fprintf(stderr, "popup_done: popup=%p data=%p xid=%p fl_win=%p\n", xdg_popup, data, window, window->fl_win);
- if (win_pos->child_popup) win_pos->child_popup->hide();
- xdg_popup_destroy(xdg_popup);
- delete win_pos;
- // The sway compositor calls popup_done directly and hides the menu
- // when the app looses focus.
- // Thus, we hide the window so FLTK and Wayland are in matching states.
- window->xdg_popup = NULL;
- window->fl_win->hide();
- if (mem_grabbing_popup == xdg_popup) {
- mem_grabbing_popup = NULL;
- }
-}
-
-
-static const struct xdg_popup_listener popup_listener = {
- .configure = popup_configure,
- .popup_done = popup_done,
-};
-
-
-bool Fl_Wayland_Window_Driver::in_flush_ = false;
-
-
-static const char *get_prog_name() {
- pid_t pid = getpid();
- char fname[100];
- snprintf(fname, 100, "/proc/%u/cmdline", pid);
- FILE *in = fopen(fname, "r");
- if (in) {
- static char line[200];
- const char *p = fgets(line, sizeof(line), in);
- fclose(in);
- p = strrchr(line, '/'); if (!p) p = line; else p++;
- return p;
- }
- return "unknown";
-}
-
-
-/* Implementation note about menu windows under Wayland.
- Wayland offers a way to position popup windows such as menu windows using constraints.
- Each popup is located relatively to a parent window which can be a popup itself and
- MUST overlap or at least touch this parent.
- Constraints determine how a popup is positioned relatively to a defined area (called
- the anchor rectangle) of its parent popup/window and what happens when this position
- would place the popup all or partly outside the display.
- In contrast, FLTK computes the adequate positions of menu windows in the display using
- knowledge about the display size and the location of the window in the display, and then
- maps them at these positions.
- These 2 logics are quite different because Wayland hides the position of windows inside the
- display, whereas FLTK uses the location of windows inside the display to position popups.
- Let's call "source window" the non-popup window above which all popups are mapped.
- The approach implemented here is two-fold.
- 1) If a menu window is not taller than the display, use Wayland constraints to position it.
- Wayland imposes that the first constructed popup must overlap or touch the source window.
- Other popups can be placed below, above, at right, or at left of a previous popup which
- allows them to expand outside the source window, while constraints can ensure they won't
- extend outside the display.
- 2) A menu window taller than the display is initially mapped with the constraint to
- begin at the top border of the display. This allows FLTK to know the distance between
- the source window and the display top. FLTK can later reposition the same tall popup,
- without the constraint not to go beyond the display top, at the exact position so that
- the desired series of menu items appear in the visible part of the tall popup.
-
- In case 1) above, the values that represent the display bounds are given very
- large values. That's done by member function Fl_Wayland_Window_Driver::menu_window_area().
- Consequently, FLTK computes an initial layout of future popups relatively to
- the source window as if it was mapped on an infinitely large display. Then, the location
- of the first popup to be mapped is modified if necessary so it overlaps or touches the
- source window. Finally, other popups are located using Wayland logic below, above or to the
- right of previous popups. Wayland constraints mechanism also allows a popup tentatively
- placed below a previous one to be flipped above it if that prevents the popup from expanding
- beyond display limits. This is used to unfold menu bar menus below or above the menu bar.
- After each popup is created and scheduled for being mapped on display by function
- process_menu_or_tooltip(), makeWindow() calls Fl_Window::wait_for_expose() so its constrained
- position is known before computing the position of the next popup. This ensures each
- popup is correctly placed relatively to its parent.
-
- Groups of popups containing a menutitle, the associated menuwindow, and optionally
- a submenu window and that don't belong to an Fl_Menu_Bar are mapped in a different order:
- the menuwindow is mapped first, and the menutitle is mapped second above it as a child popup.
- Fl_Window_Driver::is_floating_title() detects when such a menutitle is created,
- static member variable previous_floatingtitle is assigned the value of this menutitle, and
- the menutitle is mapped only after the menuwindow has been mapped, as a child of it.
- This positions better the popup group in the display relatively to where the popup
- was created.
-
- In case 2) above, a tall popup is mapped with XDG_POSITIONER_CONSTRAINT_ADJUSTMENT_SLIDE_Y
- which puts its top at the display top border. The Wayland system then calls the
- popup_configure() callback function with the x,y coordinates of the top left corner
- where the popup is mapped relatively to an anchor point in the source window.
- The difference between the asked window position and the effective position is stored
- in the state member variable of the tall popup's struct wld_window. This information
- allows FLTK to compute the distance between the source window top and the display top border.
- Function Fl_Wayland_Window_Driver::menu_window_area() sets the top of the display to
- a value such that function Fl_Wayland_Window_Driver::reposition_menu_window(), called by
- menuwindow::autoscroll(int n), ensures that menu item #n is visible. Static boolean member
- variable Fl_Wayland_Window_Driver::new_popup is useful to position tall menuwindows created
- by an Fl_Menu_Button or Fl_Choice. It is set to true when any menu popup is created.
- It is used each time menu_window_area() runs for a particular Fl_Menu_Button or Fl_Choice,
- and is reset to false after its first use. This allows menu_window_area() to give the top of
- the display an adequate value the first time and to keep this value next times it runs.
- Fl_Window_Driver::scroll_to_selected_item() scrolls the tall popup so its selected
- item, when there's one, is visible immediately after the tall popup is mapped on display.
- */
-
-
-bool Fl_Wayland_Window_Driver::process_menu_or_tooltip(struct wld_window *new_window) {
- // a menu window or tooltip
- new_window->kind = Fl_Wayland_Window_Driver::POPUP;
- Fl_Wayland_Screen_Driver *scr_driver = (Fl_Wayland_Screen_Driver*)Fl::screen_driver();
- if (Fl_Window_Driver::is_floating_title(pWindow)) {
- previous_floatingtitle = pWindow;
- return true;
- }
- new_window->xdg_surface = xdg_wm_base_get_xdg_surface(scr_driver->xdg_wm_base,
- new_window->wl_surface);
- xdg_surface_add_listener(new_window->xdg_surface, &xdg_surface_listener, new_window);
- Fl_Wayland_Window_Driver::new_popup = true;
- Fl_Window *menu_origin = NULL;
- if (pWindow->menu_window()) {
- menu_origin = Fl_Window_Driver::menu_leftorigin(pWindow);
- if (!menu_origin && !previous_floatingtitle) menu_origin =
- Fl_Window_Driver::menu_title(pWindow);
- }
- Fl_Widget *target = (pWindow->tooltip_window() ? Fl_Tooltip::current() : NULL);
- if (pWindow->user_data() == &Fl_Screen_Driver::transient_scale_display &&
- Fl_Screen_Driver::transient_scale_parent) {
- target = Fl_Screen_Driver::transient_scale_parent;
- }
- if (!target) target = Fl_Window_Driver::menu_parent();
- if (!target) target = Fl::belowmouse();
- if (!target) target = Fl::first_window();
- Fl_Window *parent_win = target->top_window();
- while (parent_win && parent_win->menu_window() && driver(parent_win)->popup_window()) {
- parent_win = Fl::next_window(parent_win);
- }
- Fl_Window *origin_win = (menu_origin ? menu_origin : parent_win);
- struct wld_window * parent_xid = fl_wl_xid(origin_win);
- struct xdg_surface *parent_xdg = parent_xid->xdg_surface;
- float f = Fl::screen_scale(parent_win->screen_num());
- //fprintf(stderr, "menu parent_win=%p pos:%dx%d size:%dx%d\n", parent_win, pWindow->x(), pWindow->y(), pWindow->w(), pWindow->h());
-//printf("window=%p menutitle=%p bartitle=%d leftorigin=%p y=%d\n", pWindow, Fl_Window_Driver::menu_title(pWindow), Fl_Window_Driver::menu_bartitle(pWindow), Fl_Window_Driver::menu_leftorigin(pWindow), pWindow->y());
- struct xdg_positioner *positioner = xdg_wm_base_create_positioner(scr_driver->xdg_wm_base);
- //xdg_positioner_get_version(positioner) <== gives 1 under Debian and Sway
- int popup_x, popup_y;
- if (Fl_Window_Driver::current_menu_button && !Fl_Window_Driver::menu_leftorigin(pWindow)) {
- int X, Y;
- Fl_Window_Driver::current_menu_button->top_window_offset(X, Y);
- xdg_positioner_set_anchor_rect(positioner, X * f, Y * f,
- Fl_Window_Driver::current_menu_button->w() * f,
- Fl_Window_Driver::current_menu_button->h() * f);
- popup_x = X * f;
- popup_y = 0;
- if (parent_xid->kind == Fl_Wayland_Window_Driver::DECORATED && !origin_win->fullscreen_active())
- libdecor_frame_translate_coordinate(parent_xid->frame, popup_x, popup_y,
- &popup_x, &popup_y);
- } else if (Fl_Window_Driver::menu_title(pWindow) && Fl_Window_Driver::menu_bartitle(pWindow)) {
- xdg_positioner_set_anchor_rect(positioner, 0, 0,
- Fl_Window_Driver::menu_title(pWindow)->w() * f,
- Fl_Window_Driver::menu_title(pWindow)->h() * f);
- popup_x = 0;
- popup_y = Fl_Window_Driver::menu_title(pWindow)->h() * f;
- } else {
- popup_x = pWindow->x() * f; popup_y = pWindow->y() * f;
- if (popup_x + pWindow->w() * f < 0) popup_x = - pWindow->w() * f;
- if (menu_origin) {
- popup_x -= menu_origin->x() * f;
- popup_y -= menu_origin->y() * f;
- }
- if (popup_x >= origin_win->w() * f) popup_x = origin_win->w() * f - 1;
- if (!Fl_Window_Driver::menu_title(pWindow) && !Fl_Window_Driver::menu_bartitle(pWindow) &&
- !Fl_Window_Driver::menu_leftorigin(pWindow)) {
- // prevent first popup from going above the permissible source window
- popup_y = fl_max(popup_y, - pWindow->h() * f);
- }
- if (parent_xid->kind == Fl_Wayland_Window_Driver::DECORATED && !origin_win->fullscreen_active())
- libdecor_frame_translate_coordinate(parent_xid->frame, popup_x, popup_y,
- &popup_x, &popup_y);
- xdg_positioner_set_anchor_rect(positioner, popup_x, 0, 1, 1);
- popup_y++;
- }
- int positioner_H = pWindow->h();
- if (Fl_Wayland_Screen_Driver::compositor == Fl_Wayland_Screen_Driver::KWIN) {
- // Under KWIN, limiting the height of the positioner to the work area height
- // results in tall popup windows starting at the top of the screen, what we want.
- // Unfortunately, we know the work area height exactly only for single-screen systems,
- // otherwise FLTK returns work area height == screen height. In that case we estimate
- // work area height ≈ screen height - 44.
- int V, work_area_H, screen_H;
- Fl::screen_work_area(V, V, V, work_area_H, origin_win->screen_num());
- Fl::screen_xywh(V, V, V, screen_H, origin_win->screen_num());
- if (work_area_H == screen_H) work_area_H -= 44;
- if (positioner_H > work_area_H) positioner_H = work_area_H;
- }
- xdg_positioner_set_size(positioner, pWindow->w() * f , positioner_H * f );
- xdg_positioner_set_anchor(positioner, XDG_POSITIONER_ANCHOR_BOTTOM_LEFT);
- xdg_positioner_set_gravity(positioner, XDG_POSITIONER_GRAVITY_BOTTOM_RIGHT);
- // prevent menuwindow from expanding beyond display limits
- int constraint = 0;
- int top_menubar = pWindow->y() -
- (Fl_Window_Driver::menu_bartitle(pWindow) && Fl_Window_Driver::menu_title(pWindow) ?
- Fl_Window_Driver::menu_title(pWindow)->h() : 0);
- if ( !(parent_win->fullscreen_active() &&
- Fl_Wayland_Screen_Driver::compositor == Fl_Wayland_Screen_Driver::MUTTER &&
- ((!Fl_Window_Driver::menu_title(pWindow) && !Fl_Window_Driver::menu_leftorigin(pWindow)) ||
- Fl_Window_Driver::menu_bartitle(pWindow)) && top_menubar < 10 &&
- !Fl_Window_Driver::current_menu_button)
- ) {
- // Condition above is only to bypass Mutter bug for fullscreen windows (see #1061)
- constraint |= (XDG_POSITIONER_CONSTRAINT_ADJUSTMENT_SLIDE_X | XDG_POSITIONER_CONSTRAINT_ADJUSTMENT_SLIDE_Y);
- if ((Fl_Window_Driver::current_menu_button || Fl_Window_Driver::menu_bartitle(pWindow)) &&
- !Fl_Window_Driver::menu_leftorigin(pWindow)) {
- constraint |= XDG_POSITIONER_CONSTRAINT_ADJUSTMENT_FLIP_Y;
- }
- xdg_positioner_set_constraint_adjustment(positioner, constraint);
- }
- if (!(Fl_Window_Driver::menu_title(pWindow) && Fl_Window_Driver::menu_bartitle(pWindow))) {
- xdg_positioner_set_offset(positioner, 0, popup_y);
- }
- new_window->xdg_popup = xdg_surface_get_popup(new_window->xdg_surface,
- parent_xdg, positioner);
- struct win_positioner *win_pos = new struct win_positioner;
- win_pos->window = new_window;
- win_pos->x = popup_x;
- win_pos->y = popup_y;
- win_pos->child_popup = NULL;
-//printf("create xdg_popup=%p data=%p xid=%p fl_win=%p\n",new_window->xdg_popup,win_pos,new_window,new_window->fl_win);
- xdg_positioner_destroy(positioner);
- xdg_popup_add_listener(new_window->xdg_popup, &popup_listener, win_pos);
- if (!mem_grabbing_popup) {
- mem_grabbing_popup = new_window->xdg_popup;
- //xdg_popup_grab(new_window->xdg_popup, scr_driver->get_wl_seat(), scr_driver->get_serial());
- //libdecor_frame_popup_grab(parent_xid->frame, scr_driver->get_seat_name());
- }
- wl_surface_commit(new_window->wl_surface);
- // put it on same screen as parent_win
- this->screen_num(parent_win->screen_num());
- return false;
-}
-
-
-void Fl_Wayland_Window_Driver::makeWindow()
-{
- Fl_Group::current(0); // get rid of very common user bug: forgot end()
- struct wld_window *new_window;
- bool is_floatingtitle = false;
- wait_for_expose_value = 1;
-
- if (pWindow->parent() && !pWindow->window()) return;
- if (pWindow->parent() && !pWindow->window()->shown()) return;
-
- if (!pWindow->parent() && !popup_window()) {
- x(0); y(0); // toplevel, non-popup windows must have origin at 0,0
- }
- new_window = (struct wld_window *)calloc(1, sizeof *new_window);
- new_window->fl_win = pWindow;
- wl_list_init(&new_window->outputs);
- Fl_Wayland_Screen_Driver *scr_driver = (Fl_Wayland_Screen_Driver*)Fl::screen_driver();
-
- new_window->wl_surface = wl_compositor_create_surface(scr_driver->wl_compositor);
-//printf("makeWindow:%p %s %s\n", pWindow, pWindow->parent()?"SUB":"", pWindow->as_gl_window()?"GL":"");
- wl_surface_add_listener(new_window->wl_surface, &surface_listener, new_window);
-
- if (!shape()) { // rectangular FLTK windows are opaque
- struct wl_region *opaque = wl_compositor_create_region(scr_driver->wl_compositor);
- wl_region_add(opaque, 0, 0, 1000000, 1000000);
- wl_surface_set_opaque_region(new_window->wl_surface, opaque);
- wl_region_destroy(opaque);
- }
-
- if (pWindow->user_data() == &Fl_Screen_Driver::transient_scale_display &&
- Fl::first_window()) {
- // put transient scale win at center of top window by making it a tooltip of top
- Fl_Screen_Driver::transient_scale_parent = Fl::first_window();
- pWindow->set_tooltip_window();
- set_popup_window();
- pWindow->position(
- (Fl_Screen_Driver::transient_scale_parent->w() - pWindow->w())/2 ,
- (Fl_Screen_Driver::transient_scale_parent->h() - pWindow->h())/2);
- }
-
- if (popup_window()) { // a menu window or tooltip
- is_floatingtitle = process_menu_or_tooltip(new_window);
-
- } else if (pWindow->border() && !pWindow->parent() ) { // a decorated window
- new_window->kind = DECORATED;
- if (!scr_driver->libdecor_context)
- scr_driver->libdecor_context = libdecor_new(Fl_Wayland_Screen_Driver::wl_display,
- &libdecor_iface);
- new_window->frame = libdecor_decorate(scr_driver->libdecor_context, new_window->wl_surface,
- &libdecor_frame_iface, new_window);
- // appears in the Gnome desktop menu bar
- libdecor_frame_set_app_id(new_window->frame, get_prog_name());
- libdecor_frame_set_title(new_window->frame, pWindow->label()?pWindow->label():"");
- if (!is_resizable()) {
- libdecor_frame_unset_capabilities(new_window->frame, LIBDECOR_ACTION_RESIZE);
- libdecor_frame_unset_capabilities(new_window->frame, LIBDECOR_ACTION_FULLSCREEN);
- }
- libdecor_frame_map(new_window->frame);
- float f = Fl::screen_scale(pWindow->screen_num());
- new_window->floating_width = pWindow->w() * f;
- new_window->floating_height = pWindow->h() * f;
-
- } else if (pWindow->parent()) { // for subwindows (GL or non-GL)
- new_window->kind = SUBWINDOW;
- struct wld_window *parent = fl_wl_xid(pWindow->window());
- new_window->subsurface = wl_subcompositor_get_subsurface(scr_driver->wl_subcompositor,
- new_window->wl_surface,
- parent->wl_surface);
-//fprintf(stderr, "makeWindow: subsurface=%p\n", new_window->subsurface);
- float f = Fl::screen_scale(pWindow->top_window()->screen_num());
- wl_subsurface_set_position(new_window->subsurface, pWindow->x() * f, pWindow->y() * f);
- wl_subsurface_set_desync(new_window->subsurface); // important
- // Next 5 statements ensure the subsurface will be mapped because:
- // "The effect of adding a sub-surface becomes visible on the next time
- // the state of the parent surface is applied."
- new_window->configured_width = pWindow->w();
- new_window->configured_height = pWindow->h();
- if (!pWindow->as_gl_window()) {
- parent->fl_win->wait_for_expose();
- wl_surface_commit(parent->wl_surface);
- }
- wait_for_expose_value = 0;
- pWindow->border(0);
- checkSubwindowFrame(); // make sure subwindow doesn't leak outside parent
-
- } else { // a window without decoration
- new_window->kind = UNFRAMED;
- new_window->xdg_surface = xdg_wm_base_get_xdg_surface(scr_driver->xdg_wm_base,
- new_window->wl_surface);
-//fprintf(stderr, "makeWindow: xdg_wm_base_get_xdg_surface=%p\n", new_window->xdg_surface);
- xdg_surface_add_listener(new_window->xdg_surface, &xdg_surface_listener, new_window);
- new_window->xdg_toplevel = xdg_surface_get_toplevel(new_window->xdg_surface);
- xdg_toplevel_add_listener(new_window->xdg_toplevel, &xdg_toplevel_listener, new_window);
- if (pWindow->label()) xdg_toplevel_set_title(new_window->xdg_toplevel, pWindow->label());
- wl_surface_commit(new_window->wl_surface);
- pWindow->border(0);
- }
-
- Fl_Window *old_first = Fl::first_window();
- struct wld_window * first_xid = (old_first ? fl_wl_xid(old_first) : NULL);
- Fl_X *xp = new Fl_X;
- xp->xid = (fl_uintptr_t)new_window;
- other_xid = 0;
- xp->w = pWindow;
- flx(xp);
- xp->region = 0;
- if (!pWindow->parent()) {
- xp->next = Fl_X::first;
- Fl_X::first = xp;
- } else if (Fl_X::first) {
- xp->next = Fl_X::first->next;
- Fl_X::first->next = xp;
- } else {
- xp->next = NULL;
- Fl_X::first = xp;
- }
-
- if (pWindow->modal() || pWindow->non_modal()) {
- if (pWindow->modal()) Fl::modal_ = pWindow;
- if (new_window->kind == DECORATED && first_xid && first_xid->kind == DECORATED) {
- if (first_xid->frame) libdecor_frame_set_parent(new_window->frame, first_xid->frame);
- } else if (new_window->kind == UNFRAMED && new_window->xdg_toplevel && first_xid) {
- Fl_Wayland_Window_Driver *top_dr = Fl_Wayland_Window_Driver::driver(first_xid->fl_win);
- if (top_dr->xdg_toplevel()) xdg_toplevel_set_parent(new_window->xdg_toplevel,
- top_dr->xdg_toplevel());
- }
- if (new_window->kind == DECORATED || new_window->kind == UNFRAMED) {
-#if HAVE_XDG_DIALOG
- if (scr_driver->xdg_wm_dialog) {
- new_window->xdg_dialog = xdg_wm_dialog_v1_get_xdg_dialog(scr_driver->xdg_wm_dialog, xdg_toplevel());
- if (pWindow->modal()) xdg_dialog_v1_set_modal(new_window->xdg_dialog);
- } else
-#endif
- if (scr_driver->seat->gtk_shell && pWindow->modal()) {
- // Useful to position modal windows above their parent with "gnome-shell --version" ≤ 45.2,
- // useless but harmless with "gnome-shell --version" ≥ 46.0.
- struct gtk_surface1 *gtk_surface = gtk_shell1_get_gtk_surface(scr_driver->seat->gtk_shell,
- new_window->wl_surface);
- gtk_surface1_set_modal(gtk_surface);
- if (gtk_surface1_get_version(gtk_surface) >= GTK_SURFACE1_RELEASE_SINCE_VERSION)
- gtk_surface1_release(gtk_surface); // very necessary
- else
- gtk_surface1_destroy(gtk_surface);
- }
- }
- }
-
- size_range();
- pWindow->set_visible();
- int old_event = Fl::e_number;
- pWindow->redraw();
- pWindow->handle(Fl::e_number = FL_SHOW); // get child windows to appear
- Fl::e_number = old_event;
- if (pWindow->menu_window() && popup_window() && !is_floatingtitle) {
- // make sure each menu window is mapped with its constraints before mapping next popup
- pWindow->wait_for_expose();
- if (previous_floatingtitle) { // a menuwindow with a menutitle
- //puts("previous_floatingtitle");
- int HH;
- Fl_Window_Driver::menu_parent(&HH);
- if (pWindow->h() > HH) {
- // a tall menuwindow with a menutitle: don't create the menutitle at all
- // and undo what has been created/allocated before
- struct wld_window *xid = fl_wl_xid(previous_floatingtitle);
- destroy_surface_caution_pointer_focus(xid->wl_surface, scr_driver->seat);
- free(xid);
- Fl_Window_Driver::driver(previous_floatingtitle)->hide_common();
- previous_floatingtitle = NULL;
- return;
- }
- // map the menutitle popup now as child of pWindow
- struct wld_window *xid = fl_wl_xid(previous_floatingtitle);
- xid->xdg_surface = xdg_wm_base_get_xdg_surface(scr_driver->xdg_wm_base, xid->wl_surface);
- xdg_surface_add_listener(xid->xdg_surface, &xdg_surface_listener, xid);
- struct xdg_positioner *positioner =
- xdg_wm_base_create_positioner(scr_driver->xdg_wm_base);
- xdg_positioner_set_anchor_rect(positioner, 0, 0, 1, 1);
- int snum = Fl_Window_Driver::menu_parent()->screen_num();
- float f = Fl::screen_scale(snum);
- // put it on same screen as parent menu
- Fl_Window_Driver::driver(previous_floatingtitle)->screen_num(snum);
- xdg_positioner_set_size(positioner, previous_floatingtitle->w() * f ,
- previous_floatingtitle->h() * f );
- xdg_positioner_set_anchor(positioner, XDG_POSITIONER_ANCHOR_TOP_LEFT);
- xdg_positioner_set_gravity(positioner, XDG_POSITIONER_GRAVITY_TOP_RIGHT);
- xid->xdg_popup = xdg_surface_get_popup(xid->xdg_surface, new_window->xdg_surface,
- positioner);
- xdg_positioner_destroy(positioner);
- struct win_positioner *win_pos = new struct win_positioner;
- win_pos->window = xid;
- win_pos->x = 0;
- win_pos->y = 0;
- win_pos->child_popup = NULL;
- xdg_popup_add_listener(xid->xdg_popup, &popup_listener, win_pos);
- wl_surface_commit(xid->wl_surface);
- struct win_positioner *parent_win_pos =
- (struct win_positioner*)xdg_popup_get_user_data(new_window->xdg_popup);
- parent_win_pos->child_popup = previous_floatingtitle;
- previous_floatingtitle = NULL;
- }
- }
- if (pWindow->fullscreen_active()) Fl::handle(FL_FULLSCREEN, pWindow);
-}
-
-
-int Fl_Wayland_Window_Driver::set_cursor(Fl_Cursor c) {
- Fl_Wayland_Screen_Driver *scr_driver = (Fl_Wayland_Screen_Driver*)Fl::screen_driver();
- struct wld_window *xid = (struct wld_window *)Fl_Window_Driver::xid(pWindow);
-#if HAVE_CURSOR_SHAPE
- if (scr_driver->wp_cursor_shape_device) {
- if (xid->custom_cursor) {
- delete_cursor(xid->custom_cursor);
- xid->custom_cursor = NULL;
- }
- if (c == FL_CURSOR_NONE) return 0;
- standard_cursor_ = c;
- Fl_Wayland_Screen_Driver::do_set_cursor(scr_driver->seat, NULL, c);
- return 1;
- }
-#endif // HAVE_CURSOR_SHAPE
- if (!scr_driver->seat->cursor_theme) return 1;
- // Cursor names are the files of directory /usr/share/icons/XXXX/cursors/
- // where XXXX is the name of the current 'cursor theme'.
- static struct cursor_file_struct {
- Fl_Cursor c;
- const char *fname;
- Fl_Wayland_Screen_Driver::cursor_shapes wld_c;
- } cursor_file_array[] = {
- {FL_CURSOR_ARROW, "left_ptr", Fl_Wayland_Screen_Driver::arrow },
- {FL_CURSOR_CROSS, "cross", Fl_Wayland_Screen_Driver::cross },
- {FL_CURSOR_WAIT, "watch", Fl_Wayland_Screen_Driver::wait },
- {FL_CURSOR_INSERT, "xterm", Fl_Wayland_Screen_Driver::insert },
- {FL_CURSOR_HAND, "hand1", Fl_Wayland_Screen_Driver::hand },
- {FL_CURSOR_HELP, "help", Fl_Wayland_Screen_Driver::help },
- {FL_CURSOR_MOVE, "move", Fl_Wayland_Screen_Driver::move },
- {FL_CURSOR_N, "top_side", Fl_Wayland_Screen_Driver::north },
- {FL_CURSOR_E, "right_side", Fl_Wayland_Screen_Driver::east },
- {FL_CURSOR_W, "left_side", Fl_Wayland_Screen_Driver::west },
- {FL_CURSOR_S, "bottom_side", Fl_Wayland_Screen_Driver::south },
- {FL_CURSOR_NS, "sb_v_double_arrow", Fl_Wayland_Screen_Driver::north_south },
- {FL_CURSOR_WE, "sb_h_double_arrow", Fl_Wayland_Screen_Driver::west_east },
- {FL_CURSOR_SW, "bottom_left_corner", Fl_Wayland_Screen_Driver::south_west },
- {FL_CURSOR_SE, "bottom_right_corner", Fl_Wayland_Screen_Driver::south_east },
- {FL_CURSOR_NE, "top_right_corner", Fl_Wayland_Screen_Driver::north_east },
- {FL_CURSOR_NW, "top_left_corner", Fl_Wayland_Screen_Driver::north_west },
- {FL_CURSOR_NESW, "fd_double_arrow", Fl_Wayland_Screen_Driver::nesw },
- {FL_CURSOR_NWSE, "bd_double_arrow", Fl_Wayland_Screen_Driver::nwse }
- };
-
- int found = -1;
- for (unsigned i = 0; i < sizeof(cursor_file_array) / sizeof(struct cursor_file_struct); i++) {
- if (cursor_file_array[i].c == c) {
- found = cursor_file_array[i].wld_c;
- if (!scr_driver->xc_cursor[found]) scr_driver->xc_cursor[found] =
- scr_driver->cache_cursor(cursor_file_array[i].fname);
- if (scr_driver->xc_cursor[found]) {
- scr_driver->default_cursor(scr_driver->xc_cursor[found]);
- }
- break;
- }
- }
- if (found < 0 || !scr_driver->xc_cursor[found]) return 0;
-
- if (xid->custom_cursor) {
- delete_cursor(xid->custom_cursor);
- xid->custom_cursor = NULL;
- }
- standard_cursor_ = c;
- scr_driver->set_cursor();
- return 1;
-}
-
-
-void Fl_Wayland_Window_Driver::use_border() {
- if (!shown() || pWindow->parent()) return;
- pWindow->wait_for_expose(); // useful for border(0) just after show()
- struct libdecor_frame *frame = fl_wl_xid(pWindow)->frame;
- if (frame && Fl_Wayland_Screen_Driver::compositor != Fl_Wayland_Screen_Driver::KWIN) {
- if (fl_wl_xid(pWindow)->kind == DECORATED) {
- libdecor_frame_set_visibility(frame, pWindow->border());
- } else {
- pWindow->hide();
- pWindow->show();
- }
- pWindow->redraw();
- } else {
- Fl_Window_Driver::use_border();
- }
-}
-
-
-/* Change an existing window to fullscreen */
-void Fl_Wayland_Window_Driver::fullscreen_on() {
- int top, bottom, left, right;
-
- top = fullscreen_screen_top();
- bottom = fullscreen_screen_bottom();
- left = fullscreen_screen_left();
- right = fullscreen_screen_right();
-
- if ((top < 0) || (bottom < 0) || (left < 0) || (right < 0)) {
- top = screen_num();
- bottom = top;
- left = top;
- right = top;
- }
- pWindow->wait_for_expose(); // make sure ->xdg_toplevel is initialized
- if (xdg_toplevel()) {
- xdg_toplevel_set_fullscreen(xdg_toplevel(), NULL);
- pWindow->_set_fullscreen();
- Fl::handle(FL_FULLSCREEN, pWindow);
- }
-}
-
-
-void Fl_Wayland_Window_Driver::fullscreen_off(int X, int Y, int W, int H) {
- pWindow->hide();
- pWindow->_clear_fullscreen();
- // avoid being called with W=H=0 in suboptimal scenario of #1299
- if (!W) W = w();
- if (!H) H = h();
- pWindow->resize(X, Y, W, H);
- pWindow->show();
- Fl::handle(FL_FULLSCREEN, pWindow);
-}
-
-
-void Fl_Wayland_Window_Driver::label(const char *name, const char *iname) {
- if (shown() && !parent() && fl_wl_xid(pWindow)->kind == DECORATED) {
- if (!name) name = "";
- if (!iname) iname = fl_filename_name(name);
- libdecor_frame_set_title(fl_wl_xid(pWindow)->frame, name);
- }
-}
-
-
-int Fl_Wayland_Window_Driver::set_cursor(const Fl_RGB_Image *rgb, int hotx, int hoty) {
- int retval = set_cursor_4args(rgb, hotx, hoty, true);
- if (retval) {
- Fl_Wayland_Screen_Driver *scr_driver = (Fl_Wayland_Screen_Driver*)Fl::screen_driver();
- struct wld_window *xid = (struct wld_window *)Fl_Window_Driver::xid(pWindow);
- Fl_Wayland_Screen_Driver::do_set_cursor(scr_driver->seat, xid->custom_cursor->wl_cursor);
- }
- return retval;
-}
-
-
-int Fl_Wayland_Window_Driver::set_cursor_4args(const Fl_RGB_Image *rgb, int hotx, int hoty,
- bool keep_copy) {
- if (keep_copy) {
- if (rgb->as_svg_image()) {
- int scale = wld_scale();
- Fl_RGB_Image *svg = (Fl_RGB_Image*)rgb->copy(rgb->w() * scale, rgb->h() * scale);
- svg->normalize();
- svg->scale(rgb->w(), rgb->h(), 0, 1);
- rgb = svg;
- } else {
- int ld = rgb->ld() ? rgb->ld() : rgb->data_w() * rgb->d();
- uchar *data = new uchar[ld * rgb->data_h()];
- memcpy(data, rgb->array, ld * rgb->data_h());
- Fl_RGB_Image *rgb2 = new Fl_RGB_Image(data, rgb->data_w(), rgb->data_h(), rgb->d(), rgb->ld());
- rgb2->alloc_array = 1;
- rgb2->scale(rgb->w(), rgb->h(), 0, 1);
- rgb = rgb2;
- }
- }
-// build a new wl_cursor and its image
- struct wld_window *xid = (struct wld_window *)Fl_Window_Driver::xid(pWindow);
- struct wl_cursor *new_cursor = (struct wl_cursor*)malloc(sizeof(struct wl_cursor));
- struct cursor_image *new_image = (struct cursor_image*)calloc(1,
- sizeof(struct cursor_image));
- int scale = wld_scale();
- new_image->image.width = rgb->w() * scale;
- new_image->image.height = rgb->h() * scale;
- new_image->image.hotspot_x = hotx * scale;
- new_image->image.hotspot_y = hoty * scale;
- new_image->image.delay = 0;
- new_image->offset = 0;
- //create a Wayland buffer and have it used as an image of the new cursor
- struct Fl_Wayland_Graphics_Driver::wld_buffer *offscreen;
- Fl_Image_Surface *img_surf = Fl_Wayland_Graphics_Driver::custom_offscreen(
- new_image->image.width, new_image->image.height, &offscreen);
- new_image->buffer = offscreen->wl_buffer;
- wl_buffer_set_user_data(new_image->buffer, offscreen);
- new_cursor->image_count = 1;
- new_cursor->images = (struct wl_cursor_image**)malloc(sizeof(struct wl_cursor_image*));
- new_cursor->images[0] = (struct wl_cursor_image*)new_image;
- new_cursor->name = strdup("custom cursor");
- // draw the rgb image to the cursor's drawing buffer
- Fl_Surface_Device::push_current(img_surf);
- Fl_Wayland_Graphics_Driver *driver = (Fl_Wayland_Graphics_Driver*)img_surf->driver();
- cairo_scale(driver->cr(), scale, scale);
- ((Fl_RGB_Image*)rgb)->draw(0, 0);
- Fl_Surface_Device::pop_current();
- delete img_surf;
- memcpy(offscreen->data, offscreen->draw_buffer.buffer, offscreen->draw_buffer.data_size);
- // delete the previous custom cursor, if there was one,
- // and keep its Fl_RGB_Image if appropriate
- if (xid->custom_cursor) delete_cursor(xid->custom_cursor, keep_copy);
- //have this new cursor used
- xid->custom_cursor = new custom_cursor;
- xid->custom_cursor->wl_cursor = new_cursor;
- xid->custom_cursor->rgb = rgb;
- xid->custom_cursor->hotx = hotx;
- xid->custom_cursor->hoty = hoty;
- return 1;
-}
-
-
-void Fl_Wayland_Window_Driver::resize(int X, int Y, int W, int H) {
- static int depth = 0;
- struct wld_window *fl_win = fl_wl_xid(pWindow);
- if (fl_win && fl_win->kind == DECORATED && !xdg_toplevel()) {
- pWindow->wait_for_expose();
- }
- int is_a_move = (X != x() || Y != y());
- bool true_rescale = Fl_Window::is_a_rescale();
- float f = fl_win ? Fl::screen_scale(pWindow->screen_num()) : 1;
- if (fl_win && fl_win->buffer) {
- int scale = wld_scale();
- int stride = cairo_format_stride_for_width(
- Fl_Cairo_Graphics_Driver::cairo_format, int(W * f) * scale );
- size_t bsize = stride * int(H * f) * scale;
- true_rescale = (bsize != fl_win->buffer->draw_buffer.data_size);
- }
- int is_a_resize = (W != w() || H != h() || true_rescale);
- if (is_a_move) force_position(1);
- else if (!is_a_resize && !is_a_move) return;
- depth++;
- if (shown() && !(parent() || popup_window())) {
- X = Y = 0;
- }
- Fl_Window *parent = this->parent() ? pWindow->window() : NULL;
- struct wld_window *parent_xid = parent ? fl_wl_xid(parent) : NULL;
-//printf("resize[%p] %dx%d is_a_resize=%d is_a_move=%d depth=%d parent_xid->frame_cb=%p\n", pWindow,W,H,is_a_resize,is_a_move,depth, (parent_xid?parent_xid->frame_cb:0) );
- if (depth == 1 && fl_win && parent_xid && parent_xid->frame_cb && can_expand_outside_parent_) {
- // When moving or resizing a subwindow independently from its parent while the parent window
- // is being redrawn, the processing depends on whether the moved/resize window
- // is a draggable-subwindow. For a draggable subwindow having can_expand_outside_parent_ != 0,
- // skip the X,Y,W,H tuple to process only tuples received when parent window is ready.
- // This smoothes the movement of the draggable subwindow.
- // Process regular subwindows normally.
- depth--;
- return;
- }
- if (is_a_resize) {
- if (pWindow->parent()) {
- if (W < 1) W = 1;
- if (H < 1) H = 1;
- }
- pWindow->Fl_Group::resize(X,Y,W,H);
- //fprintf(stderr, "resize: win=%p to %dx%d\n", pWindow, W, H);
- if (shown()) {pWindow->redraw();}
- } else {
- x(X); y(Y);
- //fprintf(stderr, "move win=%p to %dx%d\n", pWindow, X, Y);
- }
- if (!fl_win) {
- depth--;
- return;
- }
-
- if (is_a_resize) {
- if (pWindow->as_overlay_window() && other_xid) {
- destroy_double_buffer();
- }
- if (fl_win->kind == DECORATED) { // a decorated window
- if (fl_win->buffer) {
- Fl_Wayland_Graphics_Driver::buffer_release(fl_win);
- }
- fl_win->configured_width = W;
- fl_win->configured_height = H;
- if (!in_handle_configure && xdg_toplevel()) {
- if (Fl_Window::is_a_rescale()) size_range();
- struct libdecor_state *state = libdecor_state_new(int(W * f), int(H * f));
- // necessary only if resize is initiated by prog
- libdecor_frame_commit(fl_win->frame, state, NULL);
- libdecor_state_free(state);
- if (libdecor_frame_is_floating(fl_win->frame)) {
- fl_win->floating_width = int(W*f);
- fl_win->floating_height = int(H*f);
- }
- }
- } else if (fl_win->kind == SUBWINDOW && fl_win->subsurface) { // a subwindow
- wl_subsurface_set_position(fl_win->subsurface, X * f, Y * f);
- if (!pWindow->as_gl_window()) Fl_Wayland_Graphics_Driver::buffer_release(fl_win);
- fl_win->configured_width = W;
- fl_win->configured_height = H;
- } else if (fl_win->xdg_surface) { // a window without border
- if (!pWindow->as_gl_window()) Fl_Wayland_Graphics_Driver::buffer_release(fl_win);
- fl_win->configured_width = W;
- fl_win->configured_height = H;
- W *= f; H *= f;
- xdg_surface_set_window_geometry(fl_win->xdg_surface, 0, 0, W, H);
- //printf("xdg_surface_set_window_geometry: %dx%d\n",W, H);
- }
- } else if (!in_handle_configure && xdg_toplevel() && Fl::e_state == FL_BUTTON1) {
- // Wayland doesn't provide a way for the app to set the window position on screen.
- // This is functional when the move is mouse-driven.
- Fl_Wayland_Screen_Driver *scr_driver = (Fl_Wayland_Screen_Driver*)Fl::screen_driver();
- xdg_toplevel_move(xdg_toplevel(), scr_driver->seat->wl_seat, scr_driver->seat->serial);
- Fl::pushed(NULL);
- Fl::e_state = 0;
- }
-
- if (parent_xid) {
- if (depth > 1) {
- if (fl_win->subsurface) {
- wl_subsurface_set_position(fl_win->subsurface, X * f, Y * f);
- wl_surface_commit(parent_xid->wl_surface);
- }
- } else if (parent_xid->buffer && is_a_move) {
- if (fl_win->subsurface) wl_subsurface_set_position(fl_win->subsurface, X * f, Y * f);
- if (!parent_xid->buffer->wl_buffer || parent_xid->buffer->draw_buffer_needs_commit) {
- if (!parent_xid->frame_cb) Fl_Wayland_Graphics_Driver::buffer_commit(parent_xid);
- else wl_surface_commit(parent_xid->wl_surface);
- } else {
- if (!parent_xid->frame_cb) {
- // Use the frame callback mechanism applied to the object's parent window
- parent_xid->frame_cb = wl_surface_frame(parent_xid->wl_surface);
- wl_callback_add_listener(parent_xid->frame_cb,
- Fl_Wayland_Graphics_Driver::p_surface_frame_listener, parent_xid);
- }
- wl_surface_commit(parent_xid->wl_surface);
- }
- }
- checkSubwindowFrame(); // make sure subwindow doesn't leak outside parent
- }
- depth--;
-}
-
-
-static void crect_intersect(cairo_rectangle_int_t *to, cairo_rectangle_int_t *with) {
- int x = fl_max(to->x, with->x);
- to->width = fl_min(to->x + to->width, with->x + with->width) - x;
- if (to->width < 0) to->width = 0;
- int y = fl_max(to->y, with->y);
- to->height = fl_min(to->y + to->height, with->y + with->height) - y;
- if (to->height < 0) to->height = 0;
- to->x = x;
- to->y = y;
-}
-
-
-static bool crect_equal(cairo_rectangle_int_t *to, cairo_rectangle_int_t *with) {
- return (to->x == with->x && to->y == with->y && to->width == with->width &&
- to->height == with->height);
-}
-
-
-void Fl_Wayland_Window_Driver::checkSubwindowFrame() {
- if (!pWindow->parent() || can_expand_outside_parent_) return;
- // make sure this subwindow doesn't leak out of its parent window
- Fl_Window *from = pWindow, *parent;
- cairo_rectangle_int_t full = {0, 0, pWindow->w(), pWindow->h()}; // full subwindow area
- cairo_rectangle_int_t srect = full; // will become new subwindow clip
- int fromx = 0, fromy = 0;
- while ((parent = from->window()) != NULL) { // loop over all parent windows
- fromx -= from->x(); // parent origin in subwindow's coordinates
- fromy -= from->y();
- cairo_rectangle_int_t prect = {fromx, fromy, parent->w(), parent->h()};
- crect_intersect(&srect, &prect); // area of subwindow inside its parent
- from = parent;
- }
- cairo_rectangle_int_t *r = subRect();
- // current subwindow clip
- cairo_rectangle_int_t current_clip = (r ? *r : full);
- if (!crect_equal(&srect, &current_clip)) { // if new clip differs from current clip
- if (crect_equal(&srect, &full)) r = NULL;
- else {
- r = &srect;
- if (r->width == 0 || r->height == 0) {
- r = NULL;
- }
- }
- subRect(r);
- }
-}
-
-
-void Fl_Wayland_Window_Driver::subRect(cairo_rectangle_int_t *r) {
- if (subRect_) delete subRect_;
- cairo_rectangle_int_t *r2 = NULL;
- if (r) {
- r2 = new cairo_rectangle_int_t;
- *r2 = *r;
- }
- subRect_ = r2;
-}
-
-
-void Fl_Wayland_Window_Driver::reposition_menu_window(int x, int y) {
- if (y == pWindow->y()) return;
- // The top of the tall popup window was positioned at the top of the screen
- // Instead of sliding up the popup window on the display, we slide up the
- // drawing inside the fixed popup via member variable offset_y of the
- // menuwindow class, and we redraw the popup content.
- // It's also useful to make such tall popup window transparent.
- *Fl_Window_Driver::menu_offset_y(pWindow) += (y - pWindow->y());
- struct wld_window *xid = fl_wl_xid(pWindow);
- wl_surface_set_opaque_region(xid->wl_surface, NULL);
- if (xid->buffer) memset(xid->buffer->draw_buffer.buffer, 0,
- xid->buffer->draw_buffer.data_size);
- //printf("offset_y=%d\n", *Fl_Window_Driver::menu_offset_y(pWindow));
- this->y(y);
- pWindow->redraw();
-}
-
-
-void Fl_Wayland_Window_Driver::menu_window_area(int &X, int &Y, int &W, int &H, int nscreen) {
- int HH;
- Fl_Window *parent = Fl_Window_Driver::menu_parent(&HH);
- if (parent) {
- if (pWindow->menu_window() && popup_window() && pWindow->h() > HH) {
- // tall menu: set top (Y) and bottom (Y+H) bounds relatively to reference window
- int ih = Fl_Window_Driver::menu_itemheight(pWindow);
- X = -50000;
- W = 1000000;
- H = HH - 2 * ih;
- Fl_Window *origin = Fl_Window_Driver::menu_leftorigin(pWindow);
- if (origin) { // has left parent
- int selected = fl_max(Fl_Window_Driver::menu_selected(origin), 0);
- Y = origin->y() + (selected + 0.5) * ih;
- } else if (!Fl_Window_Driver::menu_bartitle(pWindow)) { // tall menu button
- static int y_offset = 0;
- if (new_popup) {
- y_offset = pWindow->y()- ih;
- new_popup = false;
- }
- Y = 1.5 * ih + y_offset;
- } else { // has a menutitle
- Y = 1.5 * ih;
- }
- } else { // position the menu window by wayland constraints
- X = -50000;
- Y = -50000;
- W = 1000000;
- H = 1000000;
- }
- //printf("menu_window_area: %dx%d - %dx%d\n",X,Y,W,H);
- } else Fl_Window_Driver::menu_window_area(X, Y, W, H, nscreen);
-}
-
-
-int Fl_Wayland_Window_Driver::wld_scale() {
- Fl_X *flx = Fl_X::flx(pWindow);
- struct wld_window *xid = (flx ? (struct wld_window *)flx->xid : NULL);
- if (!xid || wl_list_empty(&xid->outputs)) {
- int scale = 1;
- Fl_Wayland_Screen_Driver *scr_driver = (Fl_Wayland_Screen_Driver*)Fl::screen_driver();
- Fl_Wayland_Screen_Driver::output *output;
- wl_list_for_each(output, &(scr_driver->outputs), link) {
- scale = fl_max(scale, output->wld_scale);
- }
- return scale;
- }
- struct surface_output *s_output;
- s_output = wl_container_of(xid->outputs.next, s_output, link);
- return s_output->output->wld_scale;
-}
-
-
-FL_EXPORT struct wl_surface *fl_wl_surface(struct wld_window *xid) {
- return xid->wl_surface;
-}
-
-
-cairo_t *fl_wl_gc() {
- return ((Fl_Cairo_Graphics_Driver*)fl_graphics_driver)->cr();
-}
-
-
-Fl_Window *fl_wl_find(struct wld_window *xid) {
- return Fl_Window_Driver::find((fl_uintptr_t)xid);
-}
-
-
-struct wld_window *fl_wl_xid(const Fl_Window *win) {
- return (struct wld_window *)Fl_Window_Driver::xid(win);
-}
-
-
-struct wl_compositor *fl_wl_compositor() {
- Fl_Wayland_Screen_Driver *screen_driver = (Fl_Wayland_Screen_Driver*)Fl::screen_driver();
- return screen_driver->wl_compositor;
-}
-
-
-int fl_wl_buffer_scale(Fl_Window *window) {
- return Fl_Wayland_Window_Driver::driver(window)->wld_scale();
-}
-
-
-Fl_Wayland_Plugin *Fl_Wayland_Window_Driver::gl_plugin() {
- static Fl_Wayland_Plugin *plugin = NULL;
- if (!plugin) {
- Fl_Plugin_Manager pm("wayland.fltk.org");
- plugin = (Fl_Wayland_Plugin*)pm.plugin("gl.wayland.fltk.org");
- }
- return plugin;
-}
-
-
-void Fl_Wayland_Window_Driver::maximize() {
- struct wld_window *xid = (struct wld_window *)Fl_X::flx(pWindow)->xid;
- if (xid->kind == DECORATED) libdecor_frame_set_maximized(xid->frame);
- else Fl_Window_Driver::maximize();
-}
-
-
-void Fl_Wayland_Window_Driver::un_maximize() {
- struct wld_window *xid = (struct wld_window *)Fl_X::flx(pWindow)->xid;
- if (xid->kind == DECORATED) libdecor_frame_unset_maximized(xid->frame);
- else Fl_Window_Driver::un_maximize();
-}
diff --git a/src/drivers/Wayland/fl_wayland_clipboard_dnd.cxx b/src/drivers/Wayland/fl_wayland_clipboard_dnd.cxx
deleted file mode 100644
index 12c525c46..000000000
--- a/src/drivers/Wayland/fl_wayland_clipboard_dnd.cxx
+++ /dev/null
@@ -1,741 +0,0 @@
-//
-// Wayland-specific code for clipboard and drag-n-drop support.
-//
-// Copyright 1998-2026 by Bill Spitzak and others.
-//
-// This library is free software. Distribution and use rights are outlined in
-// the file "COPYING" which should have been included with this file. If this
-// file is missing or damaged, see the license at:
-//
-// https://www.fltk.org/COPYING.php
-//
-// Please see the following page on how to report bugs and issues:
-//
-// https://www.fltk.org/bugs.php
-//
-
-#if !defined(FL_DOXYGEN)
-
-# include <FL/Fl.H>
-# include <FL/platform.H>
-# include <FL/Fl_Window.H>
-# include <FL/Fl_Shared_Image.H>
-# include <FL/Fl_Image_Surface.H>
-# include "Fl_Wayland_Screen_Driver.H"
-# include "Fl_Wayland_Window_Driver.H"
-# include "../Unix/Fl_Unix_System_Driver.H"
-# include "Fl_Wayland_Graphics_Driver.H"
-# include "../../flstring.h" // includes <string.h>
-
-# include <errno.h>
-# include <stdio.h>
-# include <stdlib.h>
-# include <map>
-
-
-////////////////////////////////////////////////////////////////
-// Code used for copy and paste and DnD into the program:
-
-static char *fl_selection_buffer[2];
-static int fl_selection_length[2];
-static const char * fl_selection_type[2];
-static int fl_selection_buffer_length[2];
-static char fl_i_own_selection[2] = {0,0};
-static struct wl_data_offer *fl_selection_offer = NULL;
-// The MIME type Wayland uses for text-containing clipboard:
-static const char wld_plain_text_clipboard[] = "text/plain;charset=utf-8";
-
-
-int Fl_Wayland_Screen_Driver::clipboard_contains(const char *type)
-{
- return fl_selection_type[1] == type;
-}
-
-
-struct data_source_write_struct {
- size_t rest;
- char *from;
-};
-
-void write_data_source_cb(FL_SOCKET fd, data_source_write_struct *data) {
- while (data->rest) {
- ssize_t n = write(fd, data->from, data->rest);
- if (n == -1) {
- if (errno == EAGAIN) return;
- Fl::error("write_data_source_cb: error while writing clipboard data\n");
- break;
- }
- data->from += n;
- data->rest -= n;
- }
- Fl::remove_fd(fd, FL_WRITE);
- delete data;
- close(fd);
-}
-
-
-static void data_source_handle_send(void *data, struct wl_data_source *source,
- const char *mime_type, int fd) {
- fl_intptr_t rank = (fl_intptr_t)data;
-//fprintf(stderr, "data_source_handle_send: %s fd=%d l=%d\n", mime_type, fd, fl_selection_length[1]);
- if (((!strcmp(mime_type, wld_plain_text_clipboard) || !strcmp(mime_type, "text/plain")) &&
- fl_selection_type[rank] == Fl::clipboard_plain_text)
- ||
- (!strcmp(mime_type, "image/bmp") && fl_selection_type[rank] == Fl::clipboard_image) ) {
- data_source_write_struct *write_data = new data_source_write_struct;
- write_data->rest = fl_selection_length[rank];
- write_data->from = fl_selection_buffer[rank];
- Fl::add_fd(fd, FL_WRITE, (Fl_FD_Handler)write_data_source_cb, write_data);
- } else {
- //Fl::error("Destination client requested unsupported MIME type: %s\n", mime_type);
- close(fd);
- }
-}
-
-
-static Fl_Window *fl_dnd_target_window = 0;
-static wl_surface *fl_dnd_target_surface = 0;
-static bool doing_dnd = false; // true when DnD is in action
-static wl_surface *dnd_icon = NULL; // non null when DnD uses text as cursor
-static wl_cursor* save_cursor = NULL; // non null when DnD uses "dnd-copy" cursor
-
-
-static void data_source_handle_cancelled(void *data, struct wl_data_source *source) {
- // An application has replaced the clipboard contents or DnD finished
- wl_data_source_destroy(source);
- Fl_Wayland_Screen_Driver *scr_driver = (Fl_Wayland_Screen_Driver*)Fl::screen_driver();
- if (scr_driver->seat->data_source == source) scr_driver->seat->data_source = NULL;
- doing_dnd = false;
- if (dnd_icon) {
- struct Fl_Wayland_Graphics_Driver::wld_buffer *off =
- (struct Fl_Wayland_Graphics_Driver::wld_buffer *)
- wl_surface_get_user_data(dnd_icon);
- struct wld_window fake_window;
- memset(&fake_window, 0, sizeof(fake_window));
- fake_window.buffer = off;
- Fl_Wayland_Graphics_Driver::buffer_release(&fake_window);
- wl_surface_destroy(dnd_icon);
- dnd_icon = NULL;
- }
- fl_i_own_selection[1] = 0;
- if (data == 0) { // at end of DnD
- if (save_cursor) {
- scr_driver->default_cursor(save_cursor);
- scr_driver->set_cursor();
- save_cursor = NULL;
- }
- if (fl_dnd_target_window) {
- Fl::handle(FL_RELEASE, fl_dnd_target_window);
- fl_dnd_target_window = 0;
- }
- Fl::pushed(0);
- }
-}
-
-
-static void data_source_handle_target(void *data, struct wl_data_source *source, const char *mime_type) {
- if (!Fl::pushed()) {
- data_source_handle_cancelled(data, source);
- return;
- }
- if (mime_type != NULL) {
- //printf("Destination would accept MIME type if dropped: %s\n", mime_type);
- } else {
- //printf("Destination would reject if dropped\n");
- }
-}
-
-
-static uint32_t last_dnd_action = WL_DATA_DEVICE_MANAGER_DND_ACTION_NONE;
-
-
-static void data_source_handle_action(void *data, struct wl_data_source *source,
- uint32_t dnd_action) {
- last_dnd_action = dnd_action;
- switch (dnd_action) {
- case WL_DATA_DEVICE_MANAGER_DND_ACTION_COPY:
- //printf("Destination would perform a copy action if dropped\n");
- break;
- case WL_DATA_DEVICE_MANAGER_DND_ACTION_NONE:
- //printf("Destination would reject the drag if dropped\n");
- break;
- }
-}
-
-
-static void data_source_handle_dnd_drop_performed(void *data, struct wl_data_source *source) {
- //printf("Drop performed\n");
-}
-
-
-static void data_source_handle_dnd_finished(void *data, struct wl_data_source *source) {
- switch (last_dnd_action) {
- case WL_DATA_DEVICE_MANAGER_DND_ACTION_MOVE:
- //printf("Destination has accepted the drop with a move action\n");
- break;
- case WL_DATA_DEVICE_MANAGER_DND_ACTION_COPY:
- //printf("Destination has accepted the drop with a copy action\n");
- break;
- }
-}
-
-
-static const struct wl_data_source_listener data_source_listener = {
- .target = data_source_handle_target,
- .send = data_source_handle_send,
- .cancelled = data_source_handle_cancelled,
- .dnd_drop_performed = data_source_handle_dnd_drop_performed,
- .dnd_finished = data_source_handle_dnd_finished,
- .action = data_source_handle_action,
-};
-
-
-static struct Fl_Wayland_Graphics_Driver::wld_buffer *offscreen_from_text(const char *text,
- int scale) {
- const char *p, *q;
- int width = 0, height, w2, ltext = strlen(text);
- fl_font(FL_HELVETICA, 10 * scale);
- p = text;
- int nl = 0;
- while(nl < 20 && (q=strchr(p, '\n')) != NULL) {
- nl++;
- w2 = int(fl_width(p, q - p));
- if (w2 > width) width = w2;
- p = q + 1;
- }
- if (nl < 20 && text[ ltext - 1] != '\n') {
- nl++;
- w2 = int(fl_width(p));
- if (w2 > width) width = w2;
- }
- if (width > 300*scale) width = 300*scale;
- height = nl * fl_height() + 3;
- width += 6;
- width = ceil(width/float(scale)) * scale; // these must be multiples of scale
- height = ceil(height/float(scale)) * scale;
- struct Fl_Wayland_Graphics_Driver::wld_buffer *off;
- Fl_Image_Surface *surf = Fl_Wayland_Graphics_Driver::custom_offscreen(
- width, height, &off);
- Fl_Surface_Device::push_current(surf);
- p = text;
- fl_font(FL_HELVETICA, 10 * scale);
- int y = fl_height();
- while (nl > 0) {
- q = strchr(p, '\n');
- if (q) {
- fl_draw(p, q - p, 3, y);
- } else {
- fl_draw(p, 3, y);
- break;
- }
- y += fl_height();
- p = q + 1;
- nl--;
- }
- Fl_Surface_Device::pop_current();
- delete surf;
- cairo_surface_flush( cairo_get_target(off->draw_buffer.cairo_) );
- memcpy(off->data, off->draw_buffer.buffer, off->draw_buffer.data_size);
- return off;
-}
-
-
-int Fl_Wayland_Screen_Driver::dnd(int use_selection) {
- Fl_Wayland_Screen_Driver *scr_driver = (Fl_Wayland_Screen_Driver*)Fl::screen_driver();
-
- struct wl_data_source *source =
- wl_data_device_manager_create_data_source(scr_driver->seat->data_device_manager);
- // we transmit the adequate value of index in fl_selection_buffer[index]
- wl_data_source_add_listener(source, &data_source_listener, (void*)0);
- wl_data_source_offer(source, wld_plain_text_clipboard);
- wl_data_source_set_actions(source, WL_DATA_DEVICE_MANAGER_DND_ACTION_COPY);
- struct Fl_Wayland_Graphics_Driver::wld_buffer *off = NULL;
- int s = 1;
- if (use_selection) {
- // use the text as dragging icon
- Fl_Widget *current = Fl::pushed() ? Fl::pushed() : Fl::first_window();
- s = Fl_Wayland_Window_Driver::driver(current->top_window())->wld_scale();
- off = (struct Fl_Wayland_Graphics_Driver::wld_buffer *)offscreen_from_text(fl_selection_buffer[0], s);
- dnd_icon = wl_compositor_create_surface(scr_driver->wl_compositor);
- } else dnd_icon = NULL;
- doing_dnd = true;
- wl_data_device_start_drag(scr_driver->seat->data_device, source,
- scr_driver->seat->pointer_focus, dnd_icon,
- scr_driver->seat->serial);
- if (use_selection) {
- wl_surface_attach(dnd_icon, off->wl_buffer, 0, 0);
- wl_surface_set_buffer_scale(dnd_icon, s);
- wl_surface_damage(dnd_icon, 0, 0, 10000, 10000);
- wl_surface_commit(dnd_icon);
- wl_surface_set_user_data(dnd_icon, off);
- } else {
- static struct wl_cursor *dnd_cursor = scr_driver->cache_cursor("dnd-copy");
- if (dnd_cursor) {
- save_cursor = scr_driver->default_cursor();
- scr_driver->default_cursor(dnd_cursor);
- scr_driver->set_cursor();
- } else save_cursor = NULL;
- }
- return 1;
-}
-
-
-struct compare_utf8 { // used as key_comp member of following map object
- bool operator()(const char *a, const char *b) const { return strcmp(a, b) < 0; }
-};
-
-// map: for each clipboard mime-type FLTK has interest in, give FLTK clipboard type and priority.
-// A mime-type with higher priority for same FLTK clipboard type is preferred.
-typedef struct { const char * const fltk_type; int priority; } type_prio_struct;
-static std::map<const char * const, type_prio_struct, compare_utf8> clipboard_mimetypes_map {
-// mime-type FLTK-clipboard-type priority
- {"image/png", {Fl::clipboard_image, 1} },
- {"image/bmp", {Fl::clipboard_image, 2} },
- {"text/plain", {Fl::clipboard_plain_text, 1} },
- {"text/uri-list", {Fl::clipboard_plain_text, 2} },
- {"UTF8_STRING", {Fl::clipboard_plain_text, 3} },
- {wld_plain_text_clipboard, {Fl::clipboard_plain_text, 4} },
-};
-
-// map: for each FLTK-clipboard-type, give current preferred mime-type and priority
-typedef struct { const char *mime_type; int priority; } mime_prio_struct;
-static std::map<const char * const, mime_prio_struct> clipboard_kinds_map {
-// FLTK-clipboard-type current mime-type current highest priority
- {Fl::clipboard_image, {NULL, 0} },
- {Fl::clipboard_plain_text, {NULL, 0} },
-};
-
-
-static void data_offer_handle_offer(void *data, struct wl_data_offer *offer,
- const char *mime_type) {
- // runs when app becomes active once for each offered clipboard type
-//fprintf(stderr, "Clipboard offer=%p supports MIME type: %s\n", offer, mime_type);
- std::map<const char*const, type_prio_struct, compare_utf8>::iterator iter_mime =
- clipboard_mimetypes_map.find(mime_type);
- if (iter_mime == clipboard_mimetypes_map.end()) return; // FLTK doesn't handle this mime_type
- std::map<const char*const, mime_prio_struct>::iterator iter_kind =
- clipboard_kinds_map.find(iter_mime->second.fltk_type);
- if (iter_mime->second.priority > iter_kind->second.priority) { // found mime-type with higher priority
- iter_kind->second.priority = iter_mime->second.priority;
- iter_kind->second.mime_type = iter_mime->first;
- fl_selection_type[1] = iter_kind->first;
-//fprintf(stderr,"mime_type=%s priority=%d [%s]\n",iter_kind->second.mime_type, iter_kind->second.priority, fl_selection_type[1]);
- }
-}
-
-
-static void data_offer_handle_source_actions(void *data, struct wl_data_offer *offer,
- uint32_t actions) {
- if (actions & WL_DATA_DEVICE_MANAGER_DND_ACTION_COPY) {
- //printf("Drag supports the copy action\n");
- }
-}
-
-
-static void data_offer_handle_action(void *data, struct wl_data_offer *offer,
- uint32_t dnd_action) {
- switch (dnd_action) {
- case WL_DATA_DEVICE_MANAGER_DND_ACTION_MOVE:
- //printf("A move action would be performed if dropped\n");
- break;
- case WL_DATA_DEVICE_MANAGER_DND_ACTION_COPY:
- //printf("A copy action would be performed if dropped\n");
- break;
- case WL_DATA_DEVICE_MANAGER_DND_ACTION_NONE:
- //printf("The drag would be rejected if dropped\n");
- break;
- }
-}
-
-
-static const struct wl_data_offer_listener data_offer_listener = {
- .offer = data_offer_handle_offer,
- .source_actions = data_offer_handle_source_actions,
- .action = data_offer_handle_action,
-};
-
-
-static void data_device_handle_data_offer(void *data, struct wl_data_device *data_device,
- struct wl_data_offer *offer) {
- // An application has created a new data source
-//fprintf(stderr, "data_device_handle_data_offer offer=%p\n", offer);
- fl_selection_type[1] = NULL;
- wl_data_offer_add_listener(offer, &data_offer_listener, NULL);
- // reset current best mime-type and priority
- std::map<const char*const, mime_prio_struct>::iterator iter = clipboard_kinds_map.begin();
- while (iter != clipboard_kinds_map.end()) {
- iter->second.mime_type = NULL;
- iter->second.priority = 0;
- iter++;
- }
-}
-
-
-static void data_device_handle_selection(void *data, struct wl_data_device *data_device,
- struct wl_data_offer *offer) {
- // An application has set the clipboard contents. W
-//fprintf(stderr, "data_device_handle_selection\n");
- if (fl_selection_offer) wl_data_offer_destroy(fl_selection_offer);
- fl_selection_offer = offer;
-//if (offer == NULL) fprintf(stderr, "Clipboard is empty\n");
-}
-
-
-// Gets from the system the clipboard or dnd text and puts it in fl_selection_buffer[1]
-// which is enlarged if necessary.
-static void get_clipboard_or_dragged_text(struct wl_data_offer *offer) {
- int fds[2];
- char *from;
- if (pipe(fds)) return;
- // preferred mime-type for the text clipboard type
- const char *type = clipboard_kinds_map[Fl::clipboard_plain_text].mime_type;
- wl_data_offer_receive(offer, type, fds[1]);
- close(fds[1]);
- wl_display_flush(Fl_Wayland_Screen_Driver::wl_display);
- // read in fl_selection_buffer
- char *to = fl_selection_buffer[1];
- ssize_t rest = fl_selection_buffer_length[1];
- while (rest) {
- ssize_t n = read(fds[0], to, rest);
- if (n <= 0) {
- close(fds[0]);
- fl_selection_length[1] = to - fl_selection_buffer[1];
- fl_selection_buffer[1][ fl_selection_length[1] ] = 0;
- goto way_out;
- }
- n = Fl_Screen_Driver::convert_crlf(to, n);
- to += n;
- rest -= n;
- }
- // compute size of unread clipboard data
- rest = fl_selection_buffer_length[1];
- while (true) {
- char buf[1000];
- ssize_t n = read(fds[0], buf, sizeof(buf));
- if (n <= 0) {
- close(fds[0]);
- break;
- }
- rest += n;
- }
-//fprintf(stderr, "get_clipboard_or_dragged_text: size=%ld\n", rest);
- // read full clipboard data
- if (pipe(fds)) goto way_out;
- wl_data_offer_receive(offer, type, fds[1]);
- close(fds[1]);
- wl_display_flush(Fl_Wayland_Screen_Driver::wl_display);
- if (rest+1 > fl_selection_buffer_length[1]) {
- delete[] fl_selection_buffer[1];
- fl_selection_buffer[1] = new char[rest+1000+1];
- fl_selection_buffer_length[1] = rest+1000;
- }
- from = fl_selection_buffer[1];
- while (rest > 0) {
- ssize_t n = read(fds[0], from, rest);
- if (n <= 0) break;
- n = Fl_Screen_Driver::convert_crlf(from, n);
- from += n;
- rest -= n;
- }
- close(fds[0]);
- fl_selection_length[1] = from - fl_selection_buffer[1];
- fl_selection_buffer[1][fl_selection_length[1]] = 0;
-way_out:
- if (strcmp(type, "text/uri-list") == 0) {
- fl_decode_uri(fl_selection_buffer[1]); // decode encoded bytes
- char *p = fl_selection_buffer[1];
- while (*p) { // remove prefixes
- if (strncmp(p, "file://", 7) == 0) {
- memmove(p, p+7, strlen(p+7)+1);
- }
- p = strchr(p, '\n');
- if (!p) break;
- if (*++p == 0) *(p-1) = 0; // remove last '\n'
- }
- fl_selection_length[1] = strlen(fl_selection_buffer[1]);
- }
- Fl::e_clipboard_type = Fl::clipboard_plain_text;
-}
-
-
-static struct wl_data_offer *current_drag_offer = NULL;
-static uint32_t fl_dnd_serial;
-
-
-static void data_device_handle_enter(void *data, struct wl_data_device *data_device,
- uint32_t serial, struct wl_surface *surface,
- wl_fixed_t x, wl_fixed_t y,
- struct wl_data_offer *offer) {
- Fl_Window *win = Fl_Wayland_Window_Driver::surface_to_window(surface);
-//printf("Drag entered our surface %p(win=%p) at %dx%d\n", surface, win, wl_fixed_to_int(x), wl_fixed_to_int(y));
- if (win) {
- fl_dnd_target_surface = surface;
- float f = Fl::screen_scale(win->screen_num());
- Fl::e_x = wl_fixed_to_int(x) / f;
- Fl::e_y = wl_fixed_to_int(y) / f;
- while (win->parent()) {
- Fl::e_x += win->x();
- Fl::e_y += win->y();
- win = win->window();
- }
- fl_dnd_target_window = win;
- Fl::e_x_root = Fl::e_x + fl_dnd_target_window->x();
- Fl::e_y_root = Fl::e_y + fl_dnd_target_window->y();
- Fl::handle(FL_DND_ENTER, fl_dnd_target_window);
- current_drag_offer = offer;
- fl_dnd_serial = serial;
- } else fl_dnd_target_window = NULL; // we enter a non-FLTK window (titlebar, shade)
- uint32_t supported_actions = WL_DATA_DEVICE_MANAGER_DND_ACTION_COPY;
- uint32_t preferred_action = supported_actions;
- wl_data_offer_set_actions(offer, supported_actions, preferred_action);
-}
-
-
-static void data_device_handle_motion(void *data, struct wl_data_device *data_device,
- uint32_t time, wl_fixed_t x, wl_fixed_t y) {
- if (!current_drag_offer) return;
-//printf("data_device_handle_motion fl_dnd_target_window=%p\n", fl_dnd_target_window);
- int ret = 0;
- if (fl_dnd_target_window) {
- float f = Fl::screen_scale(fl_dnd_target_window->screen_num());
- Fl_Window *win = Fl_Wayland_Window_Driver::surface_to_window(fl_dnd_target_surface);
- Fl::e_x = wl_fixed_to_int(x) / f;
- Fl::e_y = wl_fixed_to_int(y) / f;
- while (win->parent()) {
- Fl::e_x += win->x();
- Fl::e_y += win->y();
- win = win->window();
- }
- Fl::e_x_root = Fl::e_x + fl_dnd_target_window->x();
- Fl::e_y_root = Fl::e_y + fl_dnd_target_window->y();
- ret = Fl::handle(FL_DND_DRAG, fl_dnd_target_window);
- if (Fl::belowmouse()) Fl::belowmouse()->take_focus();
- }
- uint32_t supported_actions = ret && (Fl::pushed() || !doing_dnd) ?
- WL_DATA_DEVICE_MANAGER_DND_ACTION_COPY : WL_DATA_DEVICE_MANAGER_DND_ACTION_NONE;
- uint32_t preferred_action = supported_actions;
- wl_data_offer_set_actions(current_drag_offer, supported_actions, preferred_action);
- wl_display_roundtrip(Fl_Wayland_Screen_Driver::wl_display);
- if (ret && current_drag_offer) wl_data_offer_accept(current_drag_offer, fl_dnd_serial, "text/plain");
-}
-
-
-static void data_device_handle_leave(void *data, struct wl_data_device *data_device) {
- //printf("Drag left our surface\n");
- if (current_drag_offer) Fl::handle(FL_DND_LEAVE, fl_dnd_target_window);
-}
-
-
-static void data_device_handle_drop(void *data, struct wl_data_device *data_device) {
- if (!current_drag_offer) return;
- Fl::handle(FL_ENTER, fl_dnd_target_window); // useful to set the belowmouse widget
- int ret = Fl::handle(FL_DND_RELEASE, fl_dnd_target_window);
-//printf("data_device_handle_drop ret=%d doing_dnd=%d\n", ret, doing_dnd);
-
- if (!ret) {
- wl_data_offer_destroy(current_drag_offer);
- current_drag_offer = NULL;
- return;
- }
-
- if (doing_dnd) {
- Fl::e_text = fl_selection_buffer[0];
- Fl::e_length = fl_selection_length[0];
- } else {
- get_clipboard_or_dragged_text(current_drag_offer);
- Fl::e_text = fl_selection_buffer[1];
- Fl::e_length = fl_selection_length[1];
- }
- int old_event = Fl::e_number;
- Fl::belowmouse()->handle(Fl::e_number = FL_PASTE);
- Fl::e_number = old_event;
-
- wl_data_offer_finish(current_drag_offer);
- wl_data_offer_destroy(current_drag_offer);
- current_drag_offer = NULL;
-}
-
-
-static const struct wl_data_device_listener data_device_listener = {
- .data_offer = data_device_handle_data_offer,
- .enter = data_device_handle_enter,
- .leave = data_device_handle_leave,
- .motion = data_device_handle_motion,
- .drop = data_device_handle_drop,
- .selection = data_device_handle_selection,
-};
-
-
-const struct wl_data_device_listener *Fl_Wayland_Screen_Driver::p_data_device_listener =
- &data_device_listener;
-
-
-// Reads from the clipboard an image which can be in image/bmp or image/png MIME type.
-// Returns 0 if OK, != 0 if error.
-static int get_clipboard_image(struct wl_data_offer *offer) {
- int fds[2];
- if (pipe(fds)) return 1;
- // preferred mime-type for the image clipboard type
- const char *type = clipboard_kinds_map[Fl::clipboard_image].mime_type;
- wl_data_offer_receive(offer, type, fds[1]);
- close(fds[1]);
- wl_display_roundtrip(Fl_Wayland_Screen_Driver::wl_display);
- if (strcmp(type, "image/png") == 0) {
- char tmp_fname[21];
- Fl_Shared_Image *shared = 0;
- strcpy(tmp_fname, "/tmp/clipboardXXXXXX");
- int fd = mkstemp(tmp_fname);
- if (fd >= 0) {
- while (true) {
- char buf[10000];
- ssize_t n = read(fds[0], buf, sizeof(buf));
- if (n <= 0) break;
- n = write(fd, buf, n);
- }
- close(fd);
- shared = Fl_Shared_Image::get(tmp_fname);
- fl_unlink(tmp_fname);
- }
- close(fds[0]);
- if (!shared) return 1;
- int ld = shared->ld() ? shared->ld() : shared->w() * shared->d();
- uchar *rgb = new uchar[shared->w() * shared->h() * shared->d()];
- memcpy(rgb, shared->data()[0], ld * shared->h() );
- Fl_RGB_Image *image = new Fl_RGB_Image(rgb, shared->w(), shared->h(), shared->d(),
- shared->ld());
- shared->release();
- image->alloc_array = 1;
- Fl::e_clipboard_data = (void*)image;
- } else { // process image/bmp
- uchar buf[54];
- size_t rest = 1;
- char *bmp = NULL;
- ssize_t n = read(fds[0], buf, sizeof(buf)); // read size info of the BMP image
- if (n == sizeof(buf)) {
- int w, h; // size of the BMP image
- Fl_Unix_System_Driver::read_int(buf + 18, w);
- Fl_Unix_System_Driver::read_int(buf + 22, h);
- // the number of bytes per row of BMP image, rounded up to multiple of 4
- int R = ((3*w+3)/4) * 4;
- bmp = new char[R * h + 54];
- memcpy(bmp, buf, 54);
- char *from = bmp + 54;
- rest = R * h;
- while (rest) {
- ssize_t n = read(fds[0], from, rest);
- if (n <= 0) break;
- from += n;
- rest -= n;
- }
-//fprintf(stderr, "get_clipboard_image: image/bmp %dx%d rest=%lu\n", w,h,rest);
- }
- close(fds[0]);
- if (!rest) Fl::e_clipboard_data = Fl_Unix_System_Driver::own_bmp_to_RGB(bmp);
- delete[] bmp;
- if (rest) return 1;
- }
- Fl::e_clipboard_type = Fl::clipboard_image;
- return 0;
-}
-
-
-void Fl_Wayland_Screen_Driver::paste(Fl_Widget &receiver, int clipboard, const char *type) {
- if (clipboard != 1) return;
- if (fl_i_own_selection[1]) {
- // We already have it, do it quickly without compositor.
- if (type == Fl::clipboard_plain_text && fl_selection_type[1] == type) {
- Fl::e_text = fl_selection_buffer[1];
- Fl::e_length = fl_selection_length[1];
- if (!Fl::e_text) Fl::e_text = (char *)"";
- } else if (type == Fl::clipboard_image && fl_selection_type[1] == type) {
- Fl::e_clipboard_data = Fl_Unix_System_Driver::own_bmp_to_RGB(fl_selection_buffer[1]);
- Fl::e_clipboard_type = Fl::clipboard_image;
- } else return;
- receiver.handle(FL_PASTE);
- return;
- }
- // otherwise get the compositor to return it:
- if (!fl_selection_offer) return;
- if (type == Fl::clipboard_plain_text && clipboard_contains(Fl::clipboard_plain_text)) {
- get_clipboard_or_dragged_text(fl_selection_offer);
- Fl::e_text = fl_selection_buffer[1];
- Fl::e_length = fl_selection_length[1];
- receiver.handle(FL_PASTE);
- } else if (type == Fl::clipboard_image && clipboard_contains(Fl::clipboard_image)) {
- if (get_clipboard_image(fl_selection_offer)) return;
- struct wld_window * xid = fl_wl_xid(receiver.top_window());
- if (xid) {
- int s = Fl_Wayland_Window_Driver::driver(receiver.top_window())->wld_scale();
- if ( s > 1) {
- Fl_RGB_Image *rgb = (Fl_RGB_Image*)Fl::e_clipboard_data;
- rgb->scale(rgb->data_w() / s, rgb->data_h() / s);
- }
- }
- int done = receiver.handle(FL_PASTE);
- Fl::e_clipboard_type = "";
- if (done == 0) {
- delete (Fl_RGB_Image*)Fl::e_clipboard_data;
- Fl::e_clipboard_data = NULL;
- }
- }
-}
-
-
-void Fl_Wayland_Screen_Driver::copy(const char *stuff, int len, int clipboard,
- const char *type) {
- if (!stuff || len < 0) return;
-
- if (clipboard >= 2)
- clipboard = 1; // Only on X11 do multiple clipboards make sense.
-
- if (len+1 > fl_selection_buffer_length[clipboard]) {
- delete[] fl_selection_buffer[clipboard];
- fl_selection_buffer[clipboard] = new char[len+100];
- fl_selection_buffer_length[clipboard] = len+100;
- }
- memcpy(fl_selection_buffer[clipboard], stuff, len);
- fl_selection_buffer[clipboard][len] = 0; // needed for direct paste
- fl_selection_length[clipboard] = len;
- fl_i_own_selection[clipboard] = 1;
- fl_selection_type[clipboard] = Fl::clipboard_plain_text;
- if (clipboard == 1) {
- if (seat->data_source) wl_data_source_destroy(seat->data_source);
- seat->data_source = wl_data_device_manager_create_data_source(seat->data_device_manager);
- // we transmit the adequate value of index in fl_selection_buffer[index]
- wl_data_source_add_listener(seat->data_source, &data_source_listener, (void*)1);
- wl_data_source_offer(seat->data_source, wld_plain_text_clipboard);
- wl_data_device_set_selection(seat->data_device,
- seat->data_source,
- seat->keyboard_enter_serial);
-//fprintf(stderr, "wl_data_device_set_selection len=%d to %d\n", len, clipboard);
- }
-}
-
-
-// takes a raw RGB image and puts it in the copy/paste buffer
-void Fl_Wayland_Screen_Driver::copy_image(const unsigned char *data, int W, int H){
- if (!data || W <= 0 || H <= 0) return;
- delete[] fl_selection_buffer[1];
- fl_selection_buffer[1] =
- (char *)Fl_Unix_System_Driver::create_bmp(data,W,H,&fl_selection_length[1]);
- fl_selection_buffer_length[1] = fl_selection_length[1];
- fl_i_own_selection[1] = 1;
- fl_selection_type[1] = Fl::clipboard_image;
- if (seat->data_source) wl_data_source_destroy(seat->data_source);
- seat->data_source = wl_data_device_manager_create_data_source(seat->data_device_manager);
- // we transmit the adequate value of index in fl_selection_buffer[index]
- wl_data_source_add_listener(seat->data_source, &data_source_listener, (void*)1);
- wl_data_source_offer(seat->data_source, "image/bmp");
- wl_data_device_set_selection(seat->data_device, seat->data_source,
- seat->keyboard_enter_serial);
-//fprintf(stderr, "copy_image: len=%d\n", fl_selection_length[1]);
-}
-
-////////////////////////////////////////////////////////////////
-// Code for tracking clipboard changes:
-
-// is that possible with Wayland ?
-
-////////////////////////////////////////////////////////////////
-
-#endif // !defined(FL_DOXYGEN)
diff --git a/src/drivers/Wayland/fl_wayland_platform_init.cxx b/src/drivers/Wayland/fl_wayland_platform_init.cxx
deleted file mode 100644
index 4c4477740..000000000
--- a/src/drivers/Wayland/fl_wayland_platform_init.cxx
+++ /dev/null
@@ -1,157 +0,0 @@
-//
-// Wayland-specific code to initialize wayland support.
-//
-// Copyright 2022-2023 by Bill Spitzak and others.
-//
-// This library is free software. Distribution and use rights are outlined in
-// the file "COPYING" which should have been included with this file. If this
-// file is missing or damaged, see the license at:
-//
-// https://www.fltk.org/COPYING.php
-//
-// Please see the following page on how to report bugs and issues:
-//
-// https://www.fltk.org/bugs.php
-//
-
-#include <FL/fl_config.h>
-#include "Fl_Wayland_Copy_Surface_Driver.H"
-#include "Fl_Wayland_Graphics_Driver.H"
-#include "Fl_Wayland_Screen_Driver.H"
-#include "../Unix/Fl_Unix_System_Driver.H"
-#include "Fl_Wayland_Window_Driver.H"
-#include "Fl_Wayland_Image_Surface_Driver.H"
-#include "../Base/Fl_Base_Pen_Events.H"
-#ifdef FLTK_USE_X11
-# include "../Xlib/Fl_Xlib_Copy_Surface_Driver.H"
-# include "../Cairo/Fl_X11_Cairo_Graphics_Driver.H"
-# include "../X11/Fl_X11_Screen_Driver.H"
-# include "../X11/Fl_X11_Window_Driver.H"
-# include "../Xlib/Fl_Xlib_Image_Surface_Driver.H"
-#endif
-#include <string.h>
-#include <stdlib.h>
-#include <stdio.h>
-
-
-#ifdef FLTK_USE_X11
-
-static bool attempt_wayland() {
- if (Fl_Wayland_Screen_Driver::wl_display) return true;
- static bool first = true;
- static bool disable_wl = false;
- if (first) { // get the value if it exists and cache it
- void *sym = Fl_Posix_System_Driver::dlopen_or_dlsym(NULL, "fl_disable_wayland");
- if (sym) {
- disable_wl = *(bool *)sym;
- // printf("fl_disable_wayland = %s\n", disable_wl ? "true" : "false");
- }
- first = false;
- }
- if (disable_wl)
- return false;
- const char *backend = ::getenv("FLTK_BACKEND");
- // fprintf(stderr, "FLTK_BACKEND='%s'\n", backend ? backend : "");
- if (backend && strcmp(backend, "x11") == 0) {
- return false;
- }
-
- if (backend && strcmp(backend, "wayland") == 0) {
- Fl_Wayland_Screen_Driver::wl_display = wl_display_connect(NULL);
- if (!Fl_Wayland_Screen_Driver::wl_display) {
- fprintf(stderr, "Error: no Wayland connection available, FLTK_BACKEND='wayland'\n");
- exit(1);
- }
- return true;
- }
-
- if (!backend) {
- // env var XDG_RUNTIME_DIR is required for Wayland
- const char *xdgrt = ::getenv("XDG_RUNTIME_DIR");
- if (xdgrt) {
- // is a Wayland connection available ?
- Fl_Wayland_Screen_Driver::wl_display = wl_display_connect(NULL);
- if (Fl_Wayland_Screen_Driver::wl_display) { // Yes, use Wayland drivers
- // puts("using wayland");
- return true;
- }
- }
- // no Wayland connection or environment variable XDG_RUNTIME_DIR not set,
- // falling back to X11
- return false;
- }
-
- fprintf(stderr, "Error: unexpected value of FLTK_BACKEND: '%s'\n", backend);
- exit(1);
- return false;
-}
-
-#endif // FLTK_USE_X11
-
-
-Fl_System_Driver *Fl_System_Driver::newSystemDriver() {
- return new Fl_Unix_System_Driver();
-}
-
-
-Fl_Graphics_Driver *Fl_Graphics_Driver::newMainGraphicsDriver() {
-#ifdef FLTK_USE_X11
- if (!attempt_wayland()) return new Fl_X11_Cairo_Graphics_Driver();
-#endif
- return new Fl_Wayland_Graphics_Driver();
-}
-
-
-Fl_Copy_Surface_Driver *Fl_Copy_Surface_Driver::newCopySurfaceDriver(int w, int h) {
-#ifdef FLTK_USE_X11
- if (!Fl_Wayland_Screen_Driver::wl_display) return new Fl_Xlib_Copy_Surface_Driver(w, h);
-#endif
- return new Fl_Wayland_Copy_Surface_Driver(w, h);
-}
-
-
-Fl_Screen_Driver *Fl_Screen_Driver::newScreenDriver() {
- if (!Fl_Screen_Driver::system_driver) Fl::system_driver();
-#ifdef FLTK_USE_X11
- if (attempt_wayland()) {
- return new Fl_Wayland_Screen_Driver();
- }
-
- Fl_X11_Screen_Driver *d = new Fl_X11_Screen_Driver();
- for (int i = 0; i < MAX_SCREENS; i++) d->screens[i].scale = 1;
- d->current_xft_dpi = 0.; // means the value of the Xft.dpi resource is still unknown
- return d;
-#else
- return new Fl_Wayland_Screen_Driver();
-#endif
-}
-
-
-Fl_Window_Driver *Fl_Window_Driver::newWindowDriver(Fl_Window *w)
-{
-#ifdef FLTK_USE_X11
- if (!attempt_wayland()) return new Fl_X11_Window_Driver(w);
-#endif
- return new Fl_Wayland_Window_Driver(w);
-}
-
-
-Fl_Image_Surface_Driver *Fl_Image_Surface_Driver::newImageSurfaceDriver(int w, int h, int high_res, Fl_Offscreen off)
-{
-#ifdef FLTK_USE_X11
- if (!attempt_wayland())
- return new Fl_Xlib_Image_Surface_Driver(w, h, high_res, off);
-#endif
- return new Fl_Wayland_Image_Surface_Driver(w, h, high_res, off);
-}
-
-#if defined(FLTK_HAVE_PEN_SUPPORT)
-
-namespace Fl {
-namespace Pen {
-Driver default_driver;
-Driver& driver = default_driver;
-} // namespace Pen
-} // namespace Fl
-
-#endif // FLTK_HAVE_PEN_SUPPORT
generated by cgit v1.2.3 (git 2.25.1) at 2026-02-08 06:12:40 +0000