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

#include "VectorPath.h"

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

#include <agg_basics.h>
#include <agg_bounding_rect.h>
#include <agg_conv_curve.h>
#include <agg_curves.h>
#include <agg_math.h>

#ifdef ICON_O_MATIC
#       include <debugger.h>
#       include <typeinfo>
#endif // ICON_O_MATIC

#include <Message.h>
#include <TypeConstants.h>

#ifdef ICON_O_MATIC
#       include "support.h"

#       include "CommonPropertyIDs.h"
#       include "IconProperty.h"
#       include "Icons.h"
#       include "Property.h"
#       include "PropertyObject.h"
#endif // ICON_O_MATIC

#include "Transformable.h"

#define obj_new(type, n)                ((type *)malloc ((n) * sizeof(type)))
#define obj_renew(p, type, n)   ((type *)realloc ((void *)p, (n) * sizeof(type)))
#define obj_free                                free

#define ALLOC_CHUNKS 20

_USING_ICON_NAMESPACE


bool
get_path_storage(agg::path_storage& path, const control_point* points,
        int32 count, bool closed)
{
        if (count > 1) {
                path.move_to(points[0].point.x, points[0].point.y);

                for (int32 i = 1; i < count; i++) {
                        path.curve4(points[i - 1].point_out.x, points[i - 1].point_out.y,
                                points[i].point_in.x, points[i].point_in.y,
                                points[i].point.x, points[i].point.y);
                }
                if (closed) {
                        // curve from last to first control point
                        path.curve4(
                                points[count - 1].point_out.x, points[count - 1].point_out.y,
                                points[0].point_in.x, points[0].point_in.y,
                                points[0].point.x, points[0].point.y);
                        path.close_polygon();
                }

                return true;
        }
        return false;
}


// #pragma mark -


#ifdef ICON_O_MATIC
PathListener::PathListener()
{
}


PathListener::~PathListener()
{
}
#endif


// #pragma mark -


VectorPath::VectorPath()
        :
#ifdef ICON_O_MATIC
        BArchivable(),
        IconObject("<path>"),
        fListeners(20),
#endif
        fPath(NULL),
        fClosed(false),
        fPointCount(0),
        fAllocCount(0),
        fCachedBounds(0.0, 0.0, -1.0, -1.0)
{
}


VectorPath::VectorPath(const VectorPath& from)
        :
#ifdef ICON_O_MATIC
        BArchivable(),
        IconObject(from),
        fListeners(20),
#endif
        fPath(NULL),
        fClosed(false),
        fPointCount(0),
        fAllocCount(0),
        fCachedBounds(0.0, 0.0, -1.0, -1.0)
{
        *this = from;
}


VectorPath::VectorPath(BMessage* archive)
        :
#ifdef ICON_O_MATIC
        BArchivable(),
        IconObject(archive),
        fListeners(20),
#endif
        fPath(NULL),
        fClosed(false),
        fPointCount(0),
        fAllocCount(0),
        fCachedBounds(0.0, 0.0, -1.0, -1.0)
{
        if (!archive)
                return;

        type_code typeFound;
        int32 countFound;
        if (archive->GetInfo("point", &typeFound, &countFound) >= B_OK
                && typeFound == B_POINT_TYPE
                && _SetPointCount(countFound)) {
                memset((void*)fPath, 0, fAllocCount * sizeof(control_point));

                BPoint point;
                BPoint pointIn;
                BPoint pointOut;
                bool connected;
                for (int32 i = 0; i < fPointCount
                                && archive->FindPoint("point", i, &point) >= B_OK
                                && archive->FindPoint("point in", i, &pointIn) >= B_OK
                                && archive->FindPoint("point out", i, &pointOut) >= B_OK
                                && archive->FindBool("connected", i, &connected) >= B_OK; i++) {
                        fPath[i].point = point;
                        fPath[i].point_in = pointIn;
                        fPath[i].point_out = pointOut;
                        fPath[i].connected = connected;
                }
        }
        if (archive->FindBool("path closed", &fClosed) < B_OK)
                fClosed = false;

}


