haiku.git

/*
 * Copyright 2006-2009, 2023, Haiku.
 * Distributed under the terms of the MIT License.
 *
 * Authors:
 *		Stephan Aßmus <superstippi@gmx.de>
 *		Zardshard
 */

#include "Transformable.h"

#include <stdio.h>
#include <string.h>


_USING_ICON_NAMESPACE


Transformable::Transformable()
	: agg::trans_affine()
{
}


Transformable::Transformable(const Transformable& other)
	: agg::trans_affine(other)
{
}


Transformable::~Transformable()
{
}


// #pragma mark -


void
Transformable::Invert()
{
	if (!IsIdentity()) {
		invert();
		TransformationChanged();
	}
}


// #pragma mark -


void
Transformable::InverseTransform(double* x, double* y) const
{
	inverse_transform(x, y);
}


void
Transformable::InverseTransform(BPoint* point) const
{
	if (point) {
		double x = point->x;
		double y = point->y;

		inverse_transform(&x, &y);

		point->x = x;
		point->y = y;
	}
}


BPoint
Transformable::InverseTransform(const BPoint& point) const
{
	BPoint p(point);
	InverseTransform(&p);
	return p;
}


void
Transformable::StoreTo(double matrix[matrix_size]) const
{
	store_to(matrix);
}


void
Transformable::LoadFrom(const double matrix[matrix_size])
{
	// before calling the potentially heavy TransformationChanged()
	// hook function, make sure that the transformation
	// really changed
	Transformable t;
	t.load_from(matrix);
	if (*this != t) {
		load_from(matrix);
		TransformationChanged();
	}
}


void
Transformable::SetTransform(const Transformable& other)
{
	if (*this != other) {
		*this = other;
		TransformationChanged();
	}
}


Transformable&
Transformable::operator=(const Transformable& other)
{
	if (other != *this) {
		reset();
		multiply(other);
		TransformationChanged();
	}
	return *this;
}


Transformable&
Transformable::Multiply(const Transformable& other)
{
	if (!other.IsIdentity()) {
		multiply(other);
		TransformationChanged();
	}
	return *this;
}


void
Transformable::Reset()
{
	if (!IsIdentity()) {
		reset();
		TransformationChanged();
	}
}


bool
Transformable::IsIdentity() const
{
	double m[matrix_size];
	store_to(m);
	if (m[0] == 1.0 &&
		m[1] == 0.0 &&
		m[2] == 0.0 &&
		m[3] == 1.0 &&
		m[4] == 0.0 &&
		m[5] == 0.0)
		return true;
	return false;
}


bool
Transformable::IsTranslationOnly() const
{
	double m[matrix_size];
	store_to(m);
	if (m[0] == 1.0 &&
		m[1] == 0.0 &&
		m[2] == 0.0 &&
		m[3] == 1.0)
		return true;
	return false;
}


bool
Transformable::IsNotDistorted() const
{
	double m[matrix_size];
	store_to(m);
	return (m[0] == m[3]);
}


bool
Transformable::IsValid() const
{
	double m[matrix_size];
	store_to(m);
	return ((m[0] * m[3] - m[1] * m[2]) != 0.0);
}


bool
Transformable::operator==(const Transformable& other) const
{
	double m1[matrix_size];
	other.store_to(m1);
	double m2[matrix_size];
	store_to(m2);
	return memcmp(m1, m2, sizeof(m1)) == 0;
}


bool
Transformable::operator!=(const Transformable& other) const
{
	return !(*this == other);
}


inline float
min4(float a, float b, float c, float d)
{
	return min_c(a, min_c(b, min_c(c, d)));
}


inline float
max4(float a, float b, float c, float d)
{
	return max_c(a, max_c(b, max_c(c, d)));
}


BRect
Transformable::TransformBounds(BRect bounds) const
{
	if (bounds.IsValid()) {
		BPoint lt(bounds.left, bounds.top);
		BPoint rt(bounds.right, bounds.top);
		BPoint lb(bounds.left, bounds.bottom);
		BPoint rb(bounds.right, bounds.bottom);

		StyleTransformer::Transform(&lt);
		StyleTransformer::Transform(&rt);
		StyleTransformer::Transform(&lb);
		StyleTransformer::Transform(&rb);

		return BRect(floorf(min4(lt.x, rt.x, lb.x, rb.x)),
					 floorf(min4(lt.y, rt.y, lb.y, rb.y)),
					 ceilf(max4(lt.x, rt.x, lb.x, rb.x)),
					 ceilf(max4(lt.y, rt.y, lb.y, rb.y)));
	}
	return bounds;
}


void
Transformable::TranslateBy(BPoint offset)
{
	if (offset.x != 0.0 || offset.y != 0.0) {
		multiply(agg::trans_affine_translation(offset.x, offset.y));
		TransformationChanged();
	}
}


void
Transformable::RotateBy(BPoint origin, double degrees)
{
	if (degrees != 0.0) {
		multiply(agg::trans_affine_translation(-origin.x, -origin.y));
		multiply(agg::trans_affine_rotation(degrees * (M_PI / 180.0)));
		multiply(agg::trans_affine_translation(origin.x, origin.y));
		TransformationChanged();
	}
}


void
Transformable::ScaleBy(BPoint origin, double xScale, double yScale)
{
	if (xScale != 1.0 || yScale != 1.0) {
		multiply(agg::trans_affine_translation(-origin.x, -origin.y));
		multiply(agg::trans_affine_scaling(xScale, yScale));
		multiply(agg::trans_affine_translation(origin.x, origin.y));
		TransformationChanged();
	}
}


void
Transformable::ShearBy(BPoint origin, double xShear, double yShear)
{
	if (xShear != 0.0 || yShear != 0.0) {
		multiply(agg::trans_affine_translation(-origin.x, -origin.y));
		multiply(agg::trans_affine_skewing(xShear, yShear));
		multiply(agg::trans_affine_translation(origin.x, origin.y));
		TransformationChanged();
	}
}


void
Transformable::TransformationChanged()
{
	// default implementation doesn't care
}


void
Transformable::PrintToStream() const
{
	double matrix[6];
	store_to(matrix);
	printf("Transform:\n%f\t%f\t%f\n%f\t%f\t%f\n",
		matrix[0], matrix[2], matrix[4], matrix[1], matrix[3], matrix[5]);
}