Esempio n. 1
0
static cairo_test_status_t
draw (cairo_t *cr, int width, int height)
{
    cairo_surface_t *surface;
    uint32_t data[16] = {
        0xffffffff, 0xffffffff,		0xffff0000, 0xffff0000,
        0xffffffff, 0xffffffff,		0xffff0000, 0xffff0000,

        0xff00ff00, 0xff00ff00,		0xff0000ff, 0xff0000ff,
        0xff00ff00, 0xff00ff00,		0xff0000ff, 0xff0000ff
    };

    surface = cairo_image_surface_create_for_data ((unsigned char *) data,
              CAIRO_FORMAT_RGB24, 4, 4, 16);

    /* We use a non-zero offset larger than the source surface size to
     * stress cairo out a bit more. */
    cairo_set_source_surface (cr, surface, 10, 10);
    cairo_pattern_set_filter (cairo_get_source (cr), CAIRO_FILTER_NEAREST);
    cairo_pattern_set_extend (cairo_get_source (cr), CAIRO_EXTEND_REPEAT);
    cairo_paint (cr);

    cairo_surface_destroy (surface);

    return CAIRO_TEST_SUCCESS;
}
Esempio n. 2
0
static cairo_test_status_t
draw (cairo_t *cr, int width, int height)
{
    cairo_surface_t *image;
    cairo_t *cr2;

    image = cairo_image_surface_create (CAIRO_FORMAT_RGB24, 2, 2);

    /* Fill with an opaque background to avoid a separate rgb24 ref image */
    cairo_set_source_rgb (cr, 0, 0, 0);
    cairo_paint (cr);

    /* First check handling of pattern extents > surface extents */
    cairo_save (cr);
    cairo_scale (cr, width/2., height/2.);

    /* Create a solid black source to merge with the background */
    cr2 = cairo_create (image);
    cairo_set_source_rgb (cr2, 0, 0 ,0);
    cairo_paint (cr2);
    cairo_set_source_surface (cr, cairo_get_target (cr2), 0, 0);
    cairo_destroy (cr2);
    cairo_pattern_set_filter (cairo_get_source (cr), CAIRO_FILTER_BILINEAR);
    cairo_paint (cr);
    cairo_restore (cr);

    /* Then scale to smaller so we can see the full bilinear extents */
    cairo_save (cr);
    cairo_translate (cr, PAD, PAD);
    cairo_scale (cr, SCALE, SCALE);
    cairo_translate (cr, 0.5, 0.5);

    /* Create a 2x2 blue+red checkerboard source */
    cr2 = cairo_create (image);
    cairo_set_source_rgb (cr2, 1, 0 ,0); /* red */
    cairo_paint (cr2);
    cairo_set_source_rgb (cr2, 0, 0, 1); /* blue */
    cairo_rectangle (cr2, 0, 1, 1, 1);
    cairo_rectangle (cr2, 1, 0, 1, 1);
    cairo_fill (cr2);
    cairo_set_source_surface (cr, cairo_get_target (cr2), 0, 0);
    cairo_destroy (cr2);

    cairo_pattern_set_filter (cairo_get_source (cr), CAIRO_FILTER_BILINEAR);
    cairo_paint (cr);
    cairo_restore (cr);

    cairo_surface_destroy (image);

    return CAIRO_TEST_SUCCESS;
}
Esempio n. 3
0
void CairoDevice::PushPenColor( const VGColor & color)
{
	double r, g, b, a;
	cairo_pattern_get_rgba (cairo_get_source(fNativeDevice), &r, &g, &b, &a);	
	fPenColorStack.push (VGColor(cc2c(r), cc2c(g), cc2c(b), cc2c(a))); 
	SelectPenColor (color);
}
Esempio n. 4
0
cairo_surface_t *
BitmapSource::GetSurface (cairo_t *cr)
{
	if (image_surface == NULL)
		return NULL;

	if (native_surface)
		return native_surface;
	
	if (cr == NULL)
		return image_surface;

	native_surface = cairo_surface_create_similar (cairo_get_group_target (cr), 
						       cairo_surface_get_content (image_surface), 
						       GetPixelWidth (), GetPixelHeight ());

	cairo_t *context = cairo_create (native_surface);

	cairo_set_source_surface (context, image_surface, 0, 0);
	cairo_pattern_set_filter (cairo_get_source (context), CAIRO_FILTER_FAST);

	cairo_paint (context);
	cairo_destroy (context);

	return native_surface;
}
Esempio n. 5
0
/* Scale the surface with the width and height requested */
cairo_surface_t *
scale_surface      (cairo_surface_t  *surface,
                    gdouble           width,
                    gdouble           height)
{
  gdouble old_width = cairo_image_surface_get_width (surface);
  gdouble old_height = cairo_image_surface_get_height (surface);
	
  cairo_surface_t *new_surface = cairo_surface_create_similar(surface, CAIRO_CONTENT_COLOR_ALPHA, width, height);
  cairo_t *cr = cairo_create (new_surface);

  /* Scale *before* setting the source surface (1) */
  cairo_scale (cr, width / old_width, height / old_height);
  cairo_set_source_surface (cr, surface, 0, 0);

  /* To avoid getting the edge pixels blended with 0 alpha, which would 
   * occur with the default EXTEND_NONE. Use EXTEND_PAD for 1.2 or newer (2)
   */
  cairo_pattern_set_extend (cairo_get_source(cr), CAIRO_EXTEND_REFLECT); 

  /* Replace the destination with the source instead of overlaying */
  cairo_set_operator (cr, CAIRO_OPERATOR_SOURCE);

  /* Do the actual drawing */
  cairo_paint (cr);
   
  cairo_destroy (cr);

  return new_surface;
}
Esempio n. 6
0
	value lime_cairo_get_source (value handle) {
		
		cairo_pattern_t* pattern = cairo_get_source ((cairo_t*)val_data (handle));
		cairo_pattern_reference (pattern);
		return CFFIPointer (pattern, gc_cairo_pattern);
		
	}