VectorPath::~VectorPath()
{
        if (fPath)
                obj_free(fPath);

#ifdef ICON_O_MATIC
        if (fListeners.CountItems() > 0) {
                PathListener* listener = (PathListener*)fListeners.ItemAt(0);
                char message[512];
                sprintf(message, "VectorPath::~VectorPath() - "
                                 "there are still listeners attached! %p/%s",
                                 listener, typeid(*listener).name());
                debugger(message);
        }
#endif
}


// #pragma mark -


#ifdef ICON_O_MATIC

PropertyObject*
VectorPath::MakePropertyObject() const
{
        PropertyObject* object = IconObject::MakePropertyObject();
        if (!object)
                return NULL;

        // closed
        object->AddProperty(new BoolProperty(PROPERTY_CLOSED, fClosed));

        // archived path
        BMessage* archive = new BMessage();
        if (Archive(archive) == B_OK) {
                object->AddProperty(new IconProperty(PROPERTY_PATH,
                        kPathPropertyIconBits, kPathPropertyIconWidth,
                        kPathPropertyIconHeight, kPathPropertyIconFormat, archive));
        }

        return object;
}


bool
VectorPath::SetToPropertyObject(const PropertyObject* object)
{
        AutoNotificationSuspender _(this);
        IconObject::SetToPropertyObject(object);

        SetClosed(object->Value(PROPERTY_CLOSED, fClosed));

        IconProperty* pathProperty = dynamic_cast<IconProperty*>(
                object->FindProperty(PROPERTY_PATH));
        if (pathProperty && pathProperty->Message()) {
                VectorPath archivedPath(pathProperty->Message());
                *this = archivedPath;
        }

        return HasPendingNotifications();
}


status_t
VectorPath::Archive(BMessage* into, bool deep) const
{
        status_t ret = IconObject::Archive(into, deep);
        if (ret != B_OK)
                return ret;

        if (fPointCount > 0) {
                // improve BMessage efficency by preallocating storage for all points
                // with the first call
                ret = into->AddData("point", B_POINT_TYPE, &fPath[0].point,
                        sizeof(BPoint), true, fPointCount);
                if (ret >= B_OK) {
                        ret = into->AddData("point in", B_POINT_TYPE, &fPath[0].point_in,
                                sizeof(BPoint), true, fPointCount);
                }
                if (ret >= B_OK) {
                        ret = into->AddData("point out", B_POINT_TYPE, &fPath[0].point_out,
                                sizeof(BPoint), true, fPointCount);
                }
                if (ret >= B_OK) {
                        ret = into->AddData("connected", B_BOOL_TYPE, &fPath[0].connected,
                                sizeof(bool), true, fPointCount);
                }

                // add the rest of the points
                for (int32 i = 1; i < fPointCount && ret >= B_OK; i++) {
                        ret = into->AddData("point", B_POINT_TYPE, &fPath[i].point,
                                sizeof(BPoint));
                        if (ret >= B_OK) {
                                ret = into->AddData("point in", B_POINT_TYPE, &fPath[i].point_in,
                                        sizeof(BPoint));
                        }
                        if (ret >= B_OK) {
                                ret = into->AddData("point out", B_POINT_TYPE,
                                        &fPath[i].point_out, sizeof(BPoint));
                        }
                        if (ret >= B_OK) {
                                ret = into->AddData("connected", B_BOOL_TYPE,
                                        &fPath[i].connected, sizeof(bool));
                        }
                }
        }

        if (ret >= B_OK)
                ret = into->AddBool("path closed", fClosed);
        else
                fprintf(stderr, "failed adding points!\n");

        if (ret < B_OK)
                fprintf(stderr, "failed adding close!\n");

        // finish off
        if (ret < B_OK)
                ret = into->AddString("class", "VectorPath");

        return ret;
}

#endif // ICON_O_MATIC


// #pragma mark -


