From 00807705bf00ce370bb5860db23edbc0fa507015 Mon Sep 17 00:00:00 2001 From: Carl Worth Date: Tue, 11 Jun 2002 04:02:23 +0000 Subject: [PATCH] Initial import of Xr --- Imakefile | 49 ++++++ Xr.h | 103 ++++++++++++ src/Xr.h | 103 ++++++++++++ src/xr.c | 149 ++++++++++++++++++ src/xrcolor.c | 72 +++++++++ src/xrgstate.c | 389 ++++++++++++++++++++++++++++++++++++++++++++++ src/xrint.h | 343 ++++++++++++++++++++++++++++++++++++++++ src/xrpath.c | 169 ++++++++++++++++++++ src/xrstate.c | 94 +++++++++++ src/xrtransform.c | 129 +++++++++++++++ xr.c | 149 ++++++++++++++++++ xrcolor.c | 72 +++++++++ xrgstate.c | 389 ++++++++++++++++++++++++++++++++++++++++++++++ xrint.h | 343 ++++++++++++++++++++++++++++++++++++++++ xrpath.c | 169 ++++++++++++++++++++ xrpicture.c | 102 ++++++++++++ xrstate.c | 94 +++++++++++ xrsubpath.c | 147 ++++++++++++++++++ xrtransform.c | 129 +++++++++++++++ 19 files changed, 3194 insertions(+) create mode 100644 Imakefile create mode 100644 Xr.h create mode 100644 src/Xr.h create mode 100644 src/xr.c create mode 100644 src/xrcolor.c create mode 100644 src/xrgstate.c create mode 100644 src/xrint.h create mode 100644 src/xrpath.c create mode 100644 src/xrstate.c create mode 100644 src/xrtransform.c create mode 100644 xr.c create mode 100644 xrcolor.c create mode 100644 xrgstate.c create mode 100644 xrint.h create mode 100644 xrpath.c create mode 100644 xrpicture.c create mode 100644 xrstate.c create mode 100644 xrsubpath.c create mode 100644 xrtransform.c diff --git a/Imakefile b/Imakefile new file mode 100644 index 000000000..bb49fc78b --- /dev/null +++ b/Imakefile @@ -0,0 +1,49 @@ +XCOMM $XFree86: $ + +#define DoNormalLib NormalLibXr +#define DoSharedLib SharedLibXr +#define DoDebugLib DebugLibXr +#define DoProfileLib ProfileLibXr + +#define LibName Xr +#define SoRev SOXRREV +#define IncSubdir X11 +#define IncSubSubdir Xr + +#include + +WARNINGS=-Wall -Wpointer-arith -Wstrict-prototypes -Wmissing-prototypes -Wmissing-declarations -Wnested-externs +INCLUDES=$(WARNINGS) +DEFINES=$(RENDERDEFINES) + +XRENDER_LIBS=$(XRENDERLIB) +XRENDER_CFLAGS=$(XRENDERINCLUDES) + +REQUIREDLIBS=$(LDPRELIBS) $(XRENDERLIB) $(XLIB) + +SRCS = xr.c \ + xrcolor.c \ + xrgstate.c \ + xrpath.c \ + xrpicture.c \ + xrstate.c \ + xrsubpath.c \ + xrtransform.c + +OBJS = xr.o \ + xrcolor.o \ + xrgstate.o \ + xrpath.o \ + xrpicture.o \ + xrstate.o \ + xrsubpath.o \ + xrtransform.o + +HEADERS = Xr.h + +#include + +CDEBUGFLAGS=-g -Wall + +DependTarget() + diff --git a/Xr.h b/Xr.h new file mode 100644 index 000000000..24df20fe1 --- /dev/null +++ b/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 + +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.h b/src/Xr.h new file mode 100644 index 000000000..24df20fe1 --- /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 + +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 000000000..2211a45c4 --- /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 000000000..a09b10e42 --- /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 000000000..a7bd58418 --- /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 +#include + +#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 000000000..6ac30b0ac --- /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 000000000..4ee16e437 --- /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 +#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 000000000..37c8f501f --- /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 +#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 000000000..b90d02c70 --- /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 +#include + +#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]; +} diff --git a/xr.c b/xr.c new file mode 100644 index 000000000..2211a45c4 --- /dev/null +++ b/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/xrcolor.c b/xrcolor.c new file mode 100644 index 000000000..a09b10e42 --- /dev/null +++ b/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/xrgstate.c b/xrgstate.c new file mode 100644 index 000000000..a7bd58418 --- /dev/null +++ b/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 +#include + +#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/xrint.h b/xrint.h new file mode 100644 index 000000000..6ac30b0ac --- /dev/null +++ b/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/xrpath.c b/xrpath.c new file mode 100644 index 000000000..4ee16e437 --- /dev/null +++ b/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 +#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/xrpicture.c b/xrpicture.c new file mode 100644 index 000000000..79f62e290 --- /dev/null +++ b/xrpicture.c @@ -0,0 +1,102 @@ +/* + * $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" + +void +XrPictureInit(XrPicture *picture, Display *dpy) +{ + picture->dpy = dpy; + + picture->drawable = 0; + + picture->depth = 0; + picture->visual = 0; + + picture->format = 0; + picture->pa_mask = 0; + + picture->picture = 0; +} + +void +XrPictureDeinit(XrPicture *picture) +{ + /* XXX: Leak for now. The problem is that I'm not currently cloning this as I should be sometime during XrSave. + if (picture->picture) { + XRenderFreePicture(picture->dpy, picture->picture); + } + */ +} + +void +XrPictureSetSolidColor(XrPicture *picture, XrColor *color, XRenderPictFormat *format) +{ + /* XXX: Special handling for depth==1 ala xftdraw.c? */ + + if (picture->picture == 0) { + Pixmap pix; + XRenderPictureAttributes pa; + + pix = XCreatePixmap(picture->dpy, DefaultRootWindow(picture->dpy), 1, 1, format->depth); + pa.repeat = True; + picture->picture = XRenderCreatePicture(picture->dpy, pix, format, CPRepeat, &pa); + XFreePixmap(picture->dpy, pix); + } + + XRenderFillRectangle(picture->dpy, PictOpSrc, + picture->picture, &color->render, + 0, 0, 1, 1); +} + +static void +_XrPictureFindFormat(XrPicture *picture) +{ + if (picture->format) { + return; + } + + picture->format = XRenderFindVisualFormat(picture->dpy, picture->visual); +} + +void +XrPictureSetDrawable(XrPicture *picture, Drawable drawable, Visual *visual) +{ + if (picture->picture) { + XRenderFreePicture(picture->dpy, picture->picture); + } + + picture->visual = visual; + picture->drawable = drawable; + + _XrPictureFindFormat(picture); + + picture->picture = XRenderCreatePicture(picture->dpy, drawable, + picture->format, picture->pa_mask, &picture->pa); +} + diff --git a/xrstate.c b/xrstate.c new file mode 100644 index 000000000..37c8f501f --- /dev/null +++ b/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 +#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/xrsubpath.c b/xrsubpath.c new file mode 100644 index 000000000..79384cfcf --- /dev/null +++ b/xrsubpath.c @@ -0,0 +1,147 @@ +/* + * $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 +#include "xrint.h" + +#define XR_SUBPATH_GROWTH_INC 10 + +XrSubPath * +XrSubPathCreate(void) +{ + XrSubPath *path; + + path = malloc(sizeof(XrSubPath)); + + XrSubPathInit(path); + + return path; +} + +void +XrSubPathInit(XrSubPath *path) +{ + path->num_pts = 0; + + path->pts_size = 0; + path->pts = NULL; + + path->closed = 0; + + path->next = NULL; +} + +void +XrSubPathInitCopy(XrSubPath *path, XrSubPath *other) +{ + *path = *other; + + path->pts = malloc(path->pts_size * sizeof(XPointDouble)); + *path->pts = *other->pts; +} + +void +XrSubPathDeinit(XrSubPath *path) +{ + if (path->pts_size) { + free(path->pts); + path->pts_size = 0; + path->num_pts = 0; + } +} + +void +XrSubPathDestroy(XrSubPath *path) +{ + XrSubPathDeinit(path); + free(path); +} + +XrSubPath * +XrSubPathClone(XrSubPath *path) +{ + XrSubPath *clone; + + clone = XrSubPathCreate(); + XrSubPathInitCopy(clone, path); + + return clone; +} + +void +XrSubPathGetCurrentPoint(XrSubPath *path, XPointDouble *pt) +{ + if (path->num_pts) { + *pt = path->pts[path->num_pts-1]; + } else { + /* XXX: What to do for error handling? */ + } +} + +void +XrSubPathSetCurrentPoint(XrSubPath *path, const XPointDouble *pt) +{ + if (path->num_pts) { + path->pts[path->num_pts - 1] = *pt; + } else { + /* XXX: What to do for error handling? */ + } +} + +static void +_XrSubPathGrow(XrSubPath *path) +{ + XPointDouble *new_pts; + + path->pts_size += XR_SUBPATH_GROWTH_INC; + new_pts = realloc(path->pts, path->pts_size * sizeof(XPointDouble)); + + if (new_pts) { + path->pts = new_pts; + } else { + path->pts_size -= XR_SUBPATH_GROWTH_INC; + } +} + +void +XrSubPathAddPoint(XrSubPath *path, const XPointDouble *pt) +{ + if (path->num_pts == path->pts_size) { + _XrSubPathGrow(path); + } + + if (path->num_pts < path->pts_size) { + path->pts[path->num_pts++] = *pt; + } +} + +void +XrSubPathClose(XrSubPath *path) +{ + path->closed = 1; +} diff --git a/xrtransform.c b/xrtransform.c new file mode 100644 index 000000000..b90d02c70 --- /dev/null +++ b/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 +#include + +#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]; +}