diff options
Diffstat (limited to 'src')
| -rw-r--r-- | src/Xr.h | 103 | ||||
| -rw-r--r-- | src/xr.c | 149 | ||||
| -rw-r--r-- | src/xrcolor.c | 72 | ||||
| -rw-r--r-- | src/xrgstate.c | 389 | ||||
| -rw-r--r-- | src/xrint.h | 343 | ||||
| -rw-r--r-- | src/xrpath.c | 169 | ||||
| -rw-r--r-- | src/xrstate.c | 94 | ||||
| -rw-r--r-- | src/xrtransform.c | 129 |
8 files changed, 1448 insertions, 0 deletions
diff --git a/src/Xr.h b/src/Xr.h new file mode 100644 index 00000000..24df20fe --- /dev/null +++ b/src/Xr.h @@ -0,0 +1,103 @@ +/* + * $XFree86: $ + * + * Copyright © 2002 University of Southern California + * + * Permission to use, copy, modify, distribute, and sell this software + * and its documentation for any purpose is hereby granted without + * fee, provided that the above copyright notice appear in all copies + * and that both that copyright notice and this permission notice + * appear in supporting documentation, and that the name of University + * of Southern California not be used in advertising or publicity + * pertaining to distribution of the software without specific, + * written prior permission. University of Southern California makes + * no representations about the suitability of this software for any + * purpose. It is provided "as is" without express or implied + * warranty. + * + * UNIVERSITY OF SOUTHERN CALIFORNIA DISCLAIMS ALL WARRANTIES WITH + * REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL UNIVERSITY OF + * SOUTHERN CALIFORNIA BE LIABLE FOR ANY SPECIAL, INDIRECT OR + * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS + * OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, + * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN + * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + * + * Author: Carl Worth, USC, Information Sciences Institute */ + +#ifndef _XR_H_ +#define _XR_H_ + +#include <X11/extensions/Xrender.h> + +typedef struct _XrState XrState; + +/* Functions for manipulating state objects */ +XrState * +XrCreate(Display *dpy, Drawable drawable, Visual *visual); + +void +XrDestroy(XrState *xrs); + +void +XrSave(XrState *xrs); + +void +XrRestore(XrState *xrs); + +/* XXX: XrClone */ + +/* Modify state */ +void +XrSetDrawable(XrState *xrs, Drawable drawable, Visual *visual); + +void +XrSetColorRGB(XrState *xrs, double red, double green, double blue); + +void +XrSetAlpha(XrState *xrs, double alpha); + +void +XrSetLineWidth(XrState *xrs, double width); + +void +XrTranslate(XrState *xrs, double tx, double ty); + +void +XrScale(XrState *xrs, double sx, double sy); + +void +XrRotate(XrState *xrs, double angle); + +/* XXX: XrSetLineCap, XrSetLineJoin, XrSetDash, ... */ + +/* Path creation */ +void +XrNewPath(XrState *xrs); + +void +XrMoveTo(XrState *xrs, double x, double y); + +void +XrLineTo(XrState *xrs, double x, double y); + +void +XrRelMoveTo(XrState *xrs, double x, double y); + +void +XrRelLineTo(XrState *xrs, double x, double y); + +void +XrClosePath(XrState *xrs); + +/* XXX: XrArcTo, XrCurveTo, XrRelCurveTo, ... */ + +/* Render current path */ +void +XrStroke(XrState *xrs); + +void +XrFill(XrState *xrs); + +#endif diff --git a/src/xr.c b/src/xr.c new file mode 100644 index 00000000..2211a45c --- /dev/null +++ b/src/xr.c @@ -0,0 +1,149 @@ +/* + * $XFree86: $ + * + * Copyright © 2002 University of Southern California + * + * Permission to use, copy, modify, distribute, and sell this software + * and its documentation for any purpose is hereby granted without + * fee, provided that the above copyright notice appear in all copies + * and that both that copyright notice and this permission notice + * appear in supporting documentation, and that the name of University + * of Southern California not be used in advertising or publicity + * pertaining to distribution of the software without specific, + * written prior permission. University of Southern California makes + * no representations about the suitability of this software for any + * purpose. It is provided "as is" without express or implied + * warranty. + * + * UNIVERSITY OF SOUTHERN CALIFORNIA DISCLAIMS ALL WARRANTIES WITH + * REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL UNIVERSITY OF + * SOUTHERN CALIFORNIA BE LIABLE FOR ANY SPECIAL, INDIRECT OR + * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS + * OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, + * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN + * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + * + * Author: Carl Worth, USC, Information Sciences Institute */ + +#include "xrint.h" + +XrState * +XrCreate(Display *dpy, Drawable drawable, Visual *visual) +{ + XrState *xrs; + + xrs = XrStateCreate(dpy); + XrSetDrawable(xrs, drawable, visual); + + return xrs; +} + +void +XrDestroy(XrState *xrs) +{ + XrStateDestroy(xrs); +} + +void +XrSave(XrState *xrs) +{ + XrStatePush(xrs); +} + +void +XrRestore(XrState *xrs) +{ + XrStatePop(xrs); +} + +void +XrSetDrawable(XrState *xrs, Drawable drawable, Visual *visual) +{ + XrGStateSetDrawable(CURRENT_GSTATE(xrs), drawable, visual); +} + +void +XrSetColorRGB(XrState *xrs, double red, double green, double blue) +{ + XrGStateSetColorRGB(CURRENT_GSTATE(xrs), red, green, blue); +} + +void +XrSetAlpha(XrState *xrs, double alpha) +{ + XrGStateSetAlpha(CURRENT_GSTATE(xrs), alpha); +} + +void +XrSetLineWidth(XrState *xrs, double width) +{ + XrGStateSetLineWidth(CURRENT_GSTATE(xrs), width); +} + +void +XrTranslate(XrState *xrs, double tx, double ty) +{ + XrGStateTranslate(CURRENT_GSTATE(xrs), tx, ty); +} + +void +XrScale(XrState *xrs, double sx, double sy) +{ + XrGStateScale(CURRENT_GSTATE(xrs), sx, sy); +} + +void +XrRotate(XrState *xrs, double angle) +{ + XrGStateRotate(CURRENT_GSTATE(xrs), angle); +} + +void +XrNewPath(XrState *xrs) +{ + XrGStateNewPath(CURRENT_GSTATE(xrs)); +} + +void +XrMoveTo(XrState *xrs, double x, double y) +{ + XrGStateMoveTo(CURRENT_GSTATE(xrs), x, y); +} + +void +XrLineTo(XrState *xrs, double x, double y) +{ + XrGStateLineTo(CURRENT_GSTATE(xrs), x, y); +} + +void +XrRelMoveTo(XrState *xrs, double x, double y) +{ + XrGStateRelMoveTo(CURRENT_GSTATE(xrs), x, y); +} + +void +XrRelLineTo(XrState *xrs, double x, double y) +{ + XrGStateRelLineTo(CURRENT_GSTATE(xrs), x, y); +} + +void +XrClosePath(XrState *xrs) +{ + XrGStateClosePath(CURRENT_GSTATE(xrs)); +} + +void +XrStroke(XrState *xrs) +{ + XrGStateStroke(CURRENT_GSTATE(xrs)); +} + +void +XrFill(XrState *xrs) +{ + XrGStateFill(CURRENT_GSTATE(xrs)); +} + diff --git a/src/xrcolor.c b/src/xrcolor.c new file mode 100644 index 00000000..a09b10e4 --- /dev/null +++ b/src/xrcolor.c @@ -0,0 +1,72 @@ +/* + * $XFree86: $ + * + * Copyright © 2002 University of Southern California + * + * Permission to use, copy, modify, distribute, and sell this software + * and its documentation for any purpose is hereby granted without + * fee, provided that the above copyright notice appear in all copies + * and that both that copyright notice and this permission notice + * appear in supporting documentation, and that the name of University + * of Southern California not be used in advertising or publicity + * pertaining to distribution of the software without specific, + * written prior permission. University of Southern California makes + * no representations about the suitability of this software for any + * purpose. It is provided "as is" without express or implied + * warranty. + * + * UNIVERSITY OF SOUTHERN CALIFORNIA DISCLAIMS ALL WARRANTIES WITH + * REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL UNIVERSITY OF + * SOUTHERN CALIFORNIA BE LIABLE FOR ANY SPECIAL, INDIRECT OR + * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS + * OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, + * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN + * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + * + * Author: Carl Worth, USC, Information Sciences Institute */ + +#include "xrint.h" + +static XrColor XR_COLOR_DEFAULT = { 1.0, 1.0, 1.0, 1.0, {0xffff, 0xffff, 0xffff, 0xffff}}; + +static void +_XrColorComputeRenderColor(XrColor *color); + +void +XrColorInit(XrColor *color) +{ + *color = XR_COLOR_DEFAULT; +} + +void +XrColorDeinit(XrColor *color) +{ + /* Nothing to do here */ +} + +static void +_XrColorComputeRenderColor(XrColor *color) +{ + color->render.red = color->red * color->alpha * 0xffff; + color->render.green = color->green * color->alpha * 0xffff; + color->render.blue = color->blue * color->alpha * 0xffff; +} + +void +XrColorSetRGB(XrColor *color, double red, double green, double blue) +{ + color->red = red; + color->green = green; + color->blue = blue; + + _XrColorComputeRenderColor(color); +} + +void +XrColorSetAlpha(XrColor *color, double alpha) +{ + color->alpha = alpha; + + _XrColorComputeRenderColor(color); +} diff --git a/src/xrgstate.c b/src/xrgstate.c new file mode 100644 index 00000000..a7bd5841 --- /dev/null +++ b/src/xrgstate.c @@ -0,0 +1,389 @@ +/* + * $XFree86: $ + * + * Copyright © 2002 University of Southern California + * + * Permission to use, copy, modify, distribute, and sell this software + * and its documentation for any purpose is hereby granted without + * fee, provided that the above copyright notice appear in all copies + * and that both that copyright notice and this permission notice + * appear in supporting documentation, and that the name of University + * of Southern California not be used in advertising or publicity + * pertaining to distribution of the software without specific, + * written prior permission. University of Southern California makes + * no representations about the suitability of this software for any + * purpose. It is provided "as is" without express or implied + * warranty. + * + * UNIVERSITY OF SOUTHERN CALIFORNIA DISCLAIMS ALL WARRANTIES WITH + * REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL UNIVERSITY OF + * SOUTHERN CALIFORNIA BE LIABLE FOR ANY SPECIAL, INDIRECT OR + * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS + * OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, + * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN + * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + * + * Author: Carl Worth, USC, Information Sciences Institute */ + +#include <stdlib.h> +#include <math.h> + +#include "xrint.h" + +/* Private functions */ +static XrGState * +_XrGStateAlloc(void); + +static void +_TranslatePoint(XPointDouble *pt, const XPointDouble *offset); + +static void +_XrGStateStrokePath(XrGState *gstate, XrPath *path, XrPath *outline); + +static void +_XrGStateStrokeSubPath(XrGState *gstate, XrSubPath *subpath, XrPath *outline); + +static void +_XrGStateStrokeSegment(XrGState *gstate, const XPointDouble *p0, const XPointDouble *p1, XrPath *outline); + +static void +_XrGStateFillPath(XrGState *gstate, XrPath *path); + +static XrGState * +_XrGStateAlloc(void) +{ + return malloc(sizeof(XrGState)); +} + +XrGState * +XrGStateCreate(Display *dpy) +{ + XrGState *gstate; + + gstate = _XrGStateAlloc(); + XrGStateInit(gstate, dpy); + + return gstate; +} + +void +XrGStateInit(XrGState *gstate, Display *dpy) +{ + gstate->dpy = dpy; + + gstate->op = XR_GSTATE_OP_DEFAULT; + gstate->winding = XR_GSTATE_WINDING_DEFAULT; + gstate->line_width = XR_GSTATE_LINE_WIDTH_DEFAULT; + + gstate->solidFormat = XRenderFindStandardFormat(dpy, PictStandardARGB32); + gstate->alphaFormat = XRenderFindStandardFormat(dpy, PictStandardA8); + + XrPictureInit(&gstate->picture, dpy); + + XrPictureInit(&gstate->src, dpy); + XrColorInit(&gstate->color); + XrPictureSetSolidColor(&gstate->src, &gstate->color, gstate->solidFormat); + + XrTransformInit(&gstate->transform); + + XrPathInit(&gstate->path); + XrPathInit(&gstate->outline); +} + +void +XrGStateInitCopy(XrGState *gstate, XrGState *other) +{ + *gstate = *other; + + XrPathInitCopy(&gstate->path, &other->path); + XrPathInitCopy(&gstate->outline, &other->outline); +} + +void +XrGStateDeinit(XrGState *gstate) +{ + XrColorDeinit(&gstate->color); + XrPictureDeinit(&gstate->src); + XrPictureDeinit(&gstate->picture); + XrTransformInit(&gstate->transform); + + XrPathDeinit(&gstate->path); +} + +void +XrGStateDestroy(XrGState *gstate) +{ + XrGStateDeinit(gstate); + free(gstate); +} + +XrGState * +XrGStateClone(XrGState *gstate) +{ + XrGState *clone; + + clone = _XrGStateAlloc(); + + XrGStateInitCopy(clone, gstate); + return clone; +} + +void +XrGStateGetCurrentPoint(XrGState *gstate, XPointDouble *pt) +{ + XrPathGetCurrentPoint(&gstate->path, pt); +} + +void +XrGStateSetDrawable(XrGState *gstate, Drawable drawable, Visual *visual) +{ + XrPictureSetDrawable(&gstate->picture, drawable, visual); +} + +void +XrGStateSetColorRGB(XrGState *gstate, double red, double green, double blue) +{ + XrColorSetRGB(&gstate->color, red, green, blue); + XrPictureSetSolidColor(&gstate->src, &gstate->color, gstate->solidFormat); +} + +void +XrGStateSetAlpha(XrGState *gstate, double alpha) +{ + XrColorSetAlpha(&gstate->color, alpha); + XrPictureSetSolidColor(&gstate->src, &gstate->color, gstate->solidFormat); +} + +void +XrGStateSetLineWidth(XrGState *gstate, double width) +{ + gstate->line_width = width; +} + +void +XrGStateTranslate(XrGState *gstate, double tx, double ty) +{ + XrTransform new; + + XrTransformInitTranslate(&new, tx, ty); + XrTransformCompose(&gstate->transform, &new); +} + +void +XrGStateScale(XrGState *gstate, double sx, double sy) +{ + XrTransform new; + + XrTransformInitScale(&new, sx, sy); + XrTransformCompose(&gstate->transform, &new); +} + +void +XrGStateRotate(XrGState *gstate, double angle) +{ + XrTransform new; + + XrTransformInitRotate(&new, angle); + XrTransformCompose(&gstate->transform, &new); +} + +void +XrGStateNewPath(XrGState *gstate) +{ + XrPathDeinit(&gstate->path); +} + +void +XrGStateMoveTo(XrGState *gstate, double x, double y) +{ + XPointDouble pt; + + pt.x = x; + pt.y = y; + + XrTransformPoint(&gstate->transform, &pt); + XrPathMoveTo(&gstate->path, &pt); +} + +void +XrGStateLineTo(XrGState *gstate, double x, double y) +{ + XPointDouble pt; + + pt.x = x; + pt.y = y; + + XrTransformPoint(&gstate->transform, &pt); + XrPathLineTo(&gstate->path, &pt); +} + +static void +_TranslatePoint(XPointDouble *pt, const XPointDouble *offset) +{ + pt->x += offset->x; + pt->y += offset->y; +} + +void +XrGStateRelMoveTo(XrGState *gstate, double x, double y) +{ + XPointDouble pt, current; + + pt.x = x; + pt.y = y; + + XrTransformPointWithoutTranslate(&gstate->transform, &pt); + XrGStateGetCurrentPoint(gstate, ¤t); + _TranslatePoint(&pt, ¤t); + XrPathMoveTo(&gstate->path, &pt); +} + +void +XrGStateRelLineTo(XrGState *gstate, double x, double y) +{ + XPointDouble pt, current; + + pt.x = x; + pt.y = y; + + XrTransformPointWithoutTranslate(&gstate->transform, &pt); + XrGStateGetCurrentPoint(gstate, ¤t); + _TranslatePoint(&pt, ¤t); + XrPathLineTo(&gstate->path, &pt); +} + +void +XrGStateClosePath(XrGState *gstate) +{ + XrPathClose(&gstate->path); +} + +void +XrGStateStroke(XrGState *gstate) +{ + int winding_save = gstate->winding; + + gstate->winding = 1; + XrPathInit(&gstate->outline); + _XrGStateStrokePath(gstate, &gstate->path, &gstate->outline); + _XrGStateFillPath(gstate, &gstate->outline); + XrPathDeinit(&gstate->outline); + gstate->winding = winding_save; +} + +void +XrGStateFill(XrGState *gstate) +{ + _XrGStateFillPath(gstate, &gstate->path); +} + +static void +_XrGStateStrokePath(XrGState *gstate, XrPath *path, XrPath *outline) +{ + XrSubPath *sub; + + for (sub = path->head; sub; sub = sub->next) { + if (sub->num_pts) { + _XrGStateStrokeSubPath(gstate, sub, outline); + } + } +} + +static void +_XrGStateStrokeSubPath(XrGState *gstate, XrSubPath *subpath, XrPath *outline) +{ + int i; + XPointDouble *p0, *p1; + + XrPathNewSubPath(outline); + + /* Stroke right-side of path forward */ + for (i = 0; i < subpath->num_pts - 1; i++) { + p0 = subpath->pts + i; + p1 = p0 + 1; + + _XrGStateStrokeSegment(gstate, p0, p1, outline); + } + + /* Close path or add cap as necessary */ + if (subpath->closed) { + p0 = subpath->pts + subpath->num_pts - 1; + p1 = subpath->pts; + _XrGStateStrokeSegment(gstate, p0, p1, outline); + XrPathClose(outline); + } else { + /* XXX: NYI: Add cap here */ + } + + /* Stroke right-side of path in reverse */ + for (i = subpath->num_pts - 1; i > 0; i--) { + p0 = subpath->pts + i; + p1 = p0 - 1; + + _XrGStateStrokeSegment(gstate, p0, p1, outline); + } + + /* Close path or add cap as necessary */ + if (subpath->closed) { + p0 = subpath->pts; + p1 = subpath->pts + subpath->num_pts - 1; + _XrGStateStrokeSegment(gstate, p0, p1, outline); + XrPathClose(outline); + } else { + /* XXX: NYI: Add cap here */ + } +} + +static void +_XrGStateStrokeSegment(XrGState *gstate, const XPointDouble *p0, const XPointDouble *p1, XrPath *outline) +{ + double dx, dy, mag; + XPointDouble offset; + XPointDouble p0_off = *p0; + XPointDouble p1_off = *p1; + + dx = p1->x - p0->x; + dy = p1->y - p0->y; + mag = (gstate->line_width / 2) / sqrt(dx * dx + dy *dy); + + offset.x = -dy * mag; + offset.y = dx * mag; + + XrTransformPointWithoutTranslate(&gstate->transform, &offset); + + _TranslatePoint(&p0_off, &offset); + XrPathAddPoint(outline, &p0_off); + + _TranslatePoint(&p1_off, &offset); + XrPathAddPoint(outline, &p1_off); +} + +static void +_XrGStateFillPath(XrGState *gstate, XrPath *path) +{ + XPolygonDouble *polys; + int i, npolys; + XrSubPath *subpath; + + npolys = XrPathNumSubPaths(path); + + polys = malloc(npolys * sizeof(XPolygonDouble)); + if (polys == NULL) { + return; + } + + for (i=0, subpath = path->head; i < npolys && subpath; i++, subpath = subpath->next) { + polys[i].points = subpath->pts; + polys[i].npoints = subpath->num_pts; + } + + XRenderCompositeDoublePolys(gstate->dpy, gstate->op, + gstate->src.picture, gstate->picture.picture, + gstate->alphaFormat, + 0, 0, 0, 0, + polys, npolys, + gstate->winding); + + free(polys); +} diff --git a/src/xrint.h b/src/xrint.h new file mode 100644 index 00000000..6ac30b0a --- /dev/null +++ b/src/xrint.h @@ -0,0 +1,343 @@ +/* + * $XFree86: $ + * + * Copyright © 2002 University of Southern California + * + * Permission to use, copy, modify, distribute, and sell this software + * and its documentation for any purpose is hereby granted without + * fee, provided that the above copyright notice appear in all copies + * and that both that copyright notice and this permission notice + * appear in supporting documentation, and that the name of University + * of Southern California not be used in advertising or publicity + * pertaining to distribution of the software without specific, + * written prior permission. University of Southern California makes + * no representations about the suitability of this software for any + * purpose. It is provided "as is" without express or implied + * warranty. + * + * UNIVERSITY OF SOUTHERN CALIFORNIA DISCLAIMS ALL WARRANTIES WITH + * REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL UNIVERSITY OF + * SOUTHERN CALIFORNIA BE LIABLE FOR ANY SPECIAL, INDIRECT OR + * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS + * OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, + * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN + * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + * + * Author: Carl Worth, USC, Information Sciences Institute */ + +/* + * These definitions are solely for use by the implementation of Xr + * and constitute no kind of standard. If you need any of these + * functions, please drop me a note. Either the library needs new + * functionality, or there's a way to do what you need using the + * existing published interfaces. cworth@isi.edu + */ + +#ifndef _XRINT_H_ +#define _XRINT_H_ + +#include "Xr.h" + +typedef struct _XrSubPath { + int num_pts; + int pts_size; + XPointDouble *pts; + int closed; + + struct _XrSubPath *next; +} XrSubPath; + +typedef struct _XrPath { + XrSubPath *head; + XrSubPath *tail; +} XrPath; + +typedef struct _XrPicture { + Display *dpy; + + Drawable drawable; + + Visual *visual; + unsigned int depth; + + XRenderPictFormat *format; + unsigned long pa_mask; + XRenderPictureAttributes pa; + + Picture picture; + Picture alpha; + + /* XXX: Will also need a mechanism for a non-render picture here */ +} XrPicture; + +typedef struct _XrColor { + double red; + double green; + double blue; + double alpha; + + XRenderColor render; + + /* XXX: Will also need a mechanism for a non-render color here */ +} XrColor; + + +typedef struct _XrTransform { + double matrix[6]; +} XrTransform; + +#define XR_GSTATE_OP_DEFAULT PictOpOver +#define XR_GSTATE_WINDING_DEFAULT 1 +#define XR_GSTATE_LINE_WIDTH_DEFAULT 1.0 + +typedef struct _XrGState { + Display *dpy; + + int op; + int winding; + double line_width; + + XRenderPictFormat *solidFormat; + XRenderPictFormat *alphaFormat; + + XrColor color; + XrPicture src; + XrPicture picture; + XrTransform transform; + + XrPath path; + XrPath outline; + + struct _XrGState *next; +} XrGState; + +struct _XrState { + Display *dpy; + XrGState *stack; +}; + +/* xrstate.c */ + +#define CURRENT_GSTATE(xrs) (xrs->stack) + +XrState * +XrStateCreate(Display *dpy); + +void +XrStateInit(XrState *state, Display *dpy); + +void +XrStateDeinit(XrState *xrs); + +void +XrStateDestroy(XrState *state); + +void +XrStatePush(XrState *xrs); + +void +XrStatePop(XrState *xrs); + +/* xrgstate.c */ +XrGState * +XrGStateCreate(Display *dpy); + +XrGState * +XrGStateClone(XrGState *gstate); + +void +XrGStateInit(XrGState *gstate, Display *dpy); + +void +XrGStateInitCopy(XrGState *gstate, XrGState *other); + +void +XrGStateDeinit(XrGState *gstate); + +void +XrGStateDestroy(XrGState *gstate); + +void +XrGStateGetCurrentPoint(XrGState *gstate, XPointDouble *pt); + +void +XrGStateSetDrawable(XrGState *gstate, Drawable drawable, Visual *visual); + +void +XrGStateSetColorRGB(XrGState *gstate, double red, double green, double blue); + +void +XrGStateSetAlpha(XrGState *gstate, double alpha); + +void +XrGStateSetLineWidth(XrGState *gstate, double width); + +void +XrGStateTranslate(XrGState *gstate, double tx, double ty); + +void +XrGStateScale(XrGState *gstate, double sx, double sy); + +void +XrGStateRotate(XrGState *gstate, double angle); + +void +XrGStateNewPath(XrGState *gstate); + +void +XrGStateMoveTo(XrGState *gstate, double x, double y); + +void +XrGStateLineTo(XrGState *gstate, double x, double y); + +void +XrGStateRelMoveTo(XrGState *gstate, double x, double y); + +void +XrGStateRelLineTo(XrGState *gstate, double x, double y); + +void +XrGStateClosePath(XrGState *gstate); + +void +XrGStateStroke(XrGState *gstate); + +void +XrGStateFill(XrGState *fill); + +/* xrcolor.c */ +void +XrColorInit(XrColor *color); + +void +XrColorDeinit(XrColor *color); + +void +XrColorSetRGB(XrColor *color, double red, double green, double blue); + +void +XrColorSetAlpha(XrColor *color, double alpha); + +/* xrpath.c */ +XrPath * +XrPathCreate(void); + +void +XrPathInit(XrPath *path); + +void +XrPathInitCopy(XrPath *path, XrPath *other); + +void +XrPathReinit(XrPath *path); + +void +XrPathDeinit(XrPath *path); + +void +XrPathDestroy(XrPath *path); + +XrPath * +XrPathClone(XrPath *path); + +void +XrPathGetCurrentPoint(XrPath *path, XPointDouble *pt); + +int +XrPathNumSubPaths(XrPath *path); + +void +XrPathNewSubPath(XrPath *path); + +void +XrPathAddPoint(XrPath *path, const XPointDouble *pt); + +void +XrPathMoveTo(XrPath *path, const XPointDouble *pt); + +void +XrPathLineTo(XrPath *path, const XPointDouble *pt); + +void +XrPathClose(XrPath *path); + +/* xrsubpath.c */ +XrSubPath * +XrSubPathCreate(void); + +void +XrSubPathInit(XrSubPath *path); + +void +XrSubPathInitCopy(XrSubPath *path, XrSubPath *other); + +void +XrSubPathDeinit(XrSubPath *path); + +void +XrSubPathDestroy(XrSubPath *path); + +XrSubPath * +XrSubPathClone(XrSubPath *path); + +void +XrSubPathGetCurrentPoint(XrSubPath *path, XPointDouble *pt); + +void +XrSubPathSetCurrentPoint(XrSubPath *path, const XPointDouble *pt); + +void +XrSubPathAddPoint(XrSubPath *path, const XPointDouble *pt); + +void +XrSubPathClose(XrSubPath *path); + +/* xrpicture.c */ +void +XrPictureInit(XrPicture *picture, Display *dpy); + +void +XrPictureDeinit(XrPicture *picture); + +void +XrPictureSetSolidColor(XrPicture *picture, XrColor *color, XRenderPictFormat *format); + +void +XrPictureSetDrawable(XrPicture *picture, Drawable drawable, Visual *visual); + +/* xrtransform.c */ +void +XrTransformInit(XrTransform *transform); + +void +XrTransformInitMatrix(XrTransform *transform, + double a, double b, + double c, double d, + double tx, double ty); + +void +XrTransformInitTranslate(XrTransform *transform, + double tx, double ty); + +void +XrTransformInitScale(XrTransform *transform, + double sx, double sy); + +void +XrTransformInitRotate(XrTransform *transform, + double angle); + +void +XrTransformDeinit(XrTransform *transform); + +void +XrTransformCompose(XrTransform *t1, const XrTransform *t2); + +void +XrTransformPointWithoutTranslate(XrTransform *transform, XPointDouble *pt); + +void +XrTransformPoint(XrTransform *transform, XPointDouble *pt); + +#endif diff --git a/src/xrpath.c b/src/xrpath.c new file mode 100644 index 00000000..4ee16e43 --- /dev/null +++ b/src/xrpath.c @@ -0,0 +1,169 @@ +/* + * $XFree86: $ + * + * Copyright © 2002 University of Southern California + * + * Permission to use, copy, modify, distribute, and sell this software + * and its documentation for any purpose is hereby granted without + * fee, provided that the above copyright notice appear in all copies + * and that both that copyright notice and this permission notice + * appear in supporting documentation, and that the name of University + * of Southern California not be used in advertising or publicity + * pertaining to distribution of the software without specific, + * written prior permission. University of Southern California makes + * no representations about the suitability of this software for any + * purpose. It is provided "as is" without express or implied + * warranty. + * + * UNIVERSITY OF SOUTHERN CALIFORNIA DISCLAIMS ALL WARRANTIES WITH + * REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL UNIVERSITY OF + * SOUTHERN CALIFORNIA BE LIABLE FOR ANY SPECIAL, INDIRECT OR + * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS + * OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, + * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN + * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + * + * Author: Carl Worth, USC, Information Sciences Institute */ + +#include <stdlib.h> +#include "xrint.h" + +/* private functions */ +static void +_XrPathAddSubPath(XrPath *path, XrSubPath *subpath); + +XrPath * +XrPathCreate(void) +{ + XrPath *path; + + path = malloc(sizeof(XrPath)); + return path; +} + +void +XrPathInit(XrPath *path) +{ + path->head = NULL; + path->tail = NULL; +} + +void +XrPathInitCopy(XrPath *path, XrPath *other) +{ + XrSubPath *subpath, *othersub; + + XrPathInit(path); + + for (othersub = other->head; othersub; othersub = othersub->next) { + subpath = XrSubPathClone(othersub); + _XrPathAddSubPath(path, subpath); + } +} + +void +XrPathDeinit(XrPath *path) +{ + XrSubPath *subpath; + + while (path->head) { + subpath = path->head; + path->head = subpath->next; + XrSubPathDestroy(subpath); + } + path->tail = NULL; +} + +void +XrPathDestroy(XrPath *path) +{ + free(path); +} + +XrPath * +XrPathClone(XrPath *path) +{ + XrPath *clone; + + clone = XrPathCreate(); + XrPathInitCopy(clone, path); + return clone; +} + +void +XrPathGetCurrentPoint(XrPath *path, XPointDouble *pt) +{ + XrSubPathGetCurrentPoint(path->tail, pt); +} + +int +XrPathNumSubPaths(XrPath *path) +{ + XrSubPath *subpath; + int num_subpaths; + + num_subpaths = 0; + for (subpath = path->head; subpath; subpath = subpath->next) { + num_subpaths++; + } + + return num_subpaths; +} + +static void +_XrPathAddSubPath(XrPath *path, XrSubPath *subpath) +{ + subpath->next = NULL; + + if (path->tail) { + path->tail->next = subpath; + } else { + path->head = subpath; + } + + path->tail = subpath; +} + +void +XrPathNewSubPath(XrPath *path) +{ + XrSubPath *subpath; + + subpath = XrSubPathCreate(); + _XrPathAddSubPath(path, subpath); +} + +void +XrPathAddPoint(XrPath *path, const XPointDouble *pt) +{ + XrSubPathAddPoint(path->tail, pt); +} + +void +XrPathMoveTo(XrPath *path, const XPointDouble *pt) +{ + XrSubPath *subpath; + + subpath = path->tail; + + if (subpath == NULL || subpath->num_pts > 1) { + XrPathNewSubPath(path); + XrPathAddPoint(path, pt); + } else { + XrSubPathSetCurrentPoint(subpath, pt); + } +} + +void +XrPathLineTo(XrPath *path, const XPointDouble *pt) +{ + XrPathAddPoint(path, pt); +} + +void +XrPathClose(XrPath *path) +{ + XrSubPathClose(path->tail); + XrPathNewSubPath(path); +} diff --git a/src/xrstate.c b/src/xrstate.c new file mode 100644 index 00000000..37c8f501 --- /dev/null +++ b/src/xrstate.c @@ -0,0 +1,94 @@ +/* + * $XFree86: $ + * + * Copyright © 2002 University of Southern California + * + * Permission to use, copy, modify, distribute, and sell this software + * and its documentation for any purpose is hereby granted without + * fee, provided that the above copyright notice appear in all copies + * and that both that copyright notice and this permission notice + * appear in supporting documentation, and that the name of University + * of Southern California not be used in advertising or publicity + * pertaining to distribution of the software without specific, + * written prior permission. University of Southern California makes + * no representations about the suitability of this software for any + * purpose. It is provided "as is" without express or implied + * warranty. + * + * UNIVERSITY OF SOUTHERN CALIFORNIA DISCLAIMS ALL WARRANTIES WITH + * REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL UNIVERSITY OF + * SOUTHERN CALIFORNIA BE LIABLE FOR ANY SPECIAL, INDIRECT OR + * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS + * OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, + * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN + * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + * + * Author: Carl Worth, USC, Information Sciences Institute */ + +#include <stdlib.h> +#include "xrint.h" + +XrState * +XrStateCreate(Display *dpy) +{ + XrState *xrs; + + xrs = malloc(sizeof(XrState)); + + XrStateInit(xrs, dpy); + + return xrs; +} + +void +XrStateInit(XrState *xrs, Display *dpy) +{ + xrs->dpy = dpy; + xrs->stack = NULL; + XrStatePush(xrs); +} + +void +XrStateDeinit(XrState *xrs) +{ + while (xrs->stack) { + XrStatePop(xrs); + } +} + +void +XrStateDestroy(XrState *xrs) +{ + XrStateDeinit(xrs); + free(xrs); +} + +void +XrStatePush(XrState *xrs) +{ + XrGState *top; + + if (xrs->stack) { + top = XrGStateClone(xrs->stack); + } else { + top = XrGStateCreate(xrs->dpy); + } + + top->next = xrs->stack; + xrs->stack = top; +} + +void +XrStatePop(XrState *xrs) +{ + XrGState *top; + + if (xrs->stack) { + top = xrs->stack; + xrs->stack = top->next; + + XrGStateDestroy(top); + } +} + diff --git a/src/xrtransform.c b/src/xrtransform.c new file mode 100644 index 00000000..b90d02c7 --- /dev/null +++ b/src/xrtransform.c @@ -0,0 +1,129 @@ +/* + * $XFree86: $ + * + * Copyright © 2002 University of Southern California + * + * Permission to use, copy, modify, distribute, and sell this software + * and its documentation for any purpose is hereby granted without + * fee, provided that the above copyright notice appear in all copies + * and that both that copyright notice and this permission notice + * appear in supporting documentation, and that the name of University + * of Southern California not be used in advertising or publicity + * pertaining to distribution of the software without specific, + * written prior permission. University of Southern California makes + * no representations about the suitability of this software for any + * purpose. It is provided "as is" without express or implied + * warranty. + * + * UNIVERSITY OF SOUTHERN CALIFORNIA DISCLAIMS ALL WARRANTIES WITH + * REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL UNIVERSITY OF + * SOUTHERN CALIFORNIA BE LIABLE FOR ANY SPECIAL, INDIRECT OR + * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS + * OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, + * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN + * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + * + * Author: Carl Worth, USC, Information Sciences Institute */ + +#include <stdlib.h> +#include <math.h> + +#include "xrint.h" + +static XrTransform XR_TRANSFORM_DEFAULT = { + {1, 0, + 0, 1, + 0, 0} +}; + +void +XrTransformInit(XrTransform *transform) +{ + *transform = XR_TRANSFORM_DEFAULT; +} + +void +XrTransformInitMatrix(XrTransform *transform, + double a, double b, + double c, double d, + double tx, double ty) +{ + transform->matrix[0] = a; transform->matrix[1] = b; + transform->matrix[2] = c; transform->matrix[3] = d; + transform->matrix[4] = tx; transform->matrix[5] = ty; +} + +void +XrTransformInitTranslate(XrTransform *transform, + double tx, double ty) +{ + XrTransformInitMatrix(transform, + 1, 0, + 0, 1, + tx, ty); +} + +void +XrTransformInitScale(XrTransform *transform, + double sx, double sy) +{ + XrTransformInitMatrix(transform, + sx, 0, + 0, sy, + 0, 0); +} + +void +XrTransformInitRotate(XrTransform *transform, + double angle) +{ + XrTransformInitMatrix(transform, + cos(angle), sin(angle), + -sin(angle), cos(angle), + 0, 0); +} + +void +XrTransformDeinit(XrTransform *transform) +{ + /* Nothing to do here */ +} + +void +XrTransformCompose(XrTransform *t1, const XrTransform *t2) +{ + double new[6]; + + new[0] = t2->matrix[0] * t1->matrix[0] + t2->matrix[1] * t1->matrix[2]; + new[1] = t2->matrix[0] * t1->matrix[1] + t2->matrix[1] * t1->matrix[3]; + new[2] = t2->matrix[2] * t1->matrix[0] + t2->matrix[3] * t1->matrix[2]; + new[3] = t2->matrix[2] * t1->matrix[1] + t2->matrix[3] * t1->matrix[3]; + new[4] = t2->matrix[4] * t1->matrix[0] + t2->matrix[5] * t1->matrix[2] + t1->matrix[4]; + new[5] = t2->matrix[4] * t1->matrix[1] + t2->matrix[5] * t1->matrix[3] + t1->matrix[5]; + + memcpy(t1->matrix, new, 6 * sizeof(double)); +} + +void +XrTransformPointWithoutTranslate(XrTransform *transform, XPointDouble *pt) +{ + double new_x, new_y; + + new_x = (transform->matrix[0] * pt->x + + transform->matrix[2] * pt->y); + new_y = (transform->matrix[1] * pt->x + + transform->matrix[3] * pt->y); + + pt->x = new_x; + pt->y = new_y; +} + +void +XrTransformPoint(XrTransform *transform, XPointDouble *pt) +{ + XrTransformPointWithoutTranslate(transform, pt); + + pt->x += transform->matrix[4]; + pt->y += transform->matrix[5]; +} |