~centralelyon2010/inkscape/imagelinks2

/** @file

 * @brief Miscellanous operations on selected items

 */

/* Authors:

 *   Lauris Kaplinski <lauris@kaplinski.com>

 *   Frank Felfe <innerspace@iname.com>

 *   MenTaLguY <mental@rydia.net>

 *   bulia byak <buliabyak@users.sf.net>

 *   Andrius R. <knutux@gmail.com>

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

 *   Martin Sucha <martin.sucha-inkscape@jts-sro.sk>

 *   Abhishek Sharma

 *

 * Copyright (C) 1999-2010 authors

 * Copyright (C) 2001-2002 Ximian, Inc.

 *

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

 */

#ifdef HAVE_CONFIG_H

# include "config.h"

#endif

#include "selection-chemistry.h"

// TOOD fixme: This should be moved into preference repr

SPCycleType SP_CYCLING = SP_CYCLE_FOCUS;

#include <gtkmm/clipboard.h>

#include "svg/svg.h"

#include "desktop.h"

#include "desktop-style.h"

#include "dir-util.h"

#include "selection.h"

#include "tools-switch.h"

#include "desktop-handles.h"

#include "message-stack.h"

#include "sp-item-transform.h"

#include "marker.h"

#include "sp-use.h"

#include "sp-textpath.h"

#include "sp-tspan.h"

#include "sp-tref.h"

#include "sp-flowtext.h"

#include "sp-flowregion.h"

#include "sp-image.h"

#include "text-editing.h"

#include "text-context.h"

#include "connector-context.h"

#include "sp-path.h"

#include "sp-conn-end.h"

#include "dropper-context.h"

#include <glibmm/i18n.h>

#include <2geom/transforms.h>

#include "xml/repr.h"

#include "xml/rebase-hrefs.h"

#include "style.h"

#include "document-private.h"

#include "sp-gradient.h"

#include "sp-gradient-reference.h"

#include "sp-linear-gradient-fns.h"

#include "sp-pattern.h"

#include "sp-radial-gradient-fns.h"

#include "gradient-context.h"

#include "sp-namedview.h"

#include "preferences.h"

#include "sp-offset.h"

#include "sp-clippath.h"

#include "sp-mask.h"

#include "file.h"

#include "helper/png-write.h"

#include "layer-fns.h"

#include "context-fns.h"

#include <map>

#include <cstring>

#include <string>

#include "helper/units.h"

#include "sp-item.h"

#include "box3d.h"

#include "persp3d.h"

#include "unit-constants.h"

#include "xml/simple-document.h"

#include "sp-filter-reference.h"

#include "gradient-drag.h"

#include "uri-references.h"

#include "display/curve.h"

#include "display/canvas-bpath.h"

#include "inkscape-private.h"

#include "path-chemistry.h"

#include "ui/tool/control-point-selection.h"

#include "ui/tool/multi-path-manipulator.h"

#include "enums.h"

#include "sp-item-group.h"

// For clippath editing

#include "tools-switch.h"

#include "ui/tool/node-tool.h"

#include "ui/clipboard.h"

using Inkscape::DocumentUndo;

using Geom::X;

using Geom::Y;

/* The clipboard handling is in ui/clipboard.cpp now. There are some legacy functions left here,

because the layer manipulation code uses them. It should be rewritten specifically

for that purpose. */

