~centralelyon2010/inkscape/imagelinks2

/*

 * Various utility methods for gradients

 *

 * Authors:

 *   Lauris Kaplinski <lauris@kaplinski.com>

 *   bulia byak

 *   Johan Engelen <j.b.c.engelen@ewi.utwente.nl>

 *   Jon A. Cruz <jon@joncruz.org>

 *   Abhishek Sharma

 *

 * Copyright (C) 2010 Authors

 * Copyright (C) 2007 Johan Engelen

 * Copyright (C) 2001-2005 authors

 * Copyright (C) 2001 Ximian, Inc.

 *

 * Released under GNU GPL, read the file 'COPYING' for more information

 */

#include <2geom/transforms.h>

#include <2geom/bezier-curve.h>

#include "style.h"

#include "document-private.h"

#include "desktop-style.h"

#include "sp-gradient-reference.h"

#include "sp-gradient-vector.h"

#include "sp-linear-gradient.h"

#include "sp-radial-gradient.h"

#include "sp-stop.h"

#include "widgets/gradient-vector.h"

#include "sp-text.h"

#include "sp-tspan.h"

#include "xml/repr.h"

#include "svg/svg.h"

#include "svg/svg-color.h"

#include "svg/css-ostringstream.h"

#include "preferences.h"

#define noSP_GR_VERBOSE

// Terminology:

//

// "vector" is a gradient that has stops but not position coords. It can be referenced by one or

// more privates. Objects should not refer to it directly. It has no radial/linear distinction.

//

// "private" is a gradient that has no stops but has position coords (e.g. center, radius etc for a

// radial). It references a vector for the actual colors. Each private is only used by one

// object. It is either linear or radial.

static void sp_gradient_repr_set_link(Inkscape::XML::Node *repr, SPGradient *gr);

SPGradient *sp_gradient_ensure_vector_normalized(SPGradient *gr)

{

#ifdef SP_GR_VERBOSE

    g_message("sp_gradient_ensure_vector_normalized(%p)", gr);

#endif

    g_return_val_if_fail(gr != NULL, NULL);

    g_return_val_if_fail(SP_IS_GRADIENT(gr), NULL);

    /* If we are already normalized vector, just return */

    if (gr->state == SP_GRADIENT_STATE_VECTOR) return gr;

    /* Fail, if we have wrong state set */

    if (gr->state != SP_GRADIENT_STATE_UNKNOWN) {

        g_warning("file %s: line %d: Cannot normalize private gradient to vector (%s)", __FILE__, __LINE__, gr->getId());

        return NULL;

    }

    /* First make sure we have vector directly defined (i.e. gr has its own stops) */

    if ( !gr->hasStops() ) {

        /* We do not have stops ourselves, so flatten stops as well */

        gr->ensureVector();

        g_assert(gr->vector.built);

        // this adds stops from gr->vector as children to gr

        sp_gradient_repr_write_vector (gr);

    }

    /* If gr hrefs some other gradient, remove the href */

    if (gr->ref->getObject()) {

        // We are hrefing someone, so require flattening

        gr->updateRepr(SP_OBJECT_WRITE_EXT | SP_OBJECT_WRITE_ALL);

        sp_gradient_repr_set_link(gr->getRepr(), NULL);

    }

    /* Everything is OK, set state flag */

    gr->state = SP_GRADIENT_STATE_VECTOR;

    return gr;

}

/**

 * Creates new private gradient for the given vector

 */

static SPGradient *sp_gradient_get_private_normalized(SPDocument *document, SPGradient *vector, SPGradientType type)