VectorPath&
VectorPath::operator=(const VectorPath& from)
{
        _SetPointCount(from.fPointCount);
        fClosed = from.fClosed;
        if (fPath) {
                memcpy((void*)fPath, from.fPath, fPointCount * sizeof(control_point));
                fCachedBounds = from.fCachedBounds;
        } else {
                fprintf(stderr, "VectorPath() -> allocation failed in operator=!\n");
                fAllocCount = 0;
                fPointCount = 0;
                fCachedBounds.Set(0.0, 0.0, -1.0, -1.0);
        }
        Notify();

        return *this;
}


bool
VectorPath::operator==(const VectorPath& other) const
{
        if (fClosed != other.fClosed)
                return false;

        if (fPointCount != other.fPointCount)
                return false;

        if (fPath == NULL && other.fPath == NULL)
                return true;

        if (fPath == NULL || other.fPath == NULL)
                return false;

        for (int32 i = 0; i < fPointCount; i++) {
                if (fPath[i].point != other.fPath[i].point
                        || fPath[i].point_in != other.fPath[i].point_in
                        || fPath[i].point_out != other.fPath[i].point_out
                        || fPath[i].connected != other.fPath[i].connected) {
                        return false;
                }
        }

        return true;
}


void
VectorPath::MakeEmpty()
{
        _SetPointCount(0);
}


// #pragma mark -


bool
VectorPath::AddPoint(BPoint point)
{
        int32 index = fPointCount;

        if (_SetPointCount(fPointCount + 1)) {
                _SetPoint(index, point);
                _NotifyPointAdded(index);
                return true;
        }

        return false;
}


bool
VectorPath::AddPoint(const BPoint& point, const BPoint& pointIn,
        const BPoint& pointOut, bool connected)
{
        int32 index = fPointCount;

        if (_SetPointCount(fPointCount + 1)) {
                _SetPoint(index, point, pointIn, pointOut, connected);
                _NotifyPointAdded(index);
                return true;
        }

        return false;
}


bool
VectorPath::AddPoint(BPoint point, int32 index)
{
        if (index < 0)
                index = 0;
        if (index > fPointCount)
                index = fPointCount;

        if (_SetPointCount(fPointCount + 1)) {
                // handle insert
                if (index < fPointCount - 1) {
                        for (int32 i = fPointCount; i > index; i--) {
                                fPath[i].point = fPath[i - 1].point;
                                fPath[i].point_in = fPath[i - 1].point_in;
                                fPath[i].point_out = fPath[i - 1].point_out;
                                fPath[i].connected = fPath[i - 1].connected;
                        }
                }
                _SetPoint(index, point);
                _NotifyPointAdded(index);
                return true;
        }
        return false;
}


bool
VectorPath::RemovePoint(int32 index)
{
        if (index >= 0 && index < fPointCount) {
                if (index < fPointCount - 1) {
                        // move points
                        for (int32 i = index; i < fPointCount - 1; i++) {
                                fPath[i].point = fPath[i + 1].point;
                                fPath[i].point_in = fPath[i + 1].point_in;
                                fPath[i].point_out = fPath[i + 1].point_out;
                                fPath[i].connected = fPath[i + 1].connected;
                        }
                }
                fPointCount -= 1;

                fCachedBounds.Set(0.0, 0.0, -1.0, -1.0);

                _NotifyPointRemoved(index);
                return true;
        }
        return false;
}


bool
VectorPath::SetPoint(int32 index, BPoint point)
{
        if (index == fPointCount)
                index = 0;
        if (index >= 0 && index < fPointCount) {
                BPoint offset = point - fPath[index].point;
                fPath[index].point = point;
                fPath[index].point_in += offset;
                fPath[index].point_out += offset;

                fCachedBounds.Set(0.0, 0.0, -1.0, -1.0);

                _NotifyPointChanged(index);
                return true;
        }
        return false;
}