namespace Inkscape {

void SelectionHelper::selectAll(SPDesktop *dt)

{

    if (tools_isactive(dt, TOOLS_NODES)) {

        InkNodeTool *nt = static_cast<InkNodeTool*>(dt->event_context);

        if (!nt->_multipath->empty()) {

            nt->_multipath->selectSubpaths();

            return;

        }

    }

    sp_edit_select_all(dt);

}

void SelectionHelper::selectAllInAll(SPDesktop *dt)

{

    if (tools_isactive(dt, TOOLS_NODES)) {

        InkNodeTool *nt = static_cast<InkNodeTool*>(dt->event_context);

        nt->_selected_nodes->selectAll();

    } else {

        sp_edit_select_all_in_all_layers(dt);

    }

}

void SelectionHelper::selectNone(SPDesktop *dt)

{

    if (tools_isactive(dt, TOOLS_NODES)) {

        InkNodeTool *nt = static_cast<InkNodeTool*>(dt->event_context);

        nt->_selected_nodes->clear();

    } else {

        sp_desktop_selection(dt)->clear();

    }

}

void SelectionHelper::invert(SPDesktop *dt)

{

    if (tools_isactive(dt, TOOLS_NODES)) {

        InkNodeTool *nt = static_cast<InkNodeTool*>(dt->event_context);

        nt->_multipath->invertSelectionInSubpaths();

    } else {

        sp_edit_invert(dt);

    }

}

void SelectionHelper::invertAllInAll(SPDesktop *dt)

{

    if (tools_isactive(dt, TOOLS_NODES)) {

        InkNodeTool *nt = static_cast<InkNodeTool*>(dt->event_context);

        nt->_selected_nodes->invertSelection();

    } else {

        sp_edit_invert_in_all_layers(dt);

    }

}

void SelectionHelper::reverse(SPDesktop *dt)

{

    // TODO make this a virtual method of event context!

    if (tools_isactive(dt, TOOLS_NODES)) {

        InkNodeTool *nt = static_cast<InkNodeTool*>(dt->event_context);

        nt->_multipath->reverseSubpaths();

    } else {

        sp_selected_path_reverse(dt);

    }

}

void SelectionHelper::selectNext(SPDesktop *dt)

{

    SPEventContext *ec = dt->event_context;

    if (tools_isactive(dt, TOOLS_NODES)) {

        InkNodeTool *nt = static_cast<InkNodeTool*>(dt->event_context);

        nt->_multipath->shiftSelection(1);

    } else if (tools_isactive(dt, TOOLS_GRADIENT)

               && ec->_grdrag->isNonEmpty()) {

        sp_gradient_context_select_next(ec);

    } else {

        sp_selection_item_next(dt);

    }

}

void SelectionHelper::selectPrev(SPDesktop *dt)

{

    SPEventContext *ec = dt->event_context;

    if (tools_isactive(dt, TOOLS_NODES)) {

        InkNodeTool *nt = static_cast<InkNodeTool*>(dt->event_context);

        nt->_multipath->shiftSelection(-1);

    } else if (tools_isactive(dt, TOOLS_GRADIENT)

               && ec->_grdrag->isNonEmpty()) {

        sp_gradient_context_select_prev(ec);

    } else {

        sp_selection_item_prev(dt);

    }

}

} // namespace Inkscape

/**

 * Copies repr and its inherited css style elements, along with the accumulated transform 'full_t',

 * then prepends the copy to 'clip'.

 */

void sp_selection_copy_one(Inkscape::XML::Node *repr, Geom::Affine full_t, GSList **clip, Inkscape::XML::Document* xml_doc)

{

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

    // copy complete inherited style

    SPCSSAttr *css = sp_repr_css_attr_inherited(repr, "style");

    sp_repr_css_set(copy, css, "style");

    sp_repr_css_attr_unref(css);

    // write the complete accumulated transform passed to us

    // (we're dealing with unattached repr, so we write to its attr

    // instead of using sp_item_set_transform)

    gchar *affinestr=sp_svg_transform_write(full_t);

    copy->setAttribute("transform", affinestr);

    g_free(affinestr);

    *clip = g_slist_prepend(*clip, copy);

}

void sp_selection_copy_impl(GSList const *items, GSList **clip, Inkscape::XML::Document* xml_doc)

{

    // Sort items:

    GSList *sorted_items = g_slist_copy((GSList *) items);

    sorted_items = g_slist_sort((GSList *) sorted_items, (GCompareFunc) sp_object_compare_position);

    // Copy item reprs:

    for (GSList *i = (GSList *) sorted_items; i != NULL; i = i->next) {

        sp_selection_copy_one(SP_OBJECT(i->data)->getRepr(), SP_ITEM(i->data)->i2doc_affine(), clip, xml_doc);

    }

    *clip = g_slist_reverse(*clip);

    g_slist_free((GSList *) sorted_items);

}

GSList *sp_selection_paste_impl(SPDocument *doc, SPObject *parent, GSList **clip)

{

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

    GSList *copied = NULL;

    // add objects to document

    for (GSList *l = *clip; l != NULL; l = l->next) {

        Inkscape::XML::Node *repr = (Inkscape::XML::Node *) l->data;

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

        // premultiply the item transform by the accumulated parent transform in the paste layer

        Geom::Affine local(SP_ITEM(parent)->i2doc_affine());

        if (!local.isIdentity()) {

            gchar const *t_str = copy->attribute("transform");

            Geom::Affine item_t(Geom::identity());

            if (t_str)

                sp_svg_transform_read(t_str, &item_t);

            item_t *= local.inverse();

            // (we're dealing with unattached repr, so we write to its attr instead of using sp_item_set_transform)

            gchar *affinestr=sp_svg_transform_write(item_t);

            copy->setAttribute("transform", affinestr);

            g_free(affinestr);

        }

        parent->appendChildRepr(copy);

        copied = g_slist_prepend(copied, copy);

        Inkscape::GC::release(copy);

    }

    return copied;

}