{

#ifdef SP_GR_VERBOSE

    g_message("sp_gradient_get_private_normalized(%p, %p, %d)", document, vector, type);

#endif

    g_return_val_if_fail(document != NULL, NULL);

    g_return_val_if_fail(vector != NULL, NULL);

    g_return_val_if_fail(SP_IS_GRADIENT(vector), NULL);

    g_return_val_if_fail(vector->hasStops(), NULL);

    SPDefs *defs = document->getDefs();

    Inkscape::XML::Document *xml_doc = document->getReprDoc();

    // create a new private gradient of the requested type

    Inkscape::XML::Node *repr;

    if (type == SP_GRADIENT_TYPE_LINEAR) {

        repr = xml_doc->createElement("svg:linearGradient");

    } else {

        repr = xml_doc->createElement("svg:radialGradient");

    }

    // privates are garbage-collectable

    repr->setAttribute("inkscape:collect", "always");

    // link to vector

    sp_gradient_repr_set_link(repr, vector);

    /* Append the new private gradient to defs */

    defs->getRepr()->appendChild(repr);

    Inkscape::GC::release(repr);

    // get corresponding object

    SPGradient *gr = (SPGradient *) document->getObjectByRepr(repr);

    g_assert(gr != NULL);

    g_assert(SP_IS_GRADIENT(gr));

    return gr;

}

/**

Count how many times gr is used by the styles of o and its descendants

*/

guint count_gradient_hrefs(SPObject *o, SPGradient *gr)

{

    if (!o)

        return 1;

    guint i = 0;

    SPStyle *style = o->style;

    if (style

        && style->fill.isPaintserver()

        && SP_IS_GRADIENT(SP_STYLE_FILL_SERVER(style))

        && SP_GRADIENT(SP_STYLE_FILL_SERVER(style)) == gr)

    {

        i ++;

    }

    if (style

        && style->stroke.isPaintserver()

        && SP_IS_GRADIENT(SP_STYLE_STROKE_SERVER(style))

        && SP_GRADIENT(SP_STYLE_STROKE_SERVER(style)) == gr)

    {

        i ++;

    }

    for ( SPObject *child = o->firstChild(); child; child = child->getNext() ) {

        i += count_gradient_hrefs(child, gr);

    }

    return i;

}

/**

 * If gr has other users, create a new private; also check if gr links to vector, relink if not

 */

SPGradient *sp_gradient_fork_private_if_necessary(SPGradient *gr, SPGradient *vector,

                                                  SPGradientType type, SPObject *o)

{

#ifdef SP_GR_VERBOSE

    g_message("sp_gradient_fork_private_if_necessary(%p, %p, %d, %p)", gr, vector, type, o);

#endif

    g_return_val_if_fail(gr != NULL, NULL);

    g_return_val_if_fail(SP_IS_GRADIENT(gr), NULL);

    // Orphaned gradient, no vector with stops at the end of the line; this used to be an assert

    // but i think we should not abort on this - maybe just write a validity warning into some sort

    // of log

    if ( !vector || !vector->hasStops() ) {

        return (gr);

    }

    // user is the object that uses this gradient; normally it's item but for tspans, we

    // check its ancestor text so that tspans don't get different gradients from their

    // texts.

    SPObject *user = o;

    while (SP_IS_TSPAN(user)) {

        user = user->parent;

    }

    // Check the number of uses of the gradient within this object;

    // if we are private and there are no other users,

    if (!vector->isSwatch() && (gr->hrefcount <= count_gradient_hrefs(user, gr))) {

        // check vector

        if ( gr != vector && gr->ref->getObject() != vector ) {

            /* our href is not the vector, and vector is different from gr; relink */

            sp_gradient_repr_set_link(gr->getRepr(), vector);

        }

        return gr;

    }

    SPDocument *doc = gr->document;

    SPObject *defs = doc->getDefs();

    if ((gr->hasStops()) ||

        (gr->state != SP_GRADIENT_STATE_UNKNOWN) ||

        (gr->parent != SP_OBJECT(defs)) ||

        (gr->hrefcount > 1)) {

        // we have to clone a fresh new private gradient for the given vector

        // create an empty one

        SPGradient *gr_new = sp_gradient_get_private_normalized(doc, vector, type);

        // copy all the attributes to it

        Inkscape::XML::Node *repr_new = gr_new->getRepr();

        Inkscape::XML::Node *repr = gr->getRepr();

        repr_new->setAttribute("gradientUnits", repr->attribute("gradientUnits"));

        repr_new->setAttribute("gradientTransform", repr->attribute("gradientTransform"));

        repr_new->setAttribute("spreadMethod", repr->attribute("spreadMethod"));

        if (SP_IS_RADIALGRADIENT(gr)) {

            repr_new->setAttribute("cx", repr->attribute("cx"));

            repr_new->setAttribute("cy", repr->attribute("cy"));

            repr_new->setAttribute("fx", repr->attribute("fx"));

            repr_new->setAttribute("fy", repr->attribute("fy"));

            repr_new->setAttribute("r", repr->attribute("r"));

        } else {

            repr_new->setAttribute("x1", repr->attribute("x1"));

            repr_new->setAttribute("y1", repr->attribute("y1"));

            repr_new->setAttribute("x2", repr->attribute("x2"));

            repr_new->setAttribute("y2", repr->attribute("y2"));

        }

        return gr_new;

    } else {

        return gr;

    }

}

