haiku.git

/*
 * Copyright 2006, Haiku. All rights reserved.
 * Distributed under the terms of the MIT License.
 *
 * Authors:
 *		Stephan Aßmus <superstippi@gmx.de>
 */

#include "TransformPointsBox.h"

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

#include "StateView.h"
#include "TransformPointsCommand.h"
#include "VectorPath.h"

using std::nothrow;

// constructor
TransformPointsBox::TransformPointsBox(CanvasView* view,
									   PathManipulator* manipulator,
									   VectorPath* path,
									   const int32* indices,
									   int32 count)
	: CanvasTransformBox(view),
	  fManipulator(manipulator),
	  fPath(path),
	  fIndices(path && count > 0 ? new (nothrow) int32[count] : NULL),
	  fCount(count),
	  fPoints(count > 0 ? new (nothrow) control_point[count] : NULL)
{
	fPath->AcquireReference();

	BRect bounds(0, 0, -1, -1);

	if (fPoints && fIndices) {
		// copy indices
		memcpy(fIndices, indices, fCount * sizeof(int32));
		// make a copy of the points as they are and calculate bounds
		for (int32 i = 0; i < fCount; i++) {
			if (fPath->GetPointsAt(fIndices[i], fPoints[i].point,
												fPoints[i].point_in,
												fPoints[i].point_out,
												&fPoints[i].connected)) {
				BRect dummy(fPoints[i].point, fPoints[i].point);
				if (i == 0) {
					bounds = dummy;
				} else {
					bounds = bounds | dummy;
				}
				dummy.Set(fPoints[i].point_in.x, fPoints[i].point_in.y,
						  fPoints[i].point_in.x, fPoints[i].point_in.y);
				bounds = bounds | dummy;
				dummy.Set(fPoints[i].point_out.x, fPoints[i].point_out.y,
						  fPoints[i].point_out.x, fPoints[i].point_out.y);
				bounds = bounds | dummy;
			} else {
				memset((void*)&fPoints[i], 0, sizeof(control_point));
			}
		}
	}

	SetBox(bounds);
}

// destructor
TransformPointsBox::~TransformPointsBox()
{
	delete[] fIndices;
	delete[] fPoints;
	fPath->ReleaseReference();
}

// #pragma mark -

// ObjectChanged
void
TransformPointsBox::ObjectChanged(const Observable* object)
{
}

// #pragma mark -

// Update
void
TransformPointsBox::Update(bool deep)
{
	BRect r = Bounds();

	TransformBox::Update(deep);

	BRect dirty(r | Bounds());
	dirty.InsetBy(-8, -8);
	fView->Invalidate(dirty);

	if (!deep || !fIndices || !fPoints)
		return;

	for (int32 i = 0; i < fCount; i++) {

		BPoint transformed = fPoints[i].point;
		BPoint transformedIn = fPoints[i].point_in;
		BPoint transformedOut = fPoints[i].point_out;

		Transform(&transformed);
		Transform(&transformedIn);
		Transform(&transformedOut);

		fPath->SetPoint(fIndices[i], transformed,
									 transformedIn,
									 transformedOut,
									 fPoints[i].connected);
	}
}

// MakeCommand
TransformCommand*
TransformPointsBox::MakeCommand(const char* commandName)
{
	return new TransformPointsCommand(this, fPath,

									  fIndices,
									  fPoints,
									  fCount,

									  Pivot(),
									  Translation(),
									  LocalRotation(),
									  LocalXScale(),
									  LocalYScale(),

									  commandName);
}

// #pragma mark -

// Cancel
void
TransformPointsBox::Cancel()
{
	SetTransformation(B_ORIGIN, B_ORIGIN, 0.0, 1.0, 1.0);
}