diff options
Diffstat (limited to 'src/live_effects/lpe-slice.cpp')
| -rw-r--r-- | src/live_effects/lpe-slice.cpp | 969 |
1 files changed, 969 insertions, 0 deletions
diff --git a/src/live_effects/lpe-slice.cpp b/src/live_effects/lpe-slice.cpp new file mode 100644 index 0000000..50c7713 --- /dev/null +++ b/src/live_effects/lpe-slice.cpp @@ -0,0 +1,969 @@ +// SPDX-License-Identifier: GPL-2.0-or-later +/** \file + * LPE <slice> implementation: slices a path with respect to a given line. + */ +/* + * Authors: + * Maximilian Albert + * Johan Engelen + * Abhishek Sharma + * Jabiertxof + * + * Copyright (C) Johan Engelen 2007 <j.b.c.engelen@utwente.nl> + * Copyright (C) Maximilin Albert 2008 <maximilian.albert@gmail.com> + * + * Released under GNU GPL v2+, read the file 'COPYING' for more information. + */ + +#include "live_effects/lpe-slice.h" + +#include <gtkmm.h> + +#include "2geom/affine.h" +#include "2geom/path-intersection.h" +#include "display/curve.h" +#include "helper/geom.h" +#include "live_effects/parameter/satellite-reference.h" +#include "object/sp-defs.h" +#include "object/sp-lpe-item.h" +#include "object/sp-path.h" +#include "object/sp-text.h" +#include "path-chemistry.h" +#include "path/path-boolop.h" +#include "style.h" +#include "svg/path-string.h" +#include "svg/svg.h" +#include "xml/sp-css-attr.h" + +// this is only to flatten nonzero fillrule +#include "livarot/Path.h" +#include "livarot/Shape.h" + +// TODO due to internal breakage in glibmm headers, this must be last: +#include <glibmm/i18n.h> + +typedef FillRule FillRuleFlatten; + +namespace Inkscape { +namespace LivePathEffect { +LPESlice::LPESlice(LivePathEffectObject *lpeobject) : + Effect(lpeobject), + // do not change name of this parameter us used in oncommit + lpesatellites(_("lpesatellites"), _("Items satellites"), "lpesatellites", &wr, this, false), + allow_transforms(_("Allow Transforms"), _("Allow transforms"), "allow_transforms", &wr, this, true), + start_point(_("Slice line start"), _("Start point of slice line"), "start_point", &wr, this, _("Adjust start point of slice line")), + end_point(_("Slice line end"), _("End point of slice line"), "end_point", &wr, this, _("Adjust end point of slice line")), + center_point(_("Slice line mid"), _("Center point of slice line"), "center_point", &wr, this, _("Adjust center point of slice line")) +{ + registerParameter(&lpesatellites); + registerParameter(&allow_transforms); + registerParameter(&start_point); + registerParameter(&end_point); + registerParameter(¢er_point); + show_orig_path = true; + apply_to_clippath_and_mask = false; + previous_center = Geom::Point(0,0); + center_point.param_widget_is_visible(false); + reset = false; + center_horiz = false; + center_vert = false; + allow_transforms_prev = allow_transforms; + on_remove_all = false; + container = nullptr; + satellitestoclipboard = true; +} + +LPESlice::~LPESlice() +{ + keep_paths = false; + doOnRemove(nullptr); +}; + +bool +LPESlice::doOnOpen(SPLPEItem const* lpeitem) { + bool fixed = false; + Glib::ustring version = lpeversion.param_getSVGValue(); + if (version < "1.2") { + std::vector<SPLPEItem *> lpeitems = getCurrrentLPEItems(); + if (lpeitems.size() >= 1) { + sp_lpe_item_update_patheffect(lpeitems[0], false, true); + } + lpeversion.param_setValue("1.2", true); + fixed = true; + lpesatellites.write_to_SVG(); + } + lpesatellites.start_listening(); + lpesatellites.connect_selection_changed(); + return fixed; +} + +Gtk::Widget * +LPESlice::newWidget() +{ + // use manage here, because after deletion of Effect object, others might + // still be pointing to this widget. + Gtk::Box *vbox = Gtk::manage(new Gtk::Box(Gtk::ORIENTATION_VERTICAL)); + + vbox->set_border_width(5); + vbox->set_homogeneous(false); + vbox->set_spacing(2); + Gtk::Box *hbox = Gtk::manage(new Gtk::Box(Gtk::ORIENTATION_HORIZONTAL, 0)); + Gtk::Button *center_vert_button = Gtk::manage(new Gtk::Button(Glib::ustring(_("Vertical")))); + center_vert_button->signal_clicked().connect(sigc::mem_fun(*this, &LPESlice::centerVert)); + center_vert_button->set_size_request(110, 20); + Gtk::Button *center_horiz_button = Gtk::manage(new Gtk::Button(Glib::ustring(_("Horizontal")))); + center_horiz_button->signal_clicked().connect(sigc::mem_fun(*this, &LPESlice::centerHoriz)); + center_horiz_button->set_size_request(110, 20); + Gtk::Button *reset_button = Gtk::manage(new Gtk::Button(Glib::ustring(_("Reset styles")))); + reset_button->signal_clicked().connect(sigc::mem_fun(*this, &LPESlice::resetStyles)); + reset_button->set_size_request(110, 20); + + vbox->pack_start(*hbox, true, true, 2); + hbox->pack_start(*reset_button, false, false, 2); + hbox->pack_start(*center_vert_button, false, false, 2); + hbox->pack_start(*center_horiz_button, false, false, 2); + std::vector<Parameter *>::iterator it = param_vector.begin(); + while (it != param_vector.end()) { + if ((*it)->widget_is_visible) { + Parameter *param = *it; + Gtk::Widget *widg = dynamic_cast<Gtk::Widget *>(param->param_newWidget()); + Glib::ustring *tip = param->param_getTooltip(); + if (widg) { + vbox->pack_start(*widg, true, true, 2); + if (tip) { + widg->set_tooltip_text(*tip); + } else { + widg->set_tooltip_text(""); + widg->set_has_tooltip(false); + } + } + } + + ++it; + } + if (Gtk::Widget *widg = defaultParamSet()) { + vbox->pack_start(*widg, true, true, 2); + } + return dynamic_cast<Gtk::Widget *>(vbox); +} + + +void +LPESlice::centerVert(){ + center_vert = true; + refresh_widgets = true; + std::vector<SPLPEItem *> lpeitems = getCurrrentLPEItems(); + if (lpeitems.size() == 1) { + sp_lpe_item = lpeitems[0]; + sp_lpe_item_update_patheffect(sp_lpe_item, false, false); + } +} + +void +LPESlice::centerHoriz(){ + center_horiz = true; + refresh_widgets = true; + std::vector<SPLPEItem *> lpeitems = getCurrrentLPEItems(); + if (lpeitems.size() == 1) { + sp_lpe_item = lpeitems[0]; + sp_lpe_item_update_patheffect(sp_lpe_item, false, false); + } +} + +bool sp_has_path_data(SPItem *item, bool originald) +{ + SPGroup *group = dynamic_cast<SPGroup *>(item); + if (group) { + std::vector<SPObject *> childs = group->childList(true); + for (auto &child : childs) { + SPItem *item = dynamic_cast<SPItem *>(child); + if (sp_has_path_data(item, originald)) { + return true; + } + } + } + SPShape *shape = dynamic_cast<SPShape *>(item); + if (shape) { + SPCurve const *c = shape->curve(); + if (c && !c->is_empty()) { + return true; + } + if (originald) { + if (shape->hasPathEffectRecursive()) { + SPCurve const *c = shape->curveBeforeLPE(); + if (c && !c->is_empty()) { + return true; + } + } + } + } + return false; +} +/* + * Allow changing original-d to d to "reset" temporary the LPE + * when the slice doesn't pass through item till sp_lpe_item is crossed + */ +void +LPESlice::originalDtoD(SPShape const *shape, SPCurve *curve) +{ + SPCurve const *c = shape->curveBeforeLPE(); + if (c && !c->is_empty()) { + curve->set_pathvector(c->get_pathvector()); + } +} + +/* + * Allow changing original-d to d to "reset" temporary the LPE + * when the slice doesn't pass through item till sp_lpe_item is crossed + */ +void +LPESlice::originalDtoD(SPItem *item) +{ + SPGroup *group = dynamic_cast<SPGroup *>(item); + if (group) { + std::vector<SPObject *> childs = group->childList(true); + for (auto &child : childs) { + SPItem *item = dynamic_cast<SPItem *>(child); + originalDtoD(item); + } + return; + } + SPShape *shape = dynamic_cast<SPShape *>(item); + if (shape) { + SPCurve const *c = shape->curveBeforeLPE(); + if (c && !c->is_empty()) { + shape->bbox_vis_cache_is_valid = false; + shape->bbox_geom_cache_is_valid = false; + shape->setCurveInsync(std::move(c)); + auto str = sp_svg_write_path(c->get_pathvector()); + shape->setAttribute("d", str); + } + } +} + +void +LPESlice::doAfterEffect (SPLPEItem const* lpeitem, SPCurve *curve) +{ + Glib::ustring version = lpeversion.param_getSVGValue(); + // this avoid regenerate fake satellites un undo after open a legacy LPE + if (!is_load && version < "1.2") { + return; + } + SPDocument *document = getSPDoc(); + if (!document) { + return; + } + bool m_saved = DocumentUndo::getUndoSensitive(getSPDoc()); + DocumentUndo::ScopedInsensitive _no_undo(document); + if (document->isPartial()) { + DocumentUndo::setUndoSensitive(document, m_saved); + } else if (document->isSeeking()) { + return; + } + bool is_applied_on = false; + if (is_applied) { + is_applied_on = true; + is_applied = false; + } + bool write = false; + bool active = !lpesatellites.data().size() || is_load; + for (auto lpereference : lpesatellites.data()) { + if (lpereference && lpereference->isAttached() && lpereference.get()->getObject() != nullptr) { + active = true; + } + } + if (!active && !is_load) { + lpesatellites.clear(); + return; + } + + LPESlice *nextslice = dynamic_cast<LPESlice *>(sp_lpe_item->getNextLPE(this)); + if (is_visible && (!nextslice || !nextslice->is_visible)) { + LPESlice *prevslice = dynamic_cast<LPESlice *>(sp_lpe_item->getPrevLPE(this)); + if (boundingbox_X.isSingular() || boundingbox_Y.isSingular()) { + for (auto & iter : lpesatellites.data()) { + SPObject *elemref; + if (iter && iter->isAttached() && (elemref = iter->getObject())) { + if (auto *splpeitem = dynamic_cast<SPLPEItem *>(elemref)) { + splpeitem->setHidden(true); + } + } + } + return; + } + //ungroup + if (!is_load && container && container != sp_lpe_item->parent && container != sp_lpe_item->parent->parent) { + processObjects(LPE_UPDATE); + } else if (!is_load && container && container != sp_lpe_item->parent) { // group + processObjects(LPE_UPDATE); + } + std::vector<std::pair<Geom::Line, size_t> > slicer = getSplitLines(); + if (!slicer.size()) { + return; + } + container = lpeitem->parent; + objindex = 0; + legacy = false; + bool creation = write; + split(sp_lpe_item, curve, slicer, 0, creation); + bool connected = lpesatellites.is_connected(); + if (lpesatellites.data().size() && (creation || !connected)) { + lpesatellites.write_to_SVG(); + lpesatellites.start_listening(); + lpesatellites.update_satellites(!connected); + } + bool maindata = sp_has_path_data(sp_lpe_item, true); + for (auto & iter : lpesatellites.data()) { + SPObject *elemref; + if (iter && iter->isAttached() && (elemref = iter->getObject())) { + SPLPEItem *splpeitem = dynamic_cast<SPLPEItem *>(elemref); + if (splpeitem || lpeitem->isHidden()) { + if (!maindata || lpeitem->isHidden()) { + splpeitem->setHidden(true); + } + sp_lpe_item_update_patheffect(splpeitem, false, false); + } + } + } + if (!maindata) { + if (!curve) { // group + originalDtoD(sp_lpe_item); + } else { + originalDtoD(getCurrentShape(), curve); + } + return; + } + reset = false; + if (is_applied_on && prevslice) { + sp_lpe_item_update_patheffect(sp_lpe_item, false, false); + for (auto link : prevslice->lpesatellites.data()) { + if (link && link->isAttached()) { + SPGroup *spgrp = dynamic_cast<SPGroup *>(link->getObject()); + SPShape *spit = dynamic_cast<SPShape *>(link->getObject()); + Glib::ustring transform = ""; + Glib::ustring patheffects = ""; + Geom::OptRect _gbbox = Geom::OptRect(); + if (spgrp) { + if (spgrp->getAttribute("transform")) { + transform = spgrp->getAttribute("transform"); + } + if (spgrp->getAttribute("inkscape:path-effect")) { + patheffects = spgrp->getAttribute("inkscape:path-effect"); + } + spgrp->setAttribute("transform", nullptr); + spgrp->setAttribute("inkscape:path-effect", nullptr); + _gbbox = spgrp->geometricBounds(); + } + if (spit || spgrp) { + for (auto link2 : lpesatellites.data()) { + if (link2 && link2->isAttached()) { + SPGroup *spgrp2 = dynamic_cast<SPGroup *>(link2->getObject()); + SPShape *spit2 = dynamic_cast<SPShape *>(link2->getObject()); + if (spit && spit2) { + auto edit = SPCurve::copy(spit->curveForEdit()); + auto edit2 = SPCurve::copy(spit2->curveForEdit()); + Geom::OptRect _bbox = edit->get_pathvector().boundsFast(); + Geom::OptRect _bbox2 = edit2->get_pathvector().boundsFast(); + if (_bbox && _bbox2) { + (*_bbox).expandBy(1); + if ((*_bbox).contains(*_bbox2)) { + spit2->setAttribute("transform", spit->getAttribute("transform")); + spit2->setAttribute("inkscape:path-effect", spit->getAttribute("inkscape:path-effect")); + spit2->setAttribute("style", spit->getAttribute("style")); + } + } + } else if (spgrp && spgrp2) { + Geom::OptRect _gbbox2 = spgrp2->geometricBounds(); + if (_gbbox && _gbbox2) { + (*_gbbox).expandBy(1); + if ((*_gbbox).contains(*_gbbox2)) { + spgrp2->setAttribute("transform", transform); + spgrp2->setAttribute("inkscape:path-effect", patheffects); + cloneStyle(spgrp, spgrp2); + } + } + } + } + } + if (spgrp) { + spgrp->setAttribute("transform", transform); + spgrp->setAttribute("inkscape:path-effect", patheffects); + } + } + } + } + + } + } else { + for (auto itemrf : lpesatellites.data()) { + if (itemrf && itemrf->isAttached()) { + SPLPEItem *splpeitem = dynamic_cast<SPLPEItem *>(itemrf->getObject()); + if (splpeitem) { + splpeitem->setHidden(true); + sp_lpe_item_update_patheffect(splpeitem, false, false); + } + } + } + } +} + +bool +LPESlice::split(SPItem* item, SPCurve *curve, std::vector<std::pair<Geom::Line, size_t> > slicer, size_t splitindex, bool &creation) { + bool splited = false; + size_t nsplits = slicer.size(); + SPDocument *document = getSPDoc(); + if (!document) { + return splited; + } + + SPObject *elemref = nullptr; + if (!is_load && container != sp_lpe_item->parent) { + lpesatellites.read_from_SVG(); + return splited; + } + if (objindex < lpesatellites.data().size() && lpesatellites.data()[objindex]) { + elemref = lpesatellites.data()[objindex]->getObject(); + } + bool prevreset = reset; + + if (!elemref && item->getId()) { + + Glib::ustring elemref_id = Glib::ustring("slice-"); + elemref_id += Glib::ustring::format(slicer[splitindex].second); + elemref_id += "-"; + Glib::ustring clean_id = item->getId(); + //First check is to allow effects on "satellites" + SPLPEItem *lpeitem = dynamic_cast<SPLPEItem *>(item); + if (!lpeitem) { + return splited; + } + if (!lpeitem->hasPathEffectOfType(SLICE) && clean_id.find("slice-") != Glib::ustring::npos) { + clean_id = clean_id.replace(0,6,""); + elemref_id += clean_id; + } else { + elemref_id += clean_id; + } + creation = true; + if (is_load && (elemref = document->getObjectById(elemref_id))) { + legacy = true; + lpesatellites.link(elemref, objindex); + } else { + reset = true; + Inkscape::XML::Node *phantom = createPathBase(item); + if (!container) { + return splited; + } + elemref = container->appendChildRepr(phantom); + Inkscape::GC::release(phantom); + lpesatellites.link(elemref, objindex); + } + } + SPItem *other = dynamic_cast<SPItem *>(elemref); + if (other) { + objindex++; + other->setHidden(false); + if (nsplits) { + cloneD(item, other, false); + reset = prevreset; + splited = splititem(item, curve, slicer[splitindex], true); + splititem(other, nullptr, slicer[splitindex], false); + if (!splited) { + other->setHidden(true); + } + splitindex++; + if (nsplits > splitindex) { + SPLPEItem *splpeother = dynamic_cast<SPLPEItem *>(other); + SPLPEItem *splpeitem = dynamic_cast<SPLPEItem *>(item); + if (item == sp_lpe_item || !splpeitem->hasPathEffectOfType(SLICE)) { + split(item, curve, slicer, splitindex, creation); + if (other == sp_lpe_item || !splpeother->hasPathEffectOfType(SLICE)) { + split(other, nullptr, slicer, splitindex, creation); + } + } + } + } + } + return splited; +} + +std::vector<std::pair<Geom::Line, size_t> > +LPESlice::getSplitLines() { + std::vector<std::pair<Geom::Line, size_t> > splitlines; + std::vector<SPLPEItem *> lpeitems = getCurrrentLPEItems(); + if (lpeitems.size() >= 1) { + sp_lpe_item = lpeitems[0]; + } else { + return splitlines; + } + LPESlice *prevslice = dynamic_cast<LPESlice *>(sp_lpe_item->getPrevLPE(this)); + if (prevslice) { + splitlines = prevslice->getSplitLines(); + } + Geom::Line line_separation((Geom::Point)start_point, (Geom::Point)end_point); + size_t index = sp_lpe_item->getLPEIndex(this); + std::pair<Geom::Line, size_t> slice = std::make_pair(line_separation, index); + splitlines.push_back(slice); + return splitlines; +} + +Inkscape::XML::Node * +LPESlice::createPathBase(SPObject *elemref) { + SPDocument *document = getSPDoc(); + if (!document) { + return nullptr; + } + Inkscape::XML::Document *xml_doc = getSPDoc()->getReprDoc(); + Inkscape::XML::Node *prev = elemref->getRepr(); + SPGroup *group = dynamic_cast<SPGroup *>(elemref); + if (group) { + Inkscape::XML::Node *container = xml_doc->createElement("svg:g"); + container->setAttribute("transform", prev->attribute("transform")); + container->setAttribute("mask", prev->attribute("mask")); + container->setAttribute("clip-path", prev->attribute("clip-path")); + std::vector<SPItem*> const item_list = sp_item_group_item_list(group); + Inkscape::XML::Node *previous = nullptr; + for (auto sub_item : item_list) { + Inkscape::XML::Node *resultnode = createPathBase(sub_item); + container->addChild(resultnode, previous); + previous = resultnode; + } + return container; + } + Inkscape::XML::Node *resultnode = xml_doc->createElement("svg:path"); + resultnode->setAttribute("transform", prev->attribute("transform")); + resultnode->setAttribute("mask", prev->attribute("mask")); + resultnode->setAttribute("clip-path", prev->attribute("clip-path")); + return resultnode; +} + +void +LPESlice::cloneD(SPObject *orig, SPObject *dest, bool is_original) +{ + if (!is_original && !g_strcmp0(sp_lpe_item->getId(), orig->getId())) { + is_original = true; + } + SPDocument *document = getSPDoc(); + if (!document) { + return; + } + SPItem *originalitem = dynamic_cast<SPItem *>(orig); + if ( SP_IS_GROUP(orig) && SP_IS_GROUP(dest) && SP_GROUP(orig)->getItemCount() == SP_GROUP(dest)->getItemCount() ) { + if (reset) { + cloneStyle(orig, dest); + } + if (!allow_transforms) { + auto str = sp_svg_transform_write(originalitem->transform); + dest->setAttributeOrRemoveIfEmpty("transform", str); + } + std::vector< SPObject * > childs = orig->childList(true); + size_t index = 0; + for (auto &child : childs) { + SPObject *dest_child = dest->nthChild(index); + cloneD(child, dest_child, is_original); + index++; + } + return; + } + + SPShape * shape = SP_SHAPE(orig); + SPPath * path = SP_PATH(dest); + SPLPEItem *splpeitem = dynamic_cast<SPLPEItem *>(path); + if (path && shape && splpeitem) { + SPCurve const *c = shape->curve(); + if (c && !c->is_empty()) { + auto str = sp_svg_write_path(c->get_pathvector()); + if (path->hasPathEffectRecursive()) { + sp_lpe_item_enable_path_effects(path, false); + dest->setAttribute("inkscape:original-d", str); + sp_lpe_item_enable_path_effects(path, true); + dest->setAttribute("d", str); + } else { + dest->setAttribute("d", str); + } + if (!allow_transforms) { + auto str = sp_svg_transform_write(originalitem->transform); + dest->setAttributeOrRemoveIfEmpty("transform", str); + } + if (reset) { + cloneStyle(orig, dest); + } + } + } +} + +static fill_typ GetFillTyp(SPItem *item) +{ + SPCSSAttr *css = sp_repr_css_attr(item->getRepr(), "style"); + gchar const *val = sp_repr_css_property(css, "fill-rule", nullptr); + if (val && strcmp(val, "nonzero") == 0) { + return fill_nonZero; + } else if (val && strcmp(val, "evenodd") == 0) { + return fill_oddEven; + } else { + return fill_nonZero; + } +} + +bool +LPESlice::splititem(SPItem* item, SPCurve * curve, std::pair<Geom::Line, size_t> slicer, bool toggle, bool is_original) +{ + bool splited = false; + if (!is_original && !g_strcmp0(sp_lpe_item->getId(), item->getId())) { + is_original = true; + } + Geom::Line line_separation = slicer.first; + Geom::Point s = line_separation.initialPoint(); + Geom::Point e = line_separation.finalPoint(); + Geom::Point center = Geom::middle_point(s, e); + SPGroup *group = dynamic_cast<SPGroup *>(item); + if (group) { + std::vector<SPObject *> childs = group->childList(true); + for (auto &child : childs) { + SPItem *dest_child = dynamic_cast<SPItem *>(child); + // groups not need update curve + splited = splititem(dest_child, nullptr, slicer, toggle, is_original) ? true : splited; + } + if (!is_original && group->hasPathEffectRecursive()) { + sp_lpe_item_update_patheffect(group, false, false); + } + return splited; + } + SPShape *shape = dynamic_cast<SPShape *>(item); + SPPath *path = dynamic_cast<SPPath *>(item); + if (shape) { + SPCurve const *c; + c = shape->curve(); + if (c) { + Geom::PathVector original_pathv = pathv_to_linear_and_cubic_beziers(c->get_pathvector()); + sp_flatten(original_pathv, GetFillTyp(shape)); + Geom::PathVector path_out; + Geom::Affine t = shape->transform; + if (!dynamic_cast<SPGroup *>(sp_lpe_item)) { + t = Geom::identity(); + } + for (auto & path_it : original_pathv) { + path_it *= t; + if (path_it.empty()) { + continue; + } + Geom::PathVector tmp_pathvector; + double time_start = 0.0; + int position = 0; + bool end_open = false; + if (path_it.closed()) { + const Geom::Curve &closingline = path_it.back_closed(); + if (!are_near(closingline.initialPoint(), closingline.finalPoint())) { + end_open = true; + } + } + Geom::Path original = path_it; + if (end_open && path_it.closed()) { + original.close(false); + original.appendNew<Geom::LineSegment>( original.initialPoint() ); + original.close(true); + } + double dir = line_separation.angle(); + Geom::Ray ray = line_separation.ray(0); + double diagonal = Geom::distance(Geom::Point(boundingbox_X.min(),boundingbox_Y.min()),Geom::Point(boundingbox_X.max(),boundingbox_Y.max())); + Geom::Rect bbox(Geom::Point(boundingbox_X.min(),boundingbox_Y.min()),Geom::Point(boundingbox_X.max(),boundingbox_Y.max())); + double size_divider = Geom::distance(center, bbox) + diagonal; + s = Geom::Point::polar(dir,size_divider) + center; + e = Geom::Point::polar(dir + Geom::rad_from_deg(180),size_divider) + center; + Geom::Path divider = Geom::Path(s); + divider.appendNew<Geom::LineSegment>(e); + std::vector<double> crossed; + if (Geom::are_near(s,e)) { + continue; + } + Geom::Crossings cs = crossings(original, divider); + for(auto & c : cs) { + crossed.push_back(c.ta); + } + double angle = Geom::deg_from_rad(ray.angle()); + bool toggleside = !(angle > 0 && angle < 180); + std::sort(crossed.begin(), crossed.end()); + for (double time_end : crossed) { + if (time_start != time_end && time_end - time_start > Geom::EPSILON) { + Geom::Path portion = original.portion(time_start, time_end); + if (!portion.empty()) { + Geom::Point middle = portion.pointAt((double)portion.size()/2.0); + position = Geom::sgn(Geom::cross(e - s, middle - s)); + if (toggleside) { + position *= -1; + } + if (toggle) { + position *= -1; + } + if (position == 1) { + tmp_pathvector.push_back(portion); + } + portion.clear(); + } + } + time_start = time_end; + } + position = Geom::sgn(Geom::cross(e - s, original.finalPoint() - s)); + if (toggleside) { + position *= -1; + } + if (toggle) { + position *= -1; + } + if (cs.size()!=0 && (position == 1)) { + if (time_start != original.size() && original.size() - time_start > Geom::EPSILON) { + Geom::Path portion = original.portion(time_start, original.size()); + if (!portion.empty()) { + if (!original.closed()) { + tmp_pathvector.push_back(portion); + } else { + if (cs.size() > 1 && tmp_pathvector.size() > 0 && tmp_pathvector[0].size() > 0 ) { + tmp_pathvector[0] = tmp_pathvector[0].reversed(); + portion = portion.reversed(); + portion.setInitial(tmp_pathvector[0].finalPoint()); + tmp_pathvector[0].append(portion); + tmp_pathvector[0] = tmp_pathvector[0].reversed(); + } else { + tmp_pathvector.push_back(portion); + } + } + portion.clear(); + } + } + } + if (cs.size() > 0 && original.closed()) { + for (auto &path : tmp_pathvector) { + if (!path.closed()) { + path.close(); + } + } + } + if (cs.size() == 0 && position == 1) { + splited = false; + tmp_pathvector.push_back(original); + } else { + splited = true; + } + tmp_pathvector *= t.inverse(); + path_out.insert(path_out.end(), tmp_pathvector.begin(), tmp_pathvector.end()); + + tmp_pathvector.clear(); + } + if (curve && is_original) { + curve->set_pathvector(path_out); + } + auto cpro = SPCurve::copy(shape->curve()); + if (cpro) { + shape->bbox_vis_cache_is_valid = false; + shape->bbox_geom_cache_is_valid = false; + cpro->set_pathvector(path_out); + shape->setCurveInsync(std::move(cpro)); + auto str = sp_svg_write_path(path_out); + if (!is_original && shape->hasPathEffectRecursive()) { + sp_lpe_item_enable_path_effects(shape, false); + if (path) { + shape->setAttribute("inkscape:original-d", str); + } else { + shape->setAttribute("d", str); + } + sp_lpe_item_enable_path_effects(shape, true); + } else { + shape->setAttribute("d", str); + } + } + } + } + return splited; +} + +void +LPESlice::doBeforeEffect (SPLPEItem const* lpeitem) +{ + SPDocument *document = getSPDoc(); + if (!document) { + return; + } + if (!lpesatellites.data().size()) { + lpesatellites.read_from_SVG(); + if (lpesatellites.data().size()) { + lpesatellites.update_satellites(); + } + } + using namespace Geom; + original_bbox(lpeitem, false, true); + Point point_a(boundingbox_X.max(), boundingbox_Y.min()); + Point point_b(boundingbox_X.max(), boundingbox_Y.max()); + Point point_c(boundingbox_X.middle(), boundingbox_Y.middle()); + if (center_vert) { + double dista = std::abs(end_point[Geom::Y] - boundingbox_Y.min()); + double distb = std::abs(start_point[Geom::Y] - boundingbox_Y.min()); + previous_center = Geom::Point(Geom::infinity(), g_random_double_range(0, 1000)); + end_point.param_setValue( + Geom::Point(center_point[Geom::X], dista <= distb ? boundingbox_Y.min() : boundingbox_Y.max()), true); + start_point.param_setValue( + Geom::Point(center_point[Geom::X], dista > distb ? boundingbox_Y.min() : boundingbox_Y.max()), true); + //force update + center_vert = false; + } else if (center_horiz) { + double dista = std::abs(end_point[Geom::X] - boundingbox_X.min()); + double distb = std::abs(start_point[Geom::X] - boundingbox_X.min()); + previous_center = Geom::Point(Geom::infinity(), g_random_double_range(0, 1000)); + end_point.param_setValue( + Geom::Point(dista <= distb ? boundingbox_X.min() : boundingbox_X.max(), center_point[Geom::Y]), true); + start_point.param_setValue( + Geom::Point(dista > distb ? boundingbox_X.min() : boundingbox_X.max(), center_point[Geom::Y]), true); + //force update + center_horiz = false; + } else { + if ((Geom::Point)start_point == (Geom::Point)end_point) { + start_point.param_setValue(point_a); + end_point.param_setValue(point_b); + previous_center = Geom::middle_point((Geom::Point)start_point, (Geom::Point)end_point); + center_point.param_setValue(previous_center); + return; + } + if (are_near(previous_center, (Geom::Point)center_point, 0.001)) { + center_point.param_setValue(Geom::middle_point((Geom::Point)start_point, (Geom::Point)end_point)); + } else { + Geom::Point trans = center_point - Geom::middle_point((Geom::Point)start_point, (Geom::Point)end_point); + start_point.param_setValue(start_point * trans); + end_point.param_setValue(end_point * trans); + } + } + if (allow_transforms_prev != allow_transforms) { + LPESlice *nextslice = dynamic_cast<LPESlice *>(sp_lpe_item->getNextLPE(this)); + while (nextslice) { + if (nextslice->allow_transforms != allow_transforms) { + nextslice->allow_transforms_prev = allow_transforms; + nextslice->allow_transforms.param_setValue(allow_transforms); + } + nextslice = dynamic_cast<LPESlice *>(sp_lpe_item->getNextLPE(nextslice)); + } + LPESlice *prevslice = dynamic_cast<LPESlice *>(sp_lpe_item->getPrevLPE(this)); + while (prevslice) { + if (prevslice->allow_transforms != allow_transforms) { + prevslice->allow_transforms_prev = allow_transforms; + prevslice->allow_transforms.param_setValue(allow_transforms); + } + prevslice = dynamic_cast<LPESlice *>(sp_lpe_item->getNextLPE(prevslice)); + } + } + allow_transforms_prev = allow_transforms; +} + +void LPESlice::cloneStyle(SPObject *orig, SPObject *dest) +{ + for (auto iter : orig->style->properties()) { + if (iter->style_src != SPStyleSrc::UNSET) { + auto key = iter->id(); + if (key != SPAttr::FONT && key != SPAttr::D && key != SPAttr::MARKER) { + const gchar *attr = orig->getAttribute(iter->name().c_str()); + if (attr) { + dest->setAttribute(iter->name(), attr); + } + } + } + } + dest->setAttribute("style", orig->getAttribute("style")); +} + +void +LPESlice::resetStyles(){ + std::vector<SPLPEItem *> lpeitems = getCurrrentLPEItems(); + if (lpeitems.size() == 1) { + sp_lpe_item = lpeitems[0]; + LPESlice *nextslice = dynamic_cast<LPESlice *>(sp_lpe_item->getNextLPE(this)); + while (nextslice) { + nextslice->reset = true; + nextslice = dynamic_cast<LPESlice *>(sp_lpe_item->getNextLPE(nextslice)); + } + reset = true; + sp_lpe_item_update_patheffect(sp_lpe_item, false, false); + } +} + +void +LPESlice::doOnVisibilityToggled(SPLPEItem const* /*lpeitem*/) +{ + if (!is_visible) { + for (auto itemrf : lpesatellites.data()) { + if (itemrf && itemrf->isAttached()) { + SPLPEItem *splpeitem = dynamic_cast<SPLPEItem *>(itemrf->getObject()); + if (splpeitem) { + splpeitem->setHidden(true); + sp_lpe_item_update_patheffect(splpeitem, false, false); + } + } + } + } +} + + +void +LPESlice::doOnRemove(SPLPEItem const* lpeitem) +{ + if (keep_paths) { + processObjects(LPE_TO_OBJECTS); + return; + } + processObjects(LPE_ERASE); +} + +void +LPESlice::doOnApply (SPLPEItem const* lpeitem) +{ + using namespace Geom; + original_bbox(lpeitem, false, true); + LPESlice *prevslice = dynamic_cast<LPESlice *>(sp_lpe_item->getPrevLPE(this)); + if (prevslice) { + allow_transforms_prev = prevslice->allow_transforms; + allow_transforms.param_setValue(prevslice->allow_transforms); + } + Point point_a(boundingbox_X.middle(), boundingbox_Y.min()); + Point point_b(boundingbox_X.middle(), boundingbox_Y.max()); + Point point_c(boundingbox_X.middle(), boundingbox_Y.middle()); + start_point.param_setValue(point_a, true); + start_point.param_update_default(point_a); + end_point.param_setValue(point_b, true); + end_point.param_update_default(point_b); + center_point.param_setValue(point_c, true); + end_point.param_update_default(point_c); + previous_center = center_point; + lpeversion.param_setValue("1.2", true); + lpesatellites.update_satellites(true); +} + + +Geom::PathVector +LPESlice::doEffect_path (Geom::PathVector const & path_in) +{ + return path_in; +} + +void +LPESlice::addCanvasIndicators(SPLPEItem const */*lpeitem*/, std::vector<Geom::PathVector> &hp_vec) +{ + using namespace Geom; + hp_vec.clear(); + Geom::Path path; + Geom::Point s = start_point; + Geom::Point e = end_point; + path.start( s ); + path.appendNew<Geom::LineSegment>( e ); + Geom::PathVector helper; + helper.push_back(path); + hp_vec.push_back(helper); +} + +} //namespace LivePathEffect +} /* namespace Inkscape */ + +/* + Local Variables: + mode:c++ + c-file-style:"stroustrup" + c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +)) + indent-tabs-mode:nil + fill-column:99 + End: +*/ +// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4 : |