SPGradient *sp_gradient_fork_vector_if_necessary(SPGradient *gr)

{

#ifdef SP_GR_VERBOSE

    g_message("sp_gradient_fork_vector_if_necessary(%p)", gr);

#endif

    // Some people actually prefer their gradient vectors to be shared...

    Inkscape::Preferences *prefs = Inkscape::Preferences::get();

    if (!prefs->getBool("/options/forkgradientvectors/value", true))

        return gr;

    if (gr->hrefcount > 1) {

        SPDocument *doc = gr->document;

        Inkscape::XML::Document *xml_doc = doc->getReprDoc();

        Inkscape::XML::Node *repr = gr->getRepr()->duplicate(xml_doc);

        doc->getDefs()->getRepr()->addChild(repr, NULL);

        SPGradient *gr_new = (SPGradient *) doc->getObjectByRepr(repr);

        gr_new = sp_gradient_ensure_vector_normalized (gr_new);

        Inkscape::GC::release(repr);

        return gr_new;

    }

    return gr;

}

/**

 *  Obtain the vector from the gradient. A forked vector will be created and linked to this gradient if another gradient uses it.

 */

SPGradient *sp_gradient_get_forked_vector_if_necessary(SPGradient *gradient, bool force_vector)

{

#ifdef SP_GR_VERBOSE

    g_message("sp_gradient_get_forked_vector_if_necessary(%p, %d)", gradient, force_vector);

#endif

    SPGradient *vector = gradient->getVector(force_vector);

    vector = sp_gradient_fork_vector_if_necessary (vector);

    if ( gradient != vector && gradient->ref->getObject() != vector ) {

        sp_gradient_repr_set_link(gradient->getRepr(), vector);

    }

    return vector;

}

/**

 * Convert an item's gradient to userspace _without_ preserving coords, setting them to defaults

 * instead. No forking or reapplying is done because this is only called for newly created privates.

 * @return The new gradient.

 */

SPGradient *sp_gradient_reset_to_userspace(SPGradient *gr, SPItem *item)

{

#ifdef SP_GR_VERBOSE

    g_message("sp_gradient_reset_to_userspace(%p, %p)", gr, item);

#endif

    Inkscape::XML::Node *repr = gr->getRepr();

    // calculate the bbox of the item

    item->document->ensureUpToDate();

    Geom::OptRect bbox = item->visualBounds(); // we need "true" bbox without item_i2d_affine

    if (!bbox)

        return gr;

    Geom::Coord const width = bbox->dimensions()[Geom::X];

    Geom::Coord const height = bbox->dimensions()[Geom::Y];

    Geom::Point const center = bbox->midpoint();

    if (SP_IS_RADIALGRADIENT(gr)) {

        sp_repr_set_svg_double(repr, "cx", center[Geom::X]);

        sp_repr_set_svg_double(repr, "cy", center[Geom::Y]);

        sp_repr_set_svg_double(repr, "fx", center[Geom::X]);

        sp_repr_set_svg_double(repr, "fy", center[Geom::Y]);

        sp_repr_set_svg_double(repr, "r", width/2);

        // we want it to be elliptic, not circular

        Geom::Affine squeeze = Geom::Translate (-center) *

            Geom::Scale(1, height/width) *

            Geom::Translate (center);

        gr->gradientTransform = squeeze;

        {

            gchar *c=sp_svg_transform_write(gr->gradientTransform);

            gr->getRepr()->setAttribute("gradientTransform", c);

            g_free(c);

        }

    } else {

        sp_repr_set_svg_double(repr, "x1", (center - Geom::Point(width/2, 0))[Geom::X]);

        sp_repr_set_svg_double(repr, "y1", (center - Geom::Point(width/2, 0))[Geom::Y]);

        sp_repr_set_svg_double(repr, "x2", (center + Geom::Point(width/2, 0))[Geom::X]);

        sp_repr_set_svg_double(repr, "y2", (center + Geom::Point(width/2, 0))[Geom::Y]);

    }

    // set the gradientUnits

    repr->setAttribute("gradientUnits", "userSpaceOnUse");

    return gr;

}

