Initial import of Xr

This commit is contained in:
Carl Worth 2002-06-11 04:02:23 +00:00
commit 00807705bf
19 changed files with 3194 additions and 0 deletions

49
Imakefile Normal file
View file

@ -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 <Threads.tmpl>
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 <Library.tmpl>
CDEBUGFLAGS=-g -Wall
DependTarget()

103
Xr.h Normal file
View file

@ -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

103
src/Xr.h Normal file
View file

@ -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

149
src/xr.c Normal file
View file

@ -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));
}

72
src/xrcolor.c Normal file
View file

@ -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);
}

389
src/xrgstate.c Normal file
View file

@ -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, &current);
_TranslatePoint(&pt, &current);
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, &current);
_TranslatePoint(&pt, &current);
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);
}

343
src/xrint.h Normal file
View file

@ -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

169
src/xrpath.c Normal file
View file

@ -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);
}

94
src/xrstate.c Normal file
View file

@ -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);
}
}

129
src/xrtransform.c Normal file
View file

@ -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];
}

149
xr.c Normal file
View file

@ -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));
}

72
xrcolor.c Normal file
View file

@ -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);
}

389
xrgstate.c Normal file
View file

@ -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, &current);
_TranslatePoint(&pt, &current);
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, &current);
_TranslatePoint(&pt, &current);
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);
}

343
xrint.h Normal file
View file

@ -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

169
xrpath.c Normal file
View file

@ -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);
}

102
xrpicture.c Normal file
View file

@ -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);
}

94
xrstate.c Normal file
View file

@ -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);
}
}

147
xrsubpath.c Normal file
View file

@ -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 <stdlib.h>
#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;
}

129
xrtransform.c Normal file
View file

@ -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];
}