eukara
/
WebSurf
0
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
WebSurf/desktop/scrollbar.c

1007 lines
23 KiB
C
Raw Permalink Blame History

/*
* Copyright 2004-2008 James Bursa <bursa@users.sourceforge.net>
* Copyright 2008 Michael Drake <tlsa@netsurf-browser.org>
* Copyright 2009 Paul Blokus <paul_pl@users.sourceforge.net>
*
* This file is part of NetSurf, http://www.netsurf-browser.org/
*
* NetSurf is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; version 2 of the License.
*
* NetSurf is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
/**
* \file
* implementation of scrollbar widget.
*/
#include <stdbool.h>
#include <stdlib.h>
#include "utils/log.h"
#include "utils/messages.h"
#include "utils/utils.h"
#include "utils/nscolour.h"
#include "utils/nsoption.h"
#include "netsurf/browser_window.h"
#include "netsurf/mouse.h"
#include "netsurf/plotters.h"
#include "desktop/system_colour.h"
#include "desktop/scrollbar.h"
/**
* Scrollbar context
*/
struct scrollbar {
/** Horizontal scrollbar if true, else vertical */
bool horizontal;
/** Length of the scrollbar widget */
int length;
/** Length of the full scrollable area */
int full_size;
/** Length visible part of the scrollable area */
int visible_size;
/** Current scroll offset to visible area */
int offset;
/** Position of the scrollbar */
int bar_pos;
/** Length of the scrollbar */
int bar_len;
/** Callback receiving scrollbar events */
scrollbar_client_callback client_callback;
/** User data passed to the callback */
void *client_data;
/** Flag indicating drag at progess */
bool dragging;
/** Coordinate value at drag start */
int drag_start_coord;
/** Scrollbar offset or bar_pos at drag start */
int drag_start_pos;
/** Flag indicating that the drag corresponds to a dragged
* content area, rather than a dragged scrollbar.
*/
bool drag_content;
/** Parpendicular scrollbar, or NULL */
struct scrollbar *pair;
/** Flag indicating that the current drag affects the
* perpendicular scrollbar too
*/
bool pair_drag;
};
/*
* Exported interface. Documented in desktop/scrollbar.h
*/
nserror
scrollbar_create(bool horizontal,
int length,
int full_size,
int visible_size,
void *client_data,
scrollbar_client_callback client_callback,
struct scrollbar **s)
{
struct scrollbar *scrollbar;
int well_length;
scrollbar = malloc(sizeof(struct scrollbar));
if (scrollbar == NULL) {
*s = NULL;
return NSERROR_NOMEM;
}
scrollbar->horizontal = horizontal;
scrollbar->length = length;
scrollbar->full_size = full_size;
scrollbar->visible_size = visible_size;
scrollbar->offset = 0;
scrollbar->bar_pos = 0;
scrollbar->pair = NULL;
scrollbar->pair_drag = false;
well_length = length - 2 * SCROLLBAR_WIDTH;
scrollbar->bar_len = (full_size == 0) ? 0 :
((well_length * visible_size) / full_size);
scrollbar->client_callback = client_callback;
scrollbar->client_data = client_data;
scrollbar->dragging = false;
scrollbar->drag_content = false;
*s = scrollbar;
return NSERROR_OK;
}
/*
* Exported interface. Documented in scrollbar.h
*/
void scrollbar_destroy(struct scrollbar *s)
{
if (s->pair != NULL) {
s->pair->pair = NULL;
}
free(s);
}
/**
* Draw an outline rectangle common to several scrollbar elements.
*
* \param ctx current redraw context
* \param area the area of the scrollbar
* \param c base colour of the outline, the other colours are created by
* lightening or darkening this one
* \param inset true for inset outline, false for an outset one
* \return NSERROR_OK on success else error code
*/
static inline nserror
scrollbar_rectangle(const struct redraw_context *ctx,
struct rect *area,
colour c,
bool inset)
{
struct rect line;
nserror res;
static plot_style_t c0 = {
.stroke_type = PLOT_OP_TYPE_SOLID,
.stroke_width = plot_style_int_to_fixed(1),
};
static plot_style_t c1 = {
.stroke_type = PLOT_OP_TYPE_SOLID,
.stroke_width = plot_style_int_to_fixed(1),
};
static plot_style_t c2 = {
.stroke_type = PLOT_OP_TYPE_SOLID,
.stroke_width = plot_style_int_to_fixed(1),
};
if (inset) {
c0.stroke_colour = darken_colour(c);
c1.stroke_colour = lighten_colour(c);
} else {
c0.stroke_colour = lighten_colour(c);
c1.stroke_colour = darken_colour(c);
}
c2.stroke_colour = blend_colour(c0.stroke_colour, c1.stroke_colour);
/* Plot the outline */
line.x0 = area->x0; line.y0 = area->y0;
line.x1 = area->x1; line.y1 = area->y0;
res = ctx->plot->line(ctx, &c0, &line);
if (res != NSERROR_OK) {
return res;
}
line.x0 = area->x1; line.y0 = area->y0;
line.x1 = area->x1; line.y1 = area->y1 + 1;
res = ctx->plot->line(ctx, &c1, &line);
if (res != NSERROR_OK) {
return res;
}
line.x0 = area->x1; line.y0 = area->y0;
line.x1 = area->x1; line.y1 = area->y0 + 1;
res = ctx->plot->line(ctx, &c2, &line);
if (res != NSERROR_OK) {
return res;
}
line.x0 = area->x1; line.y0 = area->y1;
line.x1 = area->x0; line.y1 = area->y1;
res = ctx->plot->line(ctx, &c1, &line);
if (res != NSERROR_OK) {
return res;
}
line.x0 = area->x0; line.y0 = area->y1;
line.x1 = area->x0; line.y1 = area->y0;
res = ctx->plot->line(ctx, &c0, &line);
if (res != NSERROR_OK) {
return res;
}
line.x0 = area->x0; line.y0 = area->y1;
line.x1 = area->x0; line.y1 = area->y1 + 1;
res = ctx->plot->line(ctx, &c2, &line);
return res;
}
/*
* Exported interface. Documented in scrollbar.h
*/
nserror
scrollbar_redraw(struct scrollbar *s,
int x, int y,
const struct rect *clip,
float scale,
const struct redraw_context *ctx)
{
int w = SCROLLBAR_WIDTH;
int bar_pos, bar_c0, bar_c1;
int v[6]; /* array of triangle vertices */
struct rect area;
struct rect rect;
nserror res;
plot_style_t bg_fill_style = {
.fill_type = PLOT_OP_TYPE_SOLID,
.fill_colour = nscolours[NSCOLOUR_SCROLL_WELL],
};
plot_style_t fg_fill_style = {
.fill_type = PLOT_OP_TYPE_SOLID,
.fill_colour = nscolours[NSCOLOUR_BUTTON_BG],
};
plot_style_t arrow_fill_style = {
.fill_type = PLOT_OP_TYPE_SOLID,
.fill_colour = nscolours[NSCOLOUR_BUTTON_FG],
};
area.x0 = x;
area.y0 = y;
area.x1 = x + (s->horizontal ? s->length : SCROLLBAR_WIDTH) - 1;
area.y1 = y + (s->horizontal ? SCROLLBAR_WIDTH : s->length) - 1;
bar_pos = s->bar_pos;
bar_c1 = (s->horizontal ? area.x0 : area.y0) + SCROLLBAR_WIDTH +
s->bar_pos + s->bar_len - 1;
if (scale != 1.0) {
w *= scale;
area.x0 *= scale;
area.y0 *= scale;
area.x1 *= scale;
area.y1 *= scale;
bar_pos *= scale;
bar_c1 *= scale;
}
bar_c0 = (s->horizontal ? area.x0 : area.y0) + w + bar_pos;
/* if scrollbar is outside the clipping rectangle, nothing to render */
if ((area.x1 < clip->x0) ||
(area.y1 < clip->y0) ||
(clip->x1 < area.x0) ||
(clip->y1 < area.y0)) {
return NSERROR_OK;
}
if (s->horizontal) {
/* scrollbar is horizontal */
/* scrollbar outline */
res = scrollbar_rectangle(ctx, &area,
bg_fill_style.fill_colour, true);
if (res != NSERROR_OK) {
return res;
}
/* left arrow icon border */
rect.x0 = area.x0 + 1;
rect.y0 = area.y0 + 1;
rect.x1 = area.x0 + w - 2;
rect.y1 = area.y1 - 1;
res = scrollbar_rectangle(ctx, &rect,
fg_fill_style.fill_colour, false);
if (res != NSERROR_OK) {
return res;
}
/* left arrow icon background */
rect.x0 = area.x0 + 2;
rect.y0 = area.y0 + 2;
rect.x1 = area.x0 + w - 2;
rect.y1 = area.y1 - 1;
res = ctx->plot->rectangle(ctx, &fg_fill_style, &rect);
if (res != NSERROR_OK) {
return res;
}
/* left arrow */
v[0] = area.x0 + w / 4;
v[1] = area.y0 + w / 2;
v[2] = area.x0 + w * 3 / 4;
v[3] = area.y0 + w / 4;
v[4] = area.x0 + w * 3 / 4;
v[5] = area.y0 + w * 3 / 4;
res = ctx->plot->polygon(ctx, &arrow_fill_style, v, 3);
if (res != NSERROR_OK) {
return res;
}
/* scrollbar well background */
rect.x0 = area.x0 + w - 1;
rect.y0 = area.y0 + 1;
rect.x1 = area.x1 - w + 2;
rect.y1 = area.y1;
res = ctx->plot->rectangle(ctx, &bg_fill_style, &rect);
if (res != NSERROR_OK) {
return res;
}
/* scrollbar position indicator bar */
rect.x0 = bar_c0;
rect.y0 = area.y0 + 1;
rect.x1 = bar_c1;
rect.y1 = area.y1 - 1;
res = scrollbar_rectangle(ctx, &rect,
fg_fill_style.fill_colour, false);
if (res != NSERROR_OK) {
return res;
}
rect.x0 = bar_c0 + 1;
rect.y0 = area.y0 + 2;
rect.x1 = bar_c1;
rect.y1 = area.y1 - 1;
res = ctx->plot->rectangle(ctx, &fg_fill_style, &rect);
if (res != NSERROR_OK) {
return res;
}
/* right arrow icon border */
rect.x0 = area.x1 - w + 2;
rect.y0 = area.y0 + 1;
rect.x1 = area.x1 - 1;
rect.y1 = area.y1 - 1;
res = scrollbar_rectangle(ctx, &rect,
fg_fill_style.fill_colour, false);
if (res != NSERROR_OK) {
return res;
}
/* right arrow icon background */
rect.x0 = area.x1 - w + 3;
rect.y0 = area.y0 + 2;
rect.x1 = area.x1 - 1;
rect.y1 = area.y1 - 1;
res = ctx->plot->rectangle(ctx, &fg_fill_style, &rect);
if (res != NSERROR_OK) {
return res;
}
/* right arrow */
v[0] = rect.x1 - w / 4 + 1;
v[1] = rect.y0 + w / 2;
v[2] = rect.x1 - w * 3 / 4 + 1;
v[3] = rect.y0 + w / 4;
v[4] = rect.x1 - w * 3 / 4 + 1;
v[5] = rect.y0 + w * 3 / 4;
res = ctx->plot->polygon(ctx, &arrow_fill_style, v, 3);
if (res != NSERROR_OK) {
return res;
}
} else {
/* scrollbar is vertical */
/* outline */
res = scrollbar_rectangle(ctx, &area,
bg_fill_style.fill_colour, true);
if (res != NSERROR_OK) {
return res;
}
/* top arrow border */
rect.x0 = area.x0 + 1;
rect.y0 = area.y0 + 1;
rect.x1 = area.x1 - 1;
rect.y1 = area.y0 + w - 2;
res = scrollbar_rectangle(ctx, &rect,
fg_fill_style.fill_colour, false);
if (res != NSERROR_OK) {
return res;
}
/* top arrow background */
rect.x0 = area.x0 + 2;
rect.y0 = area.y0 + 2;
rect.x1 = area.x1 - 1;
rect.y1 = area.y0 + w - 2;
res = ctx->plot->rectangle(ctx, &fg_fill_style, &rect);
if (res != NSERROR_OK) {
return res;
}
/* up arrow */
v[0] = area.x0 + w / 2;
v[1] = area.y0 + w / 4;
v[2] = area.x0 + w / 4;
v[3] = area.y0 + w * 3 / 4;
v[4] = area.x0 + w * 3 / 4;
v[5] = area.y0 + w * 3 / 4;
res = ctx->plot->polygon(ctx, &arrow_fill_style, v, 3);
if (res != NSERROR_OK) {
return res;
}
/* scrollbar well background */
rect.x0 = area.x0 + 1;
rect.y0 = area.y0 + w - 1;
rect.x1 = area.x1;
rect.y1 = area.y1 - w + 2;
res = ctx->plot->rectangle(ctx, &bg_fill_style, &rect);
if (res != NSERROR_OK) {
return res;
}
/* scrollbar position indicator bar */
rect.x0 = area.x0 + 1;
rect.y0 = bar_c0;
rect.x1 = area.x1 - 1;
rect.y1 = bar_c1;
res = scrollbar_rectangle(ctx, &rect,
fg_fill_style.fill_colour, false);
if (res != NSERROR_OK) {
return res;
}
rect.x0 = area.x0 + 2;
rect.y0 = bar_c0 + 1;
rect.x1 = area.x1 - 1;
rect.y1 = bar_c1;
res = ctx->plot->rectangle(ctx, &fg_fill_style, &rect);
if (res != NSERROR_OK) {
return res;
}
/* down arrow icon border */
rect.x0 = area.x0 + 1;
rect.y0 = area.y1 - w + 2;
rect.x1 = area.x1 - 1;
rect.y1 = area.y1 - 1;
res = scrollbar_rectangle(ctx, &rect,
fg_fill_style.fill_colour, false);
if (res != NSERROR_OK) {
return res;
}
/* down arrow icon background */
rect.x0 = area.x0 + 2;
rect.y0 = area.y1 - w + 3;
rect.x1 = area.x1 - 1;
rect.y1 = area.y1 - 1;
res = ctx->plot->rectangle(ctx, &fg_fill_style, &rect);
if (res != NSERROR_OK) {
return res;
}
/* down arrow */
v[0] = area.x0 + w / 2;
v[1] = area.y1 - w / 4 + 1;
v[2] = area.x0 + w / 4;
v[3] = area.y1 - w * 3 / 4 + 1;
v[4] = area.x0 + w * 3 / 4;
v[5] = area.y1 - w * 3 / 4 + 1;
res = ctx->plot->polygon(ctx, &arrow_fill_style, v, 3);
if (res != NSERROR_OK) {
return res;
}
}
return NSERROR_OK;
}
/*
* Exported interface. Documented in scrollbar.h
*/
void scrollbar_set(struct scrollbar *s, int value, bool bar_pos)
{
int well_length;
int old_offset = s->offset;
struct scrollbar_msg_data msg;
if (value < 0) {
value = 0;
}
if (s->full_size == s->visible_size) {
return;
}
well_length = s->length - 2 * SCROLLBAR_WIDTH;
if (bar_pos) {
if (value > well_length - s->bar_len) {
s->bar_pos = well_length - s->bar_len;
} else {
s->bar_pos = value;
}
s->offset = ((well_length - s->bar_len) < 1) ? 0 :
(((s->full_size - s->visible_size) *
s->bar_pos) / (well_length - s->bar_len));
} else {
if (value > s->full_size - s->visible_size) {
s->offset = s->full_size - s->visible_size;
} else {
s->offset = value;
}
s->bar_pos = (s->full_size < 1) ? 0 :
((well_length * s->offset) / s->full_size);
}
if (s->offset != old_offset) {
/* client callback if there was a chnage */
msg.scrollbar = s;
msg.msg = SCROLLBAR_MSG_MOVED;
msg.scroll_offset = s->offset;
s->client_callback(s->client_data, &msg);
}
}
/*
* Exported interface. Documented in scrollbar.h
*/
bool scrollbar_scroll(struct scrollbar *s, int change)
{
int well_length;
int old_offset = s->offset;
struct scrollbar_msg_data msg;
if (change == 0 || s->full_size <= s->visible_size) {
/* zero scroll step, or unscrollable */
return false;
}
/* Convert named change values to appropriate pixel offset value */
switch (change) {
case SCROLL_TOP:
change = -s->full_size;
break;
case SCROLL_PAGE_UP:
change = -s->visible_size;
break;
case SCROLL_PAGE_DOWN:
change = s->visible_size;
break;
case SCROLL_BOTTOM:
change = s->full_size;
break;
default:
/* Change value is already a pixel offset */
break;
}
/* Get new offset */
if (s->offset + change > s->full_size - s->visible_size) {
s->offset = s->full_size - s->visible_size;
} else if (s->offset + change < 0) {
s->offset = 0;
} else {
s->offset += change;
}
if (s->offset == old_offset) {
/* Nothing happened */
return false;
}
/* Update scrollbar */
well_length = s->length - 2 * SCROLLBAR_WIDTH;
s->bar_pos = (s->full_size < 1) ? 0 :
((well_length * s->offset) / s->full_size);
msg.scrollbar = s;
msg.msg = SCROLLBAR_MSG_MOVED;
msg.scroll_offset = s->offset;
s->client_callback(s->client_data, &msg);
return true;
}
/*
* Exported interface. Documented in scrollbar.h
*/
int scrollbar_get_offset(struct scrollbar *s)
{
if (s == NULL) {
return 0;
}
return s->offset;
}
/*
* Exported interface. Documented in scrollbar.h
*/
void scrollbar_set_extents(struct scrollbar *s, int length,
int visible_size, int full_size)
{
int cur_excess = s->full_size - s->visible_size;
int well_length;
struct scrollbar_msg_data msg;
if (length == s->length &&
visible_size == s->visible_size &&
full_size == s->full_size) {
/* Nothing's changed. */
return;
}
if (length != -1) {
s->length = length;
}
if (visible_size != -1) {
s->visible_size = visible_size;
}
if (full_size != -1) {
s->full_size = full_size;
}
if (s->full_size < s->visible_size) {
s->full_size = s->visible_size;
}
/* Update scroll offset (scaled in proportion with change in excess) */
if (cur_excess <= 0) {
s->offset = 0;
} else {
s->offset = (full_size - visible_size) * s->offset / cur_excess;
}
well_length = s->length - 2 * SCROLLBAR_WIDTH;
if (s->full_size < 1) {
s->bar_len = well_length;
s->bar_pos = 0;
} else {
s->bar_len = (well_length * s->visible_size) / s->full_size;
s->bar_pos = (well_length * s->offset) / s->full_size;
}
msg.scrollbar = s;
msg.msg = SCROLLBAR_MSG_MOVED;
msg.scroll_offset = s->offset;
s->client_callback(s->client_data, &msg);
}
/*
* Exported interface. Documented in scrollbar.h
*/
bool scrollbar_is_horizontal(struct scrollbar *s)
{
return s->horizontal;
}
/**
* Internal procedure used for starting a drag scroll for a scrollbar.
*
* \param s the scrollbar to start the drag for
* \param x the X coordinate of the drag start
* \param y the Y coordinate of the drag start
* \param content_drag whether this should be a reverse drag (used when the
* user drags the content area, rather than the scrollbar)
* \param pair whether the drag is a '2D' scroll
*/
static void
scrollbar_drag_start_internal(struct scrollbar *s,
int x, int y,
bool content_drag,
bool pair)
{
struct scrollbar_msg_data msg;
s->drag_start_coord = s->horizontal ? x : y;
s->drag_start_pos = (content_drag) ? s->offset : s->bar_pos;
s->dragging = true;
s->drag_content = content_drag;
msg.scrollbar = s;
/** \todo some proper numbers please! */
if (s->horizontal) {
msg.x0 = -2048;
msg.x1 = 2048;
msg.y0 = 0;
msg.y1 = 0;
} else {
msg.x0 = 0;
msg.x1 = 0;
msg.y0 = -2048;
msg.y1 = 2048;
}
if (pair && s->pair != NULL) {
s->pair_drag = true;
s->pair->drag_start_coord =
s->pair->horizontal ? x : y;
s->pair->drag_start_pos = (content_drag) ? s->pair->offset :
s->pair->bar_pos;
s->pair->dragging = true;
s->pair->drag_content = content_drag;
if (s->pair->horizontal) {
msg.x0 = -2048;
msg.x1 = 2048;
} else {
msg.y0 = -2048;
msg.y1 = 2048;
}
}
msg.msg = SCROLLBAR_MSG_SCROLL_START;
s->client_callback(s->client_data, &msg);
}
/*
* Exported interface. Documented in scrollbar.h
*/
scrollbar_mouse_status
scrollbar_mouse_action(struct scrollbar *s,
browser_mouse_state mouse,
int x, int y)
{
int x0, y0, x1, y1;
int val;
scrollbar_mouse_status status = SCROLLBAR_MOUSE_NONE;
bool h;
/* we want mouse presses and mouse drags that were not started at the
* scrollbar indication bar to be launching actions on the scroll area
*/
bool but1 = ((mouse & BROWSER_MOUSE_PRESS_1) ||
((mouse & BROWSER_MOUSE_HOLDING_1) &&
(mouse & BROWSER_MOUSE_DRAG_ON) &&
!s->dragging));
bool but2 = ((mouse & BROWSER_MOUSE_PRESS_2) ||
((mouse & BROWSER_MOUSE_HOLDING_2) &&
(mouse & BROWSER_MOUSE_DRAG_ON) &&
!s->dragging));
h = s->horizontal;
x0 = 0;
y0 = 0;
x1 = h ? s->length : SCROLLBAR_WIDTH;
y1 = h ? SCROLLBAR_WIDTH : s->length;
if (!s->dragging && !(x >= x0 && x <= x1 && y >= y0 && y <= y1)) {
/* Not a drag and mouse outside scrollbar widget */
return SCROLLBAR_MOUSE_NONE;
}
if (h) {
val = x;
} else {
val = y;
}
if (s->dragging) {
val -= s->drag_start_coord;
if (s->drag_content) {
val = -val;
}
if (val != 0) {
scrollbar_set(s, s->drag_start_pos + val,
!(s->drag_content));
}
if (s->pair_drag) {
scrollbar_mouse_action(s->pair, mouse, x, y);
status = SCROLLBAR_MOUSE_BOTH;
} else {
status = h ? SCROLLBAR_MOUSE_HRZ : SCROLLBAR_MOUSE_VRT;
}
return status;
}
if (val < SCROLLBAR_WIDTH) {
/* left/up arrow */
status = h ? SCROLLBAR_MOUSE_LFT : SCROLLBAR_MOUSE_UP;
if (but1) {
scrollbar_set(s, s->offset - SCROLLBAR_WIDTH, false);
} else if (but2) {
scrollbar_set(s, s->offset + SCROLLBAR_WIDTH, false);
}
} else if (val < SCROLLBAR_WIDTH + s->bar_pos) {
/* well between left/up arrow and bar */
status = h ? SCROLLBAR_MOUSE_PLFT : SCROLLBAR_MOUSE_PUP;
if (but1) {
scrollbar_set(s, s->offset - s->length, false);
} else if (but2) {
scrollbar_set(s, s->offset + s->length, false);
}
} else if (val > s->length - SCROLLBAR_WIDTH) {
/* right/down arrow */
status = h ? SCROLLBAR_MOUSE_RGT : SCROLLBAR_MOUSE_DWN;
if (but1) {
scrollbar_set(s, s->offset + SCROLLBAR_WIDTH, false);
} else if (but2) {
scrollbar_set(s, s->offset - SCROLLBAR_WIDTH, false);
}
} else if (val > SCROLLBAR_WIDTH + s->bar_pos + s->bar_len) {
/* well between right/down arrow and bar */
status = h ? SCROLLBAR_MOUSE_PRGT : SCROLLBAR_MOUSE_PDWN;
if (but1) {
scrollbar_set(s, s->offset + s->length, false);
} else if (but2) {
scrollbar_set(s, s->offset - s->length, false);
}
} else {
/* scrollbar position indication bar */
status = h ? SCROLLBAR_MOUSE_HRZ : SCROLLBAR_MOUSE_VRT;
}
if (mouse & (BROWSER_MOUSE_DRAG_1 | BROWSER_MOUSE_DRAG_2) &&
(val >= SCROLLBAR_WIDTH + s->bar_pos
&& val < SCROLLBAR_WIDTH + s->bar_pos +
s->bar_len)) {
/* The mouse event is a drag start on the scrollbar position
* indication bar. */
scrollbar_drag_start_internal(s, x, y, false,
(mouse & BROWSER_MOUSE_DRAG_2) ? true : false);
}
return status;
}
/*
* Exported interface. Documented in scrollbar.h
*/
const char *scrollbar_mouse_status_to_message(scrollbar_mouse_status status)
{
switch ((unsigned int) status) {
case SCROLLBAR_MOUSE_UP:
case SCROLLBAR_MOUSE_UP | SCROLLBAR_MOUSE_USED:
return messages_get("ScrollUp");
case SCROLLBAR_MOUSE_PUP:
case SCROLLBAR_MOUSE_PUP | SCROLLBAR_MOUSE_USED:
return messages_get("ScrollPUp");
case SCROLLBAR_MOUSE_VRT:
case SCROLLBAR_MOUSE_VRT | SCROLLBAR_MOUSE_USED:
return messages_get("ScrollV");
case SCROLLBAR_MOUSE_PDWN:
case SCROLLBAR_MOUSE_PDWN | SCROLLBAR_MOUSE_USED:
return messages_get("ScrollPDown");
case SCROLLBAR_MOUSE_DWN:
case SCROLLBAR_MOUSE_DWN | SCROLLBAR_MOUSE_USED:
return messages_get("ScrollDown");
case SCROLLBAR_MOUSE_LFT:
case SCROLLBAR_MOUSE_LFT | SCROLLBAR_MOUSE_USED:
return messages_get("ScrollLeft");
case SCROLLBAR_MOUSE_PLFT:
case SCROLLBAR_MOUSE_PLFT | SCROLLBAR_MOUSE_USED:
return messages_get("ScrollPLeft");
case SCROLLBAR_MOUSE_HRZ:
case SCROLLBAR_MOUSE_HRZ | SCROLLBAR_MOUSE_USED:
return messages_get("ScrollH");
case SCROLLBAR_MOUSE_PRGT:
case SCROLLBAR_MOUSE_PRGT | SCROLLBAR_MOUSE_USED:
return messages_get("ScrollPRight");
case SCROLLBAR_MOUSE_RGT:
case SCROLLBAR_MOUSE_RGT | SCROLLBAR_MOUSE_USED:
return messages_get("ScrollRight");
default:
break;
}
return NULL;
}
/*
* Exported interface. Documented in scrollbar.h
*/
void scrollbar_mouse_drag_end(struct scrollbar *s,
browser_mouse_state mouse, int x, int y)
{
struct scrollbar_msg_data msg;
int val, drag_start_pos;
assert(s->dragging);
drag_start_pos = s->drag_start_pos;
val = (s->horizontal ? x : y) - s->drag_start_coord;
if (s->drag_content) {
val = -val;
}
if (val != 0) {
scrollbar_set(s, drag_start_pos + val, !(s->drag_content));
}
s->dragging = false;
s->drag_content = false;
if (s->pair_drag) {
s->pair_drag = false;
drag_start_pos = s->pair->drag_start_pos;
val = (s->pair->horizontal ? x : y) - s->pair->drag_start_coord;
if (s->pair->drag_content) {
val = -val;
}
if (val != 0) {
scrollbar_set(s->pair, drag_start_pos + val,
!(s->pair->drag_content));
}
s->pair->dragging = false;
s->pair->drag_content = false;
}
msg.scrollbar = s;
msg.msg = SCROLLBAR_MSG_SCROLL_FINISHED;
s->client_callback(s->client_data, &msg);
}
/*
* Exported interface. Documented in scrollbar.h
*/
void scrollbar_start_content_drag(struct scrollbar *s, int x, int y)
{
scrollbar_drag_start_internal(s, x, y, true, true);
}
/*
* Exported interface. Documented in scrollbar.h
*/
void scrollbar_make_pair(struct scrollbar *horizontal,
struct scrollbar *vertical)
{
assert(horizontal->horizontal &&
!vertical->horizontal);
horizontal->pair = vertical;
vertical->pair = horizontal;
}
/*
* Exported interface. Documented in scrollbar.h
*/
void *scrollbar_get_data(struct scrollbar *s)
{
return s->client_data;
}
Reference in New Issue View Git Blame Copy Permalink