/**

 * Convert an item's gradient to userspace if necessary, also fork it if necessary.

 * @return The new gradient.

 */

SPGradient *sp_gradient_convert_to_userspace(SPGradient *gr, SPItem *item, gchar const *property)

{

#ifdef SP_GR_VERBOSE

    g_message("sp_gradient_convert_to_userspace(%p, %p, \"%s\")", gr, item, property);

#endif

    g_return_val_if_fail(SP_IS_GRADIENT(gr), NULL);

    if ( gr && gr->isSolid() ) {

        return gr;

    }

    // First, fork it if it is shared

    gr = sp_gradient_fork_private_if_necessary(gr, gr->getVector(),

                                               SP_IS_RADIALGRADIENT(gr) ? SP_GRADIENT_TYPE_RADIAL : SP_GRADIENT_TYPE_LINEAR, item);

    if (gr->getUnits() == SP_GRADIENT_UNITS_OBJECTBOUNDINGBOX) {

        Inkscape::XML::Node *repr = gr->getRepr();

        // calculate the bbox of the item

        item->document->ensureUpToDate();

        Geom::Affine bbox2user;

        Geom::OptRect bbox = item->visualBounds(); // we need "true" bbox without item_i2d_affine

        if ( bbox ) {

            bbox2user = Geom::Affine(bbox->dimensions()[Geom::X], 0,

                                   0, bbox->dimensions()[Geom::Y],

                                   bbox->min()[Geom::X], bbox->min()[Geom::Y]);

        } else {

            // would be degenerate otherwise

            bbox2user = Geom::identity();

        }

        /* skew is the additional transform, defined by the proportions of the item, that we need

         * to apply to the gradient in order to work around this weird bit from SVG 1.1

         * (http://www.w3.org/TR/SVG11/pservers.html#LinearGradients):

         *

         *   When gradientUnits="objectBoundingBox" and gradientTransform is the identity

         *   matrix, the stripes of the linear gradient are perpendicular to the gradient

         *   vector in object bounding box space (i.e., the abstract coordinate system where

         *   (0,0) is at the top/left of the object bounding box and (1,1) is at the

         *   bottom/right of the object bounding box). When the object's bounding box is not

         *   square, the stripes that are conceptually perpendicular to the gradient vector

         *   within object bounding box space will render non-perpendicular relative to the

         *   gradient vector in user space due to application of the non-uniform scaling

         *   transformation from bounding box space to user space.

         */

        Geom::Affine skew = bbox2user;

        double exp = skew.descrim();

        skew[0] /= exp;

        skew[1] /= exp;

        skew[2] /= exp;

        skew[3] /= exp;

        skew[4] = 0;

        skew[5] = 0;

        // apply skew to the gradient

        gr->gradientTransform = skew;

        {

            gchar *c=sp_svg_transform_write(gr->gradientTransform);

            gr->getRepr()->setAttribute("gradientTransform", c);

            g_free(c);

        }

        // Matrix to convert points to userspace coords; postmultiply by inverse of skew so

        // as to cancel it out when it's applied to the gradient during rendering

        Geom::Affine point_convert = bbox2user * skew.inverse();

        if (SP_IS_RADIALGRADIENT(gr)) {

            SPRadialGradient *rg = SP_RADIALGRADIENT(gr);

            // original points in the bbox coords

            Geom::Point c_b = Geom::Point(rg->cx.computed, rg->cy.computed);

            Geom::Point f_b = Geom::Point(rg->fx.computed, rg->fy.computed);

            double r_b = rg->r.computed;

            // converted points in userspace coords

            Geom::Point c_u = c_b * point_convert;

            Geom::Point f_u = f_b * point_convert;

            double r_u = r_b * point_convert.descrim();

            sp_repr_set_svg_double(repr, "cx", c_u[Geom::X]);

            sp_repr_set_svg_double(repr, "cy", c_u[Geom::Y]);

            sp_repr_set_svg_double(repr, "fx", f_u[Geom::X]);

            sp_repr_set_svg_double(repr, "fy", f_u[Geom::Y]);

            sp_repr_set_svg_double(repr, "r", r_u);

        } else {

            SPLinearGradient *lg = SP_LINEARGRADIENT(gr);

            Geom::Point p1_b = Geom::Point(lg->x1.computed, lg->y1.computed);

            Geom::Point p2_b = Geom::Point(lg->x2.computed, lg->y2.computed);

            Geom::Point p1_u = p1_b * point_convert;

            Geom::Point p2_u = p2_b * point_convert;

            sp_repr_set_svg_double(repr, "x1", p1_u[Geom::X]);

            sp_repr_set_svg_double(repr, "y1", p1_u[Geom::Y]);

            sp_repr_set_svg_double(repr, "x2", p2_u[Geom::X]);

            sp_repr_set_svg_double(repr, "y2", p2_u[Geom::Y]);

        }

        // set the gradientUnits

        repr->setAttribute("gradientUnits", "userSpaceOnUse");

    }

    // apply the gradient to the item (may be necessary if we forked it); not recursive

    // generally because grouped items will be taken care of later (we're being called

    // from sp_item_adjust_paint_recursive); however text and all its children should all

    // refer to one gradient, hence the recursive call for text (because we can't/don't

    // want to access tspans and set gradients on them separately)

    if (SP_IS_TEXT(item)) {

        sp_style_set_property_url(item, property, gr, true);

    } else {

        sp_style_set_property_url(item, property, gr, false);

    }

    return gr;

}

