#include "display/curve.h"

#include "libnr/nr-matrix-div.h"

#include "libnr/nr-matrix-fns.h"

#include "xml/repr.h"

#include "sp-conn-end.h"

#include "sp-path.h"

#include "uri.h"

#include "document.h"

static void change_endpts(SPCurve *const curve, NR::Point const h2endPt[2]);

static NR::Point calc_bbox_conn_pt(NR::Rect const &bbox, NR::Point const &p);

static double signed_one(double const x);

SPConnEnd::SPConnEnd(SPObject *const owner) :

ref(owner),

href(NULL),

_changed_connection(),

_delete_connection(),

_transformed_connection()

{

}

static SPObject const *

get_nearest_common_ancestor(SPObject const *const obj, SPItem const *const objs[2]) {

SPObject const *anc_sofar = obj;

for (unsigned i = 0; i < 2; ++i) {

if ( objs[i] != NULL ) {

anc_sofar = anc_sofar->nearestCommonAncestor(objs[i]);

}

}

return anc_sofar;

}

static void

sp_conn_end_move_compensate(NR::Matrix const */*mp*/, SPItem */*moved_item*/,

SPPath *const path,

bool const updatePathRepr = true)

{

// TODO: SPItem::getBounds gives the wrong result for some objects

// that have internal representations that are updated later

// by the sp_*_update functions, e.g., text.

sp_document_ensure_up_to_date(path->document);

// Get the new route around obstacles.

path->connEndPair.reroutePath();

SPItem *h2attItem[2];

path->connEndPair.getAttachedItems(h2attItem);

if ( !h2attItem[0] && !h2attItem[1] ) {

if (updatePathRepr) {

path->requestDisplayUpdate(SP_OBJECT_MODIFIED_FLAG);

path->updateRepr();

}

return;

}

SPItem const *const path_item = SP_ITEM(path);

SPObject const *const ancestor = get_nearest_common_ancestor(path_item, h2attItem);

NR::Matrix const path2anc(i2anc_affine(path_item, ancestor));

if (h2attItem[0] != NULL && h2attItem[1] != NULL) {

/* Initial end-points: centre of attached object. */

NR::Point h2endPt_icoordsys[2];

NR::Matrix h2i2anc[2];

NR::Rect h2bbox_icoordsys[2];

NR::Point last_seg_endPt[2] = {

sp_curve_second_point(path->curve),

sp_curve_penultimate_point(path->curve)

};

for (unsigned h = 0; h < 2; ++h) {

NR::Maybe<NR::Rect> bbox = h2attItem[h]->getBounds(NR::identity());

if (!bbox) {

if (updatePathRepr) {

path->requestDisplayUpdate(SP_OBJECT_MODIFIED_FLAG);

path->updateRepr();

}

return;

}

h2bbox_icoordsys[h] = *bbox;

h2i2anc[h] = i2anc_affine(h2attItem[h], ancestor);

h2endPt_icoordsys[h] = h2bbox_icoordsys[h].midpoint();

}

// For each attached object, change the corresponding point to be

// on the edge of the bbox.

NR::Point h2endPt_pcoordsys[2];

for (unsigned h = 0; h < 2; ++h) {

h2endPt_icoordsys[h] = calc_bbox_conn_pt(h2bbox_icoordsys[h],

( last_seg_endPt[h] / h2i2anc[h] ));

h2endPt_pcoordsys[h] = h2endPt_icoordsys[h] * h2i2anc[h] / path2anc;

}

change_endpts(path->curve, h2endPt_pcoordsys);

} else {

// We leave the unattached endpoint where it is, and adjust the

// position of the attached endpoint to be on the edge of the bbox.

unsigned ind;

NR::Point other_endpt;

NR::Point last_seg_pt;

if (h2attItem[0] != NULL) {

other_endpt = sp_curve_last_point(path->curve);

last_seg_pt = sp_curve_second_point(path->curve);

ind = 0;

}

else {

other_endpt = sp_curve_first_point(path->curve);

last_seg_pt = sp_curve_penultimate_point(path->curve);

ind = 1;

}

NR::Point h2endPt_icoordsys[2];

NR::Matrix h2i2anc;

NR::Rect otherpt_rect = NR::Rect(other_endpt, other_endpt);

NR::Rect h2bbox_icoordsys[2] = { otherpt_rect, otherpt_rect };

NR::Maybe<NR::Rect> bbox = h2attItem[ind]->getBounds(NR::identity());

if (!bbox) {

if (updatePathRepr) {

path->requestDisplayUpdate(SP_OBJECT_MODIFIED_FLAG);

path->updateRepr();

}

return;

}

h2bbox_icoordsys[ind] = *bbox;

h2i2anc = i2anc_affine(h2attItem[ind], ancestor);

h2endPt_icoordsys[ind] = h2bbox_icoordsys[ind].midpoint();

h2endPt_icoordsys[!ind] = other_endpt;

// For the attached object, change the corresponding point to be

// on the edge of the bbox.

NR::Point h2endPt_pcoordsys[2];

h2endPt_icoordsys[ind] = calc_bbox_conn_pt(h2bbox_icoordsys[ind],

( last_seg_pt / h2i2anc ));

h2endPt_pcoordsys[ind] = h2endPt_icoordsys[ind] * h2i2anc / path2anc;

// Leave the other where it is.

h2endPt_pcoordsys[!ind] = other_endpt;

change_endpts(path->curve, h2endPt_pcoordsys);

}

if (updatePathRepr) {

path->requestDisplayUpdate(SP_OBJECT_MODIFIED_FLAG);

path->updateRepr();

}

}