Esempio n. 7
0
static VALUE
cr_get_source (VALUE self)
{
  VALUE rb_source = Qnil;
  cairo_pattern_t *source;
  source = cairo_get_source (_SELF);

  if (source)
    {
      rb_cairo_check_status (cairo_pattern_status (source));
      rb_source = rb_ivar_get (self, cr_id_source);
      if (NIL_P (rb_source) || RVAL2CRPATTERN (rb_source) != source)
        {
          rb_source = CRPATTERN2RVAL (source);
          rb_ivar_set (self, cr_id_source, rb_source);
        }
    }
  else
    {
      rb_source = Qnil;
      rb_ivar_set (self, cr_id_source, rb_source);
    }

  return rb_source;
}
Esempio n. 8
0
static void matenu_menu_bar_reset_bg_pixmap (MatenuMenuBar* self) {
	GdkPixmap* pixmap;
	cairo_t* cairo;
	cairo_pattern_t* pattern;
	GtkStyle* style;
	GdkPixmap* _tmp0_;
	g_return_if_fail (self != NULL);
	if (matenu_menu_bar_get_background (self)->type != MATENU_BACKGROUND_TYPE_PIXMAP) {
		return;
	}
	if (!GTK_WIDGET_REALIZED ((GtkWidget*) self)) {
		return;
	}
	g_assert (GDK_IS_DRAWABLE (((GtkWidget*) self)->window));
	g_assert (GDK_IS_DRAWABLE (self->priv->_background->pixmap));
	pixmap = gdk_pixmap_new ((GdkDrawable*) ((GtkWidget*) self)->window, ((GtkWidget*) self)->allocation.width, ((GtkWidget*) self)->allocation.height, -1);
	g_assert (GDK_IS_DRAWABLE (pixmap));
	cairo = gdk_cairo_create ((GdkDrawable*) pixmap);
	g_assert (cairo != NULL);
	gdk_cairo_set_source_pixmap (cairo, self->priv->_background->pixmap, (double) (-self->priv->_background->offset_x), (double) (-self->priv->_background->offset_y));
	pattern = cairo_get_source (cairo);
	cairo_pattern_set_extend (pattern, CAIRO_EXTEND_REPEAT);
	cairo_rectangle (cairo, (double) 0, (double) 0, (double) ((GtkWidget*) self)->allocation.width, (double) ((GtkWidget*) self)->allocation.height);
	cairo_fill (cairo);
	style = _g_object_ref0 (gtk_widget_get_style ((GtkWidget*) self));
	style->bg_pixmap[(gint) GTK_STATE_NORMAL] = (_tmp0_ = _g_object_ref0 (pixmap), _g_object_unref0 (style->bg_pixmap[(gint) GTK_STATE_NORMAL]), _tmp0_);
	gtk_style_set_background (style, ((GtkWidget*) self)->window, GTK_STATE_NORMAL);
	gtk_widget_queue_draw ((GtkWidget*) self);
	_g_object_unref0 (style);
	_cairo_destroy0 (cairo);
	_g_object_unref0 (pixmap);
}
Esempio n. 9
0
static cairo_surface_t *
_cairo_image_surface_scale_bilinear_2x2 (cairo_surface_t *image,
				         int              new_width,
				         int              new_height)
{
	cairo_surface_t *output;
	cairo_t         *cr;

	output = cairo_image_surface_create (CAIRO_FORMAT_ARGB32,
					     new_width,
					     new_height);
	cr = cairo_create (output);
	cairo_scale (cr,
		     (double) new_width / cairo_image_surface_get_width (image),
		     (double) new_height / cairo_image_surface_get_height (image));
	cairo_set_source_surface (cr, image, 0.0, 0.0);
	cairo_pattern_set_filter (cairo_get_source (cr), CAIRO_FILTER_BILINEAR);
	cairo_rectangle (cr, 0.0, 0.0, cairo_image_surface_get_width (image), cairo_image_surface_get_height (image));
	cairo_fill (cr);
	cairo_surface_flush (output);

	cairo_destroy (cr);

	return output;
}
	cairo_surface_t* Win32UIBinding::ScaleCairoSurface(
		cairo_surface_t* oldSurface, int newWidth, int newHeight)
	{
		cairo_matrix_t scaleMatrix;
		cairo_matrix_init_scale(&scaleMatrix,
			(double) cairo_image_surface_get_width(oldSurface) / (double) newWidth,
			(double) cairo_image_surface_get_height(oldSurface) / (double) newHeight);

		cairo_pattern_t* surfacePattern = cairo_pattern_create_for_surface(oldSurface);
		cairo_pattern_set_matrix(surfacePattern, &scaleMatrix);
		cairo_pattern_set_filter(surfacePattern, CAIRO_FILTER_BEST);

		cairo_surface_t* newSurface = cairo_surface_create_similar(
			oldSurface, CAIRO_CONTENT_COLOR_ALPHA, newWidth, newHeight);
		cairo_t* cr = cairo_create(newSurface);
		cairo_set_source(cr, surfacePattern);

		/* To avoid getting the edge pixels blended with 0 alpha, which would 
		 * occur with the default EXTEND_NONE. Use EXTEND_PAD for 1.2 or newer (2) */
		cairo_pattern_set_extend(cairo_get_source(cr), CAIRO_EXTEND_REFLECT);

		 /* Replace the destination with the source instead of overlaying */
		cairo_set_operator(cr, CAIRO_OPERATOR_SOURCE);

		/* Do the actual drawing */
		cairo_paint(cr);
		cairo_destroy(cr);

		return newSurface;
	 }