void sp_gradient_transform_multiply(SPGradient *gradient, Geom::Affine postmul, bool set)

{

#ifdef SP_GR_VERBOSE

    g_message("sp_gradient_transform_multiply(%p, , %d)", gradient, set);

#endif

    if (set) {

        gradient->gradientTransform = postmul;

    } else {

        gradient->gradientTransform *= postmul; // fixme: get gradient transform by climbing to hrefs?

    }

    gradient->gradientTransform_set = TRUE;

    gchar *c=sp_svg_transform_write(gradient->gradientTransform);

    gradient->getRepr()->setAttribute("gradientTransform", c);

    g_free(c);

}

SPGradient *sp_item_gradient(SPItem *item, bool fill_or_stroke)

{

    SPStyle *style = item->style;

    SPGradient *gradient = 0;

    if (fill_or_stroke) {

        if (style && (style->fill.isPaintserver())) {

            SPPaintServer *server = item->style->getFillPaintServer();

            if ( SP_IS_GRADIENT(server) ) {

                gradient = SP_GRADIENT(server);

            }

        }

    } else {

        if (style && (style->stroke.isPaintserver())) {

            SPPaintServer *server = item->style->getStrokePaintServer();

            if ( SP_IS_GRADIENT(server) ) {

                gradient = SP_GRADIENT(server);

            }

        }

    }

   return gradient;

}

SPStop *sp_last_stop(SPGradient *gradient)

{

    for (SPStop *stop = gradient->getFirstStop(); stop != NULL; stop = stop->getNextStop()) {

        if (stop->getNextStop() == NULL)

            return stop;

    }

    return NULL;

}

SPStop *sp_get_stop_i(SPGradient *gradient, guint stop_i)

{

    SPStop *stop = gradient->getFirstStop();

    // if this is valid but weird gradient without an offset-zero stop element,

    // inkscape has created a handle for the start of gradient anyway,

    // so when it asks for stop N that corresponds to stop element N-1

    if (stop->offset != 0)

        stop_i --;

    for (guint i = 0; i < stop_i; i++) {

        if (!stop) {

            return NULL;

        }

        stop = stop->getNextStop();

    }

    return stop;

}