static void

sp_conn_end_shape_move_compensate(NR::Matrix const *mp, SPItem *moved_item,

SPPath *const path)

{

if (path->connEndPair.isAutoRoutingConn()) {

path->connEndPair.makePathInvalid();

}

sp_conn_end_move_compensate(mp, moved_item, path);

}

sp_conn_adjust_invalid_path(SPPath *const path)

{

sp_conn_end_move_compensate(NULL, NULL, path);

}

sp_conn_adjust_path(SPPath *const path)

{

if (path->connEndPair.isAutoRoutingConn()) {

path->connEndPair.makePathInvalid();

}

// Don't update the path repr or else connector dragging is slowed by

// constant update of values to the xml editor, and each step is also

// needlessly remembered by undo/redo.

bool const updatePathRepr = false;

sp_conn_end_move_compensate(NULL, NULL, path, updatePathRepr);

}

static NR::Point

calc_bbox_conn_pt(NR::Rect const &bbox, NR::Point const &p)

{

using NR::X;

using NR::Y;

NR::Point const ctr(bbox.midpoint());

NR::Point const lengths(bbox.dimensions());

if ( ctr == p ) {

/* Arbitrarily choose centre of right edge. */

return NR::Point(ctr[X] + .5 * lengths[X],

ctr[Y]);

}

NR::Point const cp( p - ctr );

NR::Dim2 const edgeDim = ( ( fabs(lengths[Y] * cp[X]) <

fabs(lengths[X] * cp[Y]) )

? Y

: X );

NR::Dim2 const otherDim = (NR::Dim2) !edgeDim;

NR::Point offset;

offset[edgeDim] = (signed_one(cp[edgeDim])

* lengths[edgeDim]);

offset[otherDim] = (lengths[edgeDim]

* cp[otherDim]

/ fabs(cp[edgeDim]));

g_assert((offset[otherDim] >= 0) == (cp[otherDim] >= 0));

#ifndef NDEBUG

for (unsigned d = 0; d < 2; ++d) {

g_assert(fabs(offset[d]) <= lengths[d] + .125);

}

#endif

return ctr + .5 * offset;

}

static double signed_one(double const x)

{

return (x < 0

? -1.

: 1.);

}

static void

change_endpts(SPCurve *const curve, NR::Point const h2endPt[2])

{

#if 0

sp_curve_reset(curve);

sp_curve_moveto(curve, h2endPt[0]);

sp_curve_lineto(curve, h2endPt[1]);

#else

sp_curve_move_endpoints(curve, h2endPt[0], h2endPt[1]);

#endif

}

static void

sp_conn_end_deleted(SPObject *, SPObject *const owner, unsigned const handle_ix)

{

// todo: The first argument is the deleted object, or just NULL if

// called by sp_conn_end_detach.

g_return_if_fail(handle_ix < 2);

char const *const attr_str[] = {"inkscape:connection-start",

"inkscape:connection-end"};

SP_OBJECT_REPR(owner)->setAttribute(attr_str[handle_ix], NULL);

/* I believe this will trigger sp_conn_end_href_changed. */

}

sp_conn_end_detach(SPObject *const owner, unsigned const handle_ix)

{

sp_conn_end_deleted(NULL, owner, handle_ix);

}

SPConnEnd::setAttacherHref(gchar const *value)

{

if ( value && href && ( strcmp(value, href) == 0 ) ) {

/* No change, do nothing. */

} else {

g_free(href);

href = NULL;

if (value) {

// First, set the href field, because sp_conn_end_href_changed will need it.

href = g_strdup(value);

// Now do the attaching, which emits the changed signal.

try {

ref.attach(Inkscape::URI(value));

} catch (Inkscape::BadURIException &e) {

/* TODO: Proper error handling as per

g_warning("%s", e.what());

ref.detach();

}

} else {

ref.detach();

}

}

}

sp_conn_end_href_changed(SPObject */*old_ref*/, SPObject */*ref*/,

SPConnEnd *connEndPtr, SPPath *const path, unsigned const handle_ix)

{

g_return_if_fail(connEndPtr != NULL);

SPConnEnd &connEnd = *connEndPtr;

connEnd._delete_connection.disconnect();

connEnd._transformed_connection.disconnect();

if (connEnd.href) {

SPObject *refobj = connEnd.ref.getObject();

if (refobj) {

connEnd._delete_connection

= SP_OBJECT(refobj)->connectDelete(sigc::bind(sigc::ptr_fun(&sp_conn_end_deleted),

SP_OBJECT(path), handle_ix));

connEnd._transformed_connection

= SP_ITEM(refobj)->connectTransformed(sigc::bind(sigc::ptr_fun(&sp_conn_end_shape_move_compensate),

path));

}

}

}