mirror of
https://gitlab.freedesktop.org/wayland/weston
synced 2024-09-06 18:05:39 +00:00
![Emmanuel Gil Peyrot](/assets/img/avatar_default.png)
The cairo surface used for the icon must be completely given to the frame as soon as said frame has been created. To prevent both the window and the frame from sharing ownership of the icon, we set window->icon_surface back to NULL right after creating or changing the frame, only keeping it there when no frame has been created yet. Fixes https://lists.freedesktop.org/archives/wayland-devel/2018-January/036655.html Reported-by: Derek Foreman <derekf@osg.samsung.com> Tested-by: Derek Foreman <derekf@osg.samsung.com> Signed-off-by: Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
1022 lines
23 KiB
C
1022 lines
23 KiB
C
/*
|
|
* Copyright © 2008 Kristian Høgsberg
|
|
* Copyright © 2012-2013 Collabora, Ltd.
|
|
* Copyright © 2013 Jason Ekstrand
|
|
*
|
|
* Permission is hereby granted, free of charge, to any person obtaining
|
|
* a copy of this software and associated documentation files (the
|
|
* "Software"), to deal in the Software without restriction, including
|
|
* without limitation the rights to use, copy, modify, merge, publish,
|
|
* distribute, sublicense, and/or sell copies of the Software, and to
|
|
* permit persons to whom the Software is furnished to do so, subject to
|
|
* the following conditions:
|
|
*
|
|
* The above copyright notice and this permission notice (including the
|
|
* next paragraph) shall be included in all copies or substantial
|
|
* portions of the Software.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
|
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
|
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
|
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
|
|
* BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
|
|
* ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
|
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
|
* SOFTWARE.
|
|
*/
|
|
|
|
#include "config.h"
|
|
|
|
#include <stdint.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <wayland-util.h>
|
|
#include <linux/input.h>
|
|
|
|
#include "cairo-util.h"
|
|
#include "shared/file-util.h"
|
|
|
|
enum frame_button_flags {
|
|
FRAME_BUTTON_ALIGN_RIGHT = 0x1,
|
|
FRAME_BUTTON_DECORATED = 0x2,
|
|
FRAME_BUTTON_CLICK_DOWN = 0x4,
|
|
};
|
|
|
|
struct frame_button {
|
|
struct frame *frame;
|
|
struct wl_list link; /* buttons_list */
|
|
|
|
cairo_surface_t *icon;
|
|
enum frame_button_flags flags;
|
|
int hover_count;
|
|
int press_count;
|
|
|
|
struct {
|
|
int x, y;
|
|
int width, height;
|
|
} allocation;
|
|
|
|
enum frame_status status_effect;
|
|
};
|
|
|
|
struct frame_pointer_button {
|
|
struct wl_list link;
|
|
uint32_t button;
|
|
enum theme_location press_location;
|
|
struct frame_button *frame_button;
|
|
};
|
|
|
|
struct frame_pointer {
|
|
struct wl_list link;
|
|
void *data;
|
|
|
|
int x, y;
|
|
|
|
struct frame_button *hover_button;
|
|
struct wl_list down_buttons;
|
|
};
|
|
|
|
struct frame_touch {
|
|
struct wl_list link;
|
|
void *data;
|
|
|
|
int x, y;
|
|
|
|
struct frame_button *button;
|
|
};
|
|
|
|
struct frame {
|
|
int32_t width, height;
|
|
char *title;
|
|
uint32_t flags;
|
|
struct theme *theme;
|
|
|
|
struct {
|
|
int32_t x, y;
|
|
int32_t width, height;
|
|
} interior;
|
|
int shadow_margin;
|
|
int opaque_margin;
|
|
int geometry_dirty;
|
|
|
|
cairo_rectangle_int_t title_rect;
|
|
|
|
uint32_t status;
|
|
|
|
struct wl_list buttons;
|
|
struct wl_list pointers;
|
|
struct wl_list touches;
|
|
};
|
|
|
|
static struct frame_button *
|
|
frame_button_create_from_surface(struct frame *frame, cairo_surface_t *icon,
|
|
enum frame_status status_effect,
|
|
enum frame_button_flags flags)
|
|
{
|
|
struct frame_button *button;
|
|
|
|
button = calloc(1, sizeof *button);
|
|
if (!button)
|
|
return NULL;
|
|
|
|
button->icon = icon;
|
|
button->frame = frame;
|
|
button->flags = flags;
|
|
button->status_effect = status_effect;
|
|
|
|
wl_list_insert(frame->buttons.prev, &button->link);
|
|
|
|
return button;
|
|
}
|
|
|
|
static struct frame_button *
|
|
frame_button_create(struct frame *frame, const char *icon_name,
|
|
enum frame_status status_effect,
|
|
enum frame_button_flags flags)
|
|
{
|
|
struct frame_button *button;
|
|
cairo_surface_t *icon;
|
|
|
|
icon = cairo_image_surface_create_from_png(icon_name);
|
|
if (cairo_surface_status(icon) != CAIRO_STATUS_SUCCESS)
|
|
goto error;
|
|
|
|
button = frame_button_create_from_surface(frame, icon, status_effect,
|
|
flags);
|
|
if (!button)
|
|
goto error;
|
|
|
|
return button;
|
|
|
|
error:
|
|
cairo_surface_destroy(icon);
|
|
return NULL;
|
|
}
|
|
|
|
static void
|
|
frame_button_destroy(struct frame_button *button)
|
|
{
|
|
cairo_surface_destroy(button->icon);
|
|
free(button);
|
|
}
|
|
|
|
static void
|
|
frame_button_enter(struct frame_button *button)
|
|
{
|
|
if (!button->hover_count)
|
|
button->frame->status |= FRAME_STATUS_REPAINT;
|
|
button->hover_count++;
|
|
}
|
|
|
|
static void
|
|
frame_button_leave(struct frame_button *button, struct frame_pointer *pointer)
|
|
{
|
|
button->hover_count--;
|
|
if (!button->hover_count)
|
|
button->frame->status |= FRAME_STATUS_REPAINT;
|
|
}
|
|
|
|
static void
|
|
frame_button_press(struct frame_button *button)
|
|
{
|
|
if (!button->press_count)
|
|
button->frame->status |= FRAME_STATUS_REPAINT;
|
|
button->press_count++;
|
|
|
|
if (button->flags & FRAME_BUTTON_CLICK_DOWN)
|
|
button->frame->status |= button->status_effect;
|
|
}
|
|
|
|
static void
|
|
frame_button_release(struct frame_button *button)
|
|
{
|
|
button->press_count--;
|
|
if (button->press_count)
|
|
return;
|
|
|
|
button->frame->status |= FRAME_STATUS_REPAINT;
|
|
|
|
if (!(button->flags & FRAME_BUTTON_CLICK_DOWN))
|
|
button->frame->status |= button->status_effect;
|
|
}
|
|
|
|
static void
|
|
frame_button_cancel(struct frame_button *button)
|
|
{
|
|
button->press_count--;
|
|
if (!button->press_count)
|
|
button->frame->status |= FRAME_STATUS_REPAINT;
|
|
}
|
|
|
|
static void
|
|
frame_button_repaint(struct frame_button *button, cairo_t *cr)
|
|
{
|
|
int x, y;
|
|
|
|
if (!button->allocation.width)
|
|
return;
|
|
if (!button->allocation.height)
|
|
return;
|
|
|
|
x = button->allocation.x;
|
|
y = button->allocation.y;
|
|
|
|
cairo_save(cr);
|
|
|
|
if (button->flags & FRAME_BUTTON_DECORATED) {
|
|
cairo_set_line_width(cr, 1);
|
|
|
|
cairo_set_source_rgb(cr, 0.0, 0.0, 0.0);
|
|
cairo_rectangle(cr, x, y, 25, 16);
|
|
|
|
cairo_stroke_preserve(cr);
|
|
|
|
if (button->press_count) {
|
|
cairo_set_source_rgb(cr, 0.7, 0.7, 0.7);
|
|
} else if (button->hover_count) {
|
|
cairo_set_source_rgb(cr, 1.0, 1.0, 1.0);
|
|
} else {
|
|
cairo_set_source_rgb(cr, 0.88, 0.88, 0.88);
|
|
}
|
|
|
|
cairo_fill (cr);
|
|
|
|
x += 4;
|
|
}
|
|
|
|
cairo_set_source_surface(cr, button->icon, x, y);
|
|
cairo_paint(cr);
|
|
|
|
cairo_restore(cr);
|
|
}
|
|
|
|
static struct frame_pointer *
|
|
frame_pointer_get(struct frame *frame, void *data)
|
|
{
|
|
struct frame_pointer *pointer;
|
|
|
|
wl_list_for_each(pointer, &frame->pointers, link)
|
|
if (pointer->data == data)
|
|
return pointer;
|
|
|
|
pointer = calloc(1, sizeof *pointer);
|
|
if (!pointer)
|
|
return NULL;
|
|
|
|
pointer->data = data;
|
|
wl_list_init(&pointer->down_buttons);
|
|
wl_list_insert(&frame->pointers, &pointer->link);
|
|
|
|
return pointer;
|
|
}
|
|
|
|
static void
|
|
frame_pointer_destroy(struct frame_pointer *pointer)
|
|
{
|
|
wl_list_remove(&pointer->link);
|
|
free(pointer);
|
|
}
|
|
|
|
static struct frame_touch *
|
|
frame_touch_get(struct frame *frame, void *data)
|
|
{
|
|
struct frame_touch *touch;
|
|
|
|
wl_list_for_each(touch, &frame->touches, link)
|
|
if (touch->data == data)
|
|
return touch;
|
|
|
|
touch = calloc(1, sizeof *touch);
|
|
if (!touch)
|
|
return NULL;
|
|
|
|
touch->data = data;
|
|
wl_list_insert(&frame->touches, &touch->link);
|
|
|
|
return touch;
|
|
}
|
|
|
|
static void
|
|
frame_touch_destroy(struct frame_touch *touch)
|
|
{
|
|
wl_list_remove(&touch->link);
|
|
free(touch);
|
|
}
|
|
|
|
void
|
|
frame_destroy(struct frame *frame)
|
|
{
|
|
struct frame_button *button, *next;
|
|
struct frame_touch *touch, *next_touch;
|
|
struct frame_pointer *pointer, *next_pointer;
|
|
|
|
wl_list_for_each_safe(button, next, &frame->buttons, link)
|
|
frame_button_destroy(button);
|
|
|
|
wl_list_for_each_safe(touch, next_touch, &frame->touches, link)
|
|
frame_touch_destroy(touch);
|
|
|
|
wl_list_for_each_safe(pointer, next_pointer, &frame->pointers, link)
|
|
frame_pointer_destroy(pointer);
|
|
|
|
free(frame->title);
|
|
free(frame);
|
|
}
|
|
|
|
struct frame *
|
|
frame_create(struct theme *t, int32_t width, int32_t height, uint32_t buttons,
|
|
const char *title, cairo_surface_t *icon)
|
|
{
|
|
struct frame *frame;
|
|
struct frame_button *button;
|
|
|
|
frame = calloc(1, sizeof *frame);
|
|
if (!frame)
|
|
return NULL;
|
|
|
|
frame->width = width;
|
|
frame->height = height;
|
|
frame->flags = 0;
|
|
frame->theme = t;
|
|
frame->status = FRAME_STATUS_REPAINT;
|
|
frame->geometry_dirty = 1;
|
|
|
|
wl_list_init(&frame->buttons);
|
|
wl_list_init(&frame->pointers);
|
|
wl_list_init(&frame->touches);
|
|
|
|
if (title) {
|
|
frame->title = strdup(title);
|
|
if (!frame->title)
|
|
goto free_frame;
|
|
}
|
|
|
|
if (title) {
|
|
if (icon) {
|
|
button = frame_button_create_from_surface(frame,
|
|
icon,
|
|
FRAME_STATUS_MENU,
|
|
FRAME_BUTTON_CLICK_DOWN);
|
|
} else {
|
|
char *name = file_name_with_datadir("icon_window.png");
|
|
|
|
if (!name)
|
|
goto free_frame;
|
|
|
|
button = frame_button_create(frame,
|
|
name,
|
|
FRAME_STATUS_MENU,
|
|
FRAME_BUTTON_CLICK_DOWN);
|
|
free(name);
|
|
}
|
|
if (!button)
|
|
goto free_frame;
|
|
}
|
|
|
|
if (buttons & FRAME_BUTTON_CLOSE) {
|
|
char *name = file_name_with_datadir("sign_close.png");
|
|
|
|
if (!name)
|
|
goto free_frame;
|
|
|
|
button = frame_button_create(frame,
|
|
name,
|
|
FRAME_STATUS_CLOSE,
|
|
FRAME_BUTTON_ALIGN_RIGHT |
|
|
FRAME_BUTTON_DECORATED);
|
|
free(name);
|
|
if (!button)
|
|
goto free_frame;
|
|
}
|
|
|
|
if (buttons & FRAME_BUTTON_MAXIMIZE) {
|
|
char *name = file_name_with_datadir("sign_maximize.png");
|
|
|
|
if (!name)
|
|
goto free_frame;
|
|
|
|
button = frame_button_create(frame,
|
|
name,
|
|
FRAME_STATUS_MAXIMIZE,
|
|
FRAME_BUTTON_ALIGN_RIGHT |
|
|
FRAME_BUTTON_DECORATED);
|
|
free(name);
|
|
if (!button)
|
|
goto free_frame;
|
|
}
|
|
|
|
if (buttons & FRAME_BUTTON_MINIMIZE) {
|
|
char *name = file_name_with_datadir("sign_minimize.png");
|
|
|
|
if (!name)
|
|
goto free_frame;
|
|
|
|
button = frame_button_create(frame,
|
|
name,
|
|
FRAME_STATUS_MINIMIZE,
|
|
FRAME_BUTTON_ALIGN_RIGHT |
|
|
FRAME_BUTTON_DECORATED);
|
|
free(name);
|
|
if (!button)
|
|
goto free_frame;
|
|
}
|
|
|
|
return frame;
|
|
|
|
free_frame:
|
|
frame_destroy(frame);
|
|
return NULL;
|
|
}
|
|
|
|
int
|
|
frame_set_title(struct frame *frame, const char *title)
|
|
{
|
|
char *dup = NULL;
|
|
|
|
if (title) {
|
|
dup = strdup(title);
|
|
if (!dup)
|
|
return -1;
|
|
}
|
|
|
|
free(frame->title);
|
|
frame->title = dup;
|
|
|
|
frame->geometry_dirty = 1;
|
|
frame->status |= FRAME_STATUS_REPAINT;
|
|
|
|
return 0;
|
|
}
|
|
|
|
void
|
|
frame_set_icon(struct frame *frame, cairo_surface_t *icon)
|
|
{
|
|
struct frame_button *button;
|
|
wl_list_for_each(button, &frame->buttons, link) {
|
|
if (button->status_effect != FRAME_STATUS_MENU)
|
|
continue;
|
|
if (button->icon)
|
|
cairo_surface_destroy(button->icon);
|
|
button->icon = icon;
|
|
frame->status |= FRAME_STATUS_REPAINT;
|
|
}
|
|
}
|
|
|
|
void
|
|
frame_set_flag(struct frame *frame, enum frame_flag flag)
|
|
{
|
|
if (flag & FRAME_FLAG_MAXIMIZED && !(frame->flags & FRAME_FLAG_MAXIMIZED))
|
|
frame->geometry_dirty = 1;
|
|
|
|
frame->flags |= flag;
|
|
frame->status |= FRAME_STATUS_REPAINT;
|
|
}
|
|
|
|
void
|
|
frame_unset_flag(struct frame *frame, enum frame_flag flag)
|
|
{
|
|
if (flag & FRAME_FLAG_MAXIMIZED && frame->flags & FRAME_FLAG_MAXIMIZED)
|
|
frame->geometry_dirty = 1;
|
|
|
|
frame->flags &= ~flag;
|
|
frame->status |= FRAME_STATUS_REPAINT;
|
|
}
|
|
|
|
void
|
|
frame_resize(struct frame *frame, int32_t width, int32_t height)
|
|
{
|
|
frame->width = width;
|
|
frame->height = height;
|
|
|
|
frame->geometry_dirty = 1;
|
|
frame->status |= FRAME_STATUS_REPAINT;
|
|
}
|
|
|
|
void
|
|
frame_resize_inside(struct frame *frame, int32_t width, int32_t height)
|
|
{
|
|
struct theme *t = frame->theme;
|
|
int decoration_width, decoration_height, titlebar_height;
|
|
|
|
if (frame->title || !wl_list_empty(&frame->buttons))
|
|
titlebar_height = t->titlebar_height;
|
|
else
|
|
titlebar_height = t->width;
|
|
|
|
if (frame->flags & FRAME_FLAG_MAXIMIZED) {
|
|
decoration_width = t->width * 2;
|
|
decoration_height = t->width + titlebar_height;
|
|
} else {
|
|
decoration_width = (t->width + t->margin) * 2;
|
|
decoration_height = t->width +
|
|
titlebar_height + t->margin * 2;
|
|
}
|
|
|
|
frame_resize(frame, width + decoration_width,
|
|
height + decoration_height);
|
|
}
|
|
|
|
int32_t
|
|
frame_width(struct frame *frame)
|
|
{
|
|
return frame->width;
|
|
}
|
|
|
|
int32_t
|
|
frame_height(struct frame *frame)
|
|
{
|
|
return frame->height;
|
|
}
|
|
|
|
static void
|
|
frame_refresh_geometry(struct frame *frame)
|
|
{
|
|
struct frame_button *button;
|
|
struct theme *t = frame->theme;
|
|
int x_l, x_r, y, w, h, titlebar_height;
|
|
int32_t decoration_width, decoration_height;
|
|
|
|
if (!frame->geometry_dirty)
|
|
return;
|
|
|
|
if (frame->title || !wl_list_empty(&frame->buttons))
|
|
titlebar_height = t->titlebar_height;
|
|
else
|
|
titlebar_height = t->width;
|
|
|
|
if (frame->flags & FRAME_FLAG_MAXIMIZED) {
|
|
decoration_width = t->width * 2;
|
|
decoration_height = t->width + titlebar_height;
|
|
|
|
frame->interior.x = t->width;
|
|
frame->interior.y = titlebar_height;
|
|
frame->interior.width = frame->width - decoration_width;
|
|
frame->interior.height = frame->height - decoration_height;
|
|
|
|
frame->opaque_margin = 0;
|
|
frame->shadow_margin = 0;
|
|
} else {
|
|
decoration_width = (t->width + t->margin) * 2;
|
|
decoration_height = t->width + titlebar_height + t->margin * 2;
|
|
|
|
frame->interior.x = t->width + t->margin;
|
|
frame->interior.y = titlebar_height + t->margin;
|
|
frame->interior.width = frame->width - decoration_width;
|
|
frame->interior.height = frame->height - decoration_height;
|
|
|
|
frame->opaque_margin = t->margin + t->frame_radius;
|
|
frame->shadow_margin = t->margin;
|
|
}
|
|
|
|
x_r = frame->width - t->width - frame->shadow_margin;
|
|
x_l = t->width + frame->shadow_margin;
|
|
y = t->width + frame->shadow_margin;
|
|
wl_list_for_each(button, &frame->buttons, link) {
|
|
const int button_padding = 4;
|
|
w = cairo_image_surface_get_width(button->icon);
|
|
h = cairo_image_surface_get_height(button->icon);
|
|
|
|
if (button->flags & FRAME_BUTTON_DECORATED)
|
|
w += 10;
|
|
|
|
if (button->flags & FRAME_BUTTON_ALIGN_RIGHT) {
|
|
x_r -= w;
|
|
|
|
button->allocation.x = x_r;
|
|
button->allocation.y = y;
|
|
button->allocation.width = w + 1;
|
|
button->allocation.height = h + 1;
|
|
|
|
x_r -= button_padding;
|
|
} else {
|
|
button->allocation.x = x_l;
|
|
button->allocation.y = y;
|
|
button->allocation.width = w + 1;
|
|
button->allocation.height = h + 1;
|
|
|
|
x_l += w;
|
|
x_l += button_padding;
|
|
}
|
|
}
|
|
|
|
frame->title_rect.x = x_l;
|
|
frame->title_rect.y = y;
|
|
frame->title_rect.width = x_r - x_l;
|
|
frame->title_rect.height = titlebar_height;
|
|
|
|
frame->geometry_dirty = 0;
|
|
}
|
|
|
|
void
|
|
frame_interior(struct frame *frame, int32_t *x, int32_t *y,
|
|
int32_t *width, int32_t *height)
|
|
{
|
|
frame_refresh_geometry(frame);
|
|
|
|
if (x)
|
|
*x = frame->interior.x;
|
|
if (y)
|
|
*y = frame->interior.y;
|
|
if (width)
|
|
*width = frame->interior.width;
|
|
if (height)
|
|
*height = frame->interior.height;
|
|
}
|
|
|
|
void
|
|
frame_input_rect(struct frame *frame, int32_t *x, int32_t *y,
|
|
int32_t *width, int32_t *height)
|
|
{
|
|
frame_refresh_geometry(frame);
|
|
|
|
if (x)
|
|
*x = frame->shadow_margin;
|
|
if (y)
|
|
*y = frame->shadow_margin;
|
|
if (width)
|
|
*width = frame->width - frame->shadow_margin * 2;
|
|
if (height)
|
|
*height = frame->height - frame->shadow_margin * 2;
|
|
}
|
|
|
|
void
|
|
frame_opaque_rect(struct frame *frame, int32_t *x, int32_t *y,
|
|
int32_t *width, int32_t *height)
|
|
{
|
|
frame_refresh_geometry(frame);
|
|
|
|
if (x)
|
|
*x = frame->opaque_margin;
|
|
if (y)
|
|
*y = frame->opaque_margin;
|
|
if (width)
|
|
*width = frame->width - frame->opaque_margin * 2;
|
|
if (height)
|
|
*height = frame->height - frame->opaque_margin * 2;
|
|
}
|
|
|
|
int
|
|
frame_get_shadow_margin(struct frame *frame)
|
|
{
|
|
frame_refresh_geometry(frame);
|
|
|
|
return frame->shadow_margin;
|
|
}
|
|
|
|
uint32_t
|
|
frame_status(struct frame *frame)
|
|
{
|
|
return frame->status;
|
|
}
|
|
|
|
void
|
|
frame_status_clear(struct frame *frame, enum frame_status status)
|
|
{
|
|
frame->status &= ~status;
|
|
}
|
|
|
|
static struct frame_button *
|
|
frame_find_button(struct frame *frame, int x, int y)
|
|
{
|
|
struct frame_button *button;
|
|
int rel_x, rel_y;
|
|
|
|
wl_list_for_each(button, &frame->buttons, link) {
|
|
rel_x = x - button->allocation.x;
|
|
rel_y = y - button->allocation.y;
|
|
|
|
if (0 <= rel_x && rel_x < button->allocation.width &&
|
|
0 <= rel_y && rel_y < button->allocation.height)
|
|
return button;
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
enum theme_location
|
|
frame_pointer_enter(struct frame *frame, void *data, int x, int y)
|
|
{
|
|
return frame_pointer_motion(frame, data, x, y);
|
|
}
|
|
|
|
enum theme_location
|
|
frame_pointer_motion(struct frame *frame, void *data, int x, int y)
|
|
{
|
|
struct frame_pointer *pointer = frame_pointer_get(frame, data);
|
|
struct frame_button *button = frame_find_button(frame, x, y);
|
|
enum theme_location location;
|
|
|
|
location = theme_get_location(frame->theme, x, y,
|
|
frame->width, frame->height,
|
|
frame->flags & FRAME_FLAG_MAXIMIZED ?
|
|
THEME_FRAME_MAXIMIZED : 0);
|
|
if (!pointer)
|
|
return location;
|
|
|
|
pointer->x = x;
|
|
pointer->y = y;
|
|
|
|
if (pointer->hover_button == button)
|
|
return location;
|
|
|
|
if (pointer->hover_button)
|
|
frame_button_leave(pointer->hover_button, pointer);
|
|
|
|
pointer->hover_button = button;
|
|
|
|
if (pointer->hover_button)
|
|
frame_button_enter(pointer->hover_button);
|
|
|
|
return location;
|
|
}
|
|
|
|
static void
|
|
frame_pointer_button_destroy(struct frame_pointer_button *button)
|
|
{
|
|
wl_list_remove(&button->link);
|
|
free(button);
|
|
}
|
|
|
|
static void
|
|
frame_pointer_button_press(struct frame *frame, struct frame_pointer *pointer,
|
|
struct frame_pointer_button *button)
|
|
{
|
|
if (button->button == BTN_RIGHT) {
|
|
if (button->press_location == THEME_LOCATION_TITLEBAR)
|
|
frame->status |= FRAME_STATUS_MENU;
|
|
|
|
frame_pointer_button_destroy(button);
|
|
|
|
} else if (button->button == BTN_LEFT) {
|
|
if (pointer->hover_button) {
|
|
frame_button_press(pointer->hover_button);
|
|
} else {
|
|
switch (button->press_location) {
|
|
case THEME_LOCATION_TITLEBAR:
|
|
frame->status |= FRAME_STATUS_MOVE;
|
|
|
|
frame_pointer_button_destroy(button);
|
|
break;
|
|
case THEME_LOCATION_RESIZING_TOP:
|
|
case THEME_LOCATION_RESIZING_BOTTOM:
|
|
case THEME_LOCATION_RESIZING_LEFT:
|
|
case THEME_LOCATION_RESIZING_RIGHT:
|
|
case THEME_LOCATION_RESIZING_TOP_LEFT:
|
|
case THEME_LOCATION_RESIZING_TOP_RIGHT:
|
|
case THEME_LOCATION_RESIZING_BOTTOM_LEFT:
|
|
case THEME_LOCATION_RESIZING_BOTTOM_RIGHT:
|
|
frame->status |= FRAME_STATUS_RESIZE;
|
|
|
|
frame_pointer_button_destroy(button);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
static void
|
|
frame_pointer_button_release(struct frame *frame, struct frame_pointer *pointer,
|
|
struct frame_pointer_button *button)
|
|
{
|
|
if (button->button == BTN_LEFT && button->frame_button) {
|
|
if (button->frame_button == pointer->hover_button)
|
|
frame_button_release(button->frame_button);
|
|
else
|
|
frame_button_cancel(button->frame_button);
|
|
}
|
|
}
|
|
|
|
static void
|
|
frame_pointer_button_cancel(struct frame *frame, struct frame_pointer *pointer,
|
|
struct frame_pointer_button *button)
|
|
{
|
|
if (button->frame_button)
|
|
frame_button_cancel(button->frame_button);
|
|
}
|
|
|
|
void
|
|
frame_pointer_leave(struct frame *frame, void *data)
|
|
{
|
|
struct frame_pointer *pointer = frame_pointer_get(frame, data);
|
|
struct frame_pointer_button *button, *next;
|
|
if (!pointer)
|
|
return;
|
|
|
|
if (pointer->hover_button)
|
|
frame_button_leave(pointer->hover_button, pointer);
|
|
|
|
wl_list_for_each_safe(button, next, &pointer->down_buttons, link) {
|
|
frame_pointer_button_cancel(frame, pointer, button);
|
|
frame_pointer_button_destroy(button);
|
|
}
|
|
|
|
frame_pointer_destroy(pointer);
|
|
}
|
|
|
|
enum theme_location
|
|
frame_pointer_button(struct frame *frame, void *data,
|
|
uint32_t btn, enum wl_pointer_button_state state)
|
|
{
|
|
struct frame_pointer *pointer = frame_pointer_get(frame, data);
|
|
struct frame_pointer_button *button;
|
|
enum theme_location location = THEME_LOCATION_EXTERIOR;
|
|
|
|
if (!pointer)
|
|
return location;
|
|
|
|
location = theme_get_location(frame->theme, pointer->x, pointer->y,
|
|
frame->width, frame->height,
|
|
frame->flags & FRAME_FLAG_MAXIMIZED ?
|
|
THEME_FRAME_MAXIMIZED : 0);
|
|
|
|
if (state == WL_POINTER_BUTTON_STATE_PRESSED) {
|
|
button = malloc(sizeof *button);
|
|
if (!button)
|
|
return location;
|
|
|
|
button->button = btn;
|
|
button->press_location = location;
|
|
button->frame_button = pointer->hover_button;
|
|
wl_list_insert(&pointer->down_buttons, &button->link);
|
|
|
|
frame_pointer_button_press(frame, pointer, button);
|
|
} else if (state == WL_POINTER_BUTTON_STATE_RELEASED) {
|
|
button = NULL;
|
|
wl_list_for_each(button, &pointer->down_buttons, link)
|
|
if (button->button == btn)
|
|
break;
|
|
/* Make sure we didn't hit the end */
|
|
if (&button->link == &pointer->down_buttons)
|
|
return location;
|
|
|
|
location = button->press_location;
|
|
frame_pointer_button_release(frame, pointer, button);
|
|
frame_pointer_button_destroy(button);
|
|
}
|
|
|
|
return location;
|
|
}
|
|
|
|
enum theme_location
|
|
frame_touch_down(struct frame *frame, void *data, int32_t id, int x, int y)
|
|
{
|
|
struct frame_touch *touch = frame_touch_get(frame, data);
|
|
struct frame_button *button = frame_find_button(frame, x, y);
|
|
enum theme_location location;
|
|
|
|
location = theme_get_location(frame->theme, x, y,
|
|
frame->width, frame->height,
|
|
frame->flags & FRAME_FLAG_MAXIMIZED ?
|
|
THEME_FRAME_MAXIMIZED : 0);
|
|
|
|
if (id > 0)
|
|
return location;
|
|
|
|
if (touch && button) {
|
|
touch->button = button;
|
|
frame_button_press(touch->button);
|
|
return location;
|
|
}
|
|
|
|
switch (location) {
|
|
case THEME_LOCATION_TITLEBAR:
|
|
frame->status |= FRAME_STATUS_MOVE;
|
|
break;
|
|
case THEME_LOCATION_RESIZING_TOP:
|
|
case THEME_LOCATION_RESIZING_BOTTOM:
|
|
case THEME_LOCATION_RESIZING_LEFT:
|
|
case THEME_LOCATION_RESIZING_RIGHT:
|
|
case THEME_LOCATION_RESIZING_TOP_LEFT:
|
|
case THEME_LOCATION_RESIZING_TOP_RIGHT:
|
|
case THEME_LOCATION_RESIZING_BOTTOM_LEFT:
|
|
case THEME_LOCATION_RESIZING_BOTTOM_RIGHT:
|
|
frame->status |= FRAME_STATUS_RESIZE;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
return location;
|
|
}
|
|
|
|
void
|
|
frame_touch_up(struct frame *frame, void *data, int32_t id)
|
|
{
|
|
struct frame_touch *touch = frame_touch_get(frame, data);
|
|
|
|
if (id > 0)
|
|
return;
|
|
|
|
if (touch && touch->button) {
|
|
frame_button_release(touch->button);
|
|
frame_touch_destroy(touch);
|
|
}
|
|
}
|
|
|
|
enum theme_location
|
|
frame_double_click(struct frame *frame, void *data,
|
|
uint32_t btn, enum wl_pointer_button_state state)
|
|
{
|
|
struct frame_pointer *pointer = frame_pointer_get(frame, data);
|
|
struct frame_button *button;
|
|
enum theme_location location = THEME_LOCATION_EXTERIOR;
|
|
|
|
location = theme_get_location(frame->theme, pointer->x, pointer->y,
|
|
frame->width, frame->height,
|
|
frame->flags & FRAME_FLAG_MAXIMIZED ?
|
|
THEME_FRAME_MAXIMIZED : 0);
|
|
|
|
button = frame_find_button(frame, pointer->x, pointer->y);
|
|
|
|
if (location != THEME_LOCATION_TITLEBAR || btn != BTN_LEFT)
|
|
return location;
|
|
|
|
if (state == WL_POINTER_BUTTON_STATE_PRESSED) {
|
|
if (button)
|
|
frame_button_press(button);
|
|
else
|
|
frame->status |= FRAME_STATUS_MAXIMIZE;
|
|
} else if (state == WL_POINTER_BUTTON_STATE_RELEASED) {
|
|
if (button)
|
|
frame_button_release(button);
|
|
}
|
|
|
|
return location;
|
|
}
|
|
|
|
void
|
|
frame_double_touch_down(struct frame *frame, void *data, int32_t id,
|
|
int x, int y)
|
|
{
|
|
struct frame_touch *touch = frame_touch_get(frame, data);
|
|
struct frame_button *button = frame_find_button(frame, x, y);
|
|
enum theme_location location;
|
|
|
|
if (touch && button) {
|
|
touch->button = button;
|
|
frame_button_press(touch->button);
|
|
return;
|
|
}
|
|
|
|
location = theme_get_location(frame->theme, x, y,
|
|
frame->width, frame->height,
|
|
frame->flags & FRAME_FLAG_MAXIMIZED ?
|
|
THEME_FRAME_MAXIMIZED : 0);
|
|
|
|
switch (location) {
|
|
case THEME_LOCATION_TITLEBAR:
|
|
frame->status |= FRAME_STATUS_MAXIMIZE;
|
|
break;
|
|
case THEME_LOCATION_RESIZING_TOP:
|
|
case THEME_LOCATION_RESIZING_BOTTOM:
|
|
case THEME_LOCATION_RESIZING_LEFT:
|
|
case THEME_LOCATION_RESIZING_RIGHT:
|
|
case THEME_LOCATION_RESIZING_TOP_LEFT:
|
|
case THEME_LOCATION_RESIZING_TOP_RIGHT:
|
|
case THEME_LOCATION_RESIZING_BOTTOM_LEFT:
|
|
case THEME_LOCATION_RESIZING_BOTTOM_RIGHT:
|
|
frame->status |= FRAME_STATUS_RESIZE;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
void
|
|
frame_double_touch_up(struct frame *frame, void *data, int32_t id)
|
|
{
|
|
struct frame_touch *touch = frame_touch_get(frame, data);
|
|
|
|
if (touch && touch->button) {
|
|
frame_button_release(touch->button);
|
|
frame_touch_destroy(touch);
|
|
}
|
|
}
|
|
|
|
void
|
|
frame_repaint(struct frame *frame, cairo_t *cr)
|
|
{
|
|
struct frame_button *button;
|
|
uint32_t flags = 0;
|
|
|
|
frame_refresh_geometry(frame);
|
|
|
|
if (frame->flags & FRAME_FLAG_MAXIMIZED)
|
|
flags |= THEME_FRAME_MAXIMIZED;
|
|
|
|
if (frame->flags & FRAME_FLAG_ACTIVE)
|
|
flags |= THEME_FRAME_ACTIVE;
|
|
|
|
cairo_save(cr);
|
|
theme_render_frame(frame->theme, cr, frame->width, frame->height,
|
|
frame->title, &frame->title_rect,
|
|
&frame->buttons, flags);
|
|
cairo_restore(cr);
|
|
|
|
wl_list_for_each(button, &frame->buttons, link)
|
|
frame_button_repaint(button, cr);
|
|
|
|
frame_status_clear(frame, FRAME_STATUS_REPAINT);
|
|
}
|