661 lines
17 KiB
C
661 lines
17 KiB
C
/* grTCairo3.c -
|
||
*
|
||
* Copyright 2017 Open Circuit Design
|
||
*
|
||
* This file contains additional functions to manipulate an X window system
|
||
* color display. Included here are device-dependent routines to draw and
|
||
* erase text and draw a grid.
|
||
*
|
||
* Written by Chuan Chen
|
||
*/
|
||
|
||
#include <stdio.h>
|
||
#include <string.h>
|
||
|
||
#include <cairo/cairo-xlib.h>
|
||
|
||
#include <math.h>
|
||
|
||
#include "tcltk/tclmagic.h"
|
||
#include "utils/magic.h"
|
||
#include "utils/geometry.h"
|
||
#include "utils/malloc.h"
|
||
#include "windows/windows.h"
|
||
#include "graphics/graphics.h"
|
||
#include "graphics/graphicsInt.h"
|
||
#include "dbwind/dbwind.h"
|
||
#include "textio/textio.h"
|
||
#include "utils/signals.h"
|
||
#include "utils/utils.h"
|
||
#include "utils/hash.h"
|
||
#include "graphics/grTCairoInt.h"
|
||
#include "graphics/grTkCommon.h"
|
||
#include "database/fonts.h"
|
||
|
||
extern Display *grXdpy;
|
||
|
||
static GC grXcopyGC = (GC)NULL;
|
||
|
||
/* locals */
|
||
|
||
|
||
/*---------------------------------------------------------
|
||
* grtcairoDrawGrid:
|
||
* grxDrawGrid adds a grid to the grid layer, using the current
|
||
* write mask and color.
|
||
*
|
||
* Results:
|
||
* TRUE is returned normally. However, if the grid gets too small
|
||
* to be useful, then nothing is drawn and FALSE is returned.
|
||
*
|
||
* Side Effects: None.
|
||
*---------------------------------------------------------
|
||
*/
|
||
|
||
bool
|
||
grtcairoDrawGrid (prect, outline, clip)
|
||
Rect *prect; /* A rectangle that forms the template
|
||
* for the grid. Note: in order to maintain
|
||
* precision for the grid, the rectangle
|
||
* coordinates are specified in units of
|
||
* screen coordinates multiplied by SUBPIXEL.
|
||
*/
|
||
int outline; /* the outline style */
|
||
Rect *clip; /* a clipping rectangle */
|
||
{
|
||
int xsize, ysize;
|
||
int x, y;
|
||
int xstart, ystart;
|
||
int snum, low, hi, shifted;
|
||
TCairoData *tcairodata = (TCairoData *)tcairoCurrent.mw->w_grdata2;
|
||
|
||
xsize = prect->r_xtop - prect->r_xbot;
|
||
ysize = prect->r_ytop - prect->r_ybot;
|
||
if (!xsize || !ysize || GRID_TOO_SMALL(xsize, ysize))
|
||
return FALSE;
|
||
|
||
xstart = prect->r_xbot % xsize;
|
||
while (xstart < clip->r_xbot << SUBPIXELBITS) xstart += xsize;
|
||
ystart = prect->r_ybot % ysize;
|
||
while (ystart < clip->r_ybot << SUBPIXELBITS) ystart += ysize;
|
||
|
||
snum = 0;
|
||
low = clip->r_ybot;
|
||
hi = clip->r_ytop;
|
||
for (x = xstart; x < (clip->r_xtop + 1) << SUBPIXELBITS; x += xsize)
|
||
{
|
||
shifted = x >> SUBPIXELBITS;
|
||
cairo_move_to(tcairodata->context, (double)shifted, (double)low);
|
||
cairo_line_to(tcairodata->context, (double)shifted, (double)hi);
|
||
snum++;
|
||
}
|
||
|
||
snum = 0;
|
||
low = clip->r_xbot;
|
||
hi = clip->r_xtop;
|
||
for (y = ystart; y < (clip->r_ytop + 1) << SUBPIXELBITS; y += ysize)
|
||
{
|
||
shifted = y >> SUBPIXELBITS;
|
||
cairo_move_to(tcairodata->context, (double)low, (double)shifted);
|
||
cairo_line_to(tcairodata->context, (double)hi, (double)shifted);
|
||
snum++;
|
||
}
|
||
cairo_stroke(tcairodata->context);
|
||
return TRUE;
|
||
}
|
||
|
||
|
||
/*---------------------------------------------------------
|
||
* grtcairoLoadFont
|
||
* This local routine loads the default ("toy API")
|
||
* font for Cairo.
|
||
*
|
||
* Results: Success/Failure
|
||
*
|
||
* Side Effects: None.
|
||
*---------------------------------------------------------
|
||
*/
|
||
|
||
bool
|
||
grtcairoLoadFont()
|
||
{
|
||
TCairoData *tcairodata = (TCairoData *)tcairoCurrent.mw->w_grdata2;
|
||
cairo_select_font_face(tcairodata->context, "sans-serif", CAIRO_FONT_SLANT_NORMAL, CAIRO_FONT_WEIGHT_NORMAL);
|
||
return TRUE;
|
||
}
|
||
|
||
|
||
/*---------------------------------------------------------
|
||
* grtcairoSetCharSize:
|
||
* This local routine sets the character size in the display,
|
||
* if necessary.
|
||
*
|
||
* Results: None.
|
||
*
|
||
* Side Effects: None.
|
||
*---------------------------------------------------------
|
||
*/
|
||
|
||
void
|
||
grtcairoSetCharSize (size)
|
||
int size; /* Width of characters, in pixels (6 or 8). */
|
||
{
|
||
TCairoData *tcairodata = (TCairoData *)tcairoCurrent.mw->w_grdata2;
|
||
tcairoCurrent.fontSize = size;
|
||
cairo_set_font_size(tcairodata->context, size * 4 + 10);
|
||
switch (size)
|
||
{
|
||
case GR_TEXT_DEFAULT:
|
||
case GR_TEXT_SMALL:
|
||
tcairoCurrent.font = grSmallFont;
|
||
break;
|
||
case GR_TEXT_MEDIUM:
|
||
tcairoCurrent.font = grMediumFont;
|
||
break;
|
||
case GR_TEXT_LARGE:
|
||
tcairoCurrent.font = grLargeFont;
|
||
break;
|
||
case GR_TEXT_XLARGE:
|
||
tcairoCurrent.font = grXLargeFont;
|
||
break;
|
||
default:
|
||
TxError("%s%d\n", "grtcairoSetCharSize: Unknown character size ",
|
||
size );
|
||
break;
|
||
}
|
||
}
|
||
|
||
|
||
/*
|
||
* ----------------------------------------------------------------------------
|
||
* GrTCairoTextSize --
|
||
*
|
||
* Determine the size of a text string.
|
||
*
|
||
* Results:
|
||
* None.
|
||
*
|
||
* Side effects:
|
||
* A rectangle is filled in that is the size of the text in pixels.
|
||
* The origin (0, 0) of this rectangle is located on the baseline
|
||
* at the far left side of the string.
|
||
* ----------------------------------------------------------------------------
|
||
*/
|
||
|
||
void
|
||
GrTCairoTextSize(text, size, r)
|
||
char *text;
|
||
int size;
|
||
Rect *r;
|
||
{
|
||
TCairoData *tcairodata;
|
||
cairo_text_extents_t extents;
|
||
int width;
|
||
|
||
/* Note: size is ignored, as it is passed the current value; */
|
||
/* but the font size in cairo has already been set. */
|
||
|
||
if (tcairoCurrent.mw == 0) return;
|
||
|
||
tcairodata = (TCairoData *)tcairoCurrent.mw->w_grdata2;
|
||
cairo_text_extents(tcairodata->context, text, &extents);
|
||
|
||
r->r_ytop = -extents.y_bearing;
|
||
r->r_ybot = -(extents.height + extents.y_bearing);
|
||
r->r_xtop = extents.width + extents.x_bearing;
|
||
r->r_xbot = extents.x_bearing;
|
||
}
|
||
|
||
/* Cairo backing store functions (now removed from the X11-based ones) */
|
||
|
||
void
|
||
grtcairoFreeBackingStore(MagWindow *window)
|
||
{
|
||
TCairoData *tcairodata;
|
||
Pixmap pmap = (Pixmap)window->w_backingStore;
|
||
if (pmap == (Pixmap)NULL) return;
|
||
XFreePixmap(grXdpy, pmap);
|
||
window->w_backingStore = (ClientData)NULL;
|
||
|
||
tcairodata = (TCairoData *)window->w_grdata2;
|
||
cairo_surface_destroy(tcairodata->backing_surface);
|
||
cairo_destroy(tcairodata->backing_context);
|
||
tcairodata->backing_surface = NULL;
|
||
tcairodata->backing_context = NULL;
|
||
}
|
||
|
||
void
|
||
grtcairoCreateBackingStore(MagWindow *w)
|
||
{
|
||
Pixmap pmap;
|
||
TCairoData *tcairodata;
|
||
Tk_Window tkwind = (Tk_Window)w->w_grdata;
|
||
Window wind;
|
||
unsigned int width, height;
|
||
GC gc;
|
||
XGCValues gcValues;
|
||
int grDepth;
|
||
|
||
/* Deferred */
|
||
if (tkwind == NULL) return;
|
||
|
||
wind = (Window)Tk_WindowId(tkwind);
|
||
|
||
/* ignore all windows other than layout */
|
||
if (w->w_client != DBWclientID) return;
|
||
|
||
/* deferred */
|
||
if (wind == (Window)NULL) return;
|
||
|
||
width = w->w_screenArea.r_xtop - w->w_screenArea.r_xbot;
|
||
height = w->w_screenArea.r_ytop - w->w_screenArea.r_ybot;
|
||
|
||
if (w->w_backingStore != (ClientData)NULL) grtcairoFreeBackingStore(w);
|
||
|
||
if (grXcopyGC == (GC)NULL)
|
||
{
|
||
gcValues.graphics_exposures = FALSE;
|
||
grXcopyGC = XCreateGC(grXdpy, wind, GCGraphicsExposures, &gcValues);
|
||
}
|
||
|
||
grDepth = Tk_Depth((Tk_Window)w->w_grdata);
|
||
|
||
pmap = XCreatePixmap(grXdpy, wind, width, height, grDepth);
|
||
w->w_backingStore = (ClientData)pmap;
|
||
|
||
tcairodata = (TCairoData *)w->w_grdata2;
|
||
|
||
if (tcairodata->backing_surface != NULL)
|
||
{
|
||
cairo_surface_destroy(tcairodata->backing_surface);
|
||
cairo_destroy(tcairodata->backing_context);
|
||
}
|
||
tcairodata->backing_surface = cairo_xlib_surface_create(grXdpy, pmap,
|
||
DefaultVisual(grXdpy, DefaultScreen(grXdpy)), width, height);
|
||
tcairodata->backing_context = cairo_create(tcairodata->backing_surface);
|
||
|
||
cairo_identity_matrix(tcairodata->backing_context);
|
||
}
|
||
|
||
bool
|
||
grtcairoGetBackingStore(MagWindow *w, Rect *area)
|
||
{
|
||
unsigned int width, height, sheight;
|
||
int xbot, ybot;
|
||
Rect r;
|
||
TCairoData *tcairodata = (TCairoData *)w->w_grdata2;
|
||
|
||
if (w->w_backingStore == (ClientData)0) return FALSE;
|
||
|
||
GEO_EXPAND(area, 1, &r);
|
||
GeoClip(&r, &(w->w_screenArea));
|
||
|
||
xbot = r.r_xbot;
|
||
ybot = r.r_ybot;
|
||
width = r.r_xtop - xbot;
|
||
height = r.r_ytop - ybot;
|
||
sheight = w->w_screenArea.r_ytop - w->w_screenArea.r_ybot;
|
||
|
||
// Fix Y orientation
|
||
ybot = sheight - height - ybot;
|
||
|
||
cairo_save(tcairodata->context);
|
||
cairo_identity_matrix(tcairodata->context);
|
||
cairo_set_source_surface(tcairodata->context, tcairodata->backing_surface,
|
||
0.0, 0.0);
|
||
cairo_rectangle(tcairodata->context, (double)xbot, (double)ybot,
|
||
(double)width, (double)height);
|
||
cairo_set_operator(tcairodata->context, CAIRO_OPERATOR_SOURCE);
|
||
cairo_fill(tcairodata->context);
|
||
cairo_restore(tcairodata->context);
|
||
|
||
return TRUE;
|
||
}
|
||
|
||
|
||
bool
|
||
grtcairoScrollBackingStore(MagWindow *w, Point *shift)
|
||
{
|
||
TCairoData *tcairodata = (TCairoData *)w->w_grdata2;
|
||
Pixmap pmap;
|
||
unsigned int width, height;
|
||
int xorigin, yorigin, xshift, yshift;
|
||
|
||
pmap = (Pixmap)w->w_backingStore;
|
||
if (pmap == (Pixmap)NULL)
|
||
{
|
||
TxPrintf("grtcairoScrollBackingStore %d %d failure\n",
|
||
shift->p_x, shift->p_y);
|
||
return FALSE;
|
||
}
|
||
|
||
width = w->w_screenArea.r_xtop - w->w_screenArea.r_xbot;
|
||
height = w->w_screenArea.r_ytop - w->w_screenArea.r_ybot;
|
||
xorigin = 0;
|
||
yorigin = 0;
|
||
xshift = shift->p_x;
|
||
yshift = -shift->p_y;
|
||
|
||
/* Important: Cairo does not watch where memory overlaps exist */
|
||
/* when copying and will erase memory when yshift is positive. */
|
||
|
||
if (yshift > 0)
|
||
{
|
||
/* Noting that the highlights will be redrawn anyway, use */
|
||
/* the main window surface as an intermediary to copy. */
|
||
|
||
Rect area;
|
||
|
||
cairo_save(tcairodata->context);
|
||
cairo_identity_matrix(tcairodata->context);
|
||
cairo_set_source_surface(tcairodata->context,
|
||
tcairodata->backing_surface, (double)xshift, (double)yshift);
|
||
cairo_rectangle(tcairodata->context, (double)xorigin,
|
||
(double)yorigin, (double)width, (double)height);
|
||
cairo_set_operator(tcairodata->context, CAIRO_OPERATOR_SOURCE);
|
||
cairo_fill(tcairodata->context);
|
||
cairo_restore(tcairodata->context);
|
||
|
||
area.r_xbot = 0;
|
||
area.r_xtop = width;
|
||
area.r_ybot = 0;
|
||
area.r_ytop = height;
|
||
grtcairoPutBackingStore(w, &area);
|
||
}
|
||
else
|
||
{
|
||
cairo_save(tcairodata->backing_context);
|
||
cairo_set_source_surface(tcairodata->backing_context,
|
||
tcairodata->backing_surface, (double)xshift, (double)yshift);
|
||
cairo_rectangle(tcairodata->backing_context, (double)xorigin,
|
||
(double)yorigin, (double)width, (double)height);
|
||
cairo_set_operator(tcairodata->backing_context, CAIRO_OPERATOR_SOURCE);
|
||
cairo_fill(tcairodata->backing_context);
|
||
cairo_restore(tcairodata->backing_context);
|
||
}
|
||
return TRUE;
|
||
}
|
||
|
||
void
|
||
grtcairoPutBackingStore(MagWindow *w, Rect *area)
|
||
{
|
||
unsigned int width, height, sheight;
|
||
int ybot, xbot;
|
||
TCairoData *tcairodata = (TCairoData *)w->w_grdata2;
|
||
|
||
if (w->w_backingStore == (ClientData)0) return;
|
||
|
||
if (w->w_flags & WIND_OBSCURED)
|
||
{
|
||
grtcairoFreeBackingStore(w);
|
||
return;
|
||
}
|
||
|
||
xbot = area->r_xbot;
|
||
ybot = area->r_ybot;
|
||
|
||
width = area->r_xtop - xbot;
|
||
height = area->r_ytop - ybot;
|
||
sheight = w->w_screenArea.r_ytop - w->w_screenArea.r_ybot;
|
||
|
||
// Fix Y orientation
|
||
ybot = sheight - height - ybot;
|
||
|
||
cairo_save(tcairodata->backing_context);
|
||
cairo_set_source_surface(tcairodata->backing_context, tcairodata->surface,
|
||
0.0, 0.0);
|
||
cairo_rectangle(tcairodata->backing_context, (double)xbot, (double)ybot,
|
||
(double)width, (double)height);
|
||
cairo_set_operator(tcairodata->backing_context, CAIRO_OPERATOR_SOURCE);
|
||
cairo_fill(tcairodata->backing_context);
|
||
cairo_restore(tcairodata->backing_context);
|
||
}
|
||
|
||
|
||
/*
|
||
* ----------------------------------------------------------------------------
|
||
* GrTCairoReadPixel --
|
||
*
|
||
* Read one pixel from the screen.
|
||
*
|
||
* Results:
|
||
* An integer containing the pixel's color.
|
||
*
|
||
* Side effects:
|
||
* none.
|
||
*
|
||
* ----------------------------------------------------------------------------
|
||
*/
|
||
|
||
int
|
||
GrTCairoReadPixel (w, x, y)
|
||
MagWindow *w;
|
||
int x, y; /* the location of a pixel in screen coords */
|
||
{
|
||
return 0; /* (unimplemented) */
|
||
}
|
||
|
||
|
||
/*
|
||
* ----------------------------------------------------------------------------
|
||
* GrTCairoBitBlt --
|
||
*
|
||
* Copy information in bit block transfers.
|
||
*
|
||
* Results:
|
||
* None.
|
||
*
|
||
* Side effects:
|
||
* changes the screen.
|
||
* ----------------------------------------------------------------------------
|
||
*/
|
||
|
||
void
|
||
GrTCairoBitBlt(r, p)
|
||
Rect *r;
|
||
Point *p;
|
||
{
|
||
// (unimplemented)
|
||
}
|
||
|
||
#ifdef VECTOR_FONTS
|
||
|
||
/*
|
||
*----------------------------------------------------------------------
|
||
* Draw a text character
|
||
* This routine is similar to grtcairoFillPolygon()
|
||
*----------------------------------------------------------------------
|
||
*/
|
||
|
||
void
|
||
grtcairoDrawCharacter(clist, tc, pixsize)
|
||
FontChar *clist;
|
||
unsigned char tc;
|
||
int pixsize;
|
||
{
|
||
Point *tp;
|
||
int np, nptotal;
|
||
int i;
|
||
static int maxnp = 0;
|
||
FontChar *ccur;
|
||
TCairoData *tcairodata = (TCairoData *)tcairoCurrent.mw->w_grdata2;
|
||
|
||
if (pixsize < 5) return; /* Label too small to be useful */
|
||
|
||
//should we be using cairo_show_glyphs??
|
||
for (ccur = clist; ccur != NULL; ccur = ccur->fc_next) {
|
||
tp = ccur->fc_points;
|
||
np = ccur->fc_numpoints;
|
||
cairo_move_to(tcairodata->context, (double)tp[0].p_x, (double)tp[0].p_y);
|
||
for (i = 1; i < np; i++) {
|
||
cairo_line_to(tcairodata->context, (double)tp[i].p_x,
|
||
(double)tp[i].p_y);
|
||
}
|
||
cairo_close_path(tcairodata->context);
|
||
}
|
||
cairo_fill(tcairodata->context);
|
||
}
|
||
|
||
/*---------------------------------------------------------
|
||
* grtcairoFontText:
|
||
*
|
||
* This routine draws text from font vectors using the
|
||
* font vector routines in DBlabel.c. Text is clipped
|
||
* to the clipping rectangle.
|
||
*
|
||
* For speed, should we be transferring the font
|
||
* vectors into cairo glyphs?
|
||
*
|
||
*---------------------------------------------------------
|
||
*/
|
||
|
||
void
|
||
grtcairoFontText(text, font, size, rotate, pos, clip, obscure)
|
||
char *text; /* The text to be drawn */
|
||
int font; /* Font to use from fontList */
|
||
int size; /* Pixel size of the font */
|
||
int rotate; /* Text rotation */
|
||
Point *pos; /* Text base position */
|
||
Rect *clip; /* Clipping area */
|
||
LinkedRect *obscure; /* List of obscuring areas */
|
||
{
|
||
char *tptr;
|
||
Point *coffset; /* vector to next character */
|
||
Rect *cbbox;
|
||
float fsize;
|
||
FontChar *clist;
|
||
int cheight, baseline;
|
||
float tmp;
|
||
TCairoData *tcairodata = (TCairoData *)tcairoCurrent.mw->w_grdata2;
|
||
|
||
cairo_save(tcairodata->context);
|
||
cairo_set_operator(tcairodata->context, CAIRO_OPERATOR_SOURCE);
|
||
cairo_translate(tcairodata->context, (double)pos->p_x, (double)pos->p_y);
|
||
// cairo_scale(tcairodata->context, 1.0, -1.0);
|
||
cairo_rotate(tcairodata->context, ((double)rotate) / 360 * 2 * M_PI);
|
||
|
||
/* Get label size */
|
||
cbbox = &DBFontList[font]->mf_extents;
|
||
|
||
fsize = (float)size / (float)cbbox->r_ytop;
|
||
cairo_scale(tcairodata->context, (double)fsize, (double)fsize);
|
||
|
||
/* Adjust to baseline */
|
||
baseline = 0;
|
||
for (tptr = text; *tptr != '\0'; tptr++)
|
||
{
|
||
DBFontChar(font, *tptr, NULL, NULL, &cbbox);
|
||
if (cbbox->r_ybot < baseline)
|
||
baseline = cbbox->r_ybot;
|
||
}
|
||
cairo_translate(tcairodata->context, 0.0, (double)(-baseline));
|
||
|
||
for (tptr = text; *tptr != '\0'; tptr++)
|
||
{
|
||
DBFontChar(font, *tptr, &clist, &coffset, NULL);
|
||
grtcairoDrawCharacter(clist, *tptr, size);
|
||
cairo_translate(tcairodata->context, (double)coffset->p_x,
|
||
(double)coffset->p_y);
|
||
}
|
||
cairo_restore(tcairodata->context);
|
||
}
|
||
|
||
#endif /* VECTOR_FONTS */
|
||
|
||
/*---------------------------------------------------------
|
||
* grtcairoPutText:
|
||
*
|
||
* This routine puts a chunk of text on the screen in the current
|
||
* color, size, etc. The caller must ensure that it fits on
|
||
* the screen -- no clipping is done except to the obscuring rectangle
|
||
* list and the clip rectangle.
|
||
*
|
||
* Results:
|
||
* none.
|
||
*
|
||
* Side Effects:
|
||
* The text is drawn on the screen.
|
||
*
|
||
*---------------------------------------------------------
|
||
*/
|
||
|
||
void
|
||
grtcairoPutText (text, pos, clip, obscure)
|
||
char *text; /* The text to be drawn. */
|
||
Point *pos; /* A point located at the leftmost point of
|
||
* the baseline for this string.
|
||
*/
|
||
Rect *clip; /* A rectangle to clip against */
|
||
LinkedRect *obscure; /* A list of obscuring rectangles */
|
||
|
||
{
|
||
Rect location;
|
||
Rect overlap;
|
||
Rect textrect;
|
||
LinkedRect *ob;
|
||
void grTCairoGeoSub();
|
||
int i;
|
||
float tscale;
|
||
TCairoData *tcairodata = (TCairoData *)tcairoCurrent.mw->w_grdata2;
|
||
|
||
GrTCairoTextSize(text, tcairoCurrent.fontSize, &textrect);
|
||
|
||
location.r_xbot = pos->p_x + textrect.r_xbot;
|
||
location.r_xtop = pos->p_x + textrect.r_xtop;
|
||
location.r_ybot = pos->p_y + textrect.r_ybot;
|
||
location.r_ytop = pos->p_y + textrect.r_ytop;
|
||
|
||
/* erase parts of the bitmap that are obscured */
|
||
for (ob = obscure; ob != NULL; ob = ob->r_next)
|
||
{
|
||
if (GEO_TOUCH(&ob->r_r, &location))
|
||
{
|
||
overlap = location;
|
||
GeoClip(&overlap, &ob->r_r);
|
||
grTCairoGeoSub(&location, &overlap);
|
||
}
|
||
}
|
||
|
||
overlap = location;
|
||
GeoClip(&overlap, clip);
|
||
|
||
if ((overlap.r_xbot < overlap.r_xtop) && (overlap.r_ybot <= overlap.r_ytop))
|
||
{
|
||
cairo_save(tcairodata->context);
|
||
/* Clip text to the clip rectangle */
|
||
cairo_rectangle(tcairodata->context,
|
||
(double)clip->r_xbot, (double)clip->r_ybot,
|
||
(double)(clip->r_xtop - clip->r_xbot),
|
||
(double)(clip->r_ytop - clip->r_ybot));
|
||
cairo_clip(tcairodata->context);
|
||
cairo_move_to(tcairodata->context, (double)location.r_xbot,
|
||
(double)location.r_ybot);
|
||
/* The cairo coordinate system is upside-down, so invert */
|
||
cairo_scale(tcairodata->context, 1.0, -1.0);
|
||
cairo_set_operator(tcairodata->context, CAIRO_OPERATOR_SOURCE);
|
||
cairo_show_text(tcairodata->context, text);
|
||
cairo_fill(tcairodata->context);
|
||
cairo_restore(tcairodata->context);
|
||
}
|
||
}
|
||
|
||
|
||
/* grTCairoGeoSub:
|
||
* return the tallest sub-rectangle of r not obscured by area
|
||
* area must be within r.
|
||
*/
|
||
|
||
void
|
||
grTCairoGeoSub(r, area)
|
||
Rect *r; /* Rectangle to be subtracted from. */
|
||
Rect *area; /* Area to be subtracted. */
|
||
|
||
{
|
||
if (r->r_xbot == area->r_xbot) r->r_xbot = area->r_xtop;
|
||
else if (r->r_xtop == area->r_xtop) r->r_xtop = area->r_xbot;
|
||
else if (r->r_ybot <= area->r_ybot) r->r_ybot = area->r_ytop;
|
||
else if (r->r_ytop == area->r_ytop) r->r_ytop = area->r_ybot;
|
||
else
|
||
r->r_xtop = area->r_xbot;
|
||
}
|