bool
VectorPath::SetPoint(int32 index, BPoint point, BPoint pointIn, BPoint pointOut,
        bool connected)
{
        if (index == fPointCount)
                index = 0;
        if (index >= 0 && index < fPointCount) {
                fPath[index].point = point;
                fPath[index].point_in = pointIn;
                fPath[index].point_out = pointOut;
                fPath[index].connected = connected;

                fCachedBounds.Set(0.0, 0.0, -1.0, -1.0);

                _NotifyPointChanged(index);
                return true;
        }
        return false;
}


bool
VectorPath::SetPointIn(int32 i, BPoint point)
{
        if (i == fPointCount)
                i = 0;
        if (i >= 0 && i < fPointCount) {
                // first, set the "in" point
                fPath[i].point_in = point;
                // now see what to do about the "out" point
                if (fPath[i].connected) {
                        // keep all three points in one line
                        BPoint v = fPath[i].point - fPath[i].point_in;
                        float distIn = sqrtf(v.x * v.x + v.y * v.y);
                        if (distIn > 0.0) {
                                float distOut = agg::calc_distance(
                                        fPath[i].point.x, fPath[i].point.y,
                                        fPath[i].point_out.x, fPath[i].point_out.y);
                                float scale = (distIn + distOut) / distIn;
                                v.x *= scale;
                                v.y *= scale;
                                fPath[i].point_out = fPath[i].point_in + v;
                        }
                }

                fCachedBounds.Set(0.0, 0.0, -1.0, -1.0);

                _NotifyPointChanged(i);
                return true;
        }
        return false;
}


bool
VectorPath::SetPointOut(int32 i, BPoint point, bool mirrorDist)
{
        if (i == fPointCount)
                i = 0;
        if (i >= 0 && i < fPointCount) {
                // first, set the "out" point
                fPath[i].point_out = point;
                // now see what to do about the "out" point
                if (mirrorDist) {
                        // mirror "in" point around main control point
                        BPoint v = fPath[i].point - fPath[i].point_out;
                        fPath[i].point_in = fPath[i].point + v;
                } else if (fPath[i].connected) {
                        // keep all three points in one line
                        BPoint v = fPath[i].point - fPath[i].point_out;
                        float distOut = sqrtf(v.x * v.x + v.y * v.y);
                        if (distOut > 0.0) {
                                float distIn = agg::calc_distance(
                                        fPath[i].point.x, fPath[i].point.y,
                                        fPath[i].point_in.x, fPath[i].point_in.y);
                                float scale = (distIn + distOut) / distOut;
                                v.x *= scale;
                                v.y *= scale;
                                fPath[i].point_in = fPath[i].point_out + v;
                        }
                }

                fCachedBounds.Set(0.0, 0.0, -1.0, -1.0);

                _NotifyPointChanged(i);
                return true;
        }
        return false;
}


bool
VectorPath::SetInOutConnected(int32 index, bool connected)
{
        if (index >= 0 && index < fPointCount) {
                fPath[index].connected = connected;
                _NotifyPointChanged(index);
                return true;
        }
        return false;
}


// #pragma mark -


bool
VectorPath::GetPointAt(int32 index, BPoint& point) const
{
        if (index == fPointCount)
                index = 0;
        if (index >= 0 && index < fPointCount) {
                point = fPath[index].point;
                return true;
        }
        return false;
}


bool
VectorPath::GetPointInAt(int32 index, BPoint& point) const
{
        if (index == fPointCount)
                index = 0;
        if (index >= 0 && index < fPointCount) {
                point = fPath[index].point_in;
                return true;
        }
        return false;
}


bool
VectorPath::GetPointOutAt(int32 index, BPoint& point) const
{
        if (index == fPointCount)
                index = 0;
        if (index >= 0 && index < fPointCount) {
                point = fPath[index].point_out;
                return true;
        }
        return false;
}


bool
VectorPath::GetPointsAt(int32 index, BPoint& point, BPoint& pointIn,
        BPoint& pointOut, bool* connected) const
{
        if (index >= 0 && index < fPointCount) {
                point = fPath[index].point;
                pointIn = fPath[index].point_in;
                pointOut = fPath[index].point_out;

                if (connected)
                        *connected = fPath[index].connected;

                return true;
        }
        return false;
}