Esempio n. 11
0
static JSBool
getSource_func(JSContext *context,
               unsigned   argc,
               jsval     *vp)
{
    JS::CallReceiver rec = JS::CallReceiverFromVp(vp);
    JSObject *obj = JSVAL_TO_OBJECT(rec.thisv());

    cairo_t *cr;
    cairo_pattern_t *pattern;
    JSObject *pattern_wrapper;

    if (argc > 0) {
        gjs_throw(context, "Context.getSource() takes no arguments");
        return JS_FALSE;
    }

    cr = gjs_cairo_context_get_context(context, obj);
    pattern = cairo_get_source(cr);
    if (!gjs_cairo_check_status(context, cairo_status(cr), "context"))
        return JS_FALSE;

    /* pattern belongs to the context, so keep the reference */
    pattern_wrapper = gjs_cairo_pattern_from_pattern(context, pattern);
    if (!pattern_wrapper) {
        gjs_throw(context, "failed to create pattern");
        return JS_FALSE;
    }

    rec.rval().set(OBJECT_TO_JSVAL(pattern_wrapper));

    return JS_TRUE;
}
Esempio n. 12
0
static gboolean pp_piksl_draw(GtkWidget* widget, cairo_t* cr) {

  ppPiksl* piksl = PP_PIKSL(widget);
                        
  cairo_set_source(cr, PP_APP->checker);
  
  cairo_rectangle(cr, 0, 0,
                  piksl->img_width*piksl->zoom,
                  piksl->img_height*piksl->zoom);
  cairo_fill(cr);

  // Render the graphics data...
  // Zoom the surface
  cairo_scale(cr, piksl->zoom, piksl->zoom);

  // Render each layer
  guint i;
  ppLayer* layer = NULL;
  for (i = 0; i < piksl->layers->len; ++i) {
  
    layer = g_ptr_array_index(piksl->layers, i);
    cairo_set_source_surface(cr, layer->surface, layer->x, layer->y);
    
    // Disable the gaussian filtering to preserve pixels
    cairo_pattern_set_filter(cairo_get_source(cr), CAIRO_FILTER_NEAREST);
      
    cairo_paint(cr);
  }
  
  return FALSE;
}
Esempio n. 13
0
static bool
getSource_func(JSContext *context,
               unsigned   argc,
               JS::Value *vp)
{
    GJS_GET_PRIV(context, argc, vp, rec, obj, GjsCairoContext, priv);
    cairo_t *cr = priv ? priv->cr : NULL;
    cairo_pattern_t *pattern;
    JSObject *pattern_wrapper;

    if (argc > 0) {
        gjs_throw(context, "Context.getSource() takes no arguments");
        return false;
    }

    pattern = cairo_get_source(cr);
    if (!gjs_cairo_check_status(context, cairo_status(cr), "context"))
        return false;

    /* pattern belongs to the context, so keep the reference */
    pattern_wrapper = gjs_cairo_pattern_from_pattern(context, pattern);
    if (!pattern_wrapper) {
        gjs_throw(context, "failed to create pattern");
        return false;
    }

    rec.rval().setObject(*pattern_wrapper);

    return true;
}
static cairo_test_status_t
draw (cairo_t *cr, int width, int height)
{
    cairo_surface_t *surface;
    uint32_t data[16] = {
	0x80808080, 0x80808080,		0x80800000, 0x80800000,
	0x80808080, 0x80808080,		0x80800000, 0x80800000,

	0x80008000, 0x80008000,		0x80000080, 0x80000080,
	0x80008000, 0x80008000,		0x80000080, 0x80000080
    };

    surface = cairo_image_surface_create_for_data ((unsigned char *) data,
						   CAIRO_FORMAT_ARGB32, 4, 4, 16);

    cairo_test_paint_checkered (cr);

    cairo_scale (cr, 4, 4);

    cairo_set_source_surface (cr, surface, 2 , 2);
    cairo_pattern_set_filter (cairo_get_source (cr), CAIRO_FILTER_NEAREST);
    cairo_paint (cr);

    cairo_surface_destroy (surface);

    return CAIRO_TEST_SUCCESS;
}
Esempio n. 15
0
static gint
on_draw(GtkWidget *widget, cairo_t *cr, gpointer userdata) {
	GdkPixbuf *pixbuf;
	pixbuf = gdk_pixbuf_new_from_file("/usr/share/themes/Ambiance/gtk-2.0/apps/img/panel.png", NULL);
	if (!pixbuf) {
		pixbuf = gdk_pixbuf_new_from_file("/usr/share/lxpanel/images/lubuntu-background.png", NULL);
	}
	if (!pixbuf) {
		pixbuf = gdk_pixbuf_new_from_file("/usr/share/themes/Greybird/ubiquity-panel-bg.png", NULL);
	}
	if (!pixbuf) {
		pixbuf = gdk_pixbuf_new_from_file("/usr/share/budgie-desktop/ubiquity-panel-bg.png", NULL);
	}
	if (!pixbuf) {
		pixbuf = gdk_pixbuf_new_from_file("/usr/share/ubiquity/pixmaps/panel.png", NULL);
	}
	if (pixbuf) {
		gdk_cairo_set_source_pixbuf(cr, pixbuf, 0, 0);
		cairo_pattern_set_extend(cairo_get_source(cr), CAIRO_EXTEND_PAD);
		cairo_paint(cr);
		g_object_unref(pixbuf);
	} else {
		g_warning("Could not find background image.");
	}
	struct {
		GtkWidget *container;
		cairo_t *cr;
	} data;
	data.container = widget;
	data.cr = cr;
	gtk_container_forall (GTK_CONTAINER(widget), draw_child, &data);
	return FALSE;
}
WidgetRenderingContext::~WidgetRenderingContext()
{
    // We do not need to blit back to the target in the fallback case. See above.
    RenderThemeGtk* theme = static_cast<RenderThemeGtk*>(RenderTheme::defaultTheme().get());
    if (!theme->m_themePartsHaveRGBAColormap && m_graphicsContext->gdkWindow())
        return;

    // Don't paint the results back if there was an error.
    if (m_hadError) {
        scheduleScratchBufferPurge();
        return;
    }

    // FIXME: It's unclear if it is necessary to preserve the current source here.
    cairo_t* cairoContext = m_graphicsContext->platformContext()->cr();
    RefPtr<cairo_pattern_t> previousSource(cairo_get_source(cairoContext));

    // The blit rectangle is the original target rectangle adjusted for any extra space.
    IntRect fullTargetRect(m_targetRect);
    fullTargetRect.inflateX(m_extraSpace.width());
    fullTargetRect.inflateY(m_extraSpace.height());

    gdk_cairo_set_source_pixmap(cairoContext, gScratchBuffer, fullTargetRect.x(), fullTargetRect.y());
    cairo_rectangle(cairoContext, fullTargetRect.x(), fullTargetRect.y(), fullTargetRect.width(), fullTargetRect.height());
    cairo_fill(cairoContext);
    cairo_set_source(cairoContext, previousSource.get());
    scheduleScratchBufferPurge();
}
Esempio n. 17
0
static JSBool
getSource_func(JSContext *context,
               uintN      argc,
               jsval     *vp)
{
    JSObject *obj = JS_THIS_OBJECT(context, vp);
    cairo_t *cr;
    cairo_pattern_t *pattern;
    JSObject *pattern_wrapper;

    if (argc > 0) {
        gjs_throw(context, "Context.getSource() takes no arguments");
        return JS_FALSE;
    }

    cr = gjs_cairo_context_get_context(context, obj);
    pattern = cairo_get_source(cr);
    if (!gjs_cairo_check_status(context, cairo_status(cr), "context"))
        return JS_FALSE;

    /* pattern belongs to the context, so keep the reference */
    pattern_wrapper = gjs_cairo_pattern_from_pattern(context, pattern);
    if (!pattern_wrapper) {
        gjs_throw(context, "failed to create pattern");
        return JS_FALSE;
    }

    JS_SET_RVAL(context, vp, OBJECT_TO_JSVAL(pattern_wrapper));

    return JS_TRUE;
}
Esempio n. 18
0
static cairo_test_status_t
record_replay (cairo_t *cr,
	       cairo_t *(*func)(cairo_t *,
				cairo_surface_t *(*pattern)(cairo_t *)),
	       cairo_surface_t *(*pattern)(cairo_t *),
	       int width, int height)
{
    cairo_surface_t *surface;
    int x, y;

    surface = record_get (func (record_create (cr), pattern));

    cairo_set_operator (cr, CAIRO_OPERATOR_SOURCE);
    cairo_set_source_surface (cr, surface, 0, 0);
    cairo_surface_destroy (surface);
    cairo_pattern_set_extend (cairo_get_source (cr), CAIRO_EXTEND_NONE);

    for (y = 0; y < height; y += 2) {
	for (x = 0; x < width; x += 2) {
	    cairo_rectangle (cr, x, y, 2, 2);
	    cairo_clip (cr);
	    cairo_paint (cr);
	    cairo_reset_clip (cr);
	}
    }

    return CAIRO_TEST_SUCCESS;
}
Esempio n. 19
0
static void
byzanz_layer_cursor_render (ByzanzLayer *layer,
                            cairo_t *    cr)
{
  ByzanzLayerCursor *clayer = BYZANZ_LAYER_CURSOR (layer);
  XFixesCursorImage *cursor = clayer->cursor;
  cairo_surface_t *cursor_surface;

  if (clayer->cursor == NULL)
    return;

  cursor_surface = cairo_image_surface_create_for_data ((guchar *) cursor->pixels,
      CAIRO_FORMAT_ARGB32, cursor->width * sizeof (unsigned long) / 4, cursor->height,
      cursor->width * sizeof (unsigned long));
  
  cairo_save (cr);

  cairo_translate (cr, clayer->cursor_x - cursor->xhot, clayer->cursor_y - cursor->yhot);

  /* This is neeed to map an unsigned long array to a uint32_t array */
  cairo_scale (cr, 4.0 / sizeof (unsigned long), 1);
#if G_BYTE_ORDER == G_BIG_ENDIAN
  cairo_translate (cr, (4.0 - sizeof (unsigned long)) / sizeof (unsigned long), 0);
#endif

  cairo_set_source_surface (cr, cursor_surface, 0, 0);
  /* Next line is also neeed for mapping the unsigned long array to a uint32_t array */
  cairo_pattern_set_filter (cairo_get_source (cr), CAIRO_FILTER_NEAREST);
  cairo_paint (cr);
  cairo_restore (cr);

  cairo_surface_destroy (cursor_surface);
}
Esempio n. 20
0
static cairo_test_status_t
draw (cairo_t *cr, int width, int height)
{
    const cairo_test_context_t *ctx = cairo_test_get_context (cr);
    char *filename;
    cairo_surface_t *surface;

    xasprintf (&filename, "%s/%s", ctx->srcdir,
	       "create-from-png.ref.png");

    surface = cairo_image_surface_create_from_png (filename);
    if (cairo_surface_status (surface)) {
	cairo_test_status_t result;

	result = cairo_test_status_from_status (ctx,
						cairo_surface_status (surface));
	if (result == CAIRO_TEST_FAILURE) {
	    cairo_test_log (ctx, "Error reading PNG image %s: %s\n",
			    filename,
			    cairo_status_to_string (cairo_surface_status (surface)));
	}

	free (filename);
	return result;
    }

    cairo_set_source_surface (cr, surface, 0, 0);
    cairo_pattern_set_filter (cairo_get_source (cr), CAIRO_FILTER_NEAREST);
    cairo_paint (cr);

    cairo_surface_destroy (surface);

    free (filename);
    return CAIRO_TEST_SUCCESS;
}
Esempio n. 21
0
static cairo_test_status_t
draw (cairo_t *cr, int width, int height)
{
    int i, j;
    cairo_surface_t *surface;

    surface = cairo_image_surface_create_for_data ((unsigned char *) &black_pixel,
						   CAIRO_FORMAT_ARGB32,
						   1, 1, 4);

    /* Fill background white */
    cairo_set_source_rgb (cr, 1, 1, 1);
    cairo_paint (cr);

    /* Draw in black */
    cairo_set_source_rgb (cr, 0, 0, 0);

    cairo_translate (cr, PAD, PAD);
    cairo_set_antialias (cr, CAIRO_ANTIALIAS_NONE);

    for (i = 0; i < POINTS; i++)
	for (j = 0; j < POINTS; j++) {
	    cairo_set_source_surface (cr, surface,
				      2 * i + i * STEP, 2 * j + j * STEP);
	    cairo_pattern_set_filter (cairo_get_source (cr),
				      CAIRO_FILTER_NEAREST);
	    cairo_paint (cr);
	}

    cairo_surface_destroy (surface);

    return CAIRO_TEST_SUCCESS;
}
static GdkPixmap *
tile_pixmap (GdkPixmap *pixmap,
	     int        width,
	     int        height)
{
	GdkPixmap *copy;
	cairo_t *cr;

	copy = gdk_pixmap_new (pixmap, width, height, pixmap == NULL? 24 : -1);

	cr = gdk_cairo_create (copy);

	if (pixmap != NULL) {
		cairo_pattern_t *pattern;
		gdk_cairo_set_source_pixmap (cr, pixmap, 0.0, 0.0);
		pattern = cairo_get_source (cr);
		cairo_pattern_set_extend (pattern, CAIRO_EXTEND_REPEAT);
	} else {
		GtkStyle *style;
		style = gtk_widget_get_default_style ();
		gdk_cairo_set_source_color (cr, &style->bg[GTK_STATE_NORMAL]);
	}

	cairo_paint (cr);

	if (cairo_status (cr) != CAIRO_STATUS_SUCCESS) {
		g_object_unref (copy);
		copy = NULL;
	}
	cairo_destroy (cr);

	return copy;
}
Esempio n. 23
0
cairo_surface_t *
ev_document_misc_surface_rotate_and_scale (cairo_surface_t *surface,
        gint             dest_width,
        gint             dest_height,
        gint             dest_rotation)
{
    cairo_surface_t *new_surface;
    cairo_t         *cr;
    gint             width, height;
    gint             new_width = dest_width;
    gint             new_height = dest_height;

    width = cairo_image_surface_get_width (surface);
    height = cairo_image_surface_get_height (surface);

    if (dest_width == width &&
            dest_height == height &&
            dest_rotation == 0) {
        return cairo_surface_reference (surface);
    }

    if (dest_rotation == 90 || dest_rotation == 270) {
        new_width = dest_height;
        new_height = dest_width;
    }

    new_surface = cairo_surface_create_similar (surface,
                  cairo_surface_get_content (surface),
                  new_width, new_height);

    cr = cairo_create (new_surface);
    switch (dest_rotation) {
    case 90:
        cairo_translate (cr, new_width, 0);
        break;
    case 180:
        cairo_translate (cr, new_width, new_height);
        break;
    case 270:
        cairo_translate (cr, 0, new_height);
        break;
    default:
        cairo_translate (cr, 0, 0);
    }
    cairo_rotate (cr, dest_rotation * G_PI / 180.0);

    if (dest_width != width || dest_height != height) {
        cairo_pattern_set_filter (cairo_get_source (cr), CAIRO_FILTER_BILINEAR);
        cairo_scale (cr,
                     (gdouble)dest_width / width,
                     (gdouble)dest_height / height);
    }

    cairo_set_source_surface (cr, surface, 0, 0);
    cairo_paint (cr);
    cairo_destroy (cr);

    return new_surface;
}
Esempio n. 24
0
void
cairo_test_paint_checkered (cairo_t *cr)
{
    cairo_surface_t *check;

    check = _draw_check (12, 12);

    cairo_save (cr);
    cairo_set_source_surface (cr, check, 0, 0);
    cairo_surface_destroy (check);

    cairo_pattern_set_filter (cairo_get_source (cr), CAIRO_FILTER_NEAREST);
    cairo_pattern_set_extend (cairo_get_source (cr), CAIRO_EXTEND_REPEAT);
    cairo_paint (cr);

    cairo_restore (cr);
}
Esempio n. 25
0
static int
cr_get_source (lua_State *L) {
    cairo_t **obj = luaL_checkudata(L, 1, OOCAIRO_MT_NAME_CONTEXT);
    cairo_pattern_t **pattern = create_pattern_userdata(L);
    *pattern = cairo_get_source(*obj);
    cairo_pattern_reference(*pattern);
    return 1;
}
Esempio n. 26
0
static cairo_test_status_t
draw (cairo_t *cr, int width, int height)
{
    cairo_surface_t *surface;
    uint32_t data[STAMP_WIDTH * STAMP_HEIGHT] = {
	0xffffffff, 0xffffffff,		0xffff0000, 0xffff0000,
	0xffffffff, 0xffffffff,		0xffff0000, 0xffff0000,

	0xff00ff00, 0xff00ff00,		0xff0000ff, 0xff0000ff,
	0xff00ff00, 0xff00ff00,		0xff0000ff, 0xff0000ff
    };
    int i, j;

    /* Draw reference lines where the jump should be. */
    cairo_move_to (cr, PAD + STEPS / 2 * (STAMP_WIDTH + PAD), 0);
    cairo_rel_line_to (cr, 0, IMAGE_HEIGHT);
    cairo_move_to (cr, 0, PAD + STEPS / 2 * (STAMP_HEIGHT + PAD));
    cairo_rel_line_to (cr, IMAGE_WIDTH, 0);
    cairo_set_line_width (cr, 2.0);
    cairo_stroke (cr);

    surface = cairo_image_surface_create_for_data ((unsigned char *) data,
						   CAIRO_FORMAT_RGB24,
						   STAMP_WIDTH,
						   STAMP_HEIGHT,
						   STAMP_WIDTH * 4);

    for (j=0; j < STEPS; j++) {
	double j_step;

	for (i=0; i < STEPS; i++) {
	    double i_step;

#define GENERATE_REFERENCE_IMAGE 0
#if GENERATE_REFERENCE_IMAGE
	    i_step = i >= STEPS / 2 ? 1 : 0;
	    j_step = j >= STEPS / 2 ? 1 : 0;
#else
	    i_step = i * 1.0 / STEPS;
	    j_step = j * 1.0 / STEPS;
#endif

	    cairo_save (cr);

	    cairo_set_source_surface (cr, surface,
				      PAD + i * (STAMP_WIDTH  + PAD) + i_step,
				      PAD + j * (STAMP_HEIGHT + PAD) + j_step);
	    cairo_pattern_set_filter (cairo_get_source (cr), CAIRO_FILTER_NEAREST);
	    cairo_paint (cr);

	    cairo_restore (cr);
	}
    }

    cairo_surface_destroy (surface);

    return CAIRO_TEST_SUCCESS;
}
Esempio n. 27
0
static void
hippo_canvas_image_paint_below_children(HippoCanvasBox  *box,
                                        cairo_t         *cr,
                                        HippoRectangle  *damaged_box)
{
    HippoCanvasImage *image = HIPPO_CANVAS_IMAGE(box);
    int x, y, w, h;
    int image_width, image_height;
    double xscale;
    double yscale;

    if (image->surface == NULL)
        return;

    image_width = cairo_image_surface_get_width(image->surface);
    image_height = cairo_image_surface_get_height(image->surface);

    /* Immediately short-circuit 0-sized image or scaled image,
     * which saves special cases in the math later on, in addition
     * to saving work
     */
    if (image_width == 0 || image_height == 0 ||
        image->scale_width == 0 || image->scale_height == 0)
        return;

    if (image->scale_width >= 0) {
        w = image->scale_width;
        xscale = image->scale_width / (double) image_width;
    } else {
        w = image_width;
        xscale = 1.0;
    }
    if (image->scale_height >= 0) {
        h = image->scale_height;
        yscale = image->scale_height / (double) image_height;
    } else {
        h = image_height;
        yscale = 1.0;
    }

    /* note that if an alignment is FILL the w/h will be increased
     * beyond the image's natural size, which will result in
     * a tiled image
     */
    
    hippo_canvas_box_align(box, w, h, &x, &y, &w, &h);

    cairo_rectangle(cr, x, y, w, h);
    cairo_clip(cr);

    cairo_scale (cr, xscale, yscale);
    cairo_translate (cr, x, y);
    cairo_set_source_surface(cr, image->surface, 0, 0);
    cairo_pattern_set_extend(cairo_get_source(cr), CAIRO_EXTEND_REPEAT);
    cairo_paint(cr);

    /* g_debug("cairo status %s", cairo_status_to_string(cairo_status(cr))); */
}
Esempio n. 28
0
static cairo_surface_t *
get_surface_from_pixbuf (GdkPixbuf         *pixbuf,
                         MetaImageFillType  fill_type,
                         gdouble            width,
                         gdouble            height,
                         gboolean           vertical_stripes,
                         gboolean           horizontal_stripes)
{
  gdouble pixbuf_width;
  gdouble pixbuf_height;
  cairo_surface_t *surface;
  cairo_content_t content;
  cairo_surface_t *copy;
  cairo_t *cr;

  pixbuf_width = gdk_pixbuf_get_width (pixbuf);
  pixbuf_height = gdk_pixbuf_get_height (pixbuf);
  surface = gdk_cairo_surface_create_from_pixbuf (pixbuf, 1, NULL);

  if (pixbuf_width == width && pixbuf_height == height)
    {
      return surface;
    }

  if (fill_type != META_IMAGE_FILL_TILE)
    {
      cairo_surface_t *scaled;

      scaled = scale_surface (surface, pixbuf_width, pixbuf_height,
                              width, height, vertical_stripes,
                              horizontal_stripes);

      cairo_surface_destroy (surface);
      surface = scaled;
    }

  content = CAIRO_CONTENT_COLOR_ALPHA;
  width = ceil (width);
  height = ceil (height);

  copy = cairo_surface_create_similar (surface, content, width, height);
  cr = cairo_create (copy);

  cairo_set_source_surface (cr, surface, 0, 0);

  if (fill_type == META_IMAGE_FILL_TILE ||
      vertical_stripes || horizontal_stripes)
    {
      cairo_pattern_set_extend (cairo_get_source (cr), CAIRO_EXTEND_REPEAT);
    }

  cairo_paint (cr);
  cairo_destroy (cr);

  cairo_surface_destroy (surface);

  return copy;
}
void TiledBackingStoreBackend::paintCheckerPattern(GraphicsContext* context, const FloatRect& target)
{
    PlatformContextCairo* platformContext = context->platformContext();
    cairo_t* cr = platformContext->cr();
    cairo_set_source_surface(cr, checkeredSurface(), 0, 0);
    cairo_pattern_set_extend(cairo_get_source(cr), CAIRO_EXTEND_REPEAT);
    cairo_rectangle(cr, target.x(), target.y(), target.width(), target.height());
    cairo_fill(cr);
}
Esempio n. 30
0
void CairoRenderer::Stroke(void)
{
	double r, g, b, a;

	cairo_pattern_get_rgba(cairo_get_source(m_pCairo), &r, &g, &b, &a);
	cairo_set_source_rgba(m_pCairo, m_pStrokeColor[0], m_pStrokeColor[1], m_pStrokeColor[2], 1.0);
	cairo_stroke(m_pCairo);
	cairo_set_source_rgba(m_pCairo, r, g, b, 1.0);
}