static void draw_text (cairo_t *cr) { cairo_matrix_t tm; /* skew */ cairo_matrix_init (&tm, 1, 0, -0.25, 1, 0, 0); cairo_matrix_scale (&tm, FONT_SIZE, FONT_SIZE); cairo_set_font_matrix (cr, &tm); cairo_new_path (cr); cairo_move_to (cr, 50, SIZE-PAD); cairo_show_text (cr, "A"); /* rotate and scale */ cairo_matrix_init_rotate (&tm, M_PI / 2); cairo_matrix_scale (&tm, FONT_SIZE, FONT_SIZE * 2.0); cairo_set_font_matrix (cr, &tm); cairo_new_path (cr); cairo_move_to (cr, PAD, PAD + 25); cairo_show_text (cr, "A"); cairo_matrix_init_rotate (&tm, M_PI / 2); cairo_matrix_scale (&tm, FONT_SIZE * 2.0, FONT_SIZE); cairo_set_font_matrix (cr, &tm); cairo_new_path (cr); cairo_move_to (cr, PAD, PAD + 50); cairo_show_text (cr, "A"); }
void ge_cairo_mirror (cairo_t *cr, CairoMirror mirror, gint *x, gint *y, gint *width, gint *height) { cairo_matrix_t matrix; cairo_matrix_init_identity (&matrix); cairo_translate (cr, *x, *y); *x = 0; *y = 0; if (mirror & CR_MIRROR_HORIZONTAL) { cairo_matrix_scale (&matrix, -1, 1); *x = -*width; } if (mirror & CR_MIRROR_VERTICAL) { cairo_matrix_scale (&matrix, 1, -1); *y = -*height; } cairo_transform (cr, &matrix); }
void wxGISDisplay::InitTransformMatrix(void) { m_dFrameCenterX = m_oDeviceFrameRect.GetWidth() / 2; m_dFrameCenterY = m_oDeviceFrameRect.GetHeight() / 2; double dWorldCenterX = (m_CurrentBounds.MaxX - m_CurrentBounds.MinX) / 2; double dWorldCenterY = (m_CurrentBounds.MaxY - m_CurrentBounds.MinY) / 2; //origin (UL corner) m_dOrigin_X = m_dCacheCenterX - m_dFrameCenterX; m_dOrigin_Y = m_dCacheCenterY - m_dFrameCenterY; //get scale double dScaleX = fabs(m_dFrameCenterX / dWorldCenterX); double dScaleY = fabs(m_dFrameCenterY / dWorldCenterY); m_dScale = wxMin(dScaleX, dScaleY); double dWorldDeltaX = dWorldCenterX + m_CurrentBounds.MinX; double dWorldDeltaY = dWorldCenterY + m_CurrentBounds.MinY; double dWorldDeltaXSt = m_dScale * dWorldDeltaX;// + m_dAngleRad * dWorldDeltaY; double dWorldDeltaYSt = m_dScale * dWorldDeltaY;//m_dAngleRad * dWorldDeltaX + //double dCenterX = m_dCacheCenterX - dWorldDeltaXSt;//(dWorldCenterX + m_CurrentBounds.MinX) * dScale;// //double dCenterY = m_dCacheCenterY + dWorldDeltaYSt;//(dWorldCenterY + m_CurrentBounds.MinY) * dScale;// m_dFrameXShift = m_dFrameCenterX - dWorldDeltaXSt;//(dWorldCenterX + m_CurrentBounds.MinX) * dScale;// m_dFrameYShift = m_dFrameCenterY + dWorldDeltaYSt;//(dWorldCenterY + m_CurrentBounds.MinY) * dScale;// // cairo_matrix_init (m_pMatrix, 1, 0, 0, 1, m_dCacheCenterX, m_dCacheCenterY); //cairo_matrix_init (m_pMatrix, dScale, 0.0, 0.0, -dScale, dCenterX, dCenterY); cairo_matrix_init_translate (m_pMatrix, m_dCacheCenterX, m_dCacheCenterY); //rotate //cairo_matrix_rotate(m_pMatrix, 45.0 * M_PI / 180.0); if(!IsDoubleEquil(m_dAngleRad, 0.0)) //{ //cairo_matrix_translate(m_pMatrix, dWorldDeltaXSt, dWorldDeltaYSt); cairo_matrix_rotate(m_pMatrix, m_dAngleRad); //cairo_matrix_translate(m_pMatrix, -dWorldDeltaXSt, dWorldDeltaYSt); //} //else cairo_matrix_translate(m_pMatrix, -dWorldDeltaXSt, dWorldDeltaYSt); cairo_matrix_scale(m_pMatrix, m_dScale, -m_dScale); //init matrix for Wld2DC & DC2Wld cairo_matrix_init_translate (m_pDisplayMatrix, m_dFrameCenterX, m_dFrameCenterY); if(!IsDoubleEquil(m_dAngleRad, 0.0)) cairo_matrix_rotate(m_pDisplayMatrix, m_dAngleRad); cairo_matrix_translate(m_pDisplayMatrix, -dWorldDeltaXSt, dWorldDeltaYSt); cairo_matrix_scale(m_pDisplayMatrix, m_dScale, -m_dScale); //init matrix for TransformRect cairo_matrix_init_translate (m_pDisplayMatrixNoRotate, m_dFrameCenterX, m_dFrameCenterY); cairo_matrix_translate(m_pDisplayMatrixNoRotate, -dWorldDeltaXSt, dWorldDeltaYSt); cairo_matrix_scale(m_pDisplayMatrixNoRotate, m_dScale, -m_dScale); //set matrix to all caches for(size_t i = 0; i < m_saLayerCaches.size(); ++i) cairo_set_matrix (m_saLayerCaches[i].pCairoContext, m_pMatrix); }
void draw_gdk_apply_netstate_transformation (cairo_matrix_t *fullMatrix, cairo_matrix_t *scaleMatrix, gerbv_netstate_t *state) { /* apply scale factor */ cairo_matrix_scale (fullMatrix, state->scaleA, state->scaleB); cairo_matrix_scale (scaleMatrix, state->scaleA, state->scaleB); /* apply offset */ cairo_matrix_translate (fullMatrix, state->offsetA, state->offsetB); /* apply mirror */ switch (state->mirrorState) { case GERBV_MIRROR_STATE_FLIPA: cairo_matrix_scale (fullMatrix, -1, 1); cairo_matrix_scale (scaleMatrix, -1, 1); break; case GERBV_MIRROR_STATE_FLIPB: cairo_matrix_scale (fullMatrix, 1, -1); cairo_matrix_scale (scaleMatrix, -1, 1); break; case GERBV_MIRROR_STATE_FLIPAB: cairo_matrix_scale (fullMatrix, -1, -1); cairo_matrix_scale (scaleMatrix, -1, 1); break; default: break; } /* finally, apply axis select */ if (state->axisSelect == GERBV_AXIS_SELECT_SWAPAB) { /* we do this by rotating 270 (counterclockwise, then mirroring the Y axis */ cairo_matrix_rotate (fullMatrix, 3 * M_PI / 2); cairo_matrix_scale (fullMatrix, 1, -1); } }
void _cairo_draw_film_foreground (cairo_t *cr, int x, int y, int width, int height, int thumbnail_size) { cairo_pattern_t *pattern; double film_scale; cairo_matrix_t matrix; double film_strip; /* left film strip */ pattern = _cairo_film_pattern_create (); if (thumbnail_size > 128) film_scale = 256.0 / thumbnail_size; else film_scale = 128.0 / thumbnail_size; film_strip = 9.0 / film_scale; cairo_matrix_init_identity (&matrix); cairo_matrix_scale (&matrix, film_scale, film_scale); cairo_matrix_translate (&matrix, -x, 0); cairo_pattern_set_matrix (pattern, &matrix); cairo_set_source (cr, pattern); cairo_rectangle (cr, x, y, film_strip, height); cairo_fill (cr); /* right film strip */ x = x + width - film_strip; cairo_matrix_init_identity (&matrix); cairo_matrix_scale (&matrix, film_scale, film_scale); cairo_matrix_translate (&matrix, -x, 0); cairo_pattern_set_matrix (pattern, &matrix); cairo_set_source (cr, pattern); cairo_rectangle (cr, x, y, film_strip, height); cairo_fill (cr); cairo_pattern_destroy (pattern); }
static cairo_test_status_t source (cairo_t *cr, int width, int height) { cairo_pattern_t *pattern; cairo_matrix_t mat; cairo_translate (cr, PAD, PAD); pattern = create_pattern (cr); cairo_matrix_init_identity (&mat); cairo_matrix_scale (&mat, 2, 1.5); cairo_matrix_rotate (&mat, 1); cairo_matrix_translate (&mat, -PAT_WIDTH/4.0, -PAT_WIDTH/2.0); cairo_pattern_set_matrix (pattern, &mat); cairo_pattern_set_extend (pattern, CAIRO_EXTEND_NONE); cairo_set_source (cr, pattern); cairo_set_operator (cr, CAIRO_OPERATOR_SOURCE); cairo_paint (cr); cairo_pattern_destroy (pattern); return CAIRO_TEST_SUCCESS; }
void FontPlatformData::initializeWithFontFace(cairo_font_face_t* fontFace) { cairo_font_options_t* options = getDefaultFontOptions(); cairo_matrix_t ctm; cairo_matrix_init_identity(&ctm); // Scaling a font with width zero size leads to a failed cairo_scaled_font_t instantiations. // Instead we scale we scale the font to a very tiny size and just abort rendering later on. float realSize = m_size ? m_size : 1; cairo_matrix_t fontMatrix; if (!m_pattern) cairo_matrix_init_scale(&fontMatrix, realSize, realSize); else { setCairoFontOptionsFromFontConfigPattern(options, m_pattern.get()); // FontConfig may return a list of transformation matrices with the pattern, for instance, // for fonts that are oblique. We use that to initialize the cairo font matrix. FcMatrix fontConfigMatrix, *tempFontConfigMatrix; FcMatrixInit(&fontConfigMatrix); // These matrices may be stacked in the pattern, so it's our job to get them all and multiply them. for (int i = 0; FcPatternGetMatrix(m_pattern.get(), FC_MATRIX, i, &tempFontConfigMatrix) == FcResultMatch; i++) FcMatrixMultiply(&fontConfigMatrix, &fontConfigMatrix, tempFontConfigMatrix); cairo_matrix_init(&fontMatrix, fontConfigMatrix.xx, -fontConfigMatrix.yx, -fontConfigMatrix.xy, fontConfigMatrix.yy, 0, 0); // The matrix from FontConfig does not include the scale. cairo_matrix_scale(&fontMatrix, realSize, realSize); } m_scaledFont = cairo_scaled_font_create(fontFace, &fontMatrix, &ctm, options); cairo_font_options_destroy(options); }
static cairo_status_t _cairo_type3_glyph_surface_emit_image_pattern (cairo_type3_glyph_surface_t *surface, cairo_image_surface_t *image, cairo_matrix_t *pattern_matrix) { cairo_matrix_t mat, upside_down; cairo_status_t status; if (image->width == 0 || image->height == 0) return CAIRO_STATUS_SUCCESS; mat = *pattern_matrix; /* Get the pattern space to user space matrix */ status = cairo_matrix_invert (&mat); /* cairo_pattern_set_matrix ensures the matrix is invertible */ assert (status == CAIRO_STATUS_SUCCESS); /* Make this a pattern space to Type 3 font space matrix */ cairo_matrix_multiply (&mat, &mat, &surface->cairo_to_pdf); /* PDF images are in a 1 unit by 1 unit image space. Turn the 1 by * 1 image upside down to convert to flip the Y-axis going from * cairo to PDF. Then scale the image up to the required size. */ cairo_matrix_scale (&mat, image->width, image->height); cairo_matrix_init (&upside_down, 1, 0, 0, -1, 0, 1); cairo_matrix_multiply (&mat, &upside_down, &mat); return _cairo_type3_glyph_surface_emit_image (surface, image, &mat); }
static cairo_test_status_t draw (cairo_t *cr, int width, int height) { cairo_font_face_t *font_face; cairo_font_options_t *font_options; cairo_scaled_font_t *scaled_font; cairo_matrix_t identity; cairo_matrix_t zero; cairo_matrix_init_identity(&identity); zero = identity; cairo_matrix_scale(&zero, 0, 0); font_face = cairo_get_font_face (cr); font_options = cairo_font_options_create (); cairo_get_font_options (cr, font_options); scaled_font = cairo_scaled_font_create (font_face, &identity, &zero, font_options); cairo_set_scaled_font (cr, scaled_font); cairo_show_text (cr, "Hello"); cairo_scaled_font_destroy (scaled_font); cairo_font_options_destroy (font_options); return cairo_test_status_from_status (cairo_test_get_context (cr), cairo_status(cr)); }
void FontPlatformData::initializeWithFontFace(cairo_font_face_t* fontFace) { cairo_font_options_t* options = cairo_font_options_copy(getDefaultFontOptions()); cairo_matrix_t ctm; cairo_matrix_init_identity(&ctm); cairo_matrix_t fontMatrix; if (!m_pattern) cairo_matrix_init_scale(&fontMatrix, m_size, m_size); else { setCairoFontOptionsFromFontConfigPattern(options, m_pattern.get()); // FontConfig may return a list of transformation matrices with the pattern, for instance, // for fonts that are oblique. We use that to initialize the cairo font matrix. FcMatrix fontConfigMatrix, *tempFontConfigMatrix; FcMatrixInit(&fontConfigMatrix); // These matrices may be stacked in the pattern, so it's our job to get them all and multiply them. for (int i = 0; FcPatternGetMatrix(m_pattern.get(), FC_MATRIX, i, &tempFontConfigMatrix) == FcResultMatch; i++) FcMatrixMultiply(&fontConfigMatrix, &fontConfigMatrix, tempFontConfigMatrix); cairo_matrix_init(&fontMatrix, fontConfigMatrix.xx, -fontConfigMatrix.yx, -fontConfigMatrix.xy, fontConfigMatrix.yy, 0, 0); // The matrix from FontConfig does not include the scale. cairo_matrix_scale(&fontMatrix, m_size, m_size); } m_scaledFont = adoptPlatformRef(cairo_scaled_font_create(fontFace, &fontMatrix, &ctm, options)); cairo_font_options_destroy(options); }
static SeedValue seed_cairo_matrix_scale (SeedContext ctx, SeedObject function, SeedObject this_object, gsize argument_count, const SeedValue arguments[], SeedException *exception) { gdouble x, y; cairo_matrix_t m; if (argument_count != 3) { EXPECTED_EXCEPTION("scale", "3 arguments"); } if (!seed_value_to_cairo_matrix (ctx, arguments[0], &m, exception)) { seed_make_exception (ctx, exception, "ArgumentError", "scale needs an array [xx, yx, xy, yy, x0, y0]"); } x = seed_value_to_double (ctx, arguments[1], exception); y = seed_value_to_double (ctx, arguments[2], exception); cairo_matrix_scale (&m, x, y); return seed_value_from_cairo_matrix (ctx, &m, exception); }
/** * adg_gtk_area_reset: * @area: an #AdgGtkArea * * Forcibly resets the zoom ratio and position of the canvas bound * to @area. This means the canvas will be scaled and centered on * the current available space. **/ void adg_gtk_area_reset(AdgGtkArea *area) { AdgGtkAreaPrivate *data; GtkWidget *parent; const CpmlExtents *sheet; GtkAllocation allocation; CpmlPair size; gdouble zoom; g_return_if_fail(ADG_GTK_IS_AREA(area)); data = adg_gtk_area_get_instance_private(area); cairo_matrix_init_identity(&data->render_map); sheet = _adg_get_extents(area); if (!sheet->is_defined || sheet->size.x <= 0 || sheet->size.y <= 0) return; parent = gtk_widget_get_parent((GtkWidget *) area); gtk_widget_get_allocation(parent, &allocation); size.x = allocation.width; size.y = allocation.height; zoom = MIN(size.x / sheet->size.x, size.y / sheet->size.y); cairo_matrix_scale(&data->render_map, zoom, zoom); cairo_matrix_translate(&data->render_map, (size.x / zoom - sheet->size.x) / 2 - sheet->org.x, (size.y / zoom - sheet->size.y) / 2 - sheet->org.y); /* Trigger a resize trying to hide the scrollbars on the parent */ gtk_widget_queue_resize(parent); }
JNIEXPORT void JNICALL Java_org_freedesktop_cairo_CairoMatrix_cairo_1matrix_1scale ( JNIEnv* env, jclass cls, jlong _self, jdouble _sx, jdouble _sy ) { cairo_matrix_t* self; double sx; double sy; // convert parameter self self = (cairo_matrix_t*) _self; // convert parameter sx sx = (double) _sx; // convert parameter sy sy = (double) _sy; // call function cairo_matrix_scale(self, sx, sy); // cleanup parameter self // cleanup parameter sx // cleanup parameter sy }
static int cairmat_scale (lua_State *L) { cairo_matrix_t mat; from_lua_matrix(L, &mat, 1); cairo_matrix_scale(&mat, luaL_checknumber(L, 2), luaL_checknumber(L, 3)); to_lua_matrix(L, &mat, 1); return 0; }
static int m_cairo_matrix_scale(lua_State * L) { cairo_matrix_t * matrix = luaL_checkudata(L, 1, MT_NAME_CAIRO_MATRIX); double sx = luaL_checknumber(L, 2); double sy = luaL_checknumber(L, 3); cairo_matrix_scale(matrix, sx, sy); return 0; }
void ofCairoRenderer::scale(float xAmnt, float yAmnt, float zAmnt ){ if(!surface || !cr) return; cairo_matrix_scale(getCairoMatrix(),xAmnt,yAmnt); setCairoMatrix(); if(!b3D) return; modelView.glScale(xAmnt,yAmnt,zAmnt); }
static cairo_status_t _cairo_skia_context_scale (void *abstract_cr, double sx, double sy) { cairo_skia_context_t *cr = (cairo_skia_context_t *) abstract_cr; cairo_matrix_scale (&cr->matrix, sx, sy); return CAIRO_STATUS_SUCCESS; }
//---------------------------------------------------------- void ofCairoRenderer::scale(float xAmnt, float yAmnt, float zAmnt ){ if(!surface || !cr) return; cairo_matrix_t matrix; cairo_get_matrix(cr,&matrix); cairo_matrix_scale(&matrix,xAmnt,yAmnt); cairo_set_matrix(cr,&matrix); if(!b3D) return; modelView.glScale(xAmnt,yAmnt,zAmnt); }
static PyObject * matrix_scale (PycairoMatrix *o, PyObject *args) { double sx, sy; if (!PyArg_ParseTuple(args, "dd:Matrix.scale", &sx, &sy)) return NULL; cairo_matrix_scale (&o->matrix, sx, sy); Py_RETURN_NONE; }
/** * goo_canvas_item_model_scale: * @model: an item model. * @sx: the amount to scale the horizontal axis. * @sy: the amount to scale the vertical axis. * * Scales the model's coordinate system by the given amounts. **/ void goo_canvas_item_model_scale (GooCanvasItemModel *model, gdouble sx, gdouble sy) { GooCanvasItemModelIface *iface = GOO_CANVAS_ITEM_MODEL_GET_IFACE (model); cairo_matrix_t new_matrix = { 1, 0, 0, 1, 0, 0 }; iface->get_transform (model, &new_matrix); cairo_matrix_scale (&new_matrix, sx, sy); iface->set_transform (model, &new_matrix); }
static cairo_scaled_font_t * create_scaled_font (cairo_t * cr) { FcPattern *pattern, *resolved; FcResult result; cairo_font_face_t *font_face; cairo_scaled_font_t *scaled_font; cairo_font_options_t *font_options; cairo_matrix_t font_matrix, ctm; double pixel_size; font_options = cairo_font_options_create (); cairo_get_font_options (cr, font_options); pattern = FcPatternCreate (); FcPatternAddString (pattern, FC_FAMILY, (FcChar8 *)"Bitstream Vera Sans"); FcPatternAddDouble (pattern, FC_PIXEL_SIZE, TEXT_SIZE); FcConfigSubstitute (NULL, pattern, FcMatchPattern); cairo_ft_font_options_substitute (font_options, pattern); FcDefaultSubstitute (pattern); resolved = FcFontMatch (NULL, pattern, &result); /* set layout to vertical */ FcPatternDel (resolved, FC_VERTICAL_LAYOUT); FcPatternAddBool (resolved, FC_VERTICAL_LAYOUT, FcTrue); FcPatternGetDouble (resolved, FC_PIXEL_SIZE, 0, &pixel_size); font_face = cairo_ft_font_face_create_for_pattern (resolved); cairo_matrix_init_translate (&font_matrix, 10, 30); cairo_matrix_rotate (&font_matrix, M_PI_2/3); cairo_matrix_scale (&font_matrix, pixel_size, pixel_size); cairo_get_matrix (cr, &ctm); scaled_font = cairo_scaled_font_create (font_face, &font_matrix, &ctm, font_options); cairo_font_options_destroy (font_options); cairo_font_face_destroy (font_face); FcPatternDestroy (pattern); FcPatternDestroy (resolved); return scaled_font; }
void S9xGTKDisplayDriver::output (void *src, int src_pitch, int x, int y, int width, int height, int dst_width, int dst_height) { if (last_known_width != dst_width || last_known_height != dst_height) { clear (); last_known_width = dst_width; last_known_height = dst_height; } cairo_t *cr = window->get_cairo (); cairo_surface_t *surface; surface = cairo_image_surface_create_for_data ((unsigned char *) src, CAIRO_FORMAT_RGB16_565, width, height, src_pitch); cairo_set_source_surface (cr, surface, 0, 0); if (width != dst_width || height != dst_height) { cairo_matrix_t matrix; cairo_pattern_t *pattern = cairo_get_source (cr);; cairo_matrix_init_identity (&matrix); cairo_matrix_scale (&matrix, (double) width / (double) dst_width, (double) height / (double) dst_height); cairo_matrix_translate (&matrix, -x, -y); cairo_pattern_set_matrix (pattern, &matrix); cairo_pattern_set_filter (pattern, Settings.BilinearFilter ? CAIRO_FILTER_BILINEAR : CAIRO_FILTER_NEAREST); } cairo_rectangle (cr, x, y, dst_width, dst_height); cairo_fill (cr); cairo_surface_finish (surface); cairo_surface_destroy (surface); window->release_cairo (); window->set_mouseable_area (x, y, width, height); }
void FontPlatformData::initializeWithFontFace(cairo_font_face_t* fontFace, const FontDescription& fontDescription) { cairo_font_options_t* options = getDefaultFontOptions(); cairo_matrix_t ctm; cairo_matrix_init_identity(&ctm); // Scaling a font with width zero size leads to a failed cairo_scaled_font_t instantiations. // Instead we scale we scale the font to a very tiny size and just abort rendering later on. float realSize = m_size ? m_size : 1; cairo_matrix_t fontMatrix; if (!m_pattern) cairo_matrix_init_scale(&fontMatrix, realSize, realSize); else { setCairoFontOptionsFromFontConfigPattern(options, m_pattern.get()); // FontConfig may return a list of transformation matrices with the pattern, for instance, // for fonts that are oblique. We use that to initialize the cairo font matrix. FcMatrix fontConfigMatrix, *tempFontConfigMatrix; FcMatrixInit(&fontConfigMatrix); // These matrices may be stacked in the pattern, so it's our job to get them all and multiply them. for (int i = 0; FcPatternGetMatrix(m_pattern.get(), FC_MATRIX, i, &tempFontConfigMatrix) == FcResultMatch; i++) FcMatrixMultiply(&fontConfigMatrix, &fontConfigMatrix, tempFontConfigMatrix); cairo_matrix_init(&fontMatrix, fontConfigMatrix.xx, -fontConfigMatrix.yx, -fontConfigMatrix.xy, fontConfigMatrix.yy, 0, 0); // We requested an italic font, but Fontconfig gave us one that was neither oblique nor italic. int actualFontSlant; if (fontDescription.italic() && FcPatternGetInteger(m_pattern.get(), FC_SLANT, 0, &actualFontSlant) == FcResultMatch) m_syntheticOblique = actualFontSlant == FC_SLANT_ROMAN; // The matrix from FontConfig does not include the scale. cairo_matrix_scale(&fontMatrix, realSize, realSize); } if (syntheticOblique()) { static const float syntheticObliqueSkew = -tanf(14 * acosf(0) / 90); cairo_matrix_t skew = {1, 0, syntheticObliqueSkew, 1, 0, 0}; cairo_matrix_multiply(&fontMatrix, &skew, &fontMatrix); } m_horizontalOrientationMatrix = fontMatrix; if (m_orientation == Vertical) rotateCairoMatrixForVerticalOrientation(&fontMatrix); m_scaledFont = cairo_scaled_font_create(fontFace, &fontMatrix, &ctm, options); cairo_font_options_destroy(options); }
/*! * \brief Scale in the coordinate system of the shape, afterwards rotate * @param m matrix * @param a angle in radians * @param sx horizontal scale * @param sy vertical scale * \extends _DiaMatrix */ void dia_matrix_set_angle_and_scales (DiaMatrix *m, real a, real sx, real sy) { real dx = m->x0; real dy = m->y0; cairo_matrix_init_rotate ((cairo_matrix_t *)m, a); cairo_matrix_scale ((cairo_matrix_t *)m, sx, sy); m->x0 = dx; m->y0 = dy; }
static void ar_card_theme_kde_paint_card (ArCardTheme *card_theme, cairo_t *cr, int card_id) { ArCardThemePreimage *preimage_card_theme = (ArCardThemePreimage *) card_theme; ArCardThemeKDE *theme = (ArCardThemeKDE *) card_theme; ArSvg *svg = preimage_card_theme->cards_svg; char node[32]; cairo_rectangle_t *card_extents; cairo_matrix_t matrix; cairo_font_options_t *font_options; if (G_UNLIKELY (card_id == AR_CARD_SLOT)) { ar_svg_render_cairo (preimage_card_theme->slot_preimage, cr, preimage_card_theme->card_size.width, preimage_card_theme->card_size.height); return; } if (theme->legacy) ar_card_get_legacy_node_by_id_snprintf (node, sizeof (node), card_id); else ar_card_get_node_by_id_snprintf (node, sizeof (node), card_id); card_extents = ar_card_theme_kde_get_card_extents (theme, card_id, node); if (!card_extents) return; cairo_save (cr); font_options = ar_svg_get_font_options (svg); if (font_options) { cairo_set_antialias (cr, cairo_font_options_get_antialias (font_options)); cairo_set_font_options (cr, font_options); } cairo_matrix_init_identity (&matrix); cairo_matrix_scale (&matrix, preimage_card_theme->card_size.width / card_extents->width, preimage_card_theme->card_size.height / card_extents->height); cairo_matrix_translate (&matrix, -card_extents->x, -card_extents->y); cairo_set_matrix (cr, &matrix); rsvg_handle_render_cairo_sub (RSVG_HANDLE (svg), cr, node); cairo_restore (cr); }
/** * goo_canvas_item_model_set_simple_transform: * @model: an item model. * @x: the x coordinate of the origin of the model's coordinate space. * @y: the y coordinate of the origin of the model's coordinate space. * @scale: the scale of the model. * @rotation: the clockwise rotation of the model, in degrees. * * A convenience function to set the item model's transformation matrix. **/ void goo_canvas_item_model_set_simple_transform (GooCanvasItemModel *model, gdouble x, gdouble y, gdouble scale, gdouble rotation) { GooCanvasItemModelIface *iface = GOO_CANVAS_ITEM_MODEL_GET_IFACE (model); cairo_matrix_t new_matrix = { 1, 0, 0, 1, 0, 0 }; cairo_matrix_translate (&new_matrix, x, y); cairo_matrix_scale (&new_matrix, scale, scale); cairo_matrix_rotate (&new_matrix, rotation * (M_PI / 180)); iface->set_transform (model, &new_matrix); }
void uiDrawMatrixScale(uiDrawMatrix *m, double xCenter, double yCenter, double x, double y) { cairo_matrix_t c; double xt, yt; m2c(m, &c); // TODO explain why the translation must come first xt = x; yt = y; scaleCenter(xCenter, yCenter, &xt, &yt); cairo_matrix_translate(&c, xt, yt); cairo_matrix_scale(&c, x, y); // TODO undo the translation? c2m(&c, m); }
void QCairoPaintEngine::drawImage(const QRectF &r, const QImage &pm, const QRectF &sr, Qt::ImageConversionFlags /*flags*/) { //qDebug()<<"drawImage r="<<r<<" sr="<<sr; double w, h; cairo_surface_t *image; QImage img; QRect sri=sr.toRect(); if (sri.isValid() && (sri.x()!=0 || sri.y()!=0 || sri.size()!=sri.size())) { img=pm.copy(sri).convertToFormat(QImage::Format_ARGB32); } else { img=pm.convertToFormat(QImage::Format_ARGB32); } if (!img.isNull()) { cairo_format_t imgformat=CAIRO_FORMAT_ARGB32; updateMatrix(); image = cairo_image_surface_create_for_data(img.bits(), imgformat, img.width(), img.height(), img.bytesPerLine()); w = img.width(); h = img.height(); cairo_matrix_t cm; cairo_matrix_init_identity(&cm); cairo_matrix_translate (&cm, r.x(), r.y()); if (sr.isValid()) cairo_matrix_scale(&cm, r.width() / sr.width(), r.height() / sr.height()); //cairo_matrix_translate (&cm, -sr.x(), -sr.y()); cairo_matrix_invert(&cm); cairo_pattern_t* brush=cairo_pattern_create_for_surface(image); cairo_pattern_set_matrix(brush, &cm); cairo_pattern_set_extend(brush, CAIRO_EXTEND_NONE); cairo_rectangle(cr, r.x(), r.y(), r.width(), r.height()); cairo_set_source(cr, brush); cairo_fill_preserve(cr); cairo_set_source_rgba(cr, 0,0,0,0); cairo_set_line_width(cr, 0.0); cairo_stroke(cr); //cairo_fill(cr); //cairo_set_source_surface (cr, image, 0, 0); //cairo_paint(cr); releasePattern(brush); updateMatrix(); } }
/* Scale the matrix so the largest absolute value of the non * translation components is 1.0. Return the scale required to restore * the matrix to the original values. * * eg the matrix [ 100 0 0 50 20 10 ] * * is rescaled to [ 1 0 0 0.5 0.2 0.1 ] * and the scale returned is 100 */ static void _cairo_matrix_factor_out_scale (cairo_matrix_t *m, double *scale) { double s; s = fabs (m->xx); if (fabs (m->xy) > s) s = fabs (m->xy); if (fabs (m->yx) > s) s = fabs (m->yx); if (fabs (m->yy) > s) s = fabs (m->yy); *scale = s; s = 1.0/s; cairo_matrix_scale (m, s, s); }
void Context::copySurface( const SurfaceBase &surface, const Area &srcArea, const Rectf &dstRect ) { if( ( dstRect.getWidth() == 0 ) || ( dstRect.getHeight() == 0 ) ) return; save(); cairo_set_source_surface( mCairo, const_cast<SurfaceBase&>( surface ).getCairoSurface(), 0, 0 ); cairo_pattern_t *sourcePattern = cairo_get_source( mCairo ); cairo_matrix_t m; cairo_matrix_init_identity( &m ); cairo_matrix_scale( &m, srcArea.getWidth() / (float)dstRect.getWidth(), srcArea.getHeight() / (float)dstRect.getHeight() ); cairo_matrix_translate( &m, srcArea.getX1() - dstRect.getX1(), srcArea.getY1() - dstRect.getY1() ); cairo_pattern_set_matrix( sourcePattern, &m ); cairo_rectangle( mCairo, dstRect.getX1(), dstRect.getY1(), dstRect.getWidth(), dstRect.getHeight() ); cairo_fill( mCairo ); restore(); }