int32
VectorPath::CountPoints() const
{
        return fPointCount;
}


// #pragma mark -


#ifdef ICON_O_MATIC

static float
distance_to_curve(const BPoint& p, const BPoint& a, const BPoint& aOut,
        const BPoint& bIn, const BPoint& b)
{
        agg::curve4_inc curve(a.x, a.y, aOut.x, aOut.y, bIn.x, bIn.y, b.x, b.y);

        float segDist = FLT_MAX;
        double x1, y1, x2, y2;
        unsigned cmd = curve.vertex(&x1, &y1);
        while (!agg::is_stop(cmd)) {
                cmd = curve.vertex(&x2, &y2);
                // first figure out if point is between segment start and end points
                double a = agg::calc_distance(p.x, p.y, x2, y2);
                double b = agg::calc_distance(p.x, p.y, x1, y1);

                float currentDist = min_c(a, b);

                if (a > 0.0 && b > 0.0) {
                        double c = agg::calc_distance(x1, y1, x2, y2);

                        double alpha = acos((b * b + c * c - a * a) / (2 * b * c));
                        double beta = acos((a * a + c * c - b * b) / (2 * a * c));

                        if (alpha <= M_PI_2 && beta <= M_PI_2) {
                                currentDist = fabs(agg::calc_line_point_distance(x1, y1, x2, y2,
                                        p.x, p.y));
                        }
                }

                if (currentDist < segDist)
                        segDist = currentDist;

                x1 = x2;
                y1 = y2;
        }
        return segDist;
}


bool
VectorPath::GetDistance(BPoint p, float* distance, int32* index) const
{
        if (fPointCount > 1) {
                // generate a curve for each segment of the path
                // then iterate over the segments of the curve measuring the distance
                *distance = FLT_MAX;

                for (int32 i = 0; i < fPointCount - 1; i++) {
                        float segDist = distance_to_curve(p, fPath[i].point,
                                fPath[i].point_out, fPath[i + 1].point_in, fPath[i + 1].point);
                        if (segDist < *distance) {
                                *distance = segDist;
                                *index = i + 1;
                        }
                }
                if (fClosed) {
                        float segDist = distance_to_curve(p, fPath[fPointCount - 1].point,
                                fPath[fPointCount - 1].point_out, fPath[0].point_in,
                                fPath[0].point);
                        if (segDist < *distance) {
                                *distance = segDist;
                                *index = fPointCount;
                        }
                }
                return true;
        }
        return false;
}


bool
VectorPath::FindBezierScale(int32 index, BPoint point, double* scale) const
{
        if (index >= 0 && index < fPointCount && scale) {
                int maxStep = 1000;

                double t = 0.0;
                double dt = 1.0 / maxStep;

                *scale = 0.0;
                double min = FLT_MAX;

                BPoint curvePoint;
                for (int step = 1; step < maxStep; step++) {
                        t += dt;

                        GetPoint(index, t, curvePoint);
                        double d = agg::calc_distance(curvePoint.x, curvePoint.y,
                                point.x, point.y);

                        if (d < min) {
                                min = d;
                                *scale = t;
                        }
                }
                return true;
        }
        return false;
}


bool
VectorPath::GetPoint(int32 index, double t, BPoint& point) const
{
        if (index >= 0 && index < fPointCount) {
                double t1 = (1 - t) * (1 - t) * (1 - t);
                double t2 = (1 - t) * (1 - t) * t * 3;
                double t3 = (1 - t) * t * t * 3;
                double t4 = t * t * t;

                if (index < fPointCount - 1) {
                        point.x = fPath[index].point.x * t1 + fPath[index].point_out.x * t2
                                + fPath[index + 1].point_in.x * t3
                                + fPath[index + 1].point.x * t4;

                        point.y = fPath[index].point.y * t1 + fPath[index].point_out.y * t2
                                + fPath[index + 1].point_in.y * t3
                                + fPath[index + 1].point.y * t4;
                } else if (fClosed) {
                        point.x = fPath[fPointCount - 1].point.x * t1
                                + fPath[fPointCount - 1].point_out.x * t2
                                + fPath[0].point_in.x * t3 + fPath[0].point.x * t4;

                        point.y = fPath[fPointCount - 1].point.y * t1
                                + fPath[fPointCount - 1].point_out.y * t2
                                + fPath[0].point_in.y * t3 + fPath[0].point.y * t4;
                }

                return true;
        }
        return false;
}

