mirror of
https://github.com/netsurf-browser/netsurf
synced 2024-12-23 12:36:51 +03:00
75018632a9
for F in $(git ls-files '*.c');do spatch --sp-file foo.cocci --in-place ${F};done @@ expression E; @@ -LOG(E); +NSLOG(netsurf, INFO, E); @@ expression E, E1; @@ -LOG(E, E1); +NSLOG(netsurf, INFO, E, E1); @@ expression E, E1, E2; @@ -LOG(E, E1, E2); +NSLOG(netsurf, INFO, E, E1, E2); @@ expression E, E1, E2, E3; @@ -LOG(E, E1, E2, E3); +NSLOG(netsurf, INFO, E, E1, E2, E3); @@ expression E, E1, E2, E3, E4; @@ -LOG(E, E1, E2, E3, E4); +NSLOG(netsurf, INFO, E, E1, E2, E3, E4); @@ expression E, E1, E2, E3, E4, E5; @@ -LOG(E, E1, E2, E3, E4, E5); +NSLOG(netsurf, INFO, E, E1, E2, E3, E4, E5); @@ expression E, E1, E2, E3, E4, E5, E6; @@ -LOG(E, E1, E2, E3, E4, E5, E6); +NSLOG(netsurf, INFO, E, E1, E2, E3, E4, E5, E6); @@ expression E, E1, E2, E3, E4, E5, E6, E7; @@ -LOG(E, E1, E2, E3, E4, E5, E6, E7); +NSLOG(netsurf, INFO, E, E1, E2, E3, E4, E5, E6, E7);
547 lines
13 KiB
C
547 lines
13 KiB
C
/*
|
|
* Copyright 2006 Richard Wilson <info@tinct.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
|
|
* Progress bar (implementation).
|
|
*/
|
|
|
|
#include <assert.h>
|
|
#include <stdbool.h>
|
|
#include <string.h>
|
|
#include "swis.h"
|
|
#include "oslib/colourtrans.h"
|
|
#include "oslib/os.h"
|
|
#include "oslib/osspriteop.h"
|
|
#include "oslib/wimp.h"
|
|
#include "oslib/wimpspriteop.h"
|
|
|
|
#include "utils/log.h"
|
|
#include "utils/utils.h"
|
|
#include "netsurf/plotters.h"
|
|
|
|
#include "riscos/gui.h"
|
|
#include "riscos/tinct.h"
|
|
#include "riscos/wimp_event.h"
|
|
#include "riscos/gui/progress_bar.h"
|
|
|
|
#define MARGIN 6
|
|
|
|
struct progress_bar {
|
|
wimp_w w; /**< progress bar window handle */
|
|
unsigned int range; /**< progress bar range */
|
|
unsigned int value; /**< progress bar value */
|
|
char icon[13]; /**< current icon */
|
|
int offset; /**< progress bar rotation */
|
|
os_box visible; /**< progress bar position */
|
|
int icon_x0; /**< icon x0 */
|
|
int icon_y0; /**< icon y0 */
|
|
osspriteop_header *icon_img; /**< icon image */
|
|
bool animating; /**< progress bar is animating */
|
|
bool recalculate; /**< recalculation required */
|
|
int cur_width; /**< current calculated width */
|
|
int cur_height; /**< current calculated height */
|
|
bool icon_obscured; /**< icon is partially obscured */
|
|
};
|
|
|
|
static char progress_animation_sprite[] = "progress";
|
|
static osspriteop_header *progress_icon;
|
|
static unsigned int progress_width;
|
|
static unsigned int progress_height;
|
|
|
|
struct wimp_window_base progress_bar_definition = {
|
|
{0, 0, 1, 1},
|
|
0,
|
|
0,
|
|
wimp_TOP,
|
|
wimp_WINDOW_NEW_FORMAT | wimp_WINDOW_MOVEABLE | wimp_WINDOW_NO_BOUNDS,
|
|
0xff,
|
|
wimp_COLOUR_LIGHT_GREY,
|
|
wimp_COLOUR_LIGHT_GREY,
|
|
wimp_COLOUR_VERY_LIGHT_GREY,
|
|
wimp_COLOUR_DARK_GREY,
|
|
wimp_COLOUR_MID_LIGHT_GREY,
|
|
wimp_COLOUR_CREAM,
|
|
wimp_WINDOW_NEVER3D | 0x16u /* RISC OS 5.03+ */,
|
|
{0, 0, 65535, 65535},
|
|
0,
|
|
0,
|
|
wimpspriteop_AREA,
|
|
1,
|
|
1,
|
|
{""},
|
|
0
|
|
};
|
|
|
|
|
|
static void ro_gui_progress_bar_calculate(struct progress_bar *pb, int width,
|
|
int height);
|
|
static void ro_gui_progress_bar_redraw(wimp_draw *redraw);
|
|
static void ro_gui_progress_bar_redraw_window(wimp_draw *redraw,
|
|
struct progress_bar *pb);
|
|
static void ro_gui_progress_bar_animate(void *p);
|
|
|
|
|
|
/**
|
|
* Initialise the progress bar
|
|
*
|
|
* \param icons the sprite area to use for icons
|
|
*/
|
|
void ro_gui_progress_bar_init(osspriteop_area *icons)
|
|
{
|
|
const char *name = progress_animation_sprite;
|
|
os_error *error;
|
|
|
|
progress_bar_definition.sprite_area = icons;
|
|
|
|
progress_icon = NULL;
|
|
error = xosspriteop_select_sprite(osspriteop_USER_AREA,
|
|
progress_bar_definition.sprite_area,
|
|
(osspriteop_id) name, &progress_icon);
|
|
if (!error) {
|
|
xosspriteop_read_sprite_info(osspriteop_USER_AREA,
|
|
progress_bar_definition.sprite_area,
|
|
(osspriteop_id) name,
|
|
(int *) &progress_width, (int *) &progress_height,
|
|
0, 0);
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* Create a new progress bar
|
|
*/
|
|
struct progress_bar *ro_gui_progress_bar_create(void)
|
|
{
|
|
struct progress_bar *pb;
|
|
os_error *error;
|
|
|
|
pb = calloc(1, sizeof(*pb));
|
|
if (!pb)
|
|
return NULL;
|
|
|
|
error = xwimp_create_window((wimp_window *)&progress_bar_definition,
|
|
&pb->w);
|
|
if (error) {
|
|
NSLOG(netsurf, INFO, "xwimp_create_window: 0x%x: %s",
|
|
error->errnum, error->errmess);
|
|
free(pb);
|
|
return NULL;
|
|
}
|
|
|
|
ro_gui_wimp_event_register_redraw_window(pb->w,
|
|
ro_gui_progress_bar_redraw);
|
|
ro_gui_wimp_event_set_user_data(pb->w, pb);
|
|
return pb;
|
|
}
|
|
|
|
|
|
/**
|
|
* Destroy a progress bar and free all associated resources
|
|
*
|
|
* \param pb the progress bar to destroy
|
|
*/
|
|
void ro_gui_progress_bar_destroy(struct progress_bar *pb)
|
|
{
|
|
os_error *error;
|
|
assert(pb);
|
|
|
|
if (pb->animating) {
|
|
riscos_schedule(-1, ro_gui_progress_bar_animate, pb);
|
|
}
|
|
ro_gui_wimp_event_finalise(pb->w);
|
|
error = xwimp_delete_window(pb->w);
|
|
if (error) {
|
|
NSLOG(netsurf, INFO, "xwimp_delete_window: 0x%x:%s",
|
|
error->errnum, error->errmess);
|
|
}
|
|
|
|
free(pb);
|
|
}
|
|
|
|
|
|
/**
|
|
* Get the handle of the window that represents a progress bar
|
|
*
|
|
* \param pb the progress bar to get the window handle of
|
|
* \return the progress bar's window handle
|
|
*/
|
|
wimp_w ro_gui_progress_bar_get_window(struct progress_bar *pb)
|
|
{
|
|
assert(pb);
|
|
|
|
return pb->w;
|
|
}
|
|
|
|
|
|
/**
|
|
* Set the icon for a progress bar
|
|
*
|
|
* \param pb the progress bar to set the icon for
|
|
* \param icon the icon to use, or NULL for no icon
|
|
*/
|
|
void ro_gui_progress_bar_set_icon(struct progress_bar *pb, const char *icon)
|
|
{
|
|
assert(pb);
|
|
|
|
if (!strcmp(icon, pb->icon))
|
|
return;
|
|
if (!icon)
|
|
pb->icon[0] = '\0';
|
|
else {
|
|
strncpy(pb->icon, icon, 12);
|
|
pb->icon[12] = '\0';
|
|
}
|
|
pb->recalculate = true;
|
|
xwimp_force_redraw(pb->w, 0, 0, 32, 32);
|
|
ro_gui_progress_bar_update(pb, pb->cur_width, pb->cur_height);
|
|
}
|
|
|
|
|
|
/**
|
|
* Set the value of a progress bar
|
|
*
|
|
* \param pb the progress bar to set the value for
|
|
* \param value the value to use
|
|
*/
|
|
void ro_gui_progress_bar_set_value(struct progress_bar *pb, unsigned int value)
|
|
{
|
|
assert(pb);
|
|
|
|
pb->value = value;
|
|
if (pb->value > pb->range)
|
|
pb->range = pb->value;
|
|
ro_gui_progress_bar_update(pb, pb->cur_width, pb->cur_height);
|
|
}
|
|
|
|
|
|
/**
|
|
* Get the value of a progress bar
|
|
*
|
|
* \param pb the progress bar to get the value of
|
|
* \return the current value
|
|
*/
|
|
unsigned int ro_gui_progress_bar_get_value(struct progress_bar *pb)
|
|
{
|
|
assert(pb);
|
|
|
|
return pb->value;
|
|
}
|
|
|
|
|
|
/**
|
|
* Set the range of a progress bar
|
|
*
|
|
* \param pb the progress bar to set the range for
|
|
* \param range the range to use
|
|
*/
|
|
void ro_gui_progress_bar_set_range(struct progress_bar *pb, unsigned int range)
|
|
{
|
|
assert(pb);
|
|
|
|
pb->range = range;
|
|
if (pb->value > pb->range)
|
|
pb->value = pb->range;
|
|
ro_gui_progress_bar_update(pb, pb->cur_width, pb->cur_height);
|
|
}
|
|
|
|
|
|
/**
|
|
* Get the range of a progress bar
|
|
*
|
|
* \param pb the progress bar to get the range of
|
|
* \return the current range
|
|
*/
|
|
unsigned int ro_gui_progress_bar_get_range(struct progress_bar *pb)
|
|
{
|
|
assert(pb);
|
|
|
|
return pb->range;
|
|
}
|
|
|
|
|
|
/**
|
|
* Update the progress bar to a new dimension.
|
|
*
|
|
* \param pb the progress bar to update
|
|
* \param width the new progress bar width
|
|
* \param height the new progress bar height
|
|
*/
|
|
void ro_gui_progress_bar_update(struct progress_bar *pb, int width, int height)
|
|
{
|
|
wimp_draw redraw;
|
|
os_error *error;
|
|
osbool more;
|
|
os_box cur;
|
|
|
|
/* don't allow negative dimensions */
|
|
width = max(width, 0);
|
|
height = max(height, 0);
|
|
|
|
/* update the animation state */
|
|
if ((pb->value == 0) || (pb->value == pb->range)) {
|
|
if (pb->animating) {
|
|
riscos_schedule(-1, ro_gui_progress_bar_animate, pb);
|
|
}
|
|
pb->animating = false;
|
|
} else {
|
|
if (!pb->animating) {
|
|
riscos_schedule(200, ro_gui_progress_bar_animate, pb);
|
|
}
|
|
pb->animating = true;
|
|
}
|
|
|
|
/* get old and new positions */
|
|
cur = pb->visible;
|
|
pb->recalculate = true;
|
|
ro_gui_progress_bar_calculate(pb, width, height);
|
|
|
|
/* see if the progress bar hasn't moved. we don't need to consider
|
|
* the left edge moving as this is handled by the icon setting
|
|
* function */
|
|
if (cur.x1 == pb->visible.x1)
|
|
return;
|
|
|
|
/* if size has decreased then we must force a redraw */
|
|
if (cur.x1 > pb->visible.x1) {
|
|
xwimp_force_redraw(pb->w, pb->visible.x1, pb->visible.y0,
|
|
cur.x1, pb->visible.y1);
|
|
return;
|
|
}
|
|
|
|
/* perform a minimal redraw update */
|
|
redraw.w = pb->w;
|
|
redraw.box = pb->visible;
|
|
redraw.box.x0 = cur.x1;
|
|
error = xwimp_update_window(&redraw, &more);
|
|
if (error) {
|
|
NSLOG(netsurf, INFO, "Error getting update window: 0x%x: %s",
|
|
error->errnum, error->errmess);
|
|
return;
|
|
}
|
|
if (more)
|
|
ro_gui_progress_bar_redraw_window(&redraw, pb);
|
|
}
|
|
|
|
|
|
/**
|
|
* Process a WIMP redraw request
|
|
*
|
|
* \param redraw the redraw request to process
|
|
*/
|
|
void ro_gui_progress_bar_redraw(wimp_draw *redraw)
|
|
{
|
|
struct progress_bar *pb;
|
|
os_error *error;
|
|
osbool more;
|
|
|
|
pb = (struct progress_bar *)ro_gui_wimp_event_get_user_data(redraw->w);
|
|
assert(pb);
|
|
|
|
error = xwimp_redraw_window(redraw, &more);
|
|
if (error) {
|
|
NSLOG(netsurf, INFO, "xwimp_redraw_window: 0x%x: %s",
|
|
error->errnum, error->errmess);
|
|
return;
|
|
}
|
|
if (more)
|
|
ro_gui_progress_bar_redraw_window(redraw, pb);
|
|
}
|
|
|
|
|
|
/**
|
|
* Animate the progress bar
|
|
*
|
|
* \param p the progress bar to animate
|
|
*/
|
|
void ro_gui_progress_bar_animate(void *p)
|
|
{
|
|
wimp_draw redraw;
|
|
os_error *error;
|
|
osbool more;
|
|
struct progress_bar *pb = p;
|
|
|
|
if (!progress_icon)
|
|
return;
|
|
pb->offset -= 6;
|
|
if (pb->offset < 0)
|
|
pb->offset += progress_width * 2;
|
|
|
|
if (pb->animating) {
|
|
riscos_schedule(200, ro_gui_progress_bar_animate, pb);
|
|
}
|
|
|
|
redraw.w = pb->w;
|
|
redraw.box = pb->visible;
|
|
error = xwimp_update_window(&redraw, &more);
|
|
if (error != NULL) {
|
|
NSLOG(netsurf, INFO, "Error getting update window: '%s'",
|
|
error->errmess);
|
|
return;
|
|
}
|
|
if (more)
|
|
ro_gui_progress_bar_redraw_window(&redraw, pb);
|
|
}
|
|
|
|
|
|
/**
|
|
* Calculate the position of the progress bar
|
|
*
|
|
* \param pb the progress bar to recalculate
|
|
* \param width the width of the progress bar
|
|
* \param height the height of the progress bar
|
|
* \return the address of the associated icon, or NULL
|
|
*/
|
|
void ro_gui_progress_bar_calculate(struct progress_bar *pb, int width,
|
|
int height)
|
|
{
|
|
int icon_width, icon_height;
|
|
int icon_x0 = 0, icon_y0 = 0, progress_x0, progress_x1;
|
|
osspriteop_header *icon = NULL;
|
|
bool icon_redraw = false;
|
|
|
|
/* try to use cached values */
|
|
if ((!pb->recalculate) && (pb->cur_width == width) &&
|
|
(pb->cur_height == height))
|
|
return;
|
|
|
|
/* update cache status */
|
|
pb->recalculate = false;
|
|
pb->cur_width = width;
|
|
pb->cur_height = height;
|
|
|
|
/* get the window dimensions */
|
|
width -= MARGIN * 2;
|
|
icon_width = icon_height = 0;
|
|
progress_x0 = MARGIN;
|
|
|
|
/* get the icon information */
|
|
if (progress_bar_definition.sprite_area != wimpspriteop_AREA) {
|
|
int progress_ymid = height / 2;
|
|
os_error *error;
|
|
error = xosspriteop_read_sprite_info(osspriteop_USER_AREA,
|
|
progress_bar_definition.sprite_area,
|
|
(osspriteop_id)pb->icon,
|
|
&icon_width, &icon_height, 0, 0);
|
|
if (!error) {
|
|
error = xosspriteop_select_sprite(osspriteop_USER_AREA,
|
|
progress_bar_definition.sprite_area,
|
|
(osspriteop_id)pb->icon, &icon);
|
|
}
|
|
if (!error) {
|
|
progress_x0 += 32 + MARGIN;
|
|
width -= 32 + MARGIN;
|
|
icon_x0 = MARGIN + 16 - icon_width;
|
|
icon_y0 = progress_ymid - icon_height;
|
|
if (width < -MARGIN) {
|
|
icon_x0 += width + MARGIN;
|
|
icon_redraw = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
/* update the icon */
|
|
if ((pb->icon_obscured) || (icon_redraw)) {
|
|
if (icon_x0 != pb->icon_x0)
|
|
xwimp_force_redraw(pb->w, 0, 0, 32 + MARGIN, 65536);
|
|
}
|
|
pb->icon_obscured = icon_redraw;
|
|
|
|
progress_x1 = progress_x0;
|
|
if ((pb->range > 0) && (width > 0))
|
|
progress_x1 += (width * pb->value) / pb->range;
|
|
|
|
pb->visible.x0 = progress_x0;
|
|
pb->visible.y0 = MARGIN;
|
|
pb->visible.x1 = progress_x1;
|
|
pb->visible.y1 = height - MARGIN;
|
|
pb->icon_x0 = icon_x0;
|
|
pb->icon_y0 = icon_y0;
|
|
pb->icon_img = icon;
|
|
}
|
|
|
|
|
|
/**
|
|
* Redraw a section of a progress bar window
|
|
*
|
|
* \param redraw the section of the window to redraw
|
|
* \param pb the progress bar to redraw
|
|
*/
|
|
void ro_gui_progress_bar_redraw_window(wimp_draw *redraw,
|
|
struct progress_bar *pb)
|
|
{
|
|
osbool more = true;
|
|
struct rect clip;
|
|
int progress_ymid;
|
|
struct redraw_context ctx = {
|
|
.interactive = true,
|
|
.background_images = true,
|
|
.plot = &ro_plotters
|
|
};
|
|
|
|
/* initialise the plotters */
|
|
ro_plot_origin_x = 0;
|
|
ro_plot_origin_y = 0;
|
|
|
|
/* recalculate the progress bar */
|
|
ro_gui_progress_bar_calculate(pb, redraw->box.x1 - redraw->box.x0,
|
|
redraw->box.y1 - redraw->box.y0);
|
|
progress_ymid = redraw->box.y0 + pb->visible.y0 +
|
|
((pb->visible.y1 - pb->visible.y0) >> 1);
|
|
|
|
/* redraw the window */
|
|
while (more) {
|
|
os_error *error;
|
|
if (pb->icon)
|
|
_swix(Tinct_PlotAlpha, _IN(2) | _IN(3) | _IN(4) | _IN(7),
|
|
pb->icon_img,
|
|
redraw->box.x0 + pb->icon_x0,
|
|
redraw->box.y0 + pb->icon_y0,
|
|
tinct_ERROR_DIFFUSE);
|
|
if (!pb->icon_obscured) {
|
|
clip.x0 = max(redraw->clip.x0,
|
|
redraw->box.x0 + pb->visible.x0) >> 1;
|
|
clip.y0 = -min(redraw->clip.y1,
|
|
redraw->box.y0 + pb->visible.y1) >> 1;
|
|
clip.x1 = min(redraw->clip.x1,
|
|
redraw->box.x0 + pb->visible.x1) >> 1;
|
|
clip.y1 = -max(redraw->clip.y0,
|
|
redraw->box.y0 + pb->visible.y0) >> 1;
|
|
if ((clip.x0 < clip.x1) && (clip.y0 < clip.y1)) {
|
|
if (progress_icon) {
|
|
ctx.plot->clip(&ctx, &clip);
|
|
_swix(Tinct_Plot, _IN(2) | _IN(3) | _IN(4) | _IN(7),
|
|
progress_icon,
|
|
redraw->box.x0 - pb->offset,
|
|
progress_ymid - progress_height,
|
|
tinct_FILL_HORIZONTALLY);
|
|
} else {
|
|
ctx.plot->rectangle(&ctx,
|
|
plot_style_fill_red,
|
|
&clip);
|
|
}
|
|
}
|
|
}
|
|
error = xwimp_get_rectangle(redraw, &more);
|
|
if (error) {
|
|
NSLOG(netsurf, INFO, "xwimp_get_rectangle: 0x%x: %s",
|
|
error->errnum, error->errmess);
|
|
return;
|
|
}
|
|
}
|
|
}
|