mirror of
https://github.com/netsurf-browser/netsurf
synced 2024-12-26 22:09:43 +03:00
955 lines
28 KiB
C
955 lines
28 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
|
|
* Knockout rendering (implementation).
|
|
*
|
|
* Knockout rendering is an optimisation which is particularly for
|
|
* unaccelerated screen redraw. It tries to avoid plotting the same area more
|
|
* than once.
|
|
*
|
|
* If the object is to plot two overlapping rectangles (one large, one small),
|
|
* such as:
|
|
*
|
|
* +-----------------+
|
|
* |#################|
|
|
* |####+-------+####|
|
|
* |####|:::::::|####|
|
|
* |####|:::::::|####|
|
|
* |####|:::::::|####|
|
|
* |####+-------+####|
|
|
* |#################|
|
|
* +-----------------+
|
|
*
|
|
* Without knockout rendering we plot the bottom rectangle and then the top one:
|
|
*
|
|
* +-----------------+ +-----------------+
|
|
* |#################| |#################|
|
|
* |#################| |####+-------+####|
|
|
* |#################| |####|:::::::|####|
|
|
* |#################| and then, |####|:::::::|####|
|
|
* |#################| |####|:::::::|####|
|
|
* |#################| |####+-------+####|
|
|
* |#################| |#################|
|
|
* +-----------------+ +-----------------+
|
|
*
|
|
* With knockoout rendering, the bottom rectangle is split up into smaller
|
|
* ones and each pixel is just plotted once:
|
|
*
|
|
* +-----------------+
|
|
* |#################|
|
|
* +----+-------+----+
|
|
* |####|:::::::|####|
|
|
* |####|:::::::|####|
|
|
* |####|:::::::|####|
|
|
* +----+-------+----+
|
|
* |#################|
|
|
* +-----------------+
|
|
*/
|
|
|
|
#define NDEBUG
|
|
#include <assert.h>
|
|
#include <string.h>
|
|
#include "desktop/knockout.h"
|
|
#include "desktop/plotters.h"
|
|
#include "image/bitmap.h"
|
|
#include "utils/log.h"
|
|
|
|
#define KNOCKOUT_ENTRIES 3072 /* 40 bytes each */
|
|
#define KNOCKOUT_BOXES 768 /* 28 bytes each */
|
|
#define KNOCKOUT_POLYGONS 3072 /* 4 bytes each */
|
|
|
|
|
|
struct knockout_box;
|
|
struct knockout_entry;
|
|
|
|
|
|
static void knockout_set_plotters(void);
|
|
static void knockout_calculate(int x0, int y0, int x1, int y1, struct knockout_box *box);
|
|
static bool knockout_plot_fill_recursive(struct knockout_box *box, colour c);
|
|
static bool knockout_plot_bitmap_tile_recursive(struct knockout_box *box,
|
|
struct knockout_entry *entry);
|
|
|
|
static bool knockout_plot_clg(colour c);
|
|
static bool knockout_plot_rectangle(int x0, int y0, int width, int height,
|
|
int line_width, colour c, bool dotted, bool dashed);
|
|
static bool knockout_plot_line(int x0, int y0, int x1, int y1, int width,
|
|
colour c, bool dotted, bool dashed);
|
|
static bool knockout_plot_polygon(int *p, unsigned int n, colour fill);
|
|
static bool knockout_plot_fill(int x0, int y0, int x1, int y1, colour c);
|
|
static bool knockout_plot_clip(int clip_x0, int clip_y0,
|
|
int clip_x1, int clip_y1);
|
|
static bool knockout_plot_text(int x, int y, const struct css_style *style,
|
|
const char *text, size_t length, colour bg, colour c);
|
|
static bool knockout_plot_disc(int x, int y, int radius, colour colour, bool filled);
|
|
static bool knockout_plot_arc(int x, int y, int radius, int angle1, int angle2,
|
|
colour c);
|
|
static bool knockout_plot_bitmap(int x, int y, int width, int height,
|
|
struct bitmap *bitmap, colour bg, struct content *content);
|
|
static bool knockout_plot_bitmap_tile(int x, int y, int width, int height,
|
|
struct bitmap *bitmap, colour bg,
|
|
bool repeat_x, bool repeat_y, struct content *content);
|
|
static bool knockout_plot_flush(void);
|
|
static bool knockout_plot_group_start(const char *name);
|
|
static bool knockout_plot_group_end(void);
|
|
static bool knockout_plot_path(float *p, unsigned int n, colour fill,
|
|
float width, colour c, float *transform);
|
|
|
|
|
|
const struct plotter_table knockout_plotters = {
|
|
knockout_plot_clg,
|
|
knockout_plot_rectangle,
|
|
knockout_plot_line,
|
|
knockout_plot_polygon,
|
|
knockout_plot_fill,
|
|
knockout_plot_clip,
|
|
knockout_plot_text,
|
|
knockout_plot_disc,
|
|
knockout_plot_arc,
|
|
knockout_plot_bitmap,
|
|
knockout_plot_bitmap_tile,
|
|
knockout_plot_group_start,
|
|
knockout_plot_group_end,
|
|
knockout_plot_flush,
|
|
knockout_plot_path,
|
|
true
|
|
};
|
|
|
|
|
|
typedef enum {
|
|
KNOCKOUT_PLOT_CLG, /* translated to _FILL */
|
|
KNOCKOUT_PLOT_RECTANGLE,
|
|
KNOCKOUT_PLOT_LINE,
|
|
KNOCKOUT_PLOT_POLYGON,
|
|
KNOCKOUT_PLOT_FILL, /* knockout, knocked out */
|
|
KNOCKOUT_PLOT_CLIP,
|
|
KNOCKOUT_PLOT_TEXT,
|
|
KNOCKOUT_PLOT_DISC,
|
|
KNOCKOUT_PLOT_ARC,
|
|
KNOCKOUT_PLOT_BITMAP, /* knockout */
|
|
KNOCKOUT_PLOT_BITMAP_TILE, /* knockout, knocked out */
|
|
KNOCKOUT_PLOT_GROUP_START,
|
|
KNOCKOUT_PLOT_GROUP_END,
|
|
} knockout_type;
|
|
|
|
|
|
struct knockout_box {
|
|
struct {
|
|
int x0;
|
|
int y0;
|
|
int x1;
|
|
int y1;
|
|
} bbox;
|
|
bool deleted; /* box has been deleted, ignore */
|
|
struct knockout_box *child;
|
|
struct knockout_box *next;
|
|
};
|
|
|
|
|
|
struct knockout_entry {
|
|
knockout_type type;
|
|
struct knockout_box *box; /* relating series of knockout clips */
|
|
union {
|
|
struct {
|
|
colour c;
|
|
} clg;
|
|
struct {
|
|
int x0;
|
|
int y0;
|
|
int width;
|
|
int height;
|
|
int line_width;
|
|
colour c;
|
|
bool dotted;
|
|
bool dashed;
|
|
} rectangle;
|
|
struct {
|
|
int x0;
|
|
int y0;
|
|
int x1;
|
|
int y1;
|
|
int width;
|
|
colour c;
|
|
bool dotted;
|
|
bool dashed;
|
|
} line;
|
|
struct {
|
|
int *p;
|
|
unsigned int n;
|
|
colour fill;
|
|
} polygon;
|
|
struct {
|
|
int x0;
|
|
int y0;
|
|
int x1;
|
|
int y1;
|
|
colour c;
|
|
} fill;
|
|
struct {
|
|
int x0;
|
|
int y0;
|
|
int x1;
|
|
int y1;
|
|
} clip;
|
|
struct {
|
|
int x;
|
|
int y;
|
|
const struct css_style *style;
|
|
const char *text;
|
|
size_t length;
|
|
colour bg;
|
|
colour c;
|
|
} text;
|
|
struct {
|
|
int x;
|
|
int y;
|
|
int radius;
|
|
colour colour;
|
|
bool filled;
|
|
} disc;
|
|
struct {
|
|
int x;
|
|
int y;
|
|
int radius;
|
|
int angle1;
|
|
int angle2;
|
|
colour c;
|
|
} arc;
|
|
struct {
|
|
int x;
|
|
int y;
|
|
int width;
|
|
int height;
|
|
struct bitmap *bitmap;
|
|
colour bg;
|
|
struct content *content;
|
|
} bitmap;
|
|
struct {
|
|
int x;
|
|
int y;
|
|
int width;
|
|
int height;
|
|
struct bitmap *bitmap;
|
|
colour bg;
|
|
bool repeat_x;
|
|
bool repeat_y;
|
|
struct content *content;
|
|
} bitmap_tile;
|
|
struct {
|
|
const char *name;
|
|
} group_start;
|
|
} data;
|
|
};
|
|
|
|
|
|
static struct knockout_entry knockout_entries[KNOCKOUT_ENTRIES];
|
|
static struct knockout_box knockout_boxes[KNOCKOUT_BOXES];
|
|
static int knockout_polygons[KNOCKOUT_POLYGONS];
|
|
static int knockout_entry_cur = 0;
|
|
static int knockout_box_cur = 0;
|
|
static int knockout_polygon_cur = 0;
|
|
static struct knockout_box *knockout_list = NULL;
|
|
|
|
static struct plotter_table real_plot;
|
|
|
|
static int clip_x0_cur;
|
|
static int clip_y0_cur;
|
|
static int clip_x1_cur;
|
|
static int clip_y1_cur;
|
|
static int nested_depth = 0;
|
|
|
|
/**
|
|
* Start a knockout plotting session
|
|
*
|
|
* \param plotter the plotter to use
|
|
* \return true on success, false otherwise
|
|
*/
|
|
bool knockout_plot_start(struct plotter_table *plotter)
|
|
{
|
|
/* check if we're recursing */
|
|
if (nested_depth++ > 0) {
|
|
/* we should already have the knockout renderer as default */
|
|
assert(plotter->clg == knockout_plotters.clg);
|
|
return true;
|
|
}
|
|
|
|
/* end any previous sessions */
|
|
if (knockout_entry_cur > 0)
|
|
knockout_plot_end();
|
|
|
|
/* take over the plotter */
|
|
real_plot = *plotter;
|
|
knockout_set_plotters();
|
|
return true;
|
|
}
|
|
|
|
|
|
/**
|
|
* End a knockout plotting session
|
|
*
|
|
* \return true on success, false otherwise
|
|
*/
|
|
bool knockout_plot_end(void)
|
|
{
|
|
/* only output when we've finished any nesting */
|
|
if (--nested_depth == 0)
|
|
return knockout_plot_flush();
|
|
|
|
assert(nested_depth > 0);
|
|
return true;
|
|
}
|
|
|
|
|
|
/**
|
|
* Flush the current knockout session to empty the buffers
|
|
*
|
|
* \return true on success, false otherwise
|
|
*/
|
|
bool knockout_plot_flush(void)
|
|
{
|
|
int i;
|
|
bool success = true;
|
|
struct knockout_box *box;
|
|
|
|
/* debugging information */
|
|
LOG(("Entries are %i/%i, %i/%i, %i/%i",
|
|
knockout_entry_cur, KNOCKOUT_ENTRIES,
|
|
knockout_box_cur, KNOCKOUT_BOXES,
|
|
knockout_polygon_cur, KNOCKOUT_POLYGONS));
|
|
|
|
/* release our plotter */
|
|
plot = real_plot;
|
|
|
|
for (i = 0; i < knockout_entry_cur; i++) {
|
|
switch (knockout_entries[i].type) {
|
|
case KNOCKOUT_PLOT_CLG:
|
|
success &= plot.clg(
|
|
knockout_entries[i].data.clg.c);
|
|
break;
|
|
case KNOCKOUT_PLOT_RECTANGLE:
|
|
success &= plot.rectangle(
|
|
knockout_entries[i].data.rectangle.x0,
|
|
knockout_entries[i].data.rectangle.y0,
|
|
knockout_entries[i].data.rectangle.width,
|
|
knockout_entries[i].data.rectangle.height,
|
|
knockout_entries[i].data.rectangle.line_width,
|
|
knockout_entries[i].data.rectangle.c,
|
|
knockout_entries[i].data.rectangle.dotted,
|
|
knockout_entries[i].data.rectangle.dashed);
|
|
break;
|
|
case KNOCKOUT_PLOT_LINE:
|
|
success &= plot.line(
|
|
knockout_entries[i].data.line.x0,
|
|
knockout_entries[i].data.line.y0,
|
|
knockout_entries[i].data.line.x1,
|
|
knockout_entries[i].data.line.y1,
|
|
knockout_entries[i].data.line.width,
|
|
knockout_entries[i].data.line.c,
|
|
knockout_entries[i].data.line.dotted,
|
|
knockout_entries[i].data.line.dashed);
|
|
break;
|
|
case KNOCKOUT_PLOT_POLYGON:
|
|
success &= plot.polygon(
|
|
knockout_entries[i].data.polygon.p,
|
|
knockout_entries[i].data.polygon.n,
|
|
knockout_entries[i].data.polygon.fill);
|
|
break;
|
|
case KNOCKOUT_PLOT_FILL:
|
|
box = knockout_entries[i].box->child;
|
|
if (box)
|
|
success &= knockout_plot_fill_recursive(box,
|
|
knockout_entries[i].data.fill.c);
|
|
else if (!knockout_entries[i].box->deleted)
|
|
success &= plot.fill(
|
|
knockout_entries[i].data.fill.x0,
|
|
knockout_entries[i].data.fill.y0,
|
|
knockout_entries[i].data.fill.x1,
|
|
knockout_entries[i].data.fill.y1,
|
|
knockout_entries[i].data.fill.c);
|
|
break;
|
|
case KNOCKOUT_PLOT_CLIP:
|
|
success &= plot.clip(
|
|
knockout_entries[i].data.clip.x0,
|
|
knockout_entries[i].data.clip.y0,
|
|
knockout_entries[i].data.clip.x1,
|
|
knockout_entries[i].data.clip.y1);
|
|
break;
|
|
case KNOCKOUT_PLOT_TEXT:
|
|
success &= plot.text(
|
|
knockout_entries[i].data.text.x,
|
|
knockout_entries[i].data.text.y,
|
|
knockout_entries[i].data.text.style,
|
|
knockout_entries[i].data.text.text,
|
|
knockout_entries[i].data.text.length,
|
|
knockout_entries[i].data.text.bg,
|
|
knockout_entries[i].data.text.c);
|
|
break;
|
|
case KNOCKOUT_PLOT_DISC:
|
|
success &= plot.disc(
|
|
knockout_entries[i].data.disc.x,
|
|
knockout_entries[i].data.disc.y,
|
|
knockout_entries[i].data.disc.radius,
|
|
knockout_entries[i].data.disc.colour,
|
|
knockout_entries[i].data.disc.filled);
|
|
break;
|
|
case KNOCKOUT_PLOT_ARC:
|
|
success &= plot.arc(
|
|
knockout_entries[i].data.arc.x,
|
|
knockout_entries[i].data.arc.y,
|
|
knockout_entries[i].data.arc.radius,
|
|
knockout_entries[i].data.arc.angle1,
|
|
knockout_entries[i].data.arc.angle2,
|
|
knockout_entries[i].data.arc.c);
|
|
break;
|
|
case KNOCKOUT_PLOT_BITMAP:
|
|
success &= plot.bitmap(
|
|
knockout_entries[i].data.bitmap.x,
|
|
knockout_entries[i].data.bitmap.y,
|
|
knockout_entries[i].data.bitmap.width,
|
|
knockout_entries[i].data.bitmap.height,
|
|
knockout_entries[i].data.bitmap.bitmap,
|
|
knockout_entries[i].data.bitmap.bg,
|
|
knockout_entries[i].data.bitmap.content);
|
|
break;
|
|
case KNOCKOUT_PLOT_BITMAP_TILE:
|
|
box = knockout_entries[i].box->child;
|
|
if (box) {
|
|
success &= knockout_plot_bitmap_tile_recursive(box,
|
|
&knockout_entries[i]);
|
|
} else if (!knockout_entries[i].box->deleted) {
|
|
success &= plot.bitmap_tile(
|
|
knockout_entries[i].data.
|
|
bitmap_tile.x,
|
|
knockout_entries[i].data.
|
|
bitmap_tile.y,
|
|
knockout_entries[i].data.
|
|
bitmap_tile.width,
|
|
knockout_entries[i].data.
|
|
bitmap_tile.height,
|
|
knockout_entries[i].data.
|
|
bitmap_tile.bitmap,
|
|
knockout_entries[i].data.
|
|
bitmap_tile.bg,
|
|
knockout_entries[i].data.
|
|
bitmap_tile.repeat_x,
|
|
knockout_entries[i].data.
|
|
bitmap_tile.repeat_y,
|
|
knockout_entries[i].data.
|
|
bitmap_tile.content);
|
|
}
|
|
break;
|
|
case KNOCKOUT_PLOT_GROUP_START:
|
|
success &= plot.group_start(
|
|
knockout_entries[i].data.group_start.name);
|
|
break;
|
|
case KNOCKOUT_PLOT_GROUP_END:
|
|
success &= plot.group_end();
|
|
break;
|
|
}
|
|
}
|
|
|
|
knockout_entry_cur = 0;
|
|
knockout_box_cur = 0;
|
|
knockout_polygon_cur = 0;
|
|
knockout_list = NULL;
|
|
|
|
/* re-instate knockout plotters if we are still active */
|
|
if (nested_depth > 0)
|
|
knockout_set_plotters();
|
|
return success;
|
|
}
|
|
|
|
|
|
/**
|
|
* Override the current plotters with the knockout plotters
|
|
*/
|
|
void knockout_set_plotters(void)
|
|
{
|
|
plot = knockout_plotters;
|
|
if (!real_plot.group_start)
|
|
plot.group_start = NULL;
|
|
if (!real_plot.group_end)
|
|
plot.group_end = NULL;
|
|
}
|
|
|
|
|
|
/**
|
|
* Knockout a section of previous rendering
|
|
*
|
|
* \param x0 the left edge of the removal box
|
|
* \param y0 the bottom edge of the removal box
|
|
* \param x1 the right edge of the removal box
|
|
* \param y1 the top edge of the removal box
|
|
* \param box the parent box set to consider, or NULL for top level
|
|
*/
|
|
void knockout_calculate(int x0, int y0, int x1, int y1, struct knockout_box *owner)
|
|
{
|
|
struct knockout_box *box;
|
|
struct knockout_box *parent;
|
|
struct knockout_box *prev = NULL;
|
|
int nx0, ny0, nx1, ny1;
|
|
|
|
if (owner == NULL)
|
|
box = knockout_list;
|
|
else
|
|
box = owner->child;
|
|
|
|
for (parent = box; parent; parent = parent->next) {
|
|
/* permanently delink deleted nodes */
|
|
if (parent->deleted) {
|
|
if (prev) {
|
|
/* not the first valid element: just skip future */
|
|
prev->next = parent->next;
|
|
} else {
|
|
if (owner) {
|
|
/* first valid element: update child reference */
|
|
owner->child = parent->next;
|
|
/* have we deleted all child nodes? */
|
|
if (!owner->child)
|
|
owner->deleted = true;
|
|
} else {
|
|
/* we are the head of the list */
|
|
knockout_list = parent->next;
|
|
}
|
|
}
|
|
continue;
|
|
} else {
|
|
prev = parent;
|
|
}
|
|
|
|
/* get the parent dimensions */
|
|
nx0 = parent->bbox.x0;
|
|
ny0 = parent->bbox.y0;
|
|
nx1 = parent->bbox.x1;
|
|
ny1 = parent->bbox.y1;
|
|
|
|
/* reject non-overlapping boxes */
|
|
if ((nx0 >= x1) || (nx1 <= x0) || (ny0 >= y1) || (ny1 <= y0))
|
|
continue;
|
|
|
|
/* check for a total knockout */
|
|
if ((x0 <= nx0) && (x1 >= nx1) && (y0 <= ny0) && (y1 >= ny1)) {
|
|
parent->deleted = true;
|
|
continue;
|
|
}
|
|
|
|
/* has the box been replaced by children? */
|
|
if (parent->child) {
|
|
knockout_calculate(x0, y0, x1, y1, parent);
|
|
} else {
|
|
/* we need a maximum of 4 child boxes */
|
|
if (knockout_box_cur + 4 >= KNOCKOUT_BOXES) {
|
|
knockout_plot_flush();
|
|
return;
|
|
}
|
|
|
|
/* clip top */
|
|
if (y1 < ny1) {
|
|
knockout_boxes[knockout_box_cur].bbox.x0 = nx0;
|
|
knockout_boxes[knockout_box_cur].bbox.y0 = y1;
|
|
knockout_boxes[knockout_box_cur].bbox.x1 = nx1;
|
|
knockout_boxes[knockout_box_cur].bbox.y1 = ny1;
|
|
knockout_boxes[knockout_box_cur].deleted = false;
|
|
knockout_boxes[knockout_box_cur].child = NULL;
|
|
knockout_boxes[knockout_box_cur].next = parent->child;
|
|
parent->child = &knockout_boxes[knockout_box_cur++];
|
|
ny1 = y1;
|
|
}
|
|
/* clip bottom */
|
|
if (y0 > ny0) {
|
|
knockout_boxes[knockout_box_cur].bbox.x0 = nx0;
|
|
knockout_boxes[knockout_box_cur].bbox.y0 = ny0;
|
|
knockout_boxes[knockout_box_cur].bbox.x1 = nx1;
|
|
knockout_boxes[knockout_box_cur].bbox.y1 = y0;
|
|
knockout_boxes[knockout_box_cur].deleted = false;
|
|
knockout_boxes[knockout_box_cur].child = NULL;
|
|
knockout_boxes[knockout_box_cur].next = parent->child;
|
|
parent->child = &knockout_boxes[knockout_box_cur++];
|
|
ny0 = y0;
|
|
}
|
|
/* clip right */
|
|
if (x1 < nx1) {
|
|
knockout_boxes[knockout_box_cur].bbox.x0 = x1;
|
|
knockout_boxes[knockout_box_cur].bbox.y0 = ny0;
|
|
knockout_boxes[knockout_box_cur].bbox.x1 = nx1;
|
|
knockout_boxes[knockout_box_cur].bbox.y1 = ny1;
|
|
knockout_boxes[knockout_box_cur].deleted = false;
|
|
knockout_boxes[knockout_box_cur].child = NULL;
|
|
knockout_boxes[knockout_box_cur].next = parent->child;
|
|
parent->child = &knockout_boxes[knockout_box_cur++];
|
|
nx1 = x1;
|
|
}
|
|
/* clip left */
|
|
if (x0 > nx0) {
|
|
knockout_boxes[knockout_box_cur].bbox.x0 = nx0;
|
|
knockout_boxes[knockout_box_cur].bbox.y0 = ny0;
|
|
knockout_boxes[knockout_box_cur].bbox.x1 = x0;
|
|
knockout_boxes[knockout_box_cur].bbox.y1 = ny1;
|
|
knockout_boxes[knockout_box_cur].deleted = false;
|
|
knockout_boxes[knockout_box_cur].child = NULL;
|
|
knockout_boxes[knockout_box_cur].next = parent->child;
|
|
parent->child = &knockout_boxes[knockout_box_cur++];
|
|
//nx0 = x0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
bool knockout_plot_fill_recursive(struct knockout_box *box, colour c)
|
|
{
|
|
bool success = true;
|
|
struct knockout_box *parent;
|
|
|
|
for (parent = box; parent; parent = parent->next) {
|
|
if (parent->deleted)
|
|
continue;
|
|
if (parent->child)
|
|
knockout_plot_fill_recursive(parent->child, c);
|
|
else
|
|
success &= plot.fill(parent->bbox.x0,
|
|
parent->bbox.y0,
|
|
parent->bbox.x1,
|
|
parent->bbox.y1,
|
|
c);
|
|
}
|
|
return success;
|
|
}
|
|
|
|
|
|
bool knockout_plot_bitmap_tile_recursive(struct knockout_box *box,
|
|
struct knockout_entry *entry)
|
|
{
|
|
bool success = true;
|
|
struct knockout_box *parent;
|
|
|
|
for (parent = box; parent; parent = parent->next) {
|
|
if (parent->deleted)
|
|
continue;
|
|
if (parent->child)
|
|
knockout_plot_bitmap_tile_recursive(parent->child, entry);
|
|
else {
|
|
success &= plot.clip(parent->bbox.x0,
|
|
parent->bbox.y0,
|
|
parent->bbox.x1,
|
|
parent->bbox.y1);
|
|
success &= plot.bitmap_tile(entry->data.bitmap_tile.x,
|
|
entry->data.bitmap_tile.y,
|
|
entry->data.bitmap_tile.width,
|
|
entry->data.bitmap_tile.height,
|
|
entry->data.bitmap_tile.bitmap,
|
|
entry->data.bitmap_tile.bg,
|
|
entry->data.bitmap_tile.repeat_x,
|
|
entry->data.bitmap_tile.repeat_y,
|
|
entry->data.bitmap_tile.content);
|
|
}
|
|
}
|
|
return success;
|
|
}
|
|
|
|
bool knockout_plot_clg(colour c)
|
|
{
|
|
return knockout_plot_fill(clip_x0_cur, clip_y0_cur, clip_x1_cur, clip_y1_cur, c);
|
|
}
|
|
|
|
|
|
bool knockout_plot_rectangle(int x0, int y0, int width, int height,
|
|
int line_width, colour c, bool dotted, bool dashed)
|
|
{
|
|
knockout_entries[knockout_entry_cur].data.rectangle.x0 = x0;
|
|
knockout_entries[knockout_entry_cur].data.rectangle.y0 = y0;
|
|
knockout_entries[knockout_entry_cur].data.rectangle.width = width;
|
|
knockout_entries[knockout_entry_cur].data.rectangle.height = height;
|
|
knockout_entries[knockout_entry_cur].data.rectangle.line_width = line_width;
|
|
knockout_entries[knockout_entry_cur].data.rectangle.c = c;
|
|
knockout_entries[knockout_entry_cur].data.rectangle.dotted = dotted;
|
|
knockout_entries[knockout_entry_cur].data.rectangle.dashed = dashed;
|
|
knockout_entries[knockout_entry_cur].type = KNOCKOUT_PLOT_RECTANGLE;
|
|
if (++knockout_entry_cur >= KNOCKOUT_ENTRIES)
|
|
knockout_plot_flush();
|
|
return true;
|
|
}
|
|
|
|
|
|
bool knockout_plot_line(int x0, int y0, int x1, int y1, int width,
|
|
colour c, bool dotted, bool dashed)
|
|
{
|
|
knockout_entries[knockout_entry_cur].data.line.x0 = x0;
|
|
knockout_entries[knockout_entry_cur].data.line.y0 = y0;
|
|
knockout_entries[knockout_entry_cur].data.line.x1 = x1;
|
|
knockout_entries[knockout_entry_cur].data.line.y1 = y1;
|
|
knockout_entries[knockout_entry_cur].data.line.width = width;
|
|
knockout_entries[knockout_entry_cur].data.line.c = c;
|
|
knockout_entries[knockout_entry_cur].data.line.dotted = dotted;
|
|
knockout_entries[knockout_entry_cur].data.line.dashed = dashed;
|
|
knockout_entries[knockout_entry_cur].type = KNOCKOUT_PLOT_LINE;
|
|
if (++knockout_entry_cur >= KNOCKOUT_ENTRIES)
|
|
knockout_plot_flush();
|
|
return true;
|
|
}
|
|
|
|
|
|
bool knockout_plot_polygon(int *p, unsigned int n, colour fill)
|
|
{
|
|
bool success = true;
|
|
int *dest;
|
|
|
|
/* ensure we have sufficient room even when flushed */
|
|
if (n * 2 >= KNOCKOUT_POLYGONS) {
|
|
knockout_plot_flush();
|
|
success = real_plot.polygon(p, n, fill);
|
|
return success;
|
|
}
|
|
|
|
/* ensure we have enough room right now */
|
|
if (knockout_polygon_cur + n * 2 >= KNOCKOUT_POLYGONS)
|
|
knockout_plot_flush();
|
|
|
|
/* copy our data */
|
|
dest = &(knockout_polygons[knockout_polygon_cur]);
|
|
memcpy(dest, p, n * 2 * sizeof(int));
|
|
knockout_polygon_cur += n * 2;
|
|
knockout_entries[knockout_entry_cur].data.polygon.p = dest;
|
|
knockout_entries[knockout_entry_cur].data.polygon.n = n;
|
|
knockout_entries[knockout_entry_cur].data.polygon.fill = fill;
|
|
knockout_entries[knockout_entry_cur].type = KNOCKOUT_PLOT_POLYGON;
|
|
if (++knockout_entry_cur >= KNOCKOUT_ENTRIES)
|
|
knockout_plot_flush();
|
|
return true;
|
|
}
|
|
|
|
|
|
bool knockout_plot_path(float *p, unsigned int n, colour fill,
|
|
float width, colour c, float *transform)
|
|
{
|
|
knockout_plot_flush();
|
|
return real_plot.path(p, n, fill, width, c, transform);
|
|
}
|
|
|
|
|
|
bool knockout_plot_fill(int x0, int y0, int x1, int y1, colour c)
|
|
{
|
|
int kx0, ky0, kx1, ky1;
|
|
|
|
/* get our bounds */
|
|
kx0 = (x0 > clip_x0_cur) ? x0 : clip_x0_cur;
|
|
ky0 = (y0 > clip_y0_cur) ? y0 : clip_y0_cur;
|
|
kx1 = (x1 < clip_x1_cur) ? x1 : clip_x1_cur;
|
|
ky1 = (y1 < clip_y1_cur) ? y1 : clip_y1_cur;
|
|
if ((kx0 > clip_x1_cur) || (kx1 < clip_x0_cur) ||
|
|
(ky0 > clip_y1_cur) || (ky1 < clip_y0_cur))
|
|
return true;
|
|
|
|
/* fills both knock out and get knocked out */
|
|
knockout_calculate(kx0, ky0, kx1, ky1, NULL);
|
|
knockout_boxes[knockout_box_cur].bbox.x0 = x0;
|
|
knockout_boxes[knockout_box_cur].bbox.y0 = y0;
|
|
knockout_boxes[knockout_box_cur].bbox.x1 = x1;
|
|
knockout_boxes[knockout_box_cur].bbox.y1 = y1;
|
|
knockout_boxes[knockout_box_cur].deleted = false;
|
|
knockout_boxes[knockout_box_cur].child = NULL;
|
|
knockout_boxes[knockout_box_cur].next = knockout_list;
|
|
knockout_list = &knockout_boxes[knockout_box_cur];
|
|
knockout_entries[knockout_entry_cur].box = &knockout_boxes[knockout_box_cur];
|
|
knockout_entries[knockout_entry_cur].data.fill.x0 = x0;
|
|
knockout_entries[knockout_entry_cur].data.fill.y0 = y0;
|
|
knockout_entries[knockout_entry_cur].data.fill.x1 = x1;
|
|
knockout_entries[knockout_entry_cur].data.fill.y1 = y1;
|
|
knockout_entries[knockout_entry_cur].data.fill.c = c;
|
|
knockout_entries[knockout_entry_cur].type = KNOCKOUT_PLOT_FILL;
|
|
if ((++knockout_entry_cur >= KNOCKOUT_ENTRIES) ||
|
|
(++knockout_box_cur >= KNOCKOUT_BOXES))
|
|
knockout_plot_flush();
|
|
return true;
|
|
}
|
|
|
|
|
|
bool knockout_plot_clip(int clip_x0, int clip_y0,
|
|
int clip_x1, int clip_y1)
|
|
{
|
|
if (clip_x1 < clip_x0 || clip_y0 > clip_y1) {
|
|
LOG(("bad clip rectangle %i %i %i %i",
|
|
clip_x0, clip_y0, clip_x1, clip_y1));
|
|
return false;
|
|
}
|
|
|
|
/* memorise clip for bitmap tiling */
|
|
clip_x0_cur = clip_x0;
|
|
clip_y0_cur = clip_y0;
|
|
clip_x1_cur = clip_x1;
|
|
clip_y1_cur = clip_y1;
|
|
|
|
knockout_entries[knockout_entry_cur].data.clip.x0 = clip_x0;
|
|
knockout_entries[knockout_entry_cur].data.clip.y0 = clip_y0;
|
|
knockout_entries[knockout_entry_cur].data.clip.x1 = clip_x1;
|
|
knockout_entries[knockout_entry_cur].data.clip.y1 = clip_y1;
|
|
knockout_entries[knockout_entry_cur].type = KNOCKOUT_PLOT_CLIP;
|
|
if (++knockout_entry_cur >= KNOCKOUT_ENTRIES)
|
|
knockout_plot_flush();
|
|
return true;
|
|
}
|
|
|
|
|
|
bool knockout_plot_text(int x, int y, const struct css_style *style,
|
|
const char *text, size_t length, colour bg, colour c)
|
|
{
|
|
knockout_entries[knockout_entry_cur].data.text.x = x;
|
|
knockout_entries[knockout_entry_cur].data.text.y = y;
|
|
knockout_entries[knockout_entry_cur].data.text.style = style;
|
|
knockout_entries[knockout_entry_cur].data.text.text = text;
|
|
knockout_entries[knockout_entry_cur].data.text.length = length;
|
|
knockout_entries[knockout_entry_cur].data.text.bg = bg;
|
|
knockout_entries[knockout_entry_cur].data.text.c = c;
|
|
knockout_entries[knockout_entry_cur].type = KNOCKOUT_PLOT_TEXT;
|
|
if (++knockout_entry_cur >= KNOCKOUT_ENTRIES)
|
|
knockout_plot_flush();
|
|
return true;
|
|
}
|
|
|
|
|
|
bool knockout_plot_disc(int x, int y, int radius, colour colour, bool filled)
|
|
{
|
|
knockout_entries[knockout_entry_cur].data.disc.x = x;
|
|
knockout_entries[knockout_entry_cur].data.disc.y = y;
|
|
knockout_entries[knockout_entry_cur].data.disc.radius = radius;
|
|
knockout_entries[knockout_entry_cur].data.disc.colour = colour;
|
|
knockout_entries[knockout_entry_cur].data.disc.filled = filled;
|
|
knockout_entries[knockout_entry_cur].type = KNOCKOUT_PLOT_DISC;
|
|
if (++knockout_entry_cur >= KNOCKOUT_ENTRIES)
|
|
knockout_plot_flush();
|
|
return true;
|
|
}
|
|
|
|
bool knockout_plot_arc(int x, int y, int radius, int angle1, int angle2, colour c)
|
|
{
|
|
knockout_entries[knockout_entry_cur].data.arc.x = x;
|
|
knockout_entries[knockout_entry_cur].data.arc.y = y;
|
|
knockout_entries[knockout_entry_cur].data.arc.radius = radius;
|
|
knockout_entries[knockout_entry_cur].data.arc.angle1 = angle1;
|
|
knockout_entries[knockout_entry_cur].data.arc.angle2 = angle2;
|
|
knockout_entries[knockout_entry_cur].data.arc.c = c;
|
|
knockout_entries[knockout_entry_cur].type = KNOCKOUT_PLOT_ARC;
|
|
if (++knockout_entry_cur >= KNOCKOUT_ENTRIES)
|
|
knockout_plot_flush();
|
|
return true;
|
|
}
|
|
|
|
bool knockout_plot_bitmap(int x, int y, int width, int height,
|
|
struct bitmap *bitmap, colour bg, struct content *content)
|
|
{
|
|
int kx0, ky0, kx1, ky1;
|
|
|
|
/* opaque bitmaps knockout, but don't get knocked out */
|
|
if (bitmap_get_opaque(bitmap)) {
|
|
/* get our bounds */
|
|
kx0 = (x > clip_x0_cur) ? x : clip_x0_cur;
|
|
ky0 = (y > clip_y0_cur) ? y : clip_y0_cur;
|
|
kx1 = (x + width < clip_x1_cur) ? x + width : clip_x1_cur;
|
|
ky1 = (y + height< clip_y1_cur) ? y + height: clip_y1_cur;
|
|
if ((kx0 > clip_x1_cur) || (kx1 < clip_x0_cur) ||
|
|
(ky0 > clip_y1_cur) || (ky1 < clip_y0_cur))
|
|
return true;
|
|
knockout_calculate(kx0, ky0, kx1, ky1, NULL);
|
|
}
|
|
knockout_entries[knockout_entry_cur].data.bitmap.x = x;
|
|
knockout_entries[knockout_entry_cur].data.bitmap.y = y;
|
|
knockout_entries[knockout_entry_cur].data.bitmap.width = width;
|
|
knockout_entries[knockout_entry_cur].data.bitmap.height = height;
|
|
knockout_entries[knockout_entry_cur].data.bitmap.bitmap = bitmap;
|
|
knockout_entries[knockout_entry_cur].data.bitmap.bg = bg;
|
|
knockout_entries[knockout_entry_cur].data.bitmap.content = content;
|
|
knockout_entries[knockout_entry_cur].type = KNOCKOUT_PLOT_BITMAP;
|
|
if (++knockout_entry_cur >= KNOCKOUT_ENTRIES)
|
|
knockout_plot_flush();
|
|
return true;
|
|
}
|
|
|
|
|
|
bool knockout_plot_bitmap_tile(int x, int y, int width, int height,
|
|
struct bitmap *bitmap, colour bg,
|
|
bool repeat_x, bool repeat_y, struct content *content)
|
|
{
|
|
int kx0, ky0, kx1, ky1;
|
|
|
|
/* get our bounds */
|
|
kx0 = clip_x0_cur;
|
|
ky0 = clip_y0_cur;
|
|
kx1 = clip_x1_cur;
|
|
ky1 = clip_y1_cur;
|
|
if (!repeat_x) {
|
|
if (x > kx0)
|
|
kx0 = x;
|
|
if (x + width < kx1)
|
|
kx1 = x + width;
|
|
if ((kx0 > clip_x1_cur) || (kx1 < clip_x0_cur))
|
|
return true;
|
|
}
|
|
if (!repeat_y) {
|
|
if (y > ky0)
|
|
ky0 = y;
|
|
if (y + height < ky1)
|
|
ky1 = y + height;
|
|
if ((ky0 > clip_y1_cur) || (ky1 < clip_y0_cur))
|
|
return true;
|
|
}
|
|
|
|
/* tiled bitmaps both knock out and get knocked out */
|
|
if (bitmap_get_opaque(bitmap))
|
|
knockout_calculate(kx0, ky0, kx1, ky1, NULL);
|
|
knockout_boxes[knockout_box_cur].bbox.x0 = kx0;
|
|
knockout_boxes[knockout_box_cur].bbox.y0 = ky0;
|
|
knockout_boxes[knockout_box_cur].bbox.x1 = kx1;
|
|
knockout_boxes[knockout_box_cur].bbox.y1 = ky1;
|
|
knockout_boxes[knockout_box_cur].deleted = false;
|
|
knockout_boxes[knockout_box_cur].child = NULL;
|
|
knockout_boxes[knockout_box_cur].next = knockout_list;
|
|
knockout_list = &knockout_boxes[knockout_box_cur];
|
|
knockout_entries[knockout_entry_cur].box = &knockout_boxes[knockout_box_cur];
|
|
knockout_entries[knockout_entry_cur].data.bitmap_tile.x = x;
|
|
knockout_entries[knockout_entry_cur].data.bitmap_tile.y = y;
|
|
knockout_entries[knockout_entry_cur].data.bitmap_tile.width = width;
|
|
knockout_entries[knockout_entry_cur].data.bitmap_tile.height = height;
|
|
knockout_entries[knockout_entry_cur].data.bitmap_tile.bitmap = bitmap;
|
|
knockout_entries[knockout_entry_cur].data.bitmap_tile.bg = bg;
|
|
knockout_entries[knockout_entry_cur].data.bitmap_tile.repeat_x = repeat_x;
|
|
knockout_entries[knockout_entry_cur].data.bitmap_tile.repeat_y = repeat_y;
|
|
knockout_entries[knockout_entry_cur].data.bitmap_tile.content = content;
|
|
knockout_entries[knockout_entry_cur].type = KNOCKOUT_PLOT_BITMAP_TILE;
|
|
if ((++knockout_entry_cur >= KNOCKOUT_ENTRIES) ||
|
|
(++knockout_box_cur >= KNOCKOUT_BOXES))
|
|
knockout_plot_flush();
|
|
return knockout_plot_clip(clip_x0_cur, clip_y0_cur, clip_x1_cur, clip_y1_cur);
|
|
}
|
|
|
|
bool knockout_plot_group_start(const char *name)
|
|
{
|
|
knockout_entries[knockout_entry_cur].data.group_start.name = name;
|
|
knockout_entries[knockout_entry_cur].type = KNOCKOUT_PLOT_GROUP_START;
|
|
if (++knockout_entry_cur >= KNOCKOUT_ENTRIES)
|
|
knockout_plot_flush();
|
|
return true;
|
|
}
|
|
|
|
bool knockout_plot_group_end(void)
|
|
{
|
|
knockout_entries[knockout_entry_cur].type = KNOCKOUT_PLOT_GROUP_END;
|
|
if (++knockout_entry_cur >= KNOCKOUT_ENTRIES)
|
|
knockout_plot_flush();
|
|
return true;
|
|
}
|