#endif // ICON_O_MATIC


void
VectorPath::SetClosed(bool closed)
{
        if (fClosed != closed) {
                fClosed = closed;
                _NotifyClosedChanged();
                Notify();
        }
}


BRect
VectorPath::Bounds() const
{
        // the bounds of the actual curves, not the control points!
        if (!fCachedBounds.IsValid())
                 fCachedBounds = _Bounds();
        return fCachedBounds;
}


BRect
VectorPath::_Bounds() const
{
        agg::path_storage path;

        BRect b;
        if (get_path_storage(path, fPath, fPointCount, fClosed)) {
                agg::conv_curve<agg::path_storage> curve(path);

                uint32 pathID[1];
                pathID[0] = 0;
                double left, top, right, bottom;

                agg::bounding_rect(curve, pathID, 0, 1, &left, &top, &right, &bottom);

                b.Set(left, top, right, bottom);
        } else if (fPointCount == 1) {
                b.Set(fPath[0].point.x, fPath[0].point.y, fPath[0].point.x,
                        fPath[0].point.y);
        } else {
                b.Set(0.0, 0.0, -1.0, -1.0);
        }
        return b;
}


BRect
VectorPath::ControlPointBounds() const
{
        if (fPointCount > 0) {
                BRect r(fPath[0].point, fPath[0].point);
                for (int32 i = 0; i < fPointCount; i++) {
                        // include point
                        r.left = min_c(r.left, fPath[i].point.x);
                        r.top = min_c(r.top, fPath[i].point.y);
                        r.right = max_c(r.right, fPath[i].point.x);
                        r.bottom = max_c(r.bottom, fPath[i].point.y);
                        // include "in" point
                        r.left = min_c(r.left, fPath[i].point_in.x);
                        r.top = min_c(r.top, fPath[i].point_in.y);
                        r.right = max_c(r.right, fPath[i].point_in.x);
                        r.bottom = max_c(r.bottom, fPath[i].point_in.y);
                        // include "out" point
                        r.left = min_c(r.left, fPath[i].point_out.x);
                        r.top = min_c(r.top, fPath[i].point_out.y);
                        r.right = max_c(r.right, fPath[i].point_out.x);
                        r.bottom = max_c(r.bottom, fPath[i].point_out.y);
                }
                return r;
        }
        return BRect(0.0, 0.0, -1.0, -1.0);
}


void
VectorPath::Iterate(Iterator* iterator, float smoothScale) const
{
        if (fPointCount > 1) {
                // generate a curve for each segment of the path
                // then iterate over the segments of the curve
                agg::curve4_inc curve;
                curve.approximation_scale(smoothScale);

                for (int32 i = 0; i < fPointCount - 1; i++) {
                        iterator->MoveTo(fPath[i].point);
                        curve.init(fPath[i].point.x, fPath[i].point.y,
                                fPath[i].point_out.x, fPath[i].point_out.y,
                                fPath[i + 1].point_in.x, fPath[i + 1].point_in.y,
                                fPath[i + 1].point.x, fPath[i + 1].point.y);

                        double x, y;
                        unsigned cmd = curve.vertex(&x, &y);
                        while (!agg::is_stop(cmd)) {
                                BPoint p(x, y);
                                iterator->LineTo(p);
                                cmd = curve.vertex(&x, &y);
                        }
                }
                if (fClosed) {
                        iterator->MoveTo(fPath[fPointCount - 1].point);
                        curve.init(fPath[fPointCount - 1].point.x,
                                fPath[fPointCount - 1].point.y,
                                fPath[fPointCount - 1].point_out.x,
                                fPath[fPointCount - 1].point_out.y,
                                fPath[0].point_in.x, fPath[0].point_in.y,
                                fPath[0].point.x, fPath[0].point.y);

                        double x, y;
                        unsigned cmd = curve.vertex(&x, &y);
                        while (!agg::is_stop(cmd)) {
                                BPoint p(x, y);
                                iterator->LineTo(p);
                                cmd = curve.vertex(&x, &y);
                        }
                }
        }
}