guint32 average_color(guint32 c1, guint32 c2, gdouble p)

{

    guint32 r = (guint32) (SP_RGBA32_R_U (c1) * (1 - p) + SP_RGBA32_R_U (c2) * p);

    guint32 g = (guint32) (SP_RGBA32_G_U (c1) * (1 - p) + SP_RGBA32_G_U (c2) * p);

    guint32 b = (guint32) (SP_RGBA32_B_U (c1) * (1 - p) + SP_RGBA32_B_U (c2) * p);

    guint32 a = (guint32) (SP_RGBA32_A_U (c1) * (1 - p) + SP_RGBA32_A_U (c2) * p);

    return SP_RGBA32_U_COMPOSE(r, g, b, a);

}

SPStop *sp_vector_add_stop(SPGradient *vector, SPStop* prev_stop, SPStop* next_stop, gfloat offset)

{

#ifdef SP_GR_VERBOSE

    g_message("sp_vector_add_stop(%p, %p, %p, %f)", vector, prev_stop, next_stop, offset);

#endif

    Inkscape::XML::Node *new_stop_repr = NULL;

    new_stop_repr = prev_stop->getRepr()->duplicate(vector->getRepr()->document());

    vector->getRepr()->addChild(new_stop_repr, prev_stop->getRepr());

    SPStop *newstop = reinterpret_cast<SPStop *>(vector->document->getObjectByRepr(new_stop_repr));

    newstop->offset = offset;

    sp_repr_set_css_double( newstop->getRepr(), "offset", (double)offset);

    guint32 const c1 = sp_stop_get_rgba32(prev_stop);

    guint32 const c2 = sp_stop_get_rgba32(next_stop);

    guint32 cnew = average_color (c1, c2, (offset - prev_stop->offset) / (next_stop->offset - prev_stop->offset));

    Inkscape::CSSOStringStream os;

    gchar c[64];

    sp_svg_write_color (c, sizeof(c), cnew);

    gdouble opacity = (gdouble) SP_RGBA32_A_F (cnew);

    os << "stop-color:" << c << ";stop-opacity:" << opacity <<";";

    newstop->getRepr()->setAttribute("style", os.str().c_str());

    Inkscape::GC::release(new_stop_repr);

    return newstop;

}

void sp_item_gradient_edit_stop(SPItem *item, guint point_type, guint point_i, bool fill_or_stroke)

{

    SPGradient *gradient = sp_item_gradient (item, fill_or_stroke);

    if (!gradient || !SP_IS_GRADIENT(gradient))

        return;

    SPGradient *vector = gradient->getVector();

    switch (point_type) {

        case POINT_LG_BEGIN:

        case POINT_RG_CENTER:

        case POINT_RG_FOCUS:

        {

            GtkWidget *dialog = sp_gradient_vector_editor_new (vector, vector->getFirstStop());

            gtk_widget_show (dialog);

        }

        break;

        case POINT_LG_END:

        case POINT_RG_R1:

        case POINT_RG_R2:

        {

            GtkWidget *dialog = sp_gradient_vector_editor_new (vector, sp_last_stop (vector));

            gtk_widget_show (dialog);

        }

        break;

        case POINT_LG_MID:

        case POINT_RG_MID1:

        case POINT_RG_MID2:

        {

            GtkWidget *dialog = sp_gradient_vector_editor_new (vector, sp_get_stop_i (vector, point_i));

            gtk_widget_show (dialog);

        }

        break;

        default:

            break;

    }

}

guint32 sp_item_gradient_stop_query_style(SPItem *item, guint point_type, guint point_i, bool fill_or_stroke)

{

    SPGradient *gradient = sp_item_gradient (item, fill_or_stroke);

    if (!gradient || !SP_IS_GRADIENT(gradient))

        return 0;

    SPGradient *vector = gradient->getVector();

    if (!vector) // orphan!

        return 0; // what else to do?

    switch (point_type) {

        case POINT_LG_BEGIN:

        case POINT_RG_CENTER:

        case POINT_RG_FOCUS:

        {

            SPStop *first = vector->getFirstStop();

            if (first) {

                return sp_stop_get_rgba32(first);

            }

        }

        break;