void cairo_container::draw_txdib( cairo_t* cr, CTxDIB* bmp, int x, int y, int cx, int cy )
{
cairo_save(cr);
cairo_matrix_t flib_m;
cairo_matrix_init(&flib_m, 1, 0, 0, -1, 0, 0);
cairo_surface_t* img = NULL;
CTxDIB rbmp;
if(cx != bmp->getWidth() || cy != bmp->getHeight())
{
bmp->resample(cx, cy, &rbmp);
img = cairo_image_surface_create_for_data((unsigned char*) rbmp.getBits(), CAIRO_FORMAT_ARGB32, rbmp.getWidth(), rbmp.getHeight(), rbmp.getWidth() * 4);
cairo_matrix_translate(&flib_m, 0, -rbmp.getHeight());
cairo_matrix_translate(&flib_m, x, -y);
} else
{
img = cairo_image_surface_create_for_data((unsigned char*) bmp->getBits(), CAIRO_FORMAT_ARGB32, bmp->getWidth(), bmp->getHeight(), bmp->getWidth() * 4);
cairo_matrix_translate(&flib_m, 0, -bmp->getHeight());
cairo_matrix_translate(&flib_m, x, -y);
}
cairo_transform(cr, &flib_m);
cairo_set_source_surface(cr, img, 0, 0);
cairo_paint(cr);
cairo_restore(cr);
cairo_surface_destroy(img);
}
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 handle_apply_matrix(cairo_matrix_t* mtx) const override {
if(std::abs(cx_) < DBL_EPSILON && std::abs(cy_) < DBL_EPSILON) {
cairo_matrix_rotate(mtx, angle_);
} else {
cairo_matrix_translate(mtx, cx_, cy_);
cairo_matrix_rotate(mtx, angle_);
cairo_matrix_translate(mtx, cx_, cy_);
}
}
void
gtk_css_style_render_icon_surface (GtkCssStyle *style,
cairo_t *cr,
cairo_surface_t *surface,
double x,
double y)
{
const GtkCssValue *shadows;
cairo_matrix_t matrix, transform_matrix, saved_matrix;
GdkRectangle extents;
g_return_if_fail (GTK_IS_CSS_STYLE (style));
g_return_if_fail (cr != NULL);
g_return_if_fail (surface != NULL);
shadows = gtk_css_style_get_value (style, GTK_CSS_PROPERTY_ICON_SHADOW);
if (!get_surface_extents (surface, &extents))
{
/* weird infinite surface, no special magic for you */
cairo_set_source_surface (cr, surface, x, y);
_gtk_css_shadows_value_paint_icon (gtk_css_style_get_value (style, GTK_CSS_PROPERTY_ICON_SHADOW), cr);
cairo_paint (cr);
return;
}
cairo_get_matrix (cr, &saved_matrix);
cairo_translate (cr, x + extents.x, y + extents.y);
if (_gtk_css_transform_value_get_matrix (gtk_css_style_get_value (style, GTK_CSS_PROPERTY_ICON_TRANSFORM), &transform_matrix))
{
cairo_pattern_t *pattern;
/* XXX: Implement -gtk-icon-transform-origin instead of hardcoding "50% 50%" here */
cairo_matrix_init_translate (&matrix, extents.width / 2, extents.height / 2);
cairo_matrix_multiply (&matrix, &transform_matrix, &matrix);
cairo_matrix_translate (&matrix, - extents.width / 2, - extents.height / 2);
if (cairo_matrix_invert (&matrix) != CAIRO_STATUS_SUCCESS)
{
g_assert_not_reached ();
}
cairo_matrix_translate (&matrix, extents.x, extents.y);
pattern = cairo_pattern_create_for_surface (surface);
cairo_pattern_set_matrix (pattern, &matrix);
cairo_set_source (cr, pattern);
cairo_pattern_destroy (pattern);
_gtk_css_shadows_value_paint_icon (shadows, cr);
cairo_paint (cr);
}
cairo_set_matrix (cr, &saved_matrix);
}
void uiDrawMatrixRotate(uiDrawMatrix *m, double x, double y, double amount)
{
cairo_matrix_t c;
m2c(m, &c);
cairo_matrix_translate(&c, x, y);
cairo_matrix_rotate(&c, amount);
// TODO undo the translation? also cocoa backend
cairo_matrix_translate(&c, -x, -y);
c2m(&c, m);
}
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);
}
JNIEXPORT void JNICALL
Java_org_freedesktop_cairo_CairoMatrix_cairo_1matrix_1translate
(
JNIEnv* env,
jclass cls,
jlong _self,
jdouble _tx,
jdouble _ty
)
{
cairo_matrix_t* self;
double tx;
double ty;
// convert parameter self
self = (cairo_matrix_t*) _self;
// convert parameter tx
tx = (double) _tx;
// convert parameter ty
ty = (double) _ty;
// call function
cairo_matrix_translate(self, tx, ty);
// cleanup parameter self
// cleanup parameter tx
// cleanup parameter ty
}
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
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);
}
}
/**
* goo_canvas_item_model_rotate:
* @model: an item model.
* @degrees: the clockwise angle of rotation.
* @cx: the x coordinate of the origin of the rotation.
* @cy: the y coordinate of the origin of the rotation.
*
* Rotates the model's coordinate system by the given amount, about the given
* origin.
**/
void
goo_canvas_item_model_rotate (GooCanvasItemModel *model,
gdouble degrees,
gdouble cx,
gdouble cy)
{
GooCanvasItemModelIface *iface = GOO_CANVAS_ITEM_MODEL_GET_IFACE (model);
cairo_matrix_t new_matrix = { 1, 0, 0, 1, 0, 0 };
double radians = degrees * (M_PI / 180);
iface->get_transform (model, &new_matrix);
cairo_matrix_translate (&new_matrix, cx, cy);
cairo_matrix_rotate (&new_matrix, radians);
cairo_matrix_translate (&new_matrix, -cx, -cy);
iface->set_transform (model, &new_matrix);
}
static gboolean
_adg_motion_notify_event(GtkWidget *widget, GdkEventMotion *event)
{
gboolean translating, local_space, global_space;
cairo_matrix_t map, inverted;
translating = (event->state & GDK_BUTTON2_MASK) == GDK_BUTTON2_MASK;
local_space = (event->state & ADG_GTK_MODIFIERS) == 0;
global_space = (event->state & ADG_GTK_MODIFIERS) == GDK_SHIFT_MASK;
if (translating && (local_space || global_space) &&
_adg_get_map(widget, local_space, &map, &inverted)) {
AdgGtkAreaPrivate *data = adg_gtk_area_get_instance_private((AdgGtkArea *) widget);
gdouble x = event->x - data->x_event;
gdouble y = event->y - data->y_event;
cairo_matrix_transform_distance(&inverted, &x, &y);
cairo_matrix_translate(&map, x, y);
data->x_event = event->x;
data->y_event = event->y;
_adg_set_map(widget, local_space, &map);
gtk_widget_queue_draw(widget);
/* Avoid to chain up the default handler:
* this event has been grabbed by this function */
return TRUE;
}
if (_ADG_OLD_WIDGET_CLASS->motion_notify_event == NULL)
return FALSE;
return _ADG_OLD_WIDGET_CLASS->motion_notify_event(widget, event);
}
static SeedValue
seed_cairo_matrix_translate (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("translate", "3 arguments");
}
if (!seed_value_to_cairo_matrix (ctx, arguments[0], &m, exception))
{
seed_make_exception (ctx, exception, "ArgumentError", "translate 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_translate (&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);
}
void wxGISDisplay::DrawRaster(cairo_surface_t *surface, const OGREnvelope& Envelope, bool bDrawEnvelope)
{
wxCriticalSectionLocker locker(m_CritSect);
cairo_pattern_t *pattern = cairo_pattern_create_for_surface (surface);
cairo_matrix_t matrix;
cairo_matrix_init_scale (&matrix, m_dScale, -m_dScale);
cairo_matrix_translate(&matrix, -Envelope.MinX, -Envelope.MaxY);
cairo_pattern_set_matrix (pattern, &matrix);
cairo_set_source (m_saLayerCaches[m_nCurrentLayer].pCairoContext, pattern);
cairo_paint (m_saLayerCaches[m_nCurrentLayer].pCairoContext);
if(bDrawEnvelope)
{
//TODO:
//SetLineWidth( m_dLineWidth );
//SetColor(m_FillColour);
cairo_move_to(m_saLayerCaches[m_nCurrentLayer].pCairoContext, Envelope.MinX, Envelope.MinY);
cairo_line_to(m_saLayerCaches[m_nCurrentLayer].pCairoContext, Envelope.MaxX, Envelope.MinY);
cairo_line_to(m_saLayerCaches[m_nCurrentLayer].pCairoContext, Envelope.MaxX, Envelope.MaxY);
cairo_line_to(m_saLayerCaches[m_nCurrentLayer].pCairoContext, Envelope.MinX, Envelope.MaxY);
cairo_line_to(m_saLayerCaches[m_nCurrentLayer].pCairoContext, Envelope.MinX, Envelope.MinY);
cairo_stroke (m_saLayerCaches[m_nCurrentLayer].pCairoContext);
}
cairo_pattern_destroy (pattern);
}
void RotateEnvelope(OGREnvelope &Env, double dAngle, double dX, double dY)
{
cairo_matrix_t Matrix;
cairo_matrix_init_translate(&Matrix, dX, dY);
cairo_matrix_rotate(&Matrix, dAngle);
cairo_matrix_translate(&Matrix, -dX, -dY);
//cairo_matrix_init_rotate(&Matrix, dAngle);
double X1 = Env.MinX;
double Y1 = Env.MaxY;
double X2 = Env.MaxX;
double Y2 = Env.MaxY;
double X3 = Env.MaxX;
double Y3 = Env.MinY;
double X4 = Env.MinX;
double Y4 = Env.MinY;
cairo_matrix_transform_point(&Matrix, &X1, &Y1);
cairo_matrix_transform_point(&Matrix, &X2, &Y2);
cairo_matrix_transform_point(&Matrix, &X3, &Y3);
cairo_matrix_transform_point(&Matrix, &X4, &Y4);
Env.MinX = wxMin(wxMin(X1, X2), wxMin(X3, X4));
Env.MinY = wxMin(wxMin(Y1, Y2), wxMin(Y3, Y4));
Env.MaxX = wxMax(wxMax(X1, X2), wxMax(X3, X4));
Env.MaxY = wxMax(wxMax(Y1, Y2), wxMax(Y3, Y4));
}
JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_GdkGraphics2D_gdkDrawDrawable
(JNIEnv *env, jobject self, jobject other, jint x, jint y)
{
struct graphics2d *src = NULL, *dst = NULL;
gint s_height, s_width, d_height, d_width, height, width;
cairo_matrix_t *matrix;
cairo_operator_t tmp_op;
gdk_threads_enter();
if (peer_is_disposed(env, self)) { gdk_threads_leave(); return; }
src = (struct graphics2d *)NSA_GET_G2D_PTR (env, other);
dst = (struct graphics2d *)NSA_GET_G2D_PTR (env, self);
g_assert (src != NULL);
g_assert (dst != NULL);
if (src->debug) printf ("copying from offscreen drawable\n");
begin_drawing_operation(dst);
gdk_flush();
gdk_drawable_get_size (src->drawable, &s_width, &s_height);
gdk_drawable_get_size (dst->drawable, &d_width, &d_height);
width = min (s_width, d_width);
height = min (s_height, d_height);
matrix = cairo_matrix_create ();
cairo_surface_get_matrix (src->surface, matrix);
cairo_matrix_translate (matrix, (double)-x, (double)-y);
cairo_surface_set_matrix (src->surface, matrix);
tmp_op = cairo_current_operator (dst->cr);
cairo_set_operator(dst->cr, CAIRO_OPERATOR_SRC);
cairo_show_surface (dst->cr, src->surface, width, height);
cairo_set_operator(dst->cr, tmp_op);
cairo_matrix_translate (matrix, (double)x, (double)y);
cairo_surface_set_matrix (src->surface, matrix);
cairo_matrix_destroy (matrix);
gdk_flush();
end_drawing_operation(dst);
if (src->debug) printf ("copied %d x %d pixels from offscreen drawable\n", width, height);
gdk_threads_leave();
}
/**
* goo_canvas_item_model_skew_y:
* @model: an item model.
* @degrees: the skew angle.
* @cx: the x coordinate of the origin of the skew transform.
* @cy: the y coordinate of the origin of the skew transform.
*
* Skews the model's coordinate system along the y axis by the given amount,
* about the given origin.
**/
void
goo_canvas_item_model_skew_y (GooCanvasItemModel *model,
gdouble degrees,
gdouble cx,
gdouble cy)
{
GooCanvasItemModelIface *iface = GOO_CANVAS_ITEM_MODEL_GET_IFACE (model);
cairo_matrix_t tmp, new_matrix = { 1, 0, 0, 1, 0, 0 };
double radians = degrees * (M_PI / 180);
iface->get_transform (model, &new_matrix);
cairo_matrix_translate (&new_matrix, cx, cy);
cairo_matrix_init (&tmp, 1, tan (radians), 0, 1, 0, 0);
cairo_matrix_multiply (&new_matrix, &tmp, &new_matrix);
cairo_matrix_translate (&new_matrix, -cx, -cy);
iface->set_transform (model, &new_matrix);
}
static int m_cairo_matrix_translate(lua_State * L)
{
cairo_matrix_t * matrix = luaL_checkudata(L, 1, MT_NAME_CAIRO_MATRIX);
double tx = luaL_checknumber(L, 2);
double ty = luaL_checknumber(L, 3);
cairo_matrix_translate(matrix, tx, ty);
return 0;
}
static void matrix_init(cairo_matrix_t *mat, double width, double height, OGREnvelope *bounds){
cairo_matrix_init(mat, 1, 0, 0, -1, 0, 0);
cairo_matrix_translate(mat, 0, height * -1.0);
double w,
bWidth = fabs(bounds->MaxX - bounds->MinX),
bHeight = fabs(bounds->MaxY - bounds->MinY);
if(bWidth > bHeight){
w = width / bWidth;
} else {
w = height / bHeight;
}
cairo_matrix_scale(mat, w, w);
cairo_matrix_translate(mat, -bounds->MinX, -bounds->MinY);
}
void uiDrawMatrixTranslate(uiDrawMatrix *m, double x, double y)
{
cairo_matrix_t c;
m2c(m, &c);
cairo_matrix_translate(&c, x, y);
c2m(&c, m);
}
static inline cairo_matrix_t * __get_obj_matrix(struct lobject_t * object)
{
cairo_matrix_t * m = &object->__obj_matrix;
if(!object->__obj_matrix_valid)
{
cairo_matrix_init_identity(m);
if(object->__translate)
cairo_matrix_translate(m, object->x, object->y);
if(object->__rotate)
cairo_matrix_rotate(m, object->rotation);
if(object->__anchor)
cairo_matrix_translate(m, -object->anchorx * object->width * object->scalex, -object->anchory * object->height * object->scaley);
if(object->__scale)
cairo_matrix_scale(m, object->scalex, object->scaley);
object->__obj_matrix_valid = 1;
}
return m;
}
static int
cairmat_translate (lua_State *L) {
cairo_matrix_t mat;
from_lua_matrix(L, &mat, 1);
cairo_matrix_translate(&mat, luaL_checknumber(L, 2),
luaL_checknumber(L, 3));
to_lua_matrix(L, &mat, 1);
return 0;
}
void ofCairoRenderer::translate(float x, float y, float z ){
if(!surface || !cr) return;
cairo_matrix_translate(getCairoMatrix(),x,y);
setCairoMatrix();
if(!b3D) return;
modelView.glTranslate(ofVec3f(x,y,z));
}
static void rotateCairoMatrixForVerticalOrientation(cairo_matrix_t* matrix)
{
// The resulting transformation matrix for vertical glyphs (V) is a
// combination of rotation (R) and translation (T) applied on the
// horizontal matrix (H). V = H . R . T, where R rotates by -90 degrees
// and T translates by font size towards y axis.
cairo_matrix_rotate(matrix, -M_PI_2);
cairo_matrix_translate(matrix, 0.0, 1.0);
}
static PyObject *
matrix_translate (PycairoMatrix *o, PyObject *args) {
double tx, ty;
if (!PyArg_ParseTuple(args, "dd:Matrix.translate", &tx, &ty))
return NULL;
cairo_matrix_translate (&o->matrix, tx, ty);
Py_RETURN_NONE;
}
static cairo_status_t
_cairo_skia_context_translate (void *abstract_cr,
double tx,
double ty)
{
cairo_skia_context_t *cr = (cairo_skia_context_t *) abstract_cr;
cairo_matrix_translate (&cr->matrix, tx, ty);
return CAIRO_STATUS_SUCCESS;
}
//----------------------------------------------------------
void ofCairoRenderer::translate(float x, float y, float z ){
if(!surface || !cr) return;
cairo_matrix_t matrix;
cairo_get_matrix(cr,&matrix);
cairo_matrix_translate(&matrix,x,y);
cairo_set_matrix(cr,&matrix);
if(!b3D) return;
modelView.glTranslate(ofVec3f(x,y,z));
}
/**
* goo_canvas_item_model_translate:
* @model: an item model.
* @tx: the amount to move the origin in the horizontal direction.
* @ty: the amount to move the origin in the vertical direction.
*
* Translates the origin of the model's coordinate system by the given amounts.
**/
void
goo_canvas_item_model_translate (GooCanvasItemModel *model,
gdouble tx,
gdouble ty)
{
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_translate (&new_matrix, tx, ty);
iface->set_transform (model, &new_matrix);
}
static void
_gth_image_rotator_update_tranformation_matrix (GthImageRotator *self)
{
int tx, ty;
self->priv->preview_center.x = self->priv->center.x * self->priv->preview_zoom;
self->priv->preview_center.y = self->priv->center.y * self->priv->preview_zoom;
tx = self->priv->preview_image_area.x + self->priv->preview_center.x;
ty = self->priv->preview_image_area.y + self->priv->preview_center.y;
cairo_matrix_init_identity (&self->priv->matrix);
cairo_matrix_translate (&self->priv->matrix, tx, ty);
cairo_matrix_rotate (&self->priv->matrix, self->priv->angle);
cairo_matrix_translate (&self->priv->matrix, -tx, -ty);
gth_transform_resize (&self->priv->matrix,
self->priv->resize,
&self->priv->preview_image_area,
&self->priv->clip_area);
}
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);
}