void
VectorPath::CleanUp()
{
        if (fPointCount == 0)
                return;

        bool notify = false;

        // remove last point if it is coincident with the first
        if (fClosed && fPointCount >= 1) {
                if (fPath[0].point == fPath[fPointCount - 1].point) {
                        fPath[0].point_in = fPath[fPointCount - 1].point_in;
                        _SetPointCount(fPointCount - 1);
                        notify = true;
                }
        }

        for (int32 i = 0; i < fPointCount; i++) {
                // check for unnecessary, duplicate points
                if (i > 0) {
                        if (fPath[i - 1].point == fPath[i].point
                                && fPath[i - 1].point == fPath[i - 1].point_out
                                && fPath[i].point == fPath[i].point_in) {
                                // the previous point can be removed
                                BPoint in = fPath[i - 1].point_in;
                                if (RemovePoint(i - 1)) {
                                        i--;
                                        fPath[i].point_in = in;
                                        notify = true;
                                }
                        }
                }
                // re-establish connections of in-out control points if
                // they line up with the main control point
                if (fPath[i].point_in == fPath[i].point_out
                        || fPath[i].point == fPath[i].point_out
                        || fPath[i].point == fPath[i].point_in
                        || (fabs(agg::calc_line_point_distance(fPath[i].point_in.x,
                                        fPath[i].point_in.y, fPath[i].point.x, fPath[i].point.y,
                                        fPath[i].point_out.x, fPath[i].point_out.y)) < 0.01
                                && fabs(agg::calc_line_point_distance(fPath[i].point_out.x,
                                        fPath[i].point_out.y, fPath[i].point.x, fPath[i].point.y,
                                        fPath[i].point_in.x, fPath[i].point_in.y)) < 0.01)) {
                        fPath[i].connected = true;
                        notify = true;
                }
        }

        if (notify)
                _NotifyPathChanged();
}


void
VectorPath::Reverse()
{
        VectorPath temp(*this);
        int32 index = 0;
        for (int32 i = fPointCount - 1; i >= 0; i--) {
                temp.SetPoint(index, fPath[i].point, fPath[i].point_out,
                        fPath[i].point_in, fPath[i].connected);
                index++;
        }
        *this = temp;

        _NotifyPathReversed();
}


void
VectorPath::ApplyTransform(const Transformable& transform)
{
        if (transform.IsIdentity())
                return;

        for (int32 i = 0; i < fPointCount; i++) {
                transform.Transform(&(fPath[i].point));
                transform.Transform(&(fPath[i].point_out));
                transform.Transform(&(fPath[i].point_in));
        }

        _NotifyPathChanged();
}


void
VectorPath::PrintToStream() const
{
        for (int32 i = 0; i < fPointCount; i++) {
                printf("point %" B_PRId32 ": (%f, %f) -> (%f, %f) -> (%f, %f) (%d)\n", i,
                        fPath[i].point_in.x, fPath[i].point_in.y,
                        fPath[i].point.x, fPath[i].point.y,
                        fPath[i].point_out.x, fPath[i].point_out.y, fPath[i].connected);
        }
}


bool
VectorPath::GetAGGPathStorage(agg::path_storage& path) const
{
        return get_path_storage(path, fPath, fPointCount, fClosed);
}


// #pragma mark -


#ifdef ICON_O_MATIC

bool
VectorPath::AddListener(PathListener* listener)
{
        if (listener && !fListeners.HasItem((void*)listener))
                return fListeners.AddItem((void*)listener);
        return false;
}