void sp_selection_delete_impl(GSList const *items, bool propagate = true, bool propagate_descendants = true)

{

    for (GSList const *i = items ; i ; i = i->next ) {

        sp_object_ref((SPObject *)i->data, NULL);

    }

    for (GSList const *i = items; i != NULL; i = i->next) {

        SPItem *item = reinterpret_cast<SPItem *>(i->data);

        item->deleteObject(propagate, propagate_descendants);

        sp_object_unref(item, NULL);

    }

}

void sp_selection_delete(SPDesktop *desktop)

{

    if (desktop == NULL) {

        return;

    }

    if (tools_isactive(desktop, TOOLS_TEXT))

        if (sp_text_delete_selection(desktop->event_context)) {

            DocumentUndo::done(sp_desktop_document(desktop), SP_VERB_CONTEXT_TEXT,

                               _("Delete text"));

            return;

        }

    Inkscape::Selection *selection = sp_desktop_selection(desktop);

    // check if something is selected

    if (selection->isEmpty()) {

        desktop->messageStack()->flash(Inkscape::WARNING_MESSAGE, _("<b>Nothing</b> was deleted."));

        return;

    }

    GSList const *selected = g_slist_copy(const_cast<GSList *>(selection->itemList()));

    selection->clear();

    sp_selection_delete_impl(selected);

    g_slist_free((GSList *) selected);

    /* a tool may have set up private information in it's selection context

     * that depends on desktop items.  I think the only sane way to deal with

     * this currently is to reset the current tool, which will reset it's

     * associated selection context.  For example: deleting an object

     * while moving it around the canvas.

     */

    tools_switch( desktop, tools_active( desktop ) );

    DocumentUndo::done(sp_desktop_document(desktop), SP_VERB_EDIT_DELETE,

                       _("Delete"));

}

void add_ids_recursive(std::vector<const gchar *> &ids, SPObject *obj)

{

    if (obj) {

        ids.push_back(obj->getId());

        if (SP_IS_GROUP(obj)) {

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

                add_ids_recursive(ids, child);

            }

        }

    }

}

void sp_selection_duplicate(SPDesktop *desktop, bool suppressDone)

{

    if (desktop == NULL) {

        return;

    }

    SPDocument *doc = desktop->doc();

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

    Inkscape::Selection *selection = sp_desktop_selection(desktop);

    // check if something is selected

    if (selection->isEmpty()) {

        desktop->messageStack()->flash(Inkscape::WARNING_MESSAGE, _("Select <b>object(s)</b> to duplicate."));

        return;

    }

    GSList *reprs = g_slist_copy((GSList *) selection->reprList());

    selection->clear();

    // sorting items from different parents sorts each parent's subset without possibly mixing

    // them, just what we need

    reprs = g_slist_sort(reprs, (GCompareFunc) sp_repr_compare_position);

    GSList *newsel = NULL;

    std::vector<const gchar *> old_ids;

    std::vector<const gchar *> new_ids;

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

    bool relink_clones = prefs->getBool("/options/relinkclonesonduplicate/value");

    while (reprs) {

        Inkscape::XML::Node *old_repr = (Inkscape::XML::Node *) reprs->data;

        Inkscape::XML::Node *parent = old_repr->parent();

        Inkscape::XML::Node *copy = old_repr->duplicate(xml_doc);

        parent->appendChild(copy);

        if (relink_clones) {

            SPObject *old_obj = doc->getObjectByRepr(old_repr);

            SPObject *new_obj = doc->getObjectByRepr(copy);

            add_ids_recursive(old_ids, old_obj);

            add_ids_recursive(new_ids, new_obj);

        }

        newsel = g_slist_prepend(newsel, copy);

        reprs = g_slist_remove(reprs, reprs->data);

        Inkscape::GC::release(copy);

    }

    if (relink_clones) {

        g_assert(old_ids.size() == new_ids.size());

        for (unsigned int i = 0; i < old_ids.size(); i++) {

            const gchar *id = old_ids[i];

            SPObject *old_clone = doc->getObjectById(id);

            if (SP_IS_USE(old_clone)) {

                SPItem *orig = sp_use_get_original(SP_USE(old_clone));

                if (!orig) // orphaned

                    continue;

                for (unsigned int j = 0; j < old_ids.size(); j++) {

                    if (!strcmp(orig->getId(), old_ids[j])) {

                        // we have both orig and clone in selection, relink

                        // std::cout << id  << " old, its ori: " << orig->getId() << "; will relink:" << new_ids[i] << " to " << new_ids[j] << "\n";

                        gchar *newref = g_strdup_printf("#%s", new_ids[j]);

                        SPObject *new_clone = doc->getObjectById(new_ids[i]);

                        new_clone->getRepr()->setAttribute("xlink:href", newref);

                        new_clone->requestDisplayUpdate(SP_OBJECT_MODIFIED_FLAG);

                        g_free(newref);

                    }

                }

            } else if (SP_IS_OFFSET(old_clone)) {

                for (guint j = 0; j < old_ids.size(); j++) {

                gchar *source_href = SP_OFFSET(old_clone)->sourceHref;

                    if (source_href && source_href[0]=='#' && !strcmp(source_href+1, old_ids[j])) {

                        gchar *newref = g_strdup_printf("#%s", new_ids[j]);

                        doc->getObjectById(new_ids[i])->getRepr()->setAttribute("xlink:href", newref);

                        g_free(newref);

                    }

                }

            }

        }

    }

    if ( !suppressDone ) {

        DocumentUndo::done(sp_desktop_document(desktop), SP_VERB_EDIT_DUPLICATE,

                           _("Duplicate"));

    }

    selection->setReprList(newsel);

    g_slist_free(newsel);

}

