void pango_render_text_shadow(cairo_t *context, PangoLayout *layout)
{
cairo_push_group(context);
cairo_new_path(context);
cairo_move_to(context, 15.0+8.0, 10.0+8.0);
pango_cairo_layout_path(context, layout);
cairo_set_line_width(context, 6.0);
cairo_set_miter_limit(context, 2.0);
cairo_set_source_rgb(context, 0.0, 0.0, 0.0);
cairo_stroke_preserve(context);
cairo_fill(context);
cairo_pop_group_to_source(context);
cairo_paint_with_alpha(context, 0.6);
cairo_new_path(context);
cairo_move_to(context, 15.0, 10.0);
pango_cairo_layout_path(context, layout);
cairo_set_line_width(context, 6.0);
cairo_set_miter_limit(context, 2.0);
cairo_set_source_rgb(context, 0.0, 0.3, 0.9);
cairo_stroke_preserve(context);
cairo_set_source_rgb(context, 0.9, 0.1, 0.8);
cairo_fill(context);
}
void CairoRenderer::RenderPage(const Dictionary *pPage, double dWidth, double dHeight)
{
cairo_surface_t *pSurface;
char str[32];
pSurface = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, dWidth, dHeight);
m_pCairo = cairo_create(pSurface);
cairo_set_source_rgba(m_pCairo, 1.0, 1.0, 1.0, 1.0);
cairo_paint(m_pCairo);
m_pStrokeColor[0] = 0.0;
m_pStrokeColor[1] = 0.0;
m_pStrokeColor[2] = 0.0;
cairo_set_source_rgba(m_pCairo, 0.0, 0.0, 0.0, 1.0);
cairo_set_line_width(m_pCairo, 0.5);
cairo_set_miter_limit(m_pCairo, 10.0);
m_nTextMode = 0;
m_dTextLead = 0.0;
m_pFontMatrix = new cairo_matrix_t;
cairo_translate(m_pCairo, 0, dHeight);
cairo_scale(m_pCairo, 1.0, -1.0);
Renderer::RenderPage(pPage, dWidth, dHeight);
sprintf(str, "%d.png", m_nPage);
cairo_surface_write_to_png(pSurface, str);
delete m_pFontMatrix;
cairo_destroy(m_pCairo);
cairo_surface_destroy(pSurface);
}
static cairo_test_status_t
draw (cairo_t *cr, int width, int height)
{
cairo_translate (cr, PAD, PAD);
/* Paint background white, then draw in black. */
cairo_set_source_rgb (cr, 1.0, 1.0, 1.0); /* white */
cairo_paint (cr);
cairo_set_source_rgb (cr, 0.0, 0.0, 0.0); /* black */
cairo_set_line_cap (cr, CAIRO_LINE_CAP_BUTT);
cairo_set_line_width (cr, LINE_WIDTH);
/* The default miter limit value of 10.0 guarantees that
* right-angle turns, (in fact, any angle greater than 11
* degrees), gets a miter rather than a bevel join. The
* rectilinear stroke optimization was originally written in a
* buggy way that did not respect the miter limit, (that is,
* inappropriately drawing miter joins when the miter limit would
* turn them into bevels). So we draw here with a miter limit of
* 1.0 to force all miter joins into bevels. */
cairo_set_line_join (cr, CAIRO_LINE_JOIN_MITER);
cairo_set_miter_limit (cr, 1.0);
cairo_move_to (cr, LINE_WIDTH / 2.0, LINE_WIDTH);
cairo_rel_line_to (cr, 0, - LINE_WIDTH / 2.0);
cairo_rel_line_to (cr, LINE_WIDTH / 2.0, 0);
cairo_stroke (cr);
return CAIRO_TEST_SUCCESS;
}
void uiDrawStroke(uiDrawContext *c, uiDrawPath *path, uiDrawBrush *b, uiDrawStrokeParams *p)
{
cairo_pattern_t *pat;
runPath(path, c->cr);
pat = mkbrush(b);
cairo_set_source(c->cr, pat);
switch (p->Cap) {
case uiDrawLineCapFlat:
cairo_set_line_cap(c->cr, CAIRO_LINE_CAP_BUTT);
break;
case uiDrawLineCapRound:
cairo_set_line_cap(c->cr, CAIRO_LINE_CAP_ROUND);
break;
case uiDrawLineCapSquare:
cairo_set_line_cap(c->cr, CAIRO_LINE_CAP_SQUARE);
break;
}
switch (p->Join) {
case uiDrawLineJoinMiter:
cairo_set_line_join(c->cr, CAIRO_LINE_JOIN_MITER);
cairo_set_miter_limit(c->cr, p->MiterLimit);
break;
case uiDrawLineJoinRound:
cairo_set_line_join(c->cr, CAIRO_LINE_JOIN_ROUND);
break;
case uiDrawLineJoinBevel:
cairo_set_line_join(c->cr, CAIRO_LINE_JOIN_BEVEL);
break;
}
cairo_set_line_width(c->cr, p->Thickness);
cairo_set_dash(c->cr, p->Dashes, p->NumDashes, p->DashPhase);
cairo_stroke(c->cr);
cairo_pattern_destroy(pat);
}
void GraphicsContext::setMiterLimit(float miter)
{
if (paintingDisabled())
return;
cairo_set_miter_limit(m_data->cr, miter);
}
static VALUE
cr_set_miter_limit (VALUE self, VALUE limit)
{
cairo_set_miter_limit (_SELF, NUM2DBL (limit));
cr_check_status (_SELF);
return self;
}
void GraphicsContext::setMiterLimit(float miter)
{
if (paintingDisabled())
return;
cairo_set_miter_limit(platformContext()->cr(), miter);
}
static int cairo_set_miter_limit_l( lua_State* L )
{
lua_cairo_t* lc = lua_cairo_check( L, 1 );
cairo_set_miter_limit( lc->cairo,
luaL_checknumber( L, 2 ) ); /* limit */
return( 0 );
}
JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_GdkGraphics2D_cairoSetMiterLimit
(JNIEnv *env, jobject obj, jdouble miter)
{
struct graphics2d *gr = NULL;
gr = (struct graphics2d *) NSA_GET_G2D_PTR (env, obj);
g_assert (gr != NULL);
if (gr->debug) printf ("cairo_set_miter_limit %f\n", miter);
cairo_set_miter_limit (gr->cr, miter);
}
static PyObject *
pycairo_set_miter_limit (PycairoContext *o, PyObject *args) {
double limit;
if (!PyArg_ParseTuple (args, "d:Context.set_miter_limit", &limit))
return NULL;
cairo_set_miter_limit (o->ctx, limit);
RETURN_NULL_IF_CAIRO_CONTEXT_ERROR(o->ctx);
Py_RETURN_NONE;
}
static PyObject *
pycairo_set_miter_limit (PycairoContext *o, PyObject *args)
{
double limit;
if (!PyArg_ParseTuple (args, "d:Context.set_miter_limit", &limit))
return NULL;
cairo_set_miter_limit (o->ctx, limit);
if (Pycairo_Check_Status (cairo_status (o->ctx)))
return NULL;
Py_RETURN_NONE;
}
static void
settings_set (cairo_t *cr, const settings_t *settings)
{
cairo_set_operator (cr, settings->op);
cairo_set_tolerance (cr, settings->tolerance);
cairo_set_fill_rule (cr, settings->fill_rule);
cairo_set_line_width (cr, settings->line_width);
cairo_set_line_cap (cr, settings->line_cap);
cairo_set_line_join (cr, settings->line_join);
cairo_set_miter_limit (cr, settings->miter_limit);
cairo_set_matrix (cr, &settings->matrix);
cairo_set_dash (cr, settings->dash, 5, settings->dash_offset);
}
JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_GdkGraphics2D_cairoSetMiterLimit
(JNIEnv *env, jobject obj, jdouble miter)
{
struct graphics2d *gr = NULL;
gdk_threads_enter();
if (peer_is_disposed(env, obj)) { gdk_threads_leave(); return; }
gr = (struct graphics2d *) NSA_GET_G2D_PTR (env, obj);
g_assert (gr != NULL);
if (gr->debug) printf ("cairo_set_miter_limit %f\n", miter);
cairo_set_miter_limit (gr->cr, miter);
gdk_threads_leave();
}
void copyContextProperties(cairo_t* srcCr, cairo_t* dstCr)
{
cairo_set_antialias(dstCr, cairo_get_antialias(srcCr));
size_t dashCount = cairo_get_dash_count(srcCr);
Vector<double> dashes(dashCount);
double offset;
cairo_get_dash(srcCr, dashes.data(), &offset);
cairo_set_dash(dstCr, dashes.data(), dashCount, offset);
cairo_set_line_cap(dstCr, cairo_get_line_cap(srcCr));
cairo_set_line_join(dstCr, cairo_get_line_join(srcCr));
cairo_set_line_width(dstCr, cairo_get_line_width(srcCr));
cairo_set_miter_limit(dstCr, cairo_get_miter_limit(srcCr));
cairo_set_fill_rule(dstCr, cairo_get_fill_rule(srcCr));
}
void pango_render_text_border(cairo_t *context, PangoLayout *layout)
{
cairo_new_path(context);
cairo_move_to(context, 15.0, 10.0);
pango_cairo_layout_path(context, layout);
cairo_set_line_width(context, 6.0);
cairo_set_miter_limit(context, 2.0);
cairo_set_source_rgb(context, 0.0, 0.3, 0.9);
cairo_stroke_preserve(context);
cairo_set_source_rgb(context, 0.9, 0.1, 0.8);
cairo_fill(context);
}
static void
_adg_apply(AdgStyle *style, AdgEntity *entity, cairo_t *cr)
{
AdgLineStylePrivate *data = ((AdgLineStyle *) style)->data;
adg_entity_apply_dress(entity, data->color_dress, cr);
cairo_set_line_width(cr, data->width);
cairo_set_line_cap(cr, data->cap);
cairo_set_line_join(cr, data->join);
cairo_set_miter_limit(cr, data->miter_limit);
cairo_set_antialias(cr, data->antialias);
if (data->dash != NULL) {
cairo_set_dash(cr,
adg_dash_get_dashes(data->dash),
adg_dash_get_num_dashes(data->dash),
adg_dash_get_offset(data->dash));
}
}
void CairoRenderer::SetGraphicsState(const char *pName)
{
const Dictionary *pGState;
int i, n;
const Object *pObj;
double v;
pGState = (const Dictionary *)GetResource(EXTGSTATE, pName);
n = pGState->GetSize();
for (i = 0; i < n; i++)
{
pName = pGState->GetName(i);
pObj = pGState->GetValue(pName);
if (pObj->GetType() == Object::OBJ_NUMERIC)
v = ((const Numeric *)pObj)->GetValue();
if (strcmp(pName, "Type") == 0)
assert(strcmp(((const String *)pObj)->GetValue(), "ExtGState") == 0);
else if (strcmp(pName, "LW") == 0)
cairo_set_line_width(m_pCairo, v + 0.5);
else if (strcmp(pName, "LC") == 0)
cairo_set_line_cap(m_pCairo, (cairo_line_cap_t)v);
else if (strcmp(pName, "LJ") == 0)
cairo_set_line_join(m_pCairo, (cairo_line_join_t)v);
else if (strcmp(pName, "ML") == 0)
cairo_set_miter_limit(m_pCairo, v);
else if (strcmp(pName, "D") == 0)
SetDash(((const Array *)pObj)->GetValue(0), ((Array *)pObj)->GetValue(1));
else if (strcmp(pName, "RI") == 0)
SetIntent(((const Name *)pObj)->GetValue());
else
{
//not implemented
#ifdef DEBUG_OPERATOR
printf("Not implemented: %s:%d %s\n", __func__, __LINE__, pName);
#endif
}
}
}
/**
* gimp_scan_convert_render_full:
* @sc: a #GimpScanConvert context
* @buffer: the #GeglBuffer to render to
* @off_x: horizontal offset into the @buffer
* @off_y: vertical offset into the @buffer
* @replace: if true the original content of the @buffer gets estroyed
* @antialias: if true the rendering happens antialiased
* @value: value to use for covered pixels
*
* This function renders the area described by the path to the
* @buffer, taking the offset @off_x and @off_y in the buffer into
* account. The rendering can happen antialiased and be rendered on
* top of existing content or replacing it completely. The @value
* specifies the opacity value to be used for the objects in the @sc.
*
* You cannot add additional polygons after this command.
*/
void
gimp_scan_convert_render_full (GimpScanConvert *sc,
GeglBuffer *buffer,
gint off_x,
gint off_y,
gboolean replace,
gboolean antialias,
gdouble value)
{
const Babl *format;
GeglBufferIterator *iter;
GeglRectangle *roi;
cairo_t *cr;
cairo_surface_t *surface;
cairo_path_t path;
gint bpp;
gint x, y;
gint width, height;
g_return_if_fail (sc != NULL);
g_return_if_fail (GEGL_IS_BUFFER (buffer));
x = 0;
y = 0;
width = gegl_buffer_get_width (buffer);
height = gegl_buffer_get_height (buffer);
if (sc->clip && ! gimp_rectangle_intersect (x, y, width, height,
sc->clip_x, sc->clip_y,
sc->clip_w, sc->clip_h,
&x, &y, &width, &height))
return;
path.status = CAIRO_STATUS_SUCCESS;
path.data = (cairo_path_data_t *) sc->path_data->data;
path.num_data = sc->path_data->len;
format = babl_format ("Y u8");
bpp = babl_format_get_bytes_per_pixel (format);
iter = gegl_buffer_iterator_new (buffer, NULL, 0, format,
GEGL_BUFFER_READWRITE, GEGL_ABYSS_NONE);
roi = &iter->roi[0];
while (gegl_buffer_iterator_next (iter))
{
guchar *data = iter->data[0];
guchar *tmp_buf = NULL;
const gint stride = cairo_format_stride_for_width (CAIRO_FORMAT_A8,
roi->width);
/* cairo rowstrides are always multiples of 4, whereas
* maskPR.rowstride can be anything, so to be able to create an
* image surface, we maybe have to create our own temporary
* buffer
*/
if (roi->width * bpp != stride)
{
tmp_buf = g_alloca (stride * roi->height);
if (! replace)
{
const guchar *src = data;
guchar *dest = tmp_buf;
gint i;
for (i = 0; i < roi->height; i++)
{
memcpy (dest, src, roi->width * bpp);
src += roi->width * bpp;
dest += stride;
}
}
}
surface = cairo_image_surface_create_for_data (tmp_buf ?
tmp_buf : data,
CAIRO_FORMAT_A8,
roi->width, roi->height,
stride);
cairo_surface_set_device_offset (surface,
-off_x - roi->x,
-off_y - roi->y);
cr = cairo_create (surface);
cairo_set_operator (cr, CAIRO_OPERATOR_SOURCE);
if (replace)
{
cairo_set_source_rgba (cr, 0, 0, 0, 0);
cairo_paint (cr);
}
cairo_set_source_rgba (cr, 0, 0, 0, value);
cairo_append_path (cr, &path);
cairo_set_antialias (cr, antialias ?
CAIRO_ANTIALIAS_GRAY : CAIRO_ANTIALIAS_NONE);
cairo_set_miter_limit (cr, sc->miter);
if (sc->do_stroke)
{
cairo_set_line_cap (cr,
sc->cap == GIMP_CAP_BUTT ? CAIRO_LINE_CAP_BUTT :
sc->cap == GIMP_CAP_ROUND ? CAIRO_LINE_CAP_ROUND :
CAIRO_LINE_CAP_SQUARE);
cairo_set_line_join (cr,
sc->join == GIMP_JOIN_MITER ? CAIRO_LINE_JOIN_MITER :
sc->join == GIMP_JOIN_ROUND ? CAIRO_LINE_JOIN_ROUND :
CAIRO_LINE_JOIN_BEVEL);
cairo_set_line_width (cr, sc->width);
if (sc->dash_info)
cairo_set_dash (cr,
(double *) sc->dash_info->data,
sc->dash_info->len,
sc->dash_offset);
cairo_scale (cr, 1.0, sc->ratio_xy);
cairo_stroke (cr);
}
else
{
cairo_set_fill_rule (cr, CAIRO_FILL_RULE_EVEN_ODD);
cairo_fill (cr);
}
cairo_destroy (cr);
cairo_surface_destroy (surface);
if (tmp_buf)
{
const guchar *src = tmp_buf;
guchar *dest = data;
gint i;
for (i = 0; i < roi->height; i++)
{
memcpy (dest, src, roi->width * bpp);
src += stride;
dest += roi->width * bpp;
}
}
}
}
void lime_cairo_set_miter_limit (value handle, double miterLimit) {
cairo_set_miter_limit ((cairo_t*)val_data (handle), miterLimit);
}
void cairo_context::set_miter_limit(double limit)
{
cairo_set_miter_limit(cairo_.get(), limit);
check_object_status_and_throw_exception(*this);
}
void lime_cairo_set_miter_limit (double handle, double miterLimit) {
cairo_set_miter_limit ((cairo_t*)(intptr_t)handle, miterLimit);
}
void gfxContext::SetMiterLimit(gfxFloat limit)
{
cairo_set_miter_limit(mCairo, limit);
}
static int
cr_set_miter_limit (lua_State *L) {
cairo_t **obj = luaL_checkudata(L, 1, OOCAIRO_MT_NAME_CONTEXT);
cairo_set_miter_limit(*obj, luaL_checknumber(L, 2));
return 0;
}
static void
render (GtkWidget * widget)
{
GSMColorButton *color_button = GSM_COLOR_BUTTON (widget);
GdkColor *color, tmp_color = color_button->priv->color;
color = &tmp_color;
cairo_t *cr = gdk_cairo_create (gtk_widget_get_window (widget));
cairo_path_t *path = NULL;
gint width, height;
gdouble radius, arc_start, arc_end;
gint highlight_factor;
if (color_button->priv->highlight > 0) {
highlight_factor = 8192 * color_button->priv->highlight;
if (color->red + highlight_factor > 65535)
color->red = 65535;
else
color->red = color->red + highlight_factor;
if (color->blue + highlight_factor > 65535)
color->blue = 65535;
else
color->blue = color->blue + highlight_factor;
if (color->green + highlight_factor > 65535)
color->green = 65535;
else
color->green = color->green + highlight_factor;
}
gdk_cairo_set_source_color (cr, color);
gdk_drawable_get_size (gtk_widget_get_window (widget), &width, &height);
switch (color_button->priv->type)
{
case GSMCP_TYPE_CPU:
//gtk_widget_set_size_request (widget, GSMCP_MIN_WIDTH, GSMCP_MIN_HEIGHT);
cairo_paint (cr);
cairo_set_line_width (cr, 1);
cairo_set_source_rgba (cr, 0, 0, 0, 0.5);
cairo_rectangle (cr, 0.5, 0.5, width - 1, height - 1);
cairo_stroke (cr);
cairo_set_line_width (cr, 1);
cairo_set_source_rgba (cr, 1, 1, 1, 0.4);
cairo_rectangle (cr, 1.5, 1.5, width - 3, height - 3);
cairo_stroke (cr);
break;
case GSMCP_TYPE_PIE:
if (width < 32) // 32px minimum size
gtk_widget_set_size_request (widget, 32, 32);
if (width < height)
radius = width / 2;
else
radius = height / 2;
arc_start = -G_PI_2 + 2 * G_PI * color_button->priv->fraction;
arc_end = -G_PI_2;
cairo_set_line_width (cr, 1);
// Draw external stroke and fill
if (color_button->priv->fraction < 0.01) {
cairo_arc (cr, (width / 2) + .5, (height / 2) + .5, 4.5,
0, 2 * G_PI);
} else if (color_button->priv->fraction > 0.99) {
cairo_arc (cr, (width / 2) + .5, (height / 2) + .5, radius - 2.25,
0, 2 * G_PI);
} else {
cairo_arc_negative (cr, (width / 2) + .5, (height / 2) + .5, radius - 2.25,
arc_start, arc_end);
cairo_arc_negative (cr, (width / 2) + .5, (height / 2) + .5, 4.5,
arc_end, arc_start);
cairo_arc_negative (cr, (width / 2) + .5, (height / 2) + .5, radius - 2.25,
arc_start, arc_start);
}
cairo_fill_preserve (cr);
cairo_set_source_rgba (cr, 0, 0, 0, 0.7);
cairo_stroke (cr);
// Draw internal highlight
cairo_set_source_rgba (cr, 1, 1, 1, 0.45);
cairo_set_line_width (cr, 1);
if (color_button->priv->fraction < 0.03) {
cairo_arc (cr, (width / 2) + .5, (height / 2) + .5, 3.25,
0, 2 * G_PI);
} else if (color_button->priv->fraction > 0.99) {
cairo_arc (cr, (width / 2) + .5, (height / 2) + .5, radius - 3.5,
0, 2 * G_PI);
} else {
cairo_arc_negative (cr, (width / 2) + .5, (height / 2) + .5, radius - 3.5,
arc_start + (1 / (radius - 3.75)),
arc_end - (1 / (radius - 3.75)));
cairo_arc_negative (cr, (width / 2) + .5, (height / 2) + .5, 3.25,
arc_end - (1 / (radius - 3.75)),
arc_start + (1 / (radius - 3.75)));
cairo_arc_negative (cr, (width / 2) + .5, (height / 2) + .5, radius - 3.5,
arc_start + (1 / (radius - 3.75)),
arc_start + (1 / (radius - 3.75)));
}
cairo_stroke (cr);
// Draw external shape
cairo_set_line_width (cr, 1);
cairo_set_source_rgba (cr, 0, 0, 0, 0.2);
cairo_arc (cr, (width / 2) + .5, (height / 2) + .5, radius - 1.25, 0,
G_PI * 2);
cairo_stroke (cr);
break;
case GSMCP_TYPE_NETWORK_IN:
if (color_button->priv->image_buffer == NULL)
color_button->priv->image_buffer =
fill_image_buffer_from_file (cr, DATADIR "/pixmaps/gnome-system-monitor/download.svg");
gtk_widget_set_size_request (widget, 32, 32);
cairo_move_to (cr, 8.5, 1.5);
cairo_line_to (cr, 23.5, 1.5);
cairo_line_to (cr, 23.5, 11.5);
cairo_line_to (cr, 29.5, 11.5);
cairo_line_to (cr, 16.5, 27.5);
cairo_line_to (cr, 15.5, 27.5);
cairo_line_to (cr, 2.5, 11.5);
cairo_line_to (cr, 8.5, 11.5);
cairo_line_to (cr, 8.5, 1.5);
cairo_close_path (cr);
path = cairo_copy_path (cr);
cairo_set_line_cap (cr, CAIRO_LINE_CAP_SQUARE);
cairo_set_line_join (cr, CAIRO_LINE_JOIN_MITER);
cairo_set_line_width (cr, 1);
cairo_fill_preserve (cr);
cairo_set_miter_limit (cr, 5.0);
cairo_stroke (cr);
cairo_set_source_rgba (cr, 0, 0, 0, 0.5);
cairo_append_path (cr, path);
cairo_path_destroy(path);
cairo_stroke (cr);
cairo_set_source_surface (cr, color_button->priv->image_buffer, 0.0,
0.0);
cairo_paint (cr);
break;
case GSMCP_TYPE_NETWORK_OUT:
if (color_button->priv->image_buffer == NULL)
color_button->priv->image_buffer =
fill_image_buffer_from_file (cr, DATADIR "/pixmaps/gnome-system-monitor/upload.svg");
gtk_widget_set_size_request (widget, 32, 32);
cairo_move_to (cr, 16.5, 1.5);
cairo_line_to (cr, 29.5, 17.5);
cairo_line_to (cr, 23.5, 17.5);
cairo_line_to (cr, 23.5, 27.5);
cairo_line_to (cr, 8.5, 27.5);
cairo_line_to (cr, 8.5, 17.5);
cairo_line_to (cr, 2.5, 17.5);
cairo_line_to (cr, 15.5, 1.5);
cairo_line_to (cr, 16.5, 1.5);
cairo_close_path (cr);
path = cairo_copy_path (cr);
cairo_set_line_cap (cr, CAIRO_LINE_CAP_SQUARE);
cairo_set_line_join (cr, CAIRO_LINE_JOIN_MITER);
cairo_set_line_width (cr, 1);
cairo_fill_preserve (cr);
cairo_set_miter_limit (cr, 5.0);
cairo_stroke (cr);
cairo_set_source_rgba (cr, 0, 0, 0, 0.5);
cairo_append_path (cr, path);
cairo_path_destroy(path);
cairo_stroke (cr);
cairo_set_source_surface (cr, color_button->priv->image_buffer, 0.0,
0.0);
cairo_paint (cr);
break;
}
cairo_destroy (cr);
}
void Context::setMiterLimit( double limit )
{
cairo_set_miter_limit( mCairo, limit );
}
//TODO: move to cache class
void wxGISDisplay::SetMiterLimit(double dMiterLimit)
{
wxCriticalSectionLocker locker(m_CritSect);
cairo_set_miter_limit(m_saLayerCaches[m_nCurrentLayer].pCairoContext, dMiterLimit);
}
GpStatus
gdip_pen_setup (GpGraphics *graphics, GpPen *pen)
{
GpStatus status;
cairo_matrix_t product;
double widthx;
if (!graphics || !pen)
return InvalidParameter;
status = gdip_brush_setup (graphics, pen->brush);
if (status != Ok)
return status;
cairo_matrix_init_identity (&product);
/* Here we use product of pen->matrix and graphics->copy_of_ctm.
* This gives us absolute results with respect to graphics. We
* do following irrespective of the pen->changed state since graphics
* has its own matrix and we need to multiply that with pen->matrix
* every time we perform stroke operations. Graphics matrix gets
* reset to its own state after stroking.
*/
cairo_matrix_multiply (&product, &pen->matrix, graphics->copy_of_ctm);
/* Pen scaling by 0 are supported by MS GDI+ but would error in Cairo, see bug #338233 */
if (gdip_near_zero (product.xx) || gdip_near_zero (product.yy)) {
/* *both* X and Y are affected if either is 0 */
product.xx = product.yy = 0.0001f;
}
cairo_set_matrix (graphics->ct, &product);
/* Don't need to setup, if pen is the same as the cached pen and
* it is not changed. Just comparing pointers may not be sufficient
* to say that the pens are same. It is possible to have different
* pen on the same memory, but probability is very low. We would
* need a function to check the equality of the pens in that case.
*/
if (pen == graphics->last_pen && !pen->changed)
return Ok;
if (pen->width < 1.0) { /* we draw a pixel wide line if width is < 1.0 */
double widthy = 1.0;
widthx = 1.0;
cairo_device_to_user_distance (graphics->ct, &widthx, &widthy);
} else {
widthx = (double) pen->width;
}
cairo_set_line_width (graphics->ct, widthx);
cairo_set_miter_limit (graphics->ct, (double) pen->miter_limit);
cairo_set_line_join (graphics->ct, convert_line_join (pen->line_join));
cairo_set_line_cap (graphics->ct, convert_line_cap (pen));
if (pen->dash_count > 0) {
double *dash_array;
/* note: pen->width may be different from what was used to
call cairo_set_line_width, e.g. 0.0 (#78742) */
dash_array = convert_dash_array (pen->dash_array, widthx, pen->dash_count);
if (!dash_array)
return OutOfMemory;
cairo_set_dash (graphics->ct, dash_array, pen->dash_count, pen->dash_offset);
GdipFree (dash_array);
} else /* Clear the dashes, if set in previous calls */
cairo_set_dash (graphics->ct, NULL, 0, 0);
/* We are done with using all the changes in the pen. */
pen->changed = FALSE;
graphics->last_pen = pen;
return gdip_get_status (cairo_status (graphics->ct));
}
static cairo_test_status_t
draw (cairo_t *cr, int width, int height)
{
const cairo_test_context_t *ctx = cairo_test_get_context (cr);
cairo_surface_t *surface;
cairo_t *cr2;
const char *phase;
const char string[] = "The quick brown fox jumps over the lazy dog.";
cairo_text_extents_t extents, scaled_font_extents;
cairo_status_t status;
int errors = 0;
surface = cairo_surface_create_similar (cairo_get_group_target (cr),
CAIRO_CONTENT_COLOR, 100, 100);
/* don't use cr accidentally */
cr = NULL;
cr2 = cairo_create (surface);
cairo_surface_destroy (surface);
cairo_set_line_width (cr2, 10);
cairo_set_line_join (cr2, CAIRO_LINE_JOIN_MITER);
cairo_set_miter_limit (cr2, 100);
phase = "No path";
errors += !check_extents (ctx, phase, cr2, FILL, EQUALS, 0, 0, 0, 0);
errors += !check_extents (ctx, phase, cr2, STROKE, EQUALS, 0, 0, 0, 0);
errors += !check_extents (ctx, phase, cr2, PATH, EQUALS, 0, 0, 0, 0);
cairo_save (cr2);
cairo_new_path (cr2);
cairo_move_to (cr2, 200, 400);
cairo_rel_line_to (cr2, 0., 0.);
phase = "Degenerate line";
errors += !check_extents (ctx, phase, cr2, FILL, EQUALS, 0, 0, 0, 0);
errors += !check_extents (ctx, phase, cr2, STROKE, EQUALS, 0, 0, 0, 0);
errors += !check_extents (ctx, phase, cr2, PATH, EQUALS, 200, 400, 0, 0);
cairo_new_path (cr2);
cairo_move_to (cr2, 200, 400);
cairo_rel_curve_to (cr2, 0., 0., 0., 0., 0., 0.);
phase = "Degenerate curve";
errors += !check_extents (ctx, phase, cr2, FILL, EQUALS, 0, 0, 0, 0);
errors += !check_extents (ctx, phase, cr2, STROKE, EQUALS, 0, 0, 0, 0);
errors += !check_extents (ctx, phase, cr2, PATH, EQUALS, 200, 400, 0, 0);
cairo_new_path (cr2);
cairo_arc (cr2, 200, 400, 0., 0, 2 * M_PI);
phase = "Degenerate arc (R=0)";
errors += !check_extents (ctx, phase, cr2, FILL, EQUALS, 0, 0, 0, 0);
errors += !check_extents (ctx, phase, cr2, STROKE, EQUALS, 0, 0, 0, 0);
errors += !check_extents (ctx, phase, cr2, PATH, EQUALS, 200, 400, 0, 0);
cairo_new_path (cr2);
cairo_arc (cr2, 200, 400, 10., 0, 0);
phase = "Degenerate arc (Θ=0)";
errors += !check_extents (ctx, phase, cr2, FILL, EQUALS, 0, 0, 0, 0);
errors += !check_extents (ctx, phase, cr2, STROKE, EQUALS, 0, 0, 0, 0);
errors += !check_extents (ctx, phase, cr2, PATH, EQUALS, 200, 400, 0, 0);
cairo_new_path (cr2);
cairo_restore (cr2);
/* Test that with CAIRO_LINE_CAP_ROUND, we get "dots" from
* cairo_move_to; cairo_rel_line_to(0,0) */
cairo_save (cr2);
cairo_set_line_cap (cr2, CAIRO_LINE_CAP_ROUND);
cairo_set_line_width (cr2, 20);
cairo_move_to (cr2, 200, 400);
cairo_rel_line_to (cr2, 0, 0);
phase = "Single 'dot'";
errors += !check_extents (ctx, phase, cr2, FILL, EQUALS, 0, 0, 0, 0);
errors += !check_extents (ctx, phase, cr2, STROKE, EQUALS, 190, 390, 20, 20);
errors += !check_extents (ctx, phase, cr2, PATH, EQUALS, 200, 400, 0, 0);
/* Add another dot without starting a new path */
cairo_move_to (cr2, 100, 500);
cairo_rel_line_to (cr2, 0, 0);
phase = "Multiple 'dots'";
errors += !check_extents (ctx, phase, cr2, FILL, EQUALS, 0, 0, 0, 0);
errors += !check_extents (ctx, phase, cr2, STROKE, EQUALS, 90, 390, 120, 120);
errors += !check_extents (ctx, phase, cr2, PATH, EQUALS, 100, 400, 100, 100);
cairo_new_path (cr2);
cairo_restore (cr2);
/* http://bugs.freedesktop.org/show_bug.cgi?id=7965 */
phase = "A vertical, open path";
cairo_save (cr2);
cairo_set_line_cap (cr2, CAIRO_LINE_CAP_ROUND);
cairo_set_line_join (cr2, CAIRO_LINE_JOIN_ROUND);
cairo_move_to (cr2, 0, 180);
cairo_line_to (cr2, 750, 180);
errors += !check_extents (ctx, phase, cr2, FILL, EQUALS, 0, 0, 0, 0);
errors += !check_extents (ctx, phase, cr2, STROKE, EQUALS, -5, 175, 760, 10);
errors += !check_extents (ctx, phase, cr2, PATH, EQUALS, 0, 180, 755, 0);
cairo_new_path (cr2);
cairo_restore (cr2);
phase = "Simple rect";
cairo_save (cr2);
cairo_rectangle (cr2, 10, 10, 80, 80);
errors += !check_extents (ctx, phase, cr2, FILL, EQUALS, 10, 10, 80, 80);
errors += !check_extents (ctx, phase, cr2, STROKE, EQUALS, 5, 5, 90, 90);
errors += !check_extents (ctx, phase, cr2, PATH, EQUALS, 10, 10, 80, 80);
cairo_new_path (cr2);
cairo_restore (cr2);
phase = "Two rects";
cairo_save (cr2);
cairo_rectangle (cr2, 10, 10, 10, 10);
cairo_rectangle (cr2, 20, 20, 10, 10);
errors += !check_extents (ctx, phase, cr2, FILL, EQUALS, 10, 10, 20, 20);
errors += !check_extents (ctx, phase, cr2, STROKE, EQUALS, 5, 5, 30, 30);
errors += !check_extents (ctx, phase, cr2, PATH, EQUALS, 10, 10, 20, 20);
cairo_new_path (cr2);
cairo_restore (cr2);
phase = "Triangle";
cairo_save (cr2);
cairo_move_to (cr2, 10, 10);
cairo_line_to (cr2, 90, 90);
cairo_line_to (cr2, 90, 10);
cairo_close_path (cr2);
/* miter joins protrude 5*(1+sqrt(2)) above the top-left corner and to
the right of the bottom-right corner */
errors += !check_extents (ctx, phase, cr2, FILL, EQUALS, 10, 10, 80, 80);
errors += !check_extents (ctx, phase, cr2, STROKE, CONTAINS, 0, 5, 95, 95);
errors += !check_extents (ctx, phase, cr2, PATH, CONTAINS, 10, 10, 80, 80);
cairo_new_path (cr2);
cairo_restore (cr2);
cairo_save (cr2);
cairo_set_line_width (cr2, 4);
cairo_rectangle (cr2, 10, 10, 30, 30);
cairo_rectangle (cr2, 25, 10, 15, 30);
cairo_set_fill_rule (cr2, CAIRO_FILL_RULE_EVEN_ODD);
phase = "EVEN_ODD overlapping rectangles";
errors += !check_extents (ctx, phase, cr2, FILL, EQUALS, 10, 10, 15, 30);
errors += !check_extents (ctx, phase, cr2, STROKE, EQUALS, 8, 8, 34, 34);
errors += !check_extents (ctx, phase, cr2, PATH, EQUALS, 10, 10, 30, 30);
/* Test other fill rule with the same path. */
cairo_set_fill_rule (cr2, CAIRO_FILL_RULE_WINDING);
phase = "WINDING overlapping rectangles";
errors += !check_extents (ctx, phase, cr2, FILL, EQUALS, 10, 10, 30, 30);
errors += !check_extents (ctx, phase, cr2, STROKE, EQUALS, 8, 8, 34, 34);
errors += !check_extents (ctx, phase, cr2, PATH, EQUALS, 10, 10, 30, 30);
/* Now, change the direction of the second rectangle and test both
* fill rules again. */
cairo_new_path (cr2);
cairo_rectangle (cr2, 10, 10, 30, 30);
cairo_rectangle (cr2, 25, 40, 15, -30);
cairo_set_fill_rule (cr2, CAIRO_FILL_RULE_EVEN_ODD);
phase = "EVEN_ODD overlapping rectangles";
errors += !check_extents (ctx, phase, cr2, FILL, EQUALS, 10, 10, 15, 30);
errors += !check_extents (ctx, phase, cr2, STROKE, EQUALS, 8, 8, 34, 34);
errors += !check_extents (ctx, phase, cr2, PATH, EQUALS, 10, 10, 30, 30);
/* Test other fill rule with the same path. */
cairo_set_fill_rule (cr2, CAIRO_FILL_RULE_WINDING);
phase = "WINDING overlapping rectangles";
errors += !check_extents (ctx, phase, cr2, FILL, EQUALS, 10, 10, 15, 30);
errors += !check_extents (ctx, phase, cr2, STROKE, EQUALS, 8, 8, 34, 34);
errors += !check_extents (ctx, phase, cr2, PATH, EQUALS, 10, 10, 30, 30);
cairo_new_path (cr2);
cairo_restore (cr2);
/* http://bugs.freedesktop.org/show_bug.cgi?id=7245 */
phase = "Arc";
cairo_save (cr2);
cairo_arc (cr2, 250.0, 250.0, 157.0, 5.147, 3.432);
cairo_set_line_width (cr2, 154.0);
errors += !check_extents (ctx, phase, cr2, STROKE, APPROX_EQUALS, 16, 38, 468, 446);
cairo_new_path (cr2);
cairo_restore (cr2);
phase = "Text";
cairo_save (cr2);
cairo_select_font_face (cr2, "Bitstream Vera Sans",
CAIRO_FONT_SLANT_NORMAL,
CAIRO_FONT_WEIGHT_NORMAL);
cairo_set_font_size (cr2, 12);
cairo_text_extents (cr2, string, &extents);
/* double check that the two methods of measuring the text agree... */
cairo_scaled_font_text_extents (cairo_get_scaled_font (cr2),
string,
&scaled_font_extents);
if (memcmp (&extents, &scaled_font_extents, sizeof (extents))) {
cairo_test_log (ctx, "Error: cairo_text_extents() does not match cairo_scaled_font_text_extents() - font extents (%f, %f) x (%f, %f) should be (%f, %f) x (%f, %f)\n",
scaled_font_extents.x_bearing,
scaled_font_extents.y_bearing,
scaled_font_extents.width,
scaled_font_extents.height,
extents.x_bearing,
extents.y_bearing,
extents.width,
extents.height);
errors++;
}
cairo_move_to (cr2, -extents.x_bearing, -extents.y_bearing);
cairo_text_path (cr2, string);
cairo_set_line_width (cr2, 2.0);
/* XXX: We'd like to be able to use EQUALS here, but currently
* when hinting is enabled freetype returns integer extents. See
* http://cairographics.org/todo */
errors += !check_extents (ctx, phase, cr2, FILL, APPROX_EQUALS,
0, 0, extents.width, extents.height);
errors += !check_extents (ctx, phase, cr2, STROKE, APPROX_EQUALS,
-1, -1, extents.width+2, extents.height+2);
errors += !check_extents (ctx, phase, cr2, PATH, APPROX_EQUALS,
0, 0, extents.width, extents.height);
cairo_new_path (cr2);
cairo_restore (cr2);
phase = "User space, simple scale, getting extents with same transform";
cairo_save (cr2);
cairo_scale (cr2, 2, 2);
cairo_rectangle (cr2, 5, 5, 40, 40);
errors += !check_extents (ctx, phase, cr2, FILL, EQUALS, 5, 5, 40, 40);
errors += !check_extents (ctx, phase, cr2, STROKE, EQUALS, 0, 0, 50, 50);
errors += !check_extents (ctx, phase, cr2, PATH, EQUALS, 5, 5, 40, 40);
cairo_new_path (cr2);
cairo_restore (cr2);
phase = "User space, simple scale, getting extents with no transform";
cairo_save (cr2);
cairo_save (cr2);
cairo_scale (cr2, 2, 2);
cairo_rectangle (cr2, 5, 5, 40, 40);
cairo_restore (cr2);
errors += !check_extents (ctx, phase, cr2, FILL, EQUALS, 10, 10, 80, 80);
errors += !check_extents (ctx, phase, cr2, STROKE, EQUALS, 5, 5, 90, 90);
errors += !check_extents (ctx, phase, cr2, PATH, EQUALS, 10, 10, 80, 80);
cairo_new_path (cr2);
cairo_restore (cr2);
phase = "User space, rotation, getting extents with transform";
cairo_save (cr2);
cairo_rectangle (cr2, -50, -50, 50, 50);
cairo_rotate (cr2, -M_PI/4);
/* the path in user space is now (nearly) the square rotated by
45 degrees about the origin. Thus its x1 and x2 are both nearly 0.
This should show any bugs where we just transform device-space
x1,y1 and x2,y2 to get the extents. */
/* The largest axis-aligned square inside the rotated path has
side lengths 50*sqrt(2), so a bit over 35 on either side of
the axes. With the stroke width added to the rotated path,
the largest axis-aligned square is a bit over 38 on either side of
the axes. */
errors += !check_extents (ctx, phase, cr2, FILL, CONTAINS, -35, -35, 35, 35);
errors += !check_extents (ctx, phase, cr2, STROKE, CONTAINS, -38, -38, 38, 38);
errors += !check_extents (ctx, phase, cr2, PATH, CONTAINS, -35, -35, 35, 35);
cairo_new_path (cr2);
cairo_restore (cr2);
status = cairo_status (cr2);
cairo_destroy (cr2);
if (status)
return cairo_test_status_from_status (ctx, status);
return errors == 0 ? CAIRO_TEST_SUCCESS : CAIRO_TEST_FAILURE;
}
NS_METHOD
compzillaRenderingContext::SetDimensions (PRInt32 width, PRInt32 height)
{
DEBUG ("SetDimensions (%d,%d)\n", width, height);
Destroy();
#if false
// Check that the dimensions are sane
if (!CheckSaneImageSize(width, height))
return NS_ERROR_FAILURE;
#endif
mWidth = width;
mHeight = height;
#ifdef MOZ_CAIRO_GFX
DEBUG ("thebes\n");
mThebesSurface = gfxPlatform::GetPlatform()->CreateOffscreenSurface(gfxIntSize (width, height), gfxASurface::ImageFormatARGB32);
mThebesContext = new gfxContext(mThebesSurface);
mSurface = mThebesSurface->CairoSurface();
cairo_surface_reference(mSurface);
mCairo = mThebesContext->GetCairo();
cairo_reference(mCairo);
DEBUG ("/thebes\n");
#else
// non-cairo gfx
// On most current X servers, using the software-only surface
// actually provides a much smoother and faster display.
// However, we provide MOZ_CANVAS_USE_RENDER for whomever wants to
// go that route.
//if (getenv("MOZ_CANVAS_USE_RENDER")) {
XRenderPictFormat *fmt = XRenderFindStandardFormat (GDK_DISPLAY(),
PictStandardARGB32);
if (fmt) {
int npfmts = 0;
XPixmapFormatValues *pfmts = XListPixmapFormats(GDK_DISPLAY(), &npfmts);
for (int i = 0; i < npfmts; i++) {
if (pfmts[i].depth == 32) {
npfmts = -1;
break;
}
}
XFree(pfmts);
if (npfmts == -1) {
mSurfacePixmap = XCreatePixmap (GDK_DISPLAY(),
DefaultRootWindow(GDK_DISPLAY()),
width, height, 32);
mSurface = cairo_xlib_surface_create_with_xrender_format
(GDK_DISPLAY(), mSurfacePixmap, DefaultScreenOfDisplay(GDK_DISPLAY()),
fmt, mWidth, mHeight);
}
}
//}
// fall back to image surface
if (!mSurface) {
mImageSurfaceData = (PRUint8*) PR_Malloc (mWidth * mHeight * 4);
if (!mImageSurfaceData)
return NS_ERROR_OUT_OF_MEMORY;
mSurface = cairo_image_surface_create_for_data (mImageSurfaceData,
CAIRO_FORMAT_ARGB32,
mWidth, mHeight,
mWidth * 4);
}
mCairo = cairo_create(mSurface);
#endif
cairo_set_operator(mCairo, CAIRO_OPERATOR_CLEAR);
cairo_new_path(mCairo);
cairo_rectangle(mCairo, 0, 0, mWidth, mHeight);
cairo_fill(mCairo);
cairo_set_line_width(mCairo, 1.0);
cairo_set_operator(mCairo, CAIRO_OPERATOR_OVER);
cairo_set_miter_limit(mCairo, 10.0);
cairo_set_line_cap(mCairo, CAIRO_LINE_CAP_BUTT);
cairo_set_line_join(mCairo, CAIRO_LINE_JOIN_MITER);
cairo_new_path(mCairo);
return NS_OK;
}
void CairoRenderer::RenderOperator(const Operator *pOp, const Object **pParams, int nParams)
{
const char *cstr;
double x, y;
double v[6];
int i, n;
const Object *pObj;
const Stream *pStream;
const Dictionary *pDict;
cairo_matrix_t matrix;
int nWidth, nHeight;
cairo_surface_t *pSurface;
cstr = pOp->GetValue();
if (strchr("fFbBW", *cstr) != NULL)
if (cstr[1] == '\0')
cairo_set_fill_rule(m_pCairo, CAIRO_FILL_RULE_WINDING);
else if (cstr[1] == '*')
cairo_set_fill_rule(m_pCairo, CAIRO_FILL_RULE_EVEN_ODD);
if (*cstr == 'b') //close, fill, and stroke
{
cairo_close_path(m_pCairo);
cairo_fill(m_pCairo);
Stroke();
}
else if (strcmp(cstr, "B") == 0 || strcmp(cstr, "B*") == 0) //fill and stroke
{
cairo_fill(m_pCairo);
Stroke();
}
else if (strcmp(cstr, "BDC") == 0)
{
NOT_IMPLEMENTED;
}
else if (strcmp(cstr, "BI") == 0)
{
NOT_IMPLEMENTED;
}
else if (strcmp(cstr, "BMC") == 0)
{
NOT_IMPLEMENTED;
}
else if (strcmp(cstr, "BT") == 0)
{
cairo_save(m_pCairo);
cairo_move_to(m_pCairo, 0.0, 0.0);
m_cairo_face = NULL;
}
else if (strcmp(cstr, "BX") == 0)
{
NOT_IMPLEMENTED;
}
else if (strcmp(cstr, "c") == 0) //curve to
{
ConvertNumeric(pParams, nParams, v);
cairo_curve_to(m_pCairo, v[0], v[1], v[2], v[3], v[4], v[5]);
}
else if (strcmp(cstr, "cm") == 0) //concat
{
ConvertNumeric(pParams, nParams, v);
cairo_matrix_init(&matrix, v[0], v[1], v[2], v[3], v[4], v[5]);
cairo_transform(m_pCairo, &matrix);
}
else if (strcmp(cstr, "CS") == 0) //color space
{
NOT_IMPLEMENTED;
}
else if (strcmp(cstr, "cs") == 0) //color space
{
NOT_IMPLEMENTED;
}
else if (strcmp(cstr, "d") == 0) //line dash
SetDash(pParams[0], pParams[1]);
else if (strcmp(cstr, "d0") == 0)
{
NOT_IMPLEMENTED;
}
else if (strcmp(cstr, "d1") == 0)
{
NOT_IMPLEMENTED;
}
else if (strcmp(cstr, "Do") == 0)
{
pStream = (const Stream *)GetResource(XOBJECT, ((Name *)pParams[0])->GetValue());
pDict = pStream->GetDictionary();
pObj = pDict->GetValue("Subtype");
if (strcmp(((const Name *)pObj)->GetValue(), "Image") == 0)
{
nWidth = ((const Numeric *)pDict->GetValue("Width"))->GetValue();
nHeight = ((const Numeric *)pDict->GetValue("Height"))->GetValue();
cairo_matrix_init(&matrix, 1.0 / nWidth, 0.0, 0.0, -1.0 / nHeight, 0.0, 1.0);
cairo_save(m_pCairo);
cairo_transform(m_pCairo, &matrix);
cairo_rectangle(m_pCairo, 0.0, 0.0, nWidth, nHeight);
cairo_clip(m_pCairo);
pSurface = CreateImageSurface(pStream, nWidth, nHeight);
cairo_set_source_surface(m_pCairo, pSurface, 0.0, 0.0);
cairo_paint(m_pCairo);
cairo_surface_destroy(pSurface);
cairo_restore(m_pCairo);
}
}
else if (strcmp(cstr, "DP") == 0)
{
NOT_IMPLEMENTED;
}
else if (strcmp(cstr, "EI") == 0)
{
NOT_IMPLEMENTED;
}
else if (strcmp(cstr, "EMC") == 0)
{
NOT_IMPLEMENTED;
}
else if (strcmp(cstr, "ET") == 0)
{
cairo_restore(m_pCairo);
if (m_cairo_face)
{
cairo_set_font_face(m_pCairo, NULL);
cairo_font_face_destroy(m_cairo_face);
}
}
else if (strcmp(cstr, "EX") == 0)
{
NOT_IMPLEMENTED;
}
else if (*cstr == 'f' || *cstr == 'F') //fill
cairo_fill(m_pCairo);
else if (strcmp(cstr, "G") == 0)
{
ConvertNumeric(pParams, nParams, v);
m_pStrokeColor[0] = v[0];
m_pStrokeColor[1] = v[0];
m_pStrokeColor[2] = v[0];
}
else if (strcmp(cstr, "g") == 0)
{
ConvertNumeric(pParams, nParams, v);
cairo_set_source_rgba(m_pCairo, v[0], v[0], v[0], 1.0);
}
else if (strcmp(cstr, "gs") == 0) //set graphics state
SetGraphicsState(((const Name *)pParams[0])->GetValue());
else if (strcmp(cstr, "h") == 0) //close subpath
cairo_close_path(m_pCairo);
else if (strcmp(cstr, "i") == 0) //flatness tolerance
{
ConvertNumeric(pParams, nParams, v);
cairo_set_tolerance(m_pCairo, v[0]);
}
else if (strcmp(cstr, "ID") == 0)
{
NOT_IMPLEMENTED;
}
else if (strcmp(cstr, "j") == 0) //line join
{
ConvertNumeric(pParams, nParams, v);
cairo_set_line_join(m_pCairo, (cairo_line_join_t)v[0]);
}
else if (strcmp(cstr, "J") == 0) //line cap
{
ConvertNumeric(pParams, nParams, v);
cairo_set_line_cap(m_pCairo, (cairo_line_cap_t)v[0]);
}
else if (strcmp(cstr, "K") == 0)
{
ConvertNumeric(pParams, nParams, v);
m_pStrokeColor[0] = (1.0 - v[0]) * (1.0 - v[3]);
m_pStrokeColor[1] = (1.0 - v[1]) * (1.0 - v[3]);
m_pStrokeColor[2] = (1.0 - v[2]) * (1.0 - v[3]);
}
else if (strcmp(cstr, "k") == 0)
{
ConvertNumeric(pParams, nParams, v);
cairo_set_source_rgba(m_pCairo, (1.0 - v[0]) * (1.0 - v[3]), (1.0 - v[1]) * (1.0 - v[3]), (1.0 - v[2]) * (1.0 - v[3]), 1.0);
}
else if (strcmp(cstr, "l") == 0) //line to
{
ConvertNumeric(pParams, nParams, v);
cairo_line_to(m_pCairo, v[0], v[1]);
}
else if (strcmp(cstr, "m") == 0) //new sub path
{
ConvertNumeric(pParams, nParams, v);
cairo_move_to(m_pCairo, v[0], v[1]);
}
else if (strcmp(cstr, "M") == 0) //miter limit
{
ConvertNumeric(pParams, nParams, v);
cairo_set_miter_limit(m_pCairo, v[0]);
}
else if (strcmp(cstr, "MP") == 0)
{
NOT_IMPLEMENTED;
}
else if (strcmp(cstr, "n") == 0) //end path
cairo_new_path(m_pCairo);
else if (strcmp(cstr, "q") == 0) //save graphics state
cairo_save(m_pCairo);
else if (strcmp(cstr, "Q") == 0) //restore graphics state
cairo_restore(m_pCairo);
else if (strcmp(cstr, "re") == 0) //rectangle
{
ConvertNumeric(pParams, nParams, v);
cairo_rectangle(m_pCairo, v[0], v[1], v[2], v[3]);
}
else if (strcmp(cstr, "RG") == 0)
{
ConvertNumeric(pParams, nParams, m_pStrokeColor);
}
else if (strcmp(cstr, "rg") == 0)
{
ConvertNumeric(pParams, nParams, v);
cairo_set_source_rgba(m_pCairo, v[0], v[1], v[2], 1.0);
}
else if (strcmp(cstr, "ri") == 0) //color rendering intent
SetIntent(((const Name *)pParams[0])->GetValue());
else if (strcmp(cstr, "s") == 0) //close and stroke
{
cairo_close_path(m_pCairo);
Stroke();
}
else if (strcmp(cstr, "S") == 0) //stroke
Stroke();
else if (strcmp(cstr, "SC") == 0)
{
NOT_IMPLEMENTED;
}
else if (strcmp(cstr, "sc") == 0)
{
NOT_IMPLEMENTED;
}
else if (strcmp(cstr, "SCN") == 0)
{
NOT_IMPLEMENTED;
}
else if (strcmp(cstr, "scn") == 0)
{
NOT_IMPLEMENTED;
}
else if (strcmp(cstr, "sh") == 0)
{
NOT_IMPLEMENTED;
}
else if (strcmp(cstr, "T*") == 0)
{
cairo_translate(m_pCairo, 0.0, -m_dTextLead);
cairo_move_to(m_pCairo, 0.0, 0.0);
}
else if (strcmp(cstr, "Tc") == 0)
{
NOT_IMPLEMENTED;
}
else if (strcmp(cstr, "Td") == 0)
{
ConvertNumeric(pParams, nParams, v);
cairo_translate(m_pCairo, v[0], v[1]);
cairo_move_to(m_pCairo, 0.0, 0.0);
}
else if (strcmp(cstr, "TD") == 0)
{
ConvertNumeric(pParams, nParams, v);
cairo_translate(m_pCairo, v[0], v[1]);
cairo_move_to(m_pCairo, 0.0, 0.0);
m_dTextLead = -v[1];
}
else if (strcmp(cstr, "Tf") == 0)
{
ChangeFont(((const Name *)pParams[0])->GetValue());
SetFontFace(m_pFontData->GetFontFile());
ConvertNumeric(pParams + 1, nParams - 1, v);
cairo_matrix_init_scale(m_pFontMatrix, v[0], -v[0]);
cairo_set_font_matrix(m_pCairo, m_pFontMatrix);
}
else if (strcmp(cstr, "Tj") == 0)
RenderString((const String *)pParams[0]);
else if (strcmp(cstr, "TJ") == 0)
{
n = ((const Array *)pParams[0])->GetSize();
for (i = 0; i < n; i++)
{
pObj = ((const Array *)pParams[0])->GetValue(i);
if (pObj->GetType() == Object::OBJ_STRING)
RenderString((const String *)pObj);
else if (pObj->GetType() == Object::OBJ_NUMERIC)
cairo_translate(m_pCairo, -((const Numeric *)pObj)->GetValue() / 1000.0, 0.0);
}
}
else if (strcmp(cstr, "TL") == 0)
{
ConvertNumeric(pParams, nParams, v);
m_dTextLead = v[0];
}
else if (strcmp(cstr, "Tm") == 0)
{
ConvertNumeric(pParams, nParams, v);
cairo_matrix_init(&matrix, v[0], v[1], v[2], v[3], v[4], v[5]);
cairo_matrix_multiply(&matrix, m_pFontMatrix, &matrix);
cairo_set_font_matrix(m_pCairo, &matrix);
cairo_move_to(m_pCairo, 0.0, 0.0);
}
else if (strcmp(cstr, "Tr") == 0)
{
ConvertNumeric(pParams, nParams, v);
m_nTextMode = v[0];
}
else if (strcmp(cstr, "Ts") == 0)
{
NOT_IMPLEMENTED;
}
else if (strcmp(cstr, "Tw") == 0)
{
NOT_IMPLEMENTED;
}
else if (strcmp(cstr, "Tz") == 0)
{
ConvertNumeric(pParams, nParams, v);
cairo_scale(m_pCairo, v[0] / 100.0, 1.0);
}
else if (strcmp(cstr, "v") == 0) //curve to
{
ConvertNumeric(pParams, nParams, v);
cairo_get_current_point(m_pCairo, &x, &y);
cairo_curve_to(m_pCairo, x, y, v[0], v[1], v[2], v[3]);
}
else if (strcmp(cstr, "w") == 0) //line width
{
ConvertNumeric(pParams, nParams, v);
cairo_set_line_width(m_pCairo, v[0] + 0.5);
}
else if (*cstr == 'W') //clipping path
cairo_clip(m_pCairo);
else if (strcmp(cstr, "y") == 0) //curve to
{
ConvertNumeric(pParams, nParams, v);
cairo_curve_to(m_pCairo, v[0], v[1], v[2], v[3], v[2], v[3]);
}
else if (strcmp(cstr, "'") == 0)
{
cairo_translate(m_pCairo, 0.0, -m_dTextLead);
cairo_move_to(m_pCairo, 0.0, 0.0);
RenderString((const String *)pParams[0]);
}
else if (strcmp(cstr, "\"") == 0)
{
cairo_translate(m_pCairo, 0.0, -m_dTextLead);
cairo_move_to(m_pCairo, 0.0, 0.0);
RenderString((const String *)pParams[2]);
}
else
{
assert(false);
}
}