bool
VectorPath::RemoveListener(PathListener* listener)
{
        return fListeners.RemoveItem((void*)listener);
}


int32
VectorPath::CountListeners() const
{
        return fListeners.CountItems();
}


PathListener*
VectorPath::ListenerAtFast(int32 index) const
{
        return (PathListener*)fListeners.ItemAtFast(index);
}

#endif // ICON_O_MATIC


// #pragma mark -


void
VectorPath::_SetPoint(int32 index, BPoint point)
{
        fPath[index].point = point;
        fPath[index].point_in = point;
        fPath[index].point_out = point;

        fPath[index].connected = true;

        fCachedBounds.Set(0.0, 0.0, -1.0, -1.0);
}


void
VectorPath::_SetPoint(int32 index, const BPoint& point, const BPoint& pointIn,
        const BPoint& pointOut, bool connected)
{
        fPath[index].point = point;
        fPath[index].point_in = pointIn;
        fPath[index].point_out = pointOut;

        fPath[index].connected = connected;

        fCachedBounds.Set(0.0, 0.0, -1.0, -1.0);
}


// #pragma mark -


bool
VectorPath::_SetPointCount(int32 count)
{
        // handle reallocation if we run out of room
        if (count >= fAllocCount) {
                fAllocCount = ((count) / ALLOC_CHUNKS + 1) * ALLOC_CHUNKS;
                if (fPath)
                        fPath = obj_renew(fPath, control_point, fAllocCount);
                else
                        fPath = obj_new(control_point, fAllocCount);

                if (fPath != NULL) {
                        memset((void*)(fPath + fPointCount), 0,
                                (fAllocCount - fPointCount) * sizeof(control_point));
                }
        }

        // update point count
        if (fPath) {
                fPointCount = count;
        } else {
                // reallocation might have failed
                fPointCount = 0;
                fAllocCount = 0;
                fprintf(stderr, "VectorPath::_SetPointCount(%" B_PRId32 ") - allocation failed!\n",
                        count);
        }

        fCachedBounds.Set(0.0, 0.0, -1.0, -1.0);

        return fPath != NULL;
}


// #pragma mark -


#ifdef ICON_O_MATIC

void
VectorPath::_NotifyPointAdded(int32 index) const
{
        BList listeners(fListeners);
        int32 count = listeners.CountItems();
        for (int32 i = 0; i < count; i++) {
                PathListener* listener = (PathListener*)listeners.ItemAtFast(i);
                listener->PointAdded(index);
        }
}


void
VectorPath::_NotifyPointChanged(int32 index) const
{
        BList listeners(fListeners);
        int32 count = listeners.CountItems();
        for (int32 i = 0; i < count; i++) {
                PathListener* listener = (PathListener*)listeners.ItemAtFast(i);
                listener->PointChanged(index);
        }
}


void
VectorPath::_NotifyPointRemoved(int32 index) const
{
        BList listeners(fListeners);
        int32 count = listeners.CountItems();
        for (int32 i = 0; i < count; i++) {
                PathListener* listener = (PathListener*)listeners.ItemAtFast(i);
                listener->PointRemoved(index);
        }
}


void
VectorPath::_NotifyPathChanged() const
{
        BList listeners(fListeners);
        int32 count = listeners.CountItems();
        for (int32 i = 0; i < count; i++) {
                PathListener* listener = (PathListener*)listeners.ItemAtFast(i);
                listener->PathChanged();
        }
}


void
VectorPath::_NotifyClosedChanged() const
{
        BList listeners(fListeners);
        int32 count = listeners.CountItems();
        for (int32 i = 0; i < count; i++) {
                PathListener* listener = (PathListener*)listeners.ItemAtFast(i);
                listener->PathClosedChanged();
        }
}


void
VectorPath::_NotifyPathReversed() const
{
        BList listeners(fListeners);
        int32 count = listeners.CountItems();
        for (int32 i = 0; i < count; i++) {
                PathListener* listener = (PathListener*)listeners.ItemAtFast(i);
                listener->PathReversed();
        }
}

#endif // ICON_O_MATIC