void sp_edit_clear_all(SPDesktop *dt)

{

    if (!dt)

        return;

    SPDocument *doc = sp_desktop_document(dt);

    sp_desktop_selection(dt)->clear();

    g_return_if_fail(SP_IS_GROUP(dt->currentLayer()));

    GSList *items = sp_item_group_item_list(SP_GROUP(dt->currentLayer()));

    while (items) {

        reinterpret_cast<SPObject*>(items->data)->deleteObject();

        items = g_slist_remove(items, items->data);

    }

    DocumentUndo::done(doc, SP_VERB_EDIT_CLEAR_ALL,

                       _("Delete all"));

}

GSList *get_all_items(GSList *list, SPObject *from, SPDesktop *desktop, bool onlyvisible, bool onlysensitive, GSList const *exclude)

{

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

        if (SP_IS_ITEM(child) &&

            !desktop->isLayer(SP_ITEM(child)) &&

            (!onlysensitive || !SP_ITEM(child)->isLocked()) &&

            (!onlyvisible || !desktop->itemIsHidden(SP_ITEM(child))) &&

            (!exclude || !g_slist_find((GSList *) exclude, child))

            )

        {

            list = g_slist_prepend(list, SP_ITEM(child));

        }

        if (SP_IS_ITEM(child) && desktop->isLayer(SP_ITEM(child))) {

            list = get_all_items(list, child, desktop, onlyvisible, onlysensitive, exclude);

        }

    }

    return list;

}

void sp_edit_select_all_full(SPDesktop *dt, bool force_all_layers, bool invert)

{

    if (!dt)

        return;

    Inkscape::Selection *selection = sp_desktop_selection(dt);

    g_return_if_fail(SP_IS_GROUP(dt->currentLayer()));

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

    PrefsSelectionContext inlayer = (PrefsSelectionContext) prefs->getInt("/options/kbselection/inlayer", PREFS_SELECTION_LAYER);

    bool onlyvisible = prefs->getBool("/options/kbselection/onlyvisible", true);

    bool onlysensitive = prefs->getBool("/options/kbselection/onlysensitive", true);

    GSList *items = NULL;

    GSList const *exclude = NULL;

    if (invert) {

        exclude = selection->itemList();

    }

    if (force_all_layers)

        inlayer = PREFS_SELECTION_ALL;

    switch (inlayer) {

        case PREFS_SELECTION_LAYER: {

        if ( (onlysensitive && SP_ITEM(dt->currentLayer())->isLocked()) ||

             (onlyvisible && dt->itemIsHidden(SP_ITEM(dt->currentLayer()))) )

        return;

        GSList *all_items = sp_item_group_item_list(SP_GROUP(dt->currentLayer()));

        for (GSList *i = all_items; i; i = i->next) {

            SPItem *item = SP_ITEM(i->data);

            if (item && (!onlysensitive || !item->isLocked())) {

                if (!onlyvisible || !dt->itemIsHidden(item)) {

                    if (!dt->isLayer(item)) {

                        if (!invert || !g_slist_find((GSList *) exclude, item)) {

                            items = g_slist_prepend(items, item); // leave it in the list

                        }

                    }

                }

            }

        }

        g_slist_free(all_items);

            break;

        }

        case PREFS_SELECTION_LAYER_RECURSIVE: {

            items = get_all_items(NULL, dt->currentLayer(), dt, onlyvisible, onlysensitive, exclude);

            break;

        }

        default: {

        items = get_all_items(NULL, dt->currentRoot(), dt, onlyvisible, onlysensitive, exclude);

            break;

    }

    }

    selection->setList(items);

    if (items) {

        g_slist_free(items);

    }

}

void sp_edit_select_all(SPDesktop *desktop)

{

    sp_edit_select_all_full(desktop, false, false);

}

void sp_edit_select_all_in_all_layers(SPDesktop *desktop)

{

    sp_edit_select_all_full(desktop, true, false);

}

void sp_edit_invert(SPDesktop *desktop)

{

    sp_edit_select_all_full(desktop, false, true);

}

void sp_edit_invert_in_all_layers(SPDesktop *desktop)

{

    sp_edit_select_all_full(desktop, true, true);

}

void sp_selection_group_impl(GSList *p, Inkscape::XML::Node *group, Inkscape::XML::Document *xml_doc, SPDocument *doc) {

    p = g_slist_sort(p, (GCompareFunc) sp_repr_compare_position);

    // Remember the position and parent of the topmost object.

    gint topmost = ((Inkscape::XML::Node *) g_slist_last(p)->data)->position();

    Inkscape::XML::Node *topmost_parent = ((Inkscape::XML::Node *) g_slist_last(p)->data)->parent();

    while (p) {

        Inkscape::XML::Node *current = (Inkscape::XML::Node *) p->data;

        if (current->parent() == topmost_parent) {

            Inkscape::XML::Node *spnew = current->duplicate(xml_doc);

            sp_repr_unparent(current);

            group->appendChild(spnew);

            Inkscape::GC::release(spnew);

            topmost --; // only reduce count for those items deleted from topmost_parent

        } else { // move it to topmost_parent first

            GSList *temp_clip = NULL;

            // At this point, current may already have no item, due to its being a clone whose original is already moved away

            // So we copy it artificially calculating the transform from its repr->attr("transform") and the parent transform

            gchar const *t_str = current->attribute("transform");

            Geom::Affine item_t(Geom::identity());

            if (t_str)

                sp_svg_transform_read(t_str, &item_t);

            item_t *= SP_ITEM(doc->getObjectByRepr(current->parent()))->i2doc_affine();

            // FIXME: when moving both clone and original from a transformed group (either by

            // grouping into another parent, or by cut/paste) the transform from the original's

            // parent becomes embedded into original itself, and this affects its clones. Fix

            // this by remembering the transform diffs we write to each item into an array and

            // then, if this is clone, looking up its original in that array and pre-multiplying

            // it by the inverse of that original's transform diff.

            sp_selection_copy_one(current, item_t, &temp_clip, xml_doc);

            sp_repr_unparent(current);

            // paste into topmost_parent (temporarily)

            GSList *copied = sp_selection_paste_impl(doc, doc->getObjectByRepr(topmost_parent), &temp_clip);

            if (temp_clip) g_slist_free(temp_clip);

            if (copied) { // if success,

                // take pasted object (now in topmost_parent)

                Inkscape::XML::Node *in_topmost = (Inkscape::XML::Node *) copied->data;

                // make a copy

                Inkscape::XML::Node *spnew = in_topmost->duplicate(xml_doc);

                // remove pasted

                sp_repr_unparent(in_topmost);

                // put its copy into group

                group->appendChild(spnew);

                Inkscape::GC::release(spnew);

                g_slist_free(copied);

            }

        }

        p = g_slist_remove(p, current);

    }

    // Add the new group to the topmost members' parent

    topmost_parent->appendChild(group);

    // Move to the position of the topmost, reduced by the number of items deleted from topmost_parent

    group->setPosition(topmost + 1);

}

void sp_selection_group(SPDesktop *desktop)