Home » Jabiertxo Arraiza Cenoz » Resources » PasteBin » Measure Line DIFF r.15051
  1. === modified file 'po/POTFILES.in'
  2. --- po/POTFILES.in 2016-05-30 12:34:46 +0000
  3. +++ po/POTFILES.in 2016-07-30 14:50:37 +0000
  4. @@ -154,6 +154,7 @@
  5. src/live_effects/lpe-rough-hatches.cpp
  6. src/live_effects/lpe-roughen.cpp
  7. src/live_effects/lpe-ruler.cpp
  8. +src/live_effects/lpe-measure-line.cpp
  9. src/live_effects/lpe-show_handles.cpp
  10. src/live_effects/lpe-simplify.cpp
  11. src/live_effects/lpe-sketch.cpp
  12. @@ -171,6 +172,7 @@
  13. src/live_effects/parameter/powerstrokepointarray.cpp
  14. src/live_effects/parameter/random.cpp
  15. src/live_effects/parameter/text.cpp
  16. +src/live_effects/parameter/fontbutton.cpp
  17. src/live_effects/parameter/togglebutton.cpp
  18. src/live_effects/parameter/transformedpoint.cpp
  19. src/live_effects/parameter/unit.cpp
  21. === modified file 'src/live_effects/CMakeLists.txt'
  22. --- src/live_effects/CMakeLists.txt 2015-07-24 19:53:33 +0000
  23. +++ src/live_effects/CMakeLists.txt 2016-07-29 21:22:57 +0000
  24. @@ -27,6 +27,7 @@
  25. lpe-lattice.cpp
  26. lpe-lattice2.cpp
  27. lpe-line_segment.cpp
  28. + lpe-measure-line.cpp
  29. lpe-mirror_symmetry.cpp
  30. lpe-offset.cpp
  31. lpe-parallel.cpp
  32. @@ -68,6 +69,7 @@
  33. parameter/powerstrokepointarray.cpp
  34. parameter/random.cpp
  35. parameter/text.cpp
  36. + parameter/fontbutton.cpp
  37. parameter/togglebutton.cpp
  38. parameter/transformedpoint.cpp
  39. parameter/unit.cpp
  40. @@ -105,6 +107,7 @@
  41. lpe-lattice.h
  42. lpe-lattice2.h
  43. lpe-line_segment.h
  44. + lpe-measure-line.h
  45. lpe-mirror_symmetry.h
  46. lpe-offset.h
  47. lpe-parallel.h
  48. @@ -148,6 +151,7 @@
  49. parameter/powerstrokepointarray.h
  50. parameter/random.h
  51. parameter/text.h
  52. + parameter/fontbutton.h
  53. parameter/togglebutton.h
  54. parameter/transformedpoint.h
  55. parameter/unit.h
  57. === modified file 'src/live_effects/Makefile_insert'
  58. --- src/live_effects/Makefile_insert 2015-07-24 19:53:33 +0000
  59. +++ src/live_effects/Makefile_insert 2016-07-21 18:04:54 +0000
  60. @@ -70,6 +70,8 @@
  61. live_effects/lpe-perspective_path.h \
  62. live_effects/lpe-perspective-envelope.cpp \
  63. live_effects/lpe-perspective-envelope.h \
  64. + live_effects/lpe-measure-line.cpp \
  65. + live_effects/lpe-measure-line.h \
  66. live_effects/lpe-mirror_symmetry.cpp \
  67. live_effects/lpe-mirror_symmetry.h \
  68. live_effects/lpe-circle_3pts.cpp \
  70. === modified file 'src/live_effects/effect-enum.h'
  71. --- src/live_effects/effect-enum.h 2015-01-27 22:09:47 +0000
  72. +++ src/live_effects/effect-enum.h 2016-07-21 18:55:39 +0000
  73. @@ -36,6 +36,7 @@
  74. CONSTRUCT_GRID,
  75. PERP_BISECTOR,
  76. TANGENT_TO_CURVE,
  77. + MEASURE_LINE,
  78. MIRROR_SYMMETRY,
  79. CIRCLE_3PTS,
  80. TRANSFORM_2PTS,
  82. === modified file 'src/live_effects/effect.cpp'
  83. --- src/live_effects/effect.cpp 2016-07-28 11:26:17 +0000
  84. +++ src/live_effects/effect.cpp 2016-07-30 16:41:13 +0000
  85. @@ -40,6 +40,7 @@
  86. #include "live_effects/lpe-lattice2.h"
  87. #include "live_effects/lpe-lattice.h"
  88. #include "live_effects/lpe-line_segment.h"
  89. +#include "live_effects/lpe-measure-line.h"
  90. #include "live_effects/lpe-mirror_symmetry.h"
  91. #include "live_effects/lpe-offset.h"
  92. #include "live_effects/lpe-parallel.h"
  93. @@ -151,6 +152,8 @@
  94. {FILL_BETWEEN_MANY, N_("Fill between many"), "fill_between_many"},
  95. {ELLIPSE_5PTS, N_("Ellipse by 5 points"), "ellipse_5pts"},
  96. {BOUNDING_BOX, N_("Bounding Box"), "bounding_box"},
  97. +/* 9.93 */
  98. + {MEASURE_LINE, N_("Measure Line"), "measure-line"},
  99. };
  100. const Util::EnumDataConverter<EffectType> LPETypeConverter(LPETypeData, sizeof(LPETypeData)/sizeof(*LPETypeData));
  102. @@ -319,6 +322,9 @@
  103. case TRANSFORM_2PTS:
  104. neweffect = static_cast<Effect*> ( new LPETransform2Pts(lpeobj) );
  105. break;
  106. + case MEASURE_LINE:
  107. + neweffect = static_cast<Effect*> ( new LPEMeasureLine(lpeobj) );
  108. + break;
  109. default:
  110. g_warning("LivePathEffect::Effect::New called with invalid patheffect type (%d)", lpenr);
  111. neweffect = NULL;
  112. @@ -364,6 +370,7 @@
  113. concatenate_before_pwd2(false),
  114. sp_lpe_item(NULL),
  115. current_zoom(1),
  116. + upd_params(true),
  117. sp_curve(NULL),
  118. provides_own_flash_paths(true), // is automatically set to false if providesOwnFlashPaths() is not overridden
  119. is_ready(false) // is automatically set to false if providesOwnFlashPaths() is not overridden
  120. @@ -447,7 +454,9 @@
  121. void Effect::doOnRemove (SPLPEItem const* /*lpeitem*/)
  122. {
  123. }
  124. -
  125. +void Effect::doOnVisibilityToggled(SPLPEItem const* /*lpeitem*/)
  126. +{
  127. +}
  128. //secret impl methods (shhhh!)
  129. void Effect::doOnApply_impl(SPLPEItem const* lpeitem)
  130. {
  131. @@ -691,7 +700,7 @@
  133. ++it;
  134. }
  135. -
  136. + upd_params = false;
  137. return dynamic_cast<Gtk::Widget *>(vbox);
  138. }
  141. === modified file 'src/live_effects/effect.h'
  142. --- src/live_effects/effect.h 2016-03-14 16:47:47 +0000
  143. +++ src/live_effects/effect.h 2016-07-30 16:40:47 +0000
  144. @@ -66,7 +66,7 @@
  146. virtual void doAfterEffect (SPLPEItem const* lpeitem);
  147. virtual void doOnRemove (SPLPEItem const* lpeitem);
  148. -
  149. + virtual void doOnVisibilityToggled(SPLPEItem const* lpeitem);
  150. void writeParamsToSVG();
  152. virtual void acceptParamPath (SPPath const* param_path);
  153. @@ -122,6 +122,7 @@
  155. void editNextParamOncanvas(SPItem * item, SPDesktop * desktop);
  156. bool apply_to_clippath_and_mask;
  157. + bool upd_params;
  159. protected:
  160. Effect(LivePathEffectObject *lpeobject);
  162. === modified file 'src/live_effects/lpe-ellipse_5pts.cpp'
  163. --- src/live_effects/lpe-ellipse_5pts.cpp 2016-07-28 11:26:17 +0000
  164. +++ src/live_effects/lpe-ellipse_5pts.cpp 2016-07-29 09:29:42 +0000
  165. @@ -171,7 +171,7 @@
  167. // figure out if we have a slice, guarding against rounding errors
  169. - Path p(Geom::Point(cos(0), sin(0)));
  170. + Geom::Path p(Geom::Point(cos(0), sin(0)));
  172. double end = 2 * M_PI;
  173. for (s = 0; s < end; s += M_PI_2) {
  175. === modified file 'src/live_effects/lpe-extrude.cpp'
  176. --- src/live_effects/lpe-extrude.cpp 2016-07-28 11:26:17 +0000
  177. +++ src/live_effects/lpe-extrude.cpp 2016-07-29 09:50:56 +0000
  178. @@ -66,7 +66,7 @@
  179. using namespace Geom;
  181. // generate connecting lines (the 'sides' of the extrusion)
  182. - Path path(Point(0.,0.));
  183. + Geom::Path path(Point(0.,0.));
  184. path.appendNew<Geom::LineSegment>( extrude_vector.getVector() );
  185. Piecewise<D2<SBasis> > connector = path.toPwSb();
  188. === modified file 'src/live_effects/lpe-knot.cpp'
  189. --- src/live_effects/lpe-knot.cpp 2016-07-28 11:26:17 +0000
  190. +++ src/live_effects/lpe-knot.cpp 2016-07-29 09:52:43 +0000
  191. @@ -101,7 +101,7 @@
  193. Affine mat = from_basis( T, N, pt_and_dir[0] );
  194. mat = mat.inverse();
  195. - Path p = patha * mat;
  196. + Geom::Path p = patha * mat;
  198. std::vector<double> times;
  200. @@ -484,7 +484,7 @@
  201. // std::cout<<"fusing first and last component\n";
  202. ++beg_comp;
  203. --end_comp;
  204. - Path first = gpaths[i0].portion(dom.back());
  205. + Geom::Path first = gpaths[i0].portion(dom.back());
  206. //FIXME: stitching should not be necessary (?!?)
  207. first.setStitching(true);
  208. first.append(gpaths[i0].portion(dom.front()));
  210. === added file 'src/live_effects/lpe-measure-line.cpp'
  211. --- src/live_effects/lpe-measure-line.cpp 1970-01-01 00:00:00 +0000
  212. +++ src/live_effects/lpe-measure-line.cpp 2016-08-02 11:27:01 +0000
  213. @@ -0,0 +1,821 @@
  214. +/*
  215. + * Author(s):
  216. + * Jabiertxo Arraiza Cenoz <jabier.arraiza@marker.es>
  217. + * Some code and ideas migrated from dimensioning.py by
  218. + * Johannes B. Rutzmoser, johannes.rutzmoser (at) googlemail (dot) com
  219. + * https://github.com/Rutzmoser/inkscape_dimensioning
  220. + * Copyright (C) 2014 Author(s)
  221. +
  222. + * Released under GNU GPL, read the file 'COPYING' for more information
  223. + */
  224. +#include "live_effects/lpe-measure-line.h"
  225. +#include <pangomm/fontdescription.h>
  226. +#include <libnrtype/font-lister.h>
  227. +#include "inkscape.h"
  228. +#include "xml/node.h"
  229. +#include "uri.h"
  230. +#include "uri-references.h"
  231. +#include "preferences.h"
  232. +#include "util/units.h"
  233. +#include "svg/svg-length.h"
  234. +#include "svg/svg-color.h"
  235. +#include "svg/svg.h"
  236. +#include "display/curve.h"
  237. +#include <2geom/affine.h>
  238. +#include "style.h"
  239. +#include "sp-root.h"
  240. +#include "sp-defs.h"
  241. +#include "sp-item.h"
  242. +#include "sp-shape.h"
  243. +#include "sp-path.h"
  244. +#include "desktop.h"
  245. +#include "document.h"
  246. +#include <iomanip>
  247. +
  248. +// TODO due to internal breakage in glibmm headers, this must be last:
  249. +#include <glibmm/i18n.h>
  250. +
  251. +using namespace Geom;
  252. +namespace Inkscape {
  253. +namespace LivePathEffect {
  254. +
  255. +static const Util::EnumData<OrientationMethod> OrientationMethodData[] = {
  256. + { OM_HORIZONTAL, N_("Horizontal"), "horizontal" },
  257. + { OM_VERTICAL, N_("Vertical"), "vertical" },
  258. + { OM_PARALLEL, N_("Parallel"), "parallel" }
  259. +};
  260. +static const Util::EnumDataConverter<OrientationMethod> OMConverter(OrientationMethodData, OM_END);
  261. +
  262. +LPEMeasureLine::LPEMeasureLine(LivePathEffectObject *lpeobject) :
  263. + Effect(lpeobject),
  264. + unit(_("Unit*"), _("Unit"), "unit", &wr, this, "px"),
  265. + fontbutton(_("Font*"), _("Font Selector"), "fontbutton", &wr, this),
  266. + orientation(_("Orientation"), _("Orientation method"), "orientation", OMConverter, &wr, this, OM_PARALLEL, false),
  267. + curve_linked(_("Curve on origin"), _("Curve on origin, set 0 to start/end"), "curve_linked", &wr, this, 1),
  268. + precision(_("Precision*"), _("Precision"), "precision", &wr, this, 2),
  269. + position(_("Positon*"), _("Positon"), "position", &wr, this, 5),
  270. + text_top_bottom(_("Text top/bottom*"), _("Text top/bottom"), "text_top_bottom", &wr, this, 0),
  271. + text_right_left(_("Text right/left*"), _("Text right/left"), "text_right_left", &wr, this, 0),
  272. + helpline_distance(_("Helpline distance*"), _("Helpline distance"), "helpline_distance", &wr, this, 0.0),
  273. + helpline_overlap(_("Helpline overlap*"), _("Helpline overlap"), "helpline_overlap", &wr, this, 2.0),
  274. + scale(_("Scale*"), _("Scaling factor"), "scale", &wr, this, 1.0),
  275. + format(_("Format*"), _("Format the number ex:{measure} {unit}, return to save"), "format", &wr, this,"measure unit"),
  276. + arrows_outside(_("Arrows outside"), _("Arrows outside"), "arrows_outside", &wr, this, false),
  277. + flip_side(_("Flip side*"), _("Flip side"), "flip_side", &wr, this, false),
  278. + scale_insensitive(_("Scale insensitive*"), _("Scale insensitive to transforms in element, parents..."), "scale_insensitive", &wr, this, true),
  279. + local_locale(_("Local Number Format*"), _("Local number format"), "local_locale", &wr, this, true),
  280. + line_group_05(_("Line Group 0.5*"), _("Line Group 0.5, from 0.7"), "line_group_05", &wr, this, true),
  281. + rotate_anotation(_("Rotate Anotation*"), _("Rotate Anotation"), "rotate_anotation", &wr, this, true),
  282. + hide_back(_("Hide if label over*"), _("Hide DIN line if label over"), "hide_back", &wr, this, true),
  283. + dimline_format(_("CSS DIN line*"), _("Override CSS to DIN line, return to save, empty to reset to DIM"), "dimline_format", &wr, this,""),
  284. + helperlines_format(_("CSS helpers*"), _("Override CSS to helper lines, return to save, empty to reset to DIM"), "helperlines_format", &wr, this,""),
  285. + anotation_format(_("CSS anotation*"), _("Override CSS to anotation text, return to save, empty to reset to DIM"), "anotation_format", &wr, this,""),
  286. + arrows_format(_("CSS arrows*"), _("Override CSS to arrows, return to save, empty to reset DIM"), "arrows_format", &wr, this,""),
  287. + expanded(false)
  288. +{
  289. + registerParameter(&unit);
  290. + registerParameter(&fontbutton);
  291. + registerParameter(&orientation);
  292. + registerParameter(&curve_linked);
  293. + registerParameter(&precision);
  294. + registerParameter(&position);
  295. + registerParameter(&text_top_bottom);
  296. + registerParameter(&text_right_left);
  297. + registerParameter(&helpline_distance);
  298. + registerParameter(&helpline_overlap);
  299. + registerParameter(&scale);
  300. + registerParameter(&format);
  301. + registerParameter(&arrows_outside);
  302. + registerParameter(&flip_side);
  303. + registerParameter(&scale_insensitive);
  304. + registerParameter(&local_locale);
  305. + registerParameter(&line_group_05);
  306. + registerParameter(&rotate_anotation);
  307. + registerParameter(&hide_back);
  308. + registerParameter(&dimline_format);
  309. + registerParameter(&helperlines_format);
  310. + registerParameter(&anotation_format);
  311. + registerParameter(&arrows_format);
  312. + Inkscape::Preferences *prefs = Inkscape::Preferences::get();
  313. + Glib::ustring fontbutton_value = prefs->getString("/live_effects/measure-line/fontbutton");
  314. + if(fontbutton_value.empty()){
  315. + fontbutton_value = "Sans 10";
  316. + }
  317. + fontbutton.param_update_default(fontbutton_value);
  318. + scale.param_update_default(prefs->getDouble("/live_effects/measure-line/scale", 1.0));
  319. + precision.param_update_default(prefs->getInt("/live_effects/measure-line/precision", 2));
  320. + position.param_update_default(prefs->getDouble("/live_effects/measure-line/position", 10.0));
  321. + text_top_bottom.param_update_default(prefs->getDouble("/live_effects/measure-line/text_top_bottom", 5.0));
  322. + helpline_distance.param_update_default(prefs->getDouble("/live_effects/measure-line/helpline_distance", 0.0));
  323. + helpline_overlap.param_update_default(prefs->getDouble("/live_effects/measure-line/helpline_overlap", 0.0));
  324. + Glib::ustring unit_value = prefs->getString("/live_effects/measure-line/unit");
  325. + if(unit_value.empty()){
  326. + unit_value = "px";
  327. + }
  328. + unit.param_update_default(unit_value);
  329. + Glib::ustring format_value = prefs->getString("/live_effects/measure-line/format");
  330. + if(format_value.empty()){
  331. + format_value = "{measure}{unit}";
  332. + }
  333. + format.param_update_default(format_value);
  334. + dimline_format.param_update_default(prefs->getString("/live_effects/measure-line/dimline_format"));
  335. + helperlines_format.param_update_default(prefs->getString("/live_effects/measure-line/helperlines_format"));
  336. + anotation_format.param_update_default(prefs->getString("/live_effects/measure-line/anotation_format"));
  337. + arrows_format.param_update_default(prefs->getString("/live_effects/measure-line/arrows_format"));
  338. + flip_side.param_update_default(prefs->getBool("/live_effects/measure-line/flip_side"));
  339. + scale_insensitive.param_update_default(prefs->getBool("/live_effects/measure-line/scale_insensitive"));
  340. + local_locale.param_update_default(prefs->getBool("/live_effects/measure-line/local_locale"));
  341. + line_group_05.param_update_default(prefs->getBool("/live_effects/measure-line/line_group_05"));
  342. + rotate_anotation.param_update_default(prefs->getBool("/live_effects/measure-line/rotate_anotation"));
  343. + hide_back.param_update_default(prefs->getBool("/live_effects/measure-line/hide_back"));
  344. + format.param_hide_canvas_text();
  345. + dimline_format.param_hide_canvas_text();
  346. + helperlines_format.param_hide_canvas_text();
  347. + anotation_format.param_hide_canvas_text();
  348. + arrows_format.param_hide_canvas_text();
  349. + precision.param_set_range(0, 100);
  350. + precision.param_set_increments(1, 1);
  351. + precision.param_set_digits(0);
  352. + precision.param_make_integer(true);
  353. + curve_linked.param_set_range(0, 999);
  354. + curve_linked.param_set_increments(1, 1);
  355. + curve_linked.param_set_digits(0);
  356. + curve_linked.param_make_integer(true);
  357. + precision.param_make_integer(true);
  358. + position.param_set_range(-999999.0, 999999.0);
  359. + position.param_set_increments(1, 1);
  360. + position.param_set_digits(2);
  361. + text_top_bottom.param_set_range(-999999.0, 999999.0);
  362. + text_top_bottom.param_set_increments(1, 1);
  363. + text_top_bottom.param_set_digits(2);
  364. + text_right_left.param_set_range(-999999.0, 999999.0);
  365. + text_right_left.param_set_increments(1, 1);
  366. + text_right_left.param_set_digits(2);
  367. + helpline_distance.param_set_range(-999999.0, 999999.0);
  368. + helpline_distance.param_set_increments(1, 1);
  369. + helpline_distance.param_set_digits(2);
  370. + helpline_overlap.param_set_range(-999999.0, 999999.0);
  371. + helpline_overlap.param_set_increments(1, 1);
  372. + helpline_overlap.param_set_digits(2);
  373. +}
  374. +
  375. +LPEMeasureLine::~LPEMeasureLine() {}
  376. +
  377. +void
  378. +LPEMeasureLine::doOnApply(SPLPEItem const* lpeitem)
  379. +{
  380. + if (!SP_IS_SHAPE(lpeitem)) {
  381. + g_warning("LPE measure line can only be applied to shapes (not groups).");
  382. + SPLPEItem * item = const_cast<SPLPEItem*>(lpeitem);
  383. + item->removeCurrentPathEffect(false);
  384. + }
  385. +}
  386. +
  387. +void
  388. +LPEMeasureLine::doOnVisibilityToggled(SPLPEItem const* /*lpeitem*/)
  389. +{
  390. + if (SPDesktop *desktop = SP_ACTIVE_DESKTOP) {
  391. + Inkscape::URI SVGElem_uri(((Glib::ustring)"#" + (Glib::ustring)"text-on-" + (Glib::ustring)this->getRepr()->attribute("id")).c_str());
  392. + Inkscape::URIReference* SVGElemRef = new Inkscape::URIReference(desktop->doc());
  393. + SVGElemRef->attach(SVGElem_uri);
  394. + SPObject *elemref = NULL;
  395. + Inkscape::XML::Node *node = NULL;
  396. + if (elemref = SVGElemRef->getObject()) {
  397. + node = elemref->getRepr();
  398. + if (!this->isVisible()) {
  399. + node->setAttribute("style", "display:none");
  400. + } else {
  401. + node->setAttribute("style", NULL);
  402. + }
  403. + }
  404. + Inkscape::URI SVGElem_uri2(((Glib::ustring)"#" + (Glib::ustring)"infoline-on-start-" + (Glib::ustring)this->getRepr()->attribute("id")).c_str());
  405. + SVGElemRef->attach(SVGElem_uri2);
  406. + if (elemref = SVGElemRef->getObject()) {
  407. + node = elemref->getRepr();
  408. + if (!this->isVisible()) {
  409. + node->setAttribute("style", "display:none");
  410. + } else {
  411. + node->setAttribute("style", NULL);
  412. + }
  413. + }
  414. + Inkscape::URI SVGElem_uri3(((Glib::ustring)"#" + (Glib::ustring)"infoline-on-end-" + (Glib::ustring)this->getRepr()->attribute("id")).c_str());
  415. + SVGElemRef->attach(SVGElem_uri3);
  416. + if (elemref = SVGElemRef->getObject()) {
  417. + node = elemref->getRepr();
  418. + if (!this->isVisible()) {
  419. + node->setAttribute("style", "display:none");
  420. + } else {
  421. + node->setAttribute("style", NULL);
  422. + }
  423. + }
  424. + Inkscape::URI SVGElem_uri4(((Glib::ustring)"#" + (Glib::ustring)"infoline-" + (Glib::ustring)this->getRepr()->attribute("id")).c_str());
  425. + SVGElemRef->attach(SVGElem_uri4);
  426. + if (elemref = SVGElemRef->getObject()) {
  427. + node = elemref->getRepr();
  428. + if (!this->isVisible()) {
  429. + node->setAttribute("style", "display:none");
  430. + } else {
  431. + node->setAttribute("style", NULL);
  432. + }
  433. + }
  434. + Inkscape::URI SVGElem_uri5(((Glib::ustring)"#" + (Glib::ustring)"downline-" + (Glib::ustring)this->getRepr()->attribute("id")).c_str());
  435. + SVGElemRef->attach(SVGElem_uri5);
  436. + if (elemref = SVGElemRef->getObject()) {
  437. + node = elemref->getRepr();
  438. + if (!this->isVisible()) {
  439. + node->setAttribute("style", "display:none");
  440. + } else {
  441. + node->setAttribute("style", NULL);
  442. + }
  443. + }
  444. + }
  445. +}
  446. +
  447. +void
  448. +LPEMeasureLine::createArrowMarker(Glib::ustring mode)
  449. +{
  450. + if (SPDesktop *desktop = SP_ACTIVE_DESKTOP) {
  451. + Inkscape::XML::Document *xml_doc = desktop->doc()->getReprDoc();
  452. + Inkscape::URI SVGElem_uri(((Glib::ustring)"#" + mode).c_str());
  453. + Inkscape::URIReference* SVGElemRef = new Inkscape::URIReference(desktop->doc());
  454. + SVGElemRef->attach(SVGElem_uri);
  455. + SPObject *elemref = NULL;
  456. + Inkscape::XML::Node *arrow = NULL;
  457. + if (!(elemref = SVGElemRef->getObject())) {
  458. + arrow = xml_doc->createElement("svg:marker");
  459. + arrow->setAttribute("id", mode.c_str());
  460. + arrow->setAttribute("inkscape:stockid", mode.c_str());
  461. + arrow->setAttribute("orient", "auto");
  462. + arrow->setAttribute("refX", "0.0");
  463. + arrow->setAttribute("refY", "0.0");
  464. + arrow->setAttribute("style", "overflow:visible");
  465. + /* Create <path> */
  466. + Inkscape::XML::Node *arrow_path = xml_doc->createElement("svg:path");
  467. + if (mode == (Glib::ustring)"ArrowDIN-start") {
  468. + arrow_path->setAttribute("d", "M -8,0 8,-2.11 8,2.11 z");
  469. + } else if (mode == (Glib::ustring)"ArrowDIN-end") {
  470. + arrow_path->setAttribute("d", "M 8,0 -8,2.11 -8,-2.11 z");
  471. + } else if (mode == (Glib::ustring)"ArrowDINout-start") {
  472. + arrow_path->setAttribute("d", "M 0,0 -16,2.11 -16,0.5 -26,0.5 -26,-0.5 -16,-0.5 -16,-2.11 z");
  473. + } else {
  474. + arrow_path->setAttribute("d", "M 0,0 16,2.11 16,0.5 26,0.5 26,-0.5 16,-0.5 16,-2.11 z");
  475. + }
  476. + arrow_path->setAttribute("id", (mode + (Glib::ustring)"_path").c_str());
  477. + SPCSSAttr *css = sp_repr_css_attr_new();
  478. + sp_repr_css_set_property (css, "fill","#000000");
  479. + sp_repr_css_set_property (css, "stroke","none" );
  480. + sp_repr_css_attr_add_from_string(css, arrows_format.param_getSVGValue());
  481. + Glib::ustring css_str;
  482. + sp_repr_css_write_string(css,css_str);
  483. + arrow_path->setAttribute("style", css_str.c_str());
  484. + arrow->addChild(arrow_path, NULL);
  485. + Inkscape::GC::release(arrow_path);
  486. + elemref = SP_OBJECT(desktop->getDocument()->getDefs()->appendChildRepr(arrow));
  487. + Inkscape::GC::release(arrow);
  488. + } else {
  489. + Inkscape::XML::Node *arrow= elemref->getRepr();
  490. + if (arrow) {
  491. + Inkscape::XML::Node *arrow_data = arrow->firstChild();
  492. + if (arrow_data) {
  493. + SPCSSAttr *css = sp_repr_css_attr_new();
  494. + sp_repr_css_set_property (css, "fill","#000000");
  495. + sp_repr_css_set_property (css, "stroke","none" );
  496. + sp_repr_css_attr_add_from_string(css, arrows_format.param_getSVGValue());
  497. + Glib::ustring css_str;
  498. + sp_repr_css_write_string(css,css_str);
  499. + arrow_data->setAttribute("style", css_str.c_str());
  500. + }
  501. + }
  502. + }
  503. + }
  504. +}
  505. +
  506. +void
  507. +LPEMeasureLine::createTextLabel(Geom::Point pos, double length, Geom::Coord angle, bool remove)
  508. +{
  509. + if (SPDesktop *desktop = SP_ACTIVE_DESKTOP) {
  510. + Inkscape::XML::Document *xml_doc = desktop->doc()->getReprDoc();
  511. + Inkscape::XML::Node *rtext = NULL;
  512. + double doc_w = desktop->getDocument()->getRoot()->width.value;
  513. + Geom::Scale scale = desktop->getDocument()->getDocumentScale();
  514. + SPNamedView *nv = desktop->getNamedView();
  515. + Glib::ustring display_unit = nv->display_units->abbr;
  516. + if (display_unit.empty()) {
  517. + display_unit = "px";
  518. + }
  519. + //only check constrain viewbox on X
  520. + doc_scale = Inkscape::Util::Quantity::convert( scale[Geom::X], "px", nv->display_units );
  521. + if( doc_scale > 0 ) {
  522. + doc_scale= 1.0/doc_scale;
  523. + } else {
  524. + doc_scale = 1.0;
  525. + }
  526. + Inkscape::URI SVGElem_uri(((Glib::ustring)"#" + (Glib::ustring)"text-on-" + (Glib::ustring)this->getRepr()->attribute("id")).c_str());
  527. + Inkscape::URIReference* SVGElemRef = new Inkscape::URIReference(desktop->doc());
  528. + SVGElemRef->attach(SVGElem_uri);
  529. + SPObject *elemref = NULL;
  530. + Inkscape::XML::Node *rtspan = NULL;
  531. + pos = pos - Point::polar(angle, text_right_left);
  532. + if (elemref = SVGElemRef->getObject()) {
  533. + if (remove) {
  534. + elemref->deleteObject();
  535. + return;
  536. + }
  537. + rtext = elemref->getRepr();
  538. + sp_repr_set_svg_double(rtext, "x", pos[Geom::X]);
  539. + sp_repr_set_svg_double(rtext, "y", pos[Geom::Y]);
  540. + } else {
  541. + if (remove) {
  542. + return;
  543. + }
  544. + rtext = xml_doc->createElement("svg:text");
  545. + rtext->setAttribute("xml:space", "preserve");
  546. + rtext->setAttribute("id", ( (Glib::ustring)"text-on-" + (Glib::ustring)this->getRepr()->attribute("id")).c_str());
  547. + sp_repr_set_svg_double(rtext, "x", pos[Geom::X]);
  548. + sp_repr_set_svg_double(rtext, "y", pos[Geom::Y]);
  549. + rtspan = xml_doc->createElement("svg:tspan");
  550. + rtspan->setAttribute("sodipodi:role", "line");
  551. + }
  552. + gchar * transform;
  553. + Geom::Affine affine = Geom::Affine(Geom::Translate(pos).inverse());
  554. + angle = std::fmod(angle, 2*M_PI);
  555. + if (angle < 0) angle += 2*M_PI;
  556. + if (angle >= rad_from_deg(90) && angle < rad_from_deg(270)) {
  557. + angle = std::fmod(angle + rad_from_deg(180), 2*M_PI);
  558. + if (angle < 0) angle += 2*M_PI;
  559. + }
  560. + affine *= Geom::Rotate(angle);
  561. + affine *= Geom::Translate(pos);
  562. + if (rotate_anotation) {
  563. + transform = sp_svg_transform_write(affine);
  564. + } else {
  565. + transform = NULL;
  566. + }
  567. + rtext->setAttribute("transform", transform);
  568. + SPCSSAttr *css = sp_repr_css_attr_new();
  569. + sp_repr_css_attr_add_from_string(css, anotation_format.param_getSVGValue());
  570. + Inkscape::FontLister *fontlister = Inkscape::FontLister::get_instance();
  571. + fontlister->fill_css( css, (Glib::ustring)fontbutton.param_getSVGValue() );
  572. + std::stringstream font_size;
  573. + font_size.imbue(std::locale::classic());
  574. + font_size << fontsize << "pt";
  575. +
  576. + sp_repr_css_set_property (css, "font-size",font_size.str().c_str());
  577. + sp_repr_css_set_property (css, "line-height","125%");
  578. + sp_repr_css_set_property (css, "letter-spacing","0");
  579. + sp_repr_css_set_property (css, "word-spacing", "0");
  580. + sp_repr_css_set_property (css, "text-align", "center");
  581. + sp_repr_css_set_property (css, "text-anchor", "middle");
  582. + sp_repr_css_set_property (css, "fill", "#000000");
  583. + sp_repr_css_set_property (css, "fill-opacity", "1");
  584. + sp_repr_css_set_property (css, "stroke", "none");
  585. + sp_repr_css_attr_add_from_string(css, anotation_format.param_getSVGValue());
  586. + Glib::ustring css_str;
  587. + sp_repr_css_write_string(css,css_str);
  588. + if (!rtspan) {
  589. + rtspan = rtext->firstChild();
  590. + }
  591. + rtext->setAttribute("style", css_str.c_str());
  592. + rtspan->setAttribute("style", NULL);
  593. + sp_repr_css_attr_unref (css);
  594. + if (!elemref) {
  595. + rtext->addChild(rtspan, NULL);
  596. + Inkscape::GC::release(rtspan);
  597. + }
  598. + length = Inkscape::Util::Quantity::convert(length / doc_scale, display_unit.c_str(), unit.get_abbreviation());
  599. + std::stringstream length_str;
  600. + length_str.precision(precision);
  601. + length_str.setf(std::ios::fixed, std::ios::floatfield);
  602. + if (local_locale) {
  603. + length_str.imbue(std::locale(""));
  604. + } else {
  605. + length_str.imbue(std::locale::classic());
  606. + }
  607. + length_str << std::fixed << length;
  608. + Glib::ustring label_value = Glib::ustring(format.param_getSVGValue());
  609. + size_t s = label_value.find((Glib::ustring)"{measure}",0);
  610. + if(s < label_value.length()) {
  611. + label_value.replace(s,s+9,length_str.str());
  612. + }
  613. + s = label_value.find((Glib::ustring)"{unit}",0);
  614. + if(s < label_value.length()) {
  615. + label_value.replace(s,s+6,unit.get_abbreviation());
  616. + }
  617. + Inkscape::XML::Node *rstring = NULL;
  618. + if (!elemref) {
  619. + rstring = xml_doc->createTextNode(label_value.c_str());
  620. + rtspan->addChild(rstring, NULL);
  621. + Inkscape::GC::release(rstring);
  622. + } else {
  623. + rstring = rtspan->firstChild();
  624. + rstring->setContent(label_value.c_str());
  625. + }
  626. + if (!elemref) {
  627. + elemref = SP_OBJECT(desktop->currentLayer()->appendChildRepr(rtext));
  628. + Inkscape::GC::release(rtext);
  629. + }
  630. + Inkscape::XML::Node *tmp_node = rtext->duplicate(xml_doc);
  631. + affine = Geom::Affine(Geom::Scale(1.4));
  632. + tmp_node->setAttribute("transform", sp_svg_transform_write(affine));
  633. + SPObject * tmp_obj = SP_OBJECT(desktop->currentLayer()->appendChildRepr(tmp_node));
  634. + Inkscape::GC::release(tmp_node);
  635. + tmp_obj->updateRepr();
  636. + Geom::OptRect bounds = SP_ITEM(tmp_obj)->bounds(SPItem::GEOMETRIC_BBOX);
  637. + if (bounds) {
  638. + anotation_width = bounds->width();
  639. + }
  640. + tmp_obj->deleteObject();
  641. + }
  642. +}
  643. +
  644. +void
  645. +LPEMeasureLine::createLine(Geom::Point start,Geom::Point end, Glib::ustring id, bool main, bool overflow, bool remove, bool arrows)
  646. +{
  647. + if (SPDesktop *desktop = SP_ACTIVE_DESKTOP) {
  648. + Inkscape::XML::Document *xml_doc = desktop->doc()->getReprDoc();
  649. + Inkscape::URI SVGElem_uri(((Glib::ustring)"#" + id).c_str());
  650. + Inkscape::URIReference* SVGElemRef = new Inkscape::URIReference(desktop->doc());
  651. + SVGElemRef->attach(SVGElem_uri);
  652. + SPObject *elemref = NULL;
  653. + Inkscape::XML::Node *line = NULL;
  654. + if (!main) {
  655. + Geom::Ray ray(start, end);
  656. + Geom::Coord angle = ray.angle();
  657. + start = start + Point::polar(angle, helpline_distance );
  658. + end = end + Point::polar(angle, helpline_overlap );
  659. + }
  660. + Geom::PathVector line_pathv;
  661. + if (main && std::abs(text_top_bottom) < fontsize/1.5 && hide_back && !overflow){
  662. + Geom::Path line_path;
  663. + double k = 0;
  664. + if (flip_side) {
  665. + k = (Geom::distance(start,end)/2.0) + arrow_gap - (anotation_width/2.0);
  666. + } else {
  667. + k = (Geom::distance(start,end)/2.0) - arrow_gap - (anotation_width/2.0);
  668. + }
  669. + if (Geom::distance(start,end) < anotation_width){
  670. + return;
  671. + }
  672. + Geom::Ray ray(end, start);
  673. + Geom::Coord angle = ray.angle();
  674. + line_path.start(start);
  675. + line_path.appendNew<Geom::LineSegment>(start - Point::polar(angle, k));
  676. + line_pathv.push_back(line_path);
  677. + line_path.clear();
  678. + line_path.start(end + Point::polar(angle, k));
  679. + line_path.appendNew<Geom::LineSegment>(end);
  680. + line_pathv.push_back(line_path);
  681. + } else {
  682. + Geom::Path line_path;
  683. + line_path.start(start);
  684. + line_path.appendNew<Geom::LineSegment>(end);
  685. + line_pathv.push_back(line_path);
  686. + }
  687. + gchar * line_str = sp_svg_write_path( line_pathv );
  688. + line_pathv.clear();
  689. + if (elemref = SVGElemRef->getObject()) {
  690. + if (remove) {
  691. + elemref->deleteObject();
  692. + return;
  693. + }
  694. + line = elemref->getRepr();
  695. + line->setAttribute("d" , line_str);
  696. + } else {
  697. + if (remove) {
  698. + return;
  699. + }
  700. + line = xml_doc->createElement("svg:path");
  701. + line->setAttribute("id", id.c_str());
  702. + line->setAttribute("d" , line_str);
  703. + }
  704. + Glib::ustring style = (Glib::ustring)"stroke:#000000;fill:none;";
  705. + if (overflow && !arrows) {
  706. + line->setAttribute("inkscape:label", "downline");
  707. + } else if (main) {
  708. + line->setAttribute("inkscape:label", "dinline");
  709. + if (arrows_outside) {
  710. + style = style + (Glib::ustring)"marker-start:url(#ArrowDINout-start);marker-end:url(#ArrowDINout-end);";
  711. + } else {
  712. + style = style + (Glib::ustring)"marker-start:url(#ArrowDIN-start);marker-end:url(#ArrowDIN-end);";
  713. + }
  714. + } else {
  715. + line->setAttribute("inkscape:label", "dinhelpline");
  716. + }
  717. + std::stringstream stroke_w;
  718. + stroke_w.imbue(std::locale::classic());
  719. + if (line_group_05) {
  720. + double stroke_width = Inkscape::Util::Quantity::convert(0.25 / doc_scale, "mm", display_unit.c_str());
  721. + stroke_w << stroke_width;
  722. + style = style + (Glib::ustring)"stroke-width:" + (Glib::ustring)stroke_w.str();
  723. + } else {
  724. + double stroke_width = Inkscape::Util::Quantity::convert(0.35 / doc_scale, "mm", display_unit.c_str());
  725. + stroke_w << stroke_width;
  726. + style = style + (Glib::ustring)"stroke-width:" + (Glib::ustring)stroke_w.str();
  727. + }
  728. + SPCSSAttr *css = sp_repr_css_attr_new();
  729. + sp_repr_css_attr_add_from_string(css, style.c_str());
  730. + if (main) {
  731. + sp_repr_css_attr_add_from_string(css, dimline_format.param_getSVGValue());
  732. + } else {
  733. + sp_repr_css_attr_add_from_string(css, helperlines_format.param_getSVGValue());
  734. + }
  735. + Glib::ustring css_str;
  736. + sp_repr_css_write_string(css,css_str);
  737. + line->setAttribute("style", css_str.c_str());
  738. + if (!elemref) {
  739. + elemref = SP_OBJECT(desktop->currentLayer()->appendChildRepr(line));
  740. + Inkscape::GC::release(line);
  741. + }
  742. + }
  743. +}
  744. +
  745. +void
  746. +LPEMeasureLine::doBeforeEffect (SPLPEItem const* lpeitem)
  747. +{
  748. + SPLPEItem * splpeitem = const_cast<SPLPEItem *>(lpeitem);
  749. + SPPath *sp_path = dynamic_cast<SPPath *>(splpeitem);
  750. + if (sp_path) {
  751. + Geom::PathVector pathvector = sp_path->get_original_curve()->get_pathvector();
  752. + if (arrows_outside) {
  753. + createArrowMarker((Glib::ustring)"ArrowDINout-start");
  754. + createArrowMarker((Glib::ustring)"ArrowDINout-end");
  755. + } else {
  756. + createArrowMarker((Glib::ustring)"ArrowDIN-start");
  757. + createArrowMarker((Glib::ustring)"ArrowDIN-end");
  758. + }
  759. + if (SPDesktop *desktop = SP_ACTIVE_DESKTOP) {
  760. + if (((Glib::ustring)format.param_getSVGValue()).empty()) {
  761. + format.param_setValue((Glib::ustring)"{measure}{unit}");
  762. + this->upd_params = true;
  763. + }
  764. + size_t ncurves = pathvector.curveCount();
  765. + curve_linked.param_set_range(0, ncurves);
  766. + Geom::Point start = pathvector.initialPoint();
  767. + Geom::Point end = pathvector.finalPoint();
  768. + if (curve_linked) { //!0
  769. + start = pathvector.pointAt(curve_linked -1);
  770. + end = pathvector.pointAt(curve_linked);
  771. + }
  772. + Geom::Point hstart = start;
  773. + Geom::Point hend = end;
  774. + bool remove = false;
  775. + if (Geom::are_near(hstart, hend)) {
  776. + remove = true;
  777. + }
  778. + if (orientation == OM_VERTICAL) {
  779. + Coord xpos = std::max(hstart[Geom::X],hend[Geom::X]);
  780. + if (flip_side) {
  781. + xpos = std::min(hstart[Geom::X],hend[Geom::X]);
  782. + }
  783. + hstart[Geom::X] = xpos;
  784. + hend[Geom::X] = xpos;
  785. + if (hstart[Geom::Y] > hend[Geom::Y]) {
  786. + swap(hstart,hend);
  787. + swap(start,end);
  788. + }
  789. + if (Geom::are_near(hstart[Geom::Y], hend[Geom::Y])) {
  790. + remove = true;
  791. + }
  792. + }
  793. + if (orientation == OM_HORIZONTAL) {
  794. + Coord ypos = std::max(hstart[Geom::Y],hend[Geom::Y]);
  795. + if (flip_side) {
  796. + ypos = std::min(hstart[Geom::Y],hend[Geom::Y]);
  797. + }
  798. + hstart[Geom::Y] = ypos;
  799. + hend[Geom::Y] = ypos;
  800. + if (hstart[Geom::X] < hend[Geom::X]) {
  801. + swap(hstart,hend);
  802. + swap(start,end);
  803. + }
  804. + if (Geom::are_near(hstart[Geom::X], hend[Geom::X])) {
  805. + remove = true;
  806. + }
  807. + }
  808. + double length = Geom::distance(hstart,hend) * scale;
  809. + Geom::Point pos = Geom::middle_point(hstart,hend);
  810. + Geom::Ray ray(hstart,hend);
  811. + Geom::Coord angle = ray.angle();
  812. + if (flip_side) {
  813. + angle = std::fmod(angle + rad_from_deg(180), 2*M_PI);
  814. + if (angle < 0) angle += 2*M_PI;
  815. + }
  816. + //We get the font size to offset the text to the middle
  817. + Pango::FontDescription fontdesc((Glib::ustring)fontbutton.param_getSVGValue());
  818. + fontsize = fontdesc.get_size()/(double)Pango::SCALE;
  819. + fontsize *= desktop->doc()->getRoot()->c2p.inverse().expansionX();
  820. + Geom::Coord angle_cross = std::fmod(angle + rad_from_deg(90), 2*M_PI);
  821. + if (angle_cross < 0) angle_cross += 2*M_PI;
  822. + angle = std::fmod(angle, 2*M_PI);
  823. + if (angle < 0) angle += 2*M_PI;
  824. + if (angle >= rad_from_deg(90) && angle < rad_from_deg(270)) {
  825. + pos = pos - Point::polar(angle_cross, (position - text_top_bottom) + fontsize/2.5);
  826. + } else {
  827. + pos = pos - Point::polar(angle_cross, (position + text_top_bottom) - fontsize/2.5);
  828. + }
  829. + if (!scale_insensitive) {
  830. + Geom::Affine affinetransform = i2anc_affine(SP_OBJECT(lpeitem), SP_OBJECT(desktop->doc()->getRoot()));
  831. + length *= (affinetransform.expansionX() + affinetransform.expansionY()) / 2.0;
  832. + }
  833. + createTextLabel(pos, length, angle, remove);
  834. + bool overflow = false;
  835. + if ((anotation_width/2) + std::abs(text_right_left) > Geom::distance(start,end)/2.0) {
  836. + Geom::Point sstart = end - Point::polar(angle_cross, position);
  837. + Geom::Point send = end - Point::polar(angle_cross, position);
  838. + if (text_right_left < 0 && flip_side || text_right_left > 0 && !flip_side) {
  839. + sstart = start - Point::polar(angle_cross, position);
  840. + send = start - Point::polar(angle_cross, position);
  841. + }
  842. + Geom::Point prog_end = Geom::Point();
  843. + if (std::abs(text_top_bottom) < fontsize/1.5 && hide_back) {
  844. + if (text_right_left > 0 ) {
  845. + prog_end = sstart - Point::polar(angle, std::abs(text_right_left) - (anotation_width/1.9) - (Geom::distance(start,end)/2.0));
  846. + } else {
  847. + prog_end = sstart + Point::polar(angle, std::abs(text_right_left) - (anotation_width/1.9) - (Geom::distance(start,end)/2.0));
  848. + }
  849. + } else {
  850. + if (text_right_left > 0 ) {
  851. + prog_end = sstart - Point::polar(angle,(anotation_width/2) + std::abs(text_right_left) - (Geom::distance(start,end)/2.0));
  852. + } else {
  853. + prog_end = sstart + Point::polar(angle,(anotation_width/2) + std::abs(text_right_left) - (Geom::distance(start,end)/2.0));
  854. + }
  855. + }
  856. + overflow = true;
  857. + createLine(sstart, prog_end, (Glib::ustring)"downline-" + (Glib::ustring)this->getRepr()->attribute("id"), true, overflow, false, false);
  858. + } else {
  859. + //erase it
  860. + createLine(Geom::Point(),Geom::Point(), (Glib::ustring)"downline-" + (Glib::ustring)this->getRepr()->attribute("id"), true, overflow, true, false);
  861. + }
  862. + //LINE
  863. + arrow_gap = 8 * Inkscape::Util::Quantity::convert(0.35 / doc_scale, "mm", display_unit.c_str());
  864. + if (line_group_05) {
  865. + arrow_gap = 8 * Inkscape::Util::Quantity::convert(0.25 / doc_scale, "mm", display_unit.c_str());
  866. + }
  867. + SPCSSAttr *css = sp_repr_css_attr_new();
  868. + sp_repr_css_attr_add_from_string(css, dimline_format.param_getSVGValue());
  869. + setlocale(LC_NUMERIC, std::locale::classic().name().c_str());
  870. + double width_line = atof(sp_repr_css_property(css,"stroke-width","-1"));
  871. + setlocale(LC_NUMERIC, std::locale("").name().c_str());
  872. + if (width_line > -0.0001) {
  873. + arrow_gap = 8 * Inkscape::Util::Quantity::convert(width_line/ doc_scale, "mm", display_unit.c_str());
  874. + }
  875. + if (flip_side) {
  876. + arrow_gap *= -1;
  877. + }
  878. + hstart = hstart - Point::polar(angle_cross, position);
  879. + Glib::ustring id = (Glib::ustring)"infoline-on-start-" + (Glib::ustring)this->getRepr()->attribute("id");
  880. + createLine(start, hstart, id, false, false, remove);
  881. + hend = hend - Point::polar(angle_cross, position);
  882. + id = (Glib::ustring)"infoline-on-end-" + (Glib::ustring)this->getRepr()->attribute("id");
  883. + createLine(end, hend, id, false, false, remove);
  884. + if (!arrows_outside) {
  885. + hstart = hstart + Point::polar(angle, arrow_gap);
  886. + hend = hend - Point::polar(angle, arrow_gap );
  887. + }
  888. + id = (Glib::ustring)"infoline-" + (Glib::ustring)this->getRepr()->attribute("id");
  889. + createLine(hstart, hend, id, true, overflow, remove, true);
  890. + }
  891. + }
  892. +}
  893. +
  894. +void LPEMeasureLine::doOnRemove (SPLPEItem const* lpeitem)
  895. +{
  896. + if (SPDesktop *desktop = SP_ACTIVE_DESKTOP) {
  897. + SPLPEItem * splpeitem = const_cast<SPLPEItem *>(lpeitem);
  898. + Inkscape::URI SVGElem_uri(((Glib::ustring)"#" + (Glib::ustring)"text-on-" + (Glib::ustring)this->getRepr()->attribute("id")).c_str());
  899. + Inkscape::URIReference* SVGElemRef = new Inkscape::URIReference(desktop->doc());
  900. + SVGElemRef->attach(SVGElem_uri);
  901. + SPObject *elemref = NULL;
  902. + if (elemref = SVGElemRef->getObject()) {
  903. + elemref->deleteObject();
  904. + }
  905. + Inkscape::URI SVGElem_uri2(((Glib::ustring)"#" + (Glib::ustring)"infoline-on-end-" + (Glib::ustring)this->getRepr()->attribute("id")).c_str());
  906. + SVGElemRef->attach(SVGElem_uri2);
  907. + if (elemref = SVGElemRef->getObject()) {
  908. + elemref->deleteObject();
  909. + }
  910. + Inkscape::URI SVGElem_uri3(((Glib::ustring)"#" + (Glib::ustring)"infoline-on-start-" + (Glib::ustring)this->getRepr()->attribute("id")).c_str());
  911. + SVGElemRef->attach(SVGElem_uri3);
  912. + if (elemref = SVGElemRef->getObject()) {
  913. + elemref->deleteObject();
  914. + }
  915. + Inkscape::URI SVGElem_uri4(((Glib::ustring)"#" + (Glib::ustring)"infoline-" + (Glib::ustring)this->getRepr()->attribute("id")).c_str());
  916. + SVGElemRef->attach(SVGElem_uri4);
  917. + if (elemref = SVGElemRef->getObject()) {
  918. + elemref->deleteObject();
  919. + }
  920. + Inkscape::URI SVGElem_uri5(((Glib::ustring)"#" + (Glib::ustring)"downline-" + (Glib::ustring)this->getRepr()->attribute("id")).c_str());
  921. + SVGElemRef->attach(SVGElem_uri5);
  922. + if (elemref = SVGElemRef->getObject()) {
  923. + elemref->deleteObject();
  924. + }
  925. + }
  926. +}
  927. +
  928. +Gtk::Widget *LPEMeasureLine::newWidget()
  929. +{
  930. + // use manage here, because after deletion of Effect object, others might
  931. + // still be pointing to this widget.
  932. + Gtk::VBox *vbox = Gtk::manage(new Gtk::VBox(Effect::newWidget()));
  933. +
  934. + vbox->set_border_width(5);
  935. + vbox->set_homogeneous(false);
  936. + vbox->set_spacing(2);
  937. +
  938. + std::vector<Parameter *>::iterator it = param_vector.begin();
  939. + Gtk::HBox * button1 = Gtk::manage(new Gtk::HBox(true,0));
  940. + Gtk::VBox * vbox_expander = Gtk::manage( new Gtk::VBox(Effect::newWidget()) );
  941. + vbox_expander->set_border_width(0);
  942. + vbox_expander->set_spacing(2);
  943. + while (it != param_vector.end()) {
  944. + if ((*it)->widget_is_visible) {
  945. + Parameter *param = *it;
  946. + Gtk::Widget *widg = dynamic_cast<Gtk::Widget *>(param->param_newWidget());
  947. + Glib::ustring *tip = param->param_getTooltip();
  948. + if (widg) {
  949. + if (param->param_key != "dimline_format" &&
  950. + param->param_key != "helperlines_format" &&
  951. + param->param_key != "arrows_format" &&
  952. + param->param_key != "anotation_format") {
  953. + vbox->pack_start(*widg, true, true, 2);
  954. + } else {
  955. + vbox_expander->pack_start(*widg, true, true, 2);
  956. + }
  957. + if (tip) {
  958. + widg->set_tooltip_text(*tip);
  959. + } else {
  960. + widg->set_tooltip_text("");
  961. + widg->set_has_tooltip(false);
  962. + }
  963. + }
  964. + }
  965. +
  966. + ++it;
  967. + }
  968. + Gtk::Button *save_default = Gtk::manage(new Gtk::Button(Glib::ustring(_("Save '*' as default"))));
  969. + save_default->signal_clicked().connect(sigc::mem_fun(*this, &LPEMeasureLine::saveDefault));
  970. + button1->pack_start(*save_default, true, true, 2);
  971. + expander = Gtk::manage(new Gtk::Expander(Glib::ustring(_("Show DIM CSS style override"))));
  972. + expander->add(*vbox_expander);
  973. + expander->set_expanded(expanded);
  974. + expander->property_expanded().signal_changed().connect(sigc::mem_fun(*this, &LPEMeasureLine::onExpanderChanged) );
  975. + vbox->pack_start(*expander, true, true, 2);
  976. + vbox->pack_start(*button1, true, true, 2);
  977. + return dynamic_cast<Gtk::Widget *>(vbox);
  978. +}
  979. +
  980. +void
  981. +LPEMeasureLine::onExpanderChanged()
  982. +{
  983. + expanded = expander->get_expanded();
  984. + if(expanded) {
  985. + expander->set_label (Glib::ustring(_("Hide DIM CSS style override")));
  986. + } else {
  987. + expander->set_label (Glib::ustring(_("Show DIM CSS style override")));
  988. + }
  989. +}
  990. +
  991. +Geom::PathVector
  992. +LPEMeasureLine::doEffect_path(Geom::PathVector const &path_in)
  993. +{
  994. + return path_in;
  995. +}
  996. +
  997. +void
  998. +LPEMeasureLine::saveDefault()
  999. +{
  1000. + Inkscape::Preferences *prefs = Inkscape::Preferences::get();
  1001. + prefs->setString("/live_effects/measure-line/fontbutton", (Glib::ustring)fontbutton.param_getSVGValue());
  1002. + prefs->setDouble("/live_effects/measure-line/scale", scale);
  1003. + prefs->setInt("/live_effects/measure-line/precision", precision);
  1004. + prefs->setDouble("/live_effects/measure-line/position", position);
  1005. + prefs->setDouble("/live_effects/measure-line/text_top_bottom", text_top_bottom);
  1006. + prefs->setDouble("/live_effects/measure-line/helpline_distance", helpline_distance);
  1007. + prefs->setDouble("/live_effects/measure-line/helpline_overlap", helpline_overlap);
  1008. + prefs->setString("/live_effects/measure-line/unit", (Glib::ustring)unit.get_abbreviation());
  1009. + prefs->setString("/live_effects/measure-line/format", (Glib::ustring)format.param_getSVGValue());
  1010. + prefs->setString("/live_effects/measure-line/dimline_format", (Glib::ustring)dimline_format.param_getSVGValue());
  1011. + prefs->setString("/live_effects/measure-line/helperlines_format", (Glib::ustring)helperlines_format.param_getSVGValue());
  1012. + prefs->setString("/live_effects/measure-line/anotation_format", (Glib::ustring)anotation_format.param_getSVGValue());
  1013. + prefs->setString("/live_effects/measure-line/arrows_format", (Glib::ustring)arrows_format.param_getSVGValue());
  1014. + prefs->setBool("/live_effects/measure-line/flip_side", flip_side);
  1015. + prefs->setBool("/live_effects/measure-line/scale_insensitive", scale_insensitive);
  1016. + prefs->setBool("/live_effects/measure-line/local_locale", local_locale);
  1017. + prefs->setBool("/live_effects/measure-line/line_group_05", line_group_05);
  1018. + prefs->setBool("/live_effects/measure-line/rotate_anotation", rotate_anotation);
  1019. + prefs->setBool("/live_effects/measure-line/hide_back", hide_back);
  1020. +}
  1021. +
  1022. +}; //namespace LivePathEffect
  1023. +}; /* namespace Inkscape */
  1024. +
  1025. +/*
  1026. + Local Variables:
  1027. + mode:c++
  1028. + c-file-style:"stroustrup"
  1029. + c-file-offset:((innamespace . 0)(inline-open . 0)(case-label . +))
  1030. + indent-tabs-mode:nil
  1031. + fill-column:99
  1032. + End:
  1033. +*/
  1034. +// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4 :
  1036. === added file 'src/live_effects/lpe-measure-line.h'
  1037. --- src/live_effects/lpe-measure-line.h 1970-01-01 00:00:00 +0000
  1038. +++ src/live_effects/lpe-measure-line.h 2016-08-02 11:00:55 +0000
  1039. @@ -0,0 +1,101 @@
  1040. +#ifndef INKSCAPE_LPE_MEASURE_LINE_H
  1041. +#define INKSCAPE_LPE_MEASURE_LINE_H
  1042. +
  1043. +/*
  1044. + * Author(s):
  1045. + * Jabiertxo Arraiza Cenoz <jabier.arraiza@marker.es>
  1046. + *
  1047. + * Copyright (C) 2014 Author(s)
  1048. + *
  1049. + * Released under GNU GPL, read the file 'COPYING' for more information
  1050. + */
  1051. +
  1052. +#include "live_effects/effect.h"
  1053. +#include "live_effects/parameter/enum.h"
  1054. +#include "live_effects/parameter/fontbutton.h"
  1055. +#include "live_effects/parameter/text.h"
  1056. +#include "live_effects/parameter/unit.h"
  1057. +#include "live_effects/parameter/bool.h"
  1058. +#include "live_effects/parameter/originalpath.h"
  1059. +#include <libnrtype/font-lister.h>
  1060. +#include <2geom/angle.h>
  1061. +#include <2geom/ray.h>
  1062. +#include <2geom/point.h>
  1063. +
  1064. +namespace Inkscape {
  1065. +namespace LivePathEffect {
  1066. +
  1067. +enum OrientationMethod {
  1068. + OM_HORIZONTAL,
  1069. + OM_VERTICAL,
  1070. + OM_PARALLEL,
  1071. + OM_END
  1072. +};
  1073. +
  1074. +class LPEMeasureLine : public Effect {
  1075. +public:
  1076. + LPEMeasureLine(LivePathEffectObject *lpeobject);
  1077. + virtual ~LPEMeasureLine();
  1078. + virtual void doBeforeEffect (SPLPEItem const* lpeitem);
  1079. + virtual void doOnApply(SPLPEItem const* lpeitem);
  1080. + virtual void doOnRemove (SPLPEItem const* lpeitem);
  1081. + virtual void doOnVisibilityToggled(SPLPEItem const* /*lpeitem*/);
  1082. + virtual Geom::PathVector doEffect_path(Geom::PathVector const &path_in);
  1083. + void createLine(Geom::Point start,Geom::Point end,Glib::ustring id, bool main, bool overflow, bool remove, bool arrows = false);
  1084. + void createTextLabel(Geom::Point pos, double length, Geom::Coord angle, bool remove);
  1085. + void onExpanderChanged();
  1086. + void createArrowMarker(Glib::ustring mode);
  1087. + void saveDefault();
  1088. + virtual Gtk::Widget *newWidget();
  1089. +private:
  1090. + UnitParam unit;
  1091. + FontButtonParam fontbutton;
  1092. + EnumParam<OrientationMethod> orientation;
  1093. + ScalarParam curve_linked;
  1094. + ScalarParam precision;
  1095. + ScalarParam position;
  1096. + ScalarParam text_top_bottom;
  1097. + ScalarParam text_right_left;
  1098. + ScalarParam helpline_distance;
  1099. + ScalarParam helpline_overlap;
  1100. + ScalarParam scale;
  1101. + TextParam format;
  1102. + BoolParam arrows_outside;
  1103. + BoolParam flip_side;
  1104. + BoolParam scale_insensitive;
  1105. + BoolParam local_locale;
  1106. + BoolParam line_group_05;
  1107. + BoolParam rotate_anotation;
  1108. + BoolParam hide_back;
  1109. + TextParam dimline_format;
  1110. + TextParam helperlines_format;
  1111. + TextParam anotation_format;
  1112. + TextParam arrows_format;
  1113. + Glib::ustring display_unit;
  1114. + bool expanded;
  1115. + Gtk::Expander * expander;
  1116. + double doc_scale;
  1117. + double fontsize;
  1118. + double anotation_width;
  1119. + double arrow_gap;
  1120. +/* Geom::Affine affine_over;*/
  1121. + LPEMeasureLine(const LPEMeasureLine &);
  1122. + LPEMeasureLine &operator=(const LPEMeasureLine &);
  1123. +
  1124. +};
  1125. +
  1126. +} //namespace LivePathEffect
  1127. +} //namespace Inkscape
  1128. +
  1129. +#endif
  1130. +
  1131. +/*
  1132. + Local Variables:
  1133. + mode:c++
  1134. + c-file-style:"stroustrup"
  1135. + c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
  1136. + indent-tabs-mode:nil
  1137. + fill-column:99
  1138. + End:
  1139. +*/
  1140. +// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4 :
  1142. === modified file 'src/live_effects/lpe-transform_2pts.cpp'
  1143. --- src/live_effects/lpe-transform_2pts.cpp 2016-07-28 11:26:17 +0000
  1144. +++ src/live_effects/lpe-transform_2pts.cpp 2016-07-24 16:00:12 +0000
  1145. @@ -90,7 +90,6 @@
  1146. {
  1147. using namespace Geom;
  1148. original_bbox(lpeitem);
  1149. -
  1150. point_a = Point(boundingbox_X.min(), boundingbox_Y.middle());
  1151. point_b = Point(boundingbox_X.max(), boundingbox_Y.middle());
  1152. SPLPEItem * splpeitem = const_cast<SPLPEItem *>(lpeitem);
  1154. === modified file 'src/live_effects/parameter/Makefile_insert'
  1155. --- src/live_effects/parameter/Makefile_insert 2015-03-02 01:29:50 +0000
  1156. +++ src/live_effects/parameter/Makefile_insert 2016-07-29 21:24:09 +0000
  1157. @@ -11,6 +11,8 @@
  1158. live_effects/parameter/random.h \
  1159. live_effects/parameter/point.cpp \
  1160. live_effects/parameter/point.h \
  1161. + live_effects/parameter/fontbutton.cpp \
  1162. + live_effects/parameter/fontbutton.h \
  1163. live_effects/parameter/enum.h \
  1164. live_effects/parameter/path-reference.cpp \
  1165. live_effects/parameter/path-reference.h \
  1167. === modified file 'src/live_effects/parameter/bool.cpp'
  1168. --- src/live_effects/parameter/bool.cpp 2015-10-18 19:13:13 +0000
  1169. +++ src/live_effects/parameter/bool.cpp 2016-07-24 23:27:14 +0000
  1170. @@ -36,6 +36,12 @@
  1171. param_setValue(defvalue);
  1172. }
  1174. +void
  1175. +BoolParam::param_update_default(bool const default_value)
  1176. +{
  1177. + defvalue = default_value;
  1178. +}
  1179. +
  1180. bool
  1181. BoolParam::param_readSVGValue(const gchar * strvalue)
  1182. {
  1184. === modified file 'src/live_effects/parameter/bool.h'
  1185. --- src/live_effects/parameter/bool.h 2015-10-18 19:13:13 +0000
  1186. +++ src/live_effects/parameter/bool.h 2016-07-24 23:26:29 +0000
  1187. @@ -36,7 +36,7 @@
  1189. void param_setValue(bool newvalue);
  1190. virtual void param_set_default();
  1191. -
  1192. + void param_update_default(bool const default_value);
  1193. bool get_value() const { return value; };
  1195. inline operator bool() const { return value; };
  1197. === modified file 'src/live_effects/parameter/enum.h'
  1198. --- src/live_effects/parameter/enum.h 2014-03-27 01:33:44 +0000
  1199. +++ src/live_effects/parameter/enum.h 2016-07-29 18:13:50 +0000
  1200. @@ -27,12 +27,14 @@
  1201. const Util::EnumDataConverter<E>& c,
  1202. Inkscape::UI::Widget::Registry* wr,
  1203. Effect* effect,
  1204. - E default_value)
  1205. + E default_value,
  1206. + bool sort = true)
  1207. : Parameter(label, tip, key, wr, effect)
  1208. {
  1209. enumdataconv = &c;
  1210. defvalue = default_value;
  1211. value = defvalue;
  1212. + sorted = sort;
  1213. };
  1215. virtual ~EnumParam() { };
  1216. @@ -40,12 +42,11 @@
  1217. virtual Gtk::Widget * param_newWidget() {
  1218. Inkscape::UI::Widget::RegisteredEnum<E> *regenum = Gtk::manage (
  1219. new Inkscape::UI::Widget::RegisteredEnum<E>( param_label, param_tooltip,
  1220. - param_key, *enumdataconv, *param_wr, param_effect->getRepr(), param_effect->getSPDoc() ) );
  1221. + param_key, *enumdataconv, *param_wr, param_effect->getRepr(), param_effect->getSPDoc(), sorted ) );
  1223. regenum->set_active_by_id(value);
  1224. regenum->combobox()->setProgrammatically = false;
  1225. regenum->set_undo_parameters(SP_VERB_DIALOG_LIVE_PATH_EFFECT, _("Change enumeration parameter"));
  1226. -
  1227. return dynamic_cast<Gtk::Widget *> (regenum);
  1228. };
  1230. @@ -86,6 +87,7 @@
  1232. E value;
  1233. E defvalue;
  1234. + bool sorted;
  1236. const Util::EnumDataConverter<E> * enumdataconv;
  1237. };
  1239. === added file 'src/live_effects/parameter/fontbutton.cpp'
  1240. --- src/live_effects/parameter/fontbutton.cpp 1970-01-01 00:00:00 +0000
  1241. +++ src/live_effects/parameter/fontbutton.cpp 2016-07-29 21:26:48 +0000
  1242. @@ -0,0 +1,92 @@
  1243. +/*
  1244. + * Authors:
  1245. + *
  1246. + * Released under GNU GPL, read the file 'COPYING' for more information
  1247. + */
  1248. +
  1249. +
  1250. +#include "ui/widget/registered-widget.h"
  1251. +#include "live_effects/parameter/fontbutton.h"
  1252. +#include "live_effects/effect.h"
  1253. +#include "ui/widget/font-button.h"
  1254. +#include "svg/svg.h"
  1255. +#include "svg/stringstream.h"
  1256. +#include "verbs.h"
  1257. +
  1258. +#include <glibmm/i18n.h>
  1259. +
  1260. +namespace Inkscape {
  1261. +
  1262. +namespace LivePathEffect {
  1263. +
  1264. +FontButtonParam::FontButtonParam( const Glib::ustring& label, const Glib::ustring& tip,
  1265. + const Glib::ustring& key, Inkscape::UI::Widget::Registry* wr,
  1266. + Effect* effect, const Glib::ustring default_value )
  1267. + : Parameter(label, tip, key, wr, effect),
  1268. + value(default_value),
  1269. + defvalue(default_value)
  1270. +{
  1271. +}
  1272. +
  1273. +void
  1274. +FontButtonParam::param_set_default()
  1275. +{
  1276. + param_setValue(defvalue);
  1277. +}
  1278. +void
  1279. +FontButtonParam::param_update_default(const Glib::ustring default_value){
  1280. + defvalue = default_value;
  1281. +}
  1282. +
  1283. +bool
  1284. +FontButtonParam::param_readSVGValue(const gchar * strvalue)
  1285. +{
  1286. + Inkscape::SVGOStringStream os;
  1287. + os << strvalue;
  1288. + param_setValue((Glib::ustring)os.str());
  1289. + return true;
  1290. +}
  1291. +
  1292. +gchar *
  1293. +FontButtonParam::param_getSVGValue() const
  1294. +{
  1295. + return g_strdup(value.c_str());
  1296. +}
  1297. +
  1298. +Gtk::Widget *
  1299. +FontButtonParam::param_newWidget()
  1300. +{
  1301. + Inkscape::UI::Widget::RegisteredFontButton * fontbuttonwdg = Gtk::manage(
  1302. + new Inkscape::UI::Widget::RegisteredFontButton( param_label,
  1303. + param_tooltip,
  1304. + param_key,
  1305. + *param_wr,
  1306. + param_effect->getRepr(),
  1307. + param_effect->getSPDoc() ) );
  1308. + Glib::ustring fontspec = param_getSVGValue();
  1309. + fontbuttonwdg->setValue( fontspec);
  1310. + fontbuttonwdg->set_undo_parameters(SP_VERB_DIALOG_LIVE_PATH_EFFECT, _("Change font button parameter"));
  1311. + param_effect->upd_params = false;
  1312. + return dynamic_cast<Gtk::Widget *> (fontbuttonwdg);
  1313. +}
  1314. +
  1315. +void
  1316. +FontButtonParam::param_setValue(const Glib::ustring newvalue)
  1317. +{
  1318. + value = newvalue;
  1319. +}
  1320. +
  1321. +} /* namespace LivePathEffect */
  1322. +
  1323. +} /* namespace Inkscape */
  1324. +
  1325. +/*
  1326. + Local Variables:
  1327. + mode:c++
  1328. + c-file-style:"stroustrup"
  1329. + c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
  1330. + indent-tabs-mode:nil
  1331. + fill-column:99
  1332. + End:
  1333. +*/
  1334. +// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4 :
  1336. === added file 'src/live_effects/parameter/fontbutton.h'
  1337. --- src/live_effects/parameter/fontbutton.h 1970-01-01 00:00:00 +0000
  1338. +++ src/live_effects/parameter/fontbutton.h 2016-07-29 20:44:37 +0000
  1339. @@ -0,0 +1,62 @@
  1340. +#ifndef INKSCAPE_LIVEPATHEFFECT_PARAMETER_FONT_H
  1341. +#define INKSCAPE_LIVEPATHEFFECT_PARAMETER_FONT_H
  1342. +
  1343. +/*
  1344. + * Inkscape::LivePathEffectParameters
  1345. + *
  1346. + * Authors:
  1347. + * Released under GNU GPL, read the file 'COPYING' for more information
  1348. + */
  1349. +#include <glib.h>
  1350. +#include <gtkmm.h>
  1351. +#include "live_effects/parameter/parameter.h"
  1352. +
  1353. +namespace Inkscape {
  1354. +
  1355. +namespace LivePathEffect {
  1356. +
  1357. +class FontButtonParam : public Parameter {
  1358. +public:
  1359. + FontButtonParam( const Glib::ustring& label,
  1360. + const Glib::ustring& tip,
  1361. + const Glib::ustring& key,
  1362. + Inkscape::UI::Widget::Registry* wr,
  1363. + Effect* effect,
  1364. + const Glib::ustring default_value = "");
  1365. + virtual ~FontButtonParam() {}
  1366. +
  1367. + virtual Gtk::Widget * param_newWidget();
  1368. + virtual bool param_readSVGValue(const gchar * strvalue);
  1369. + void param_update_default(const Glib::ustring defvalue);
  1370. + virtual gchar * param_getSVGValue() const;
  1371. +
  1372. + void param_setValue(const Glib::ustring newvalue);
  1373. +
  1374. + virtual void param_set_default();
  1375. +
  1376. + const Glib::ustring get_value() const { return defvalue; };
  1377. +
  1378. +private:
  1379. + FontButtonParam(const FontButtonParam&);
  1380. + FontButtonParam& operator=(const FontButtonParam&);
  1381. + Glib::ustring value;
  1382. + Glib::ustring defvalue;
  1383. +
  1384. +};
  1385. +
  1386. +} //namespace LivePathEffect
  1387. +
  1388. +} //namespace Inkscape
  1389. +
  1390. +#endif
  1391. +
  1392. +/*
  1393. + Local Variables:
  1394. + mode:c++
  1395. + c-file-style:"stroustrup"
  1396. + c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
  1397. + indent-tabs-mode:nil
  1398. + fill-column:99
  1399. + End:
  1400. +*/
  1401. +// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4 :
  1403. === modified file 'src/live_effects/parameter/parameter.cpp'
  1404. --- src/live_effects/parameter/parameter.cpp 2015-10-18 19:13:13 +0000
  1405. +++ src/live_effects/parameter/parameter.cpp 2016-07-30 16:08:21 +0000
  1406. @@ -4,11 +4,9 @@
  1407. * Released under GNU GPL, read the file 'COPYING' for more information
  1408. */
  1410. -#include "ui/widget/registered-widget.h"
  1411. -#include <glibmm/i18n.h>
  1413. +#include "live_effects/effect.h"
  1414. #include "live_effects/parameter/parameter.h"
  1415. -#include "live_effects/effect.h"
  1416. #include "svg/svg.h"
  1417. #include "xml/repr.h"
  1419. @@ -16,6 +14,8 @@
  1421. #include "verbs.h"
  1423. +#include <glibmm/i18n.h>
  1424. +
  1425. #define noLPEREALPARAM_DEBUG
  1427. namespace Inkscape {
  1428. @@ -101,9 +101,16 @@
  1429. param_set_value(defvalue);
  1430. }
  1432. +void
  1433. +ScalarParam::param_update_default(gdouble default_value)
  1434. +{
  1435. + defvalue = default_value;
  1436. +}
  1437. +
  1438. void
  1439. ScalarParam::param_set_value(gdouble val)
  1440. {
  1441. + param_effect->upd_params = true;
  1442. value = val;
  1443. if (integer)
  1444. value = round(value);
  1445. @@ -121,7 +128,7 @@
  1446. // Once again, in gtk2, this is not a problem. But in gtk3,
  1447. // widgets get allocated the amount of size they ask for,
  1448. // leading to excessively long widgets.
  1449. -
  1450. + param_effect->upd_params = true;
  1451. if (min >= -SCALARPARAM_G_MAXDOUBLE) {
  1452. this->min = min;
  1453. } else {
  1454. @@ -130,15 +137,15 @@
  1455. if (max <= SCALARPARAM_G_MAXDOUBLE) {
  1456. this->max = max;
  1457. } else {
  1458. - this->max = SCALARPARAM_G_MAXDOUBLE;
  1459. + this->max = SCALARPARAM_G_MAXDOUBLE;
  1460. }
  1461. -
  1462. param_set_value(value); // reset value to see whether it is in ranges
  1463. }
  1465. void
  1466. ScalarParam::param_make_integer(bool yes)
  1467. {
  1468. + param_effect->upd_params = true;
  1469. integer = yes;
  1470. digits = 0;
  1471. inc_step = 1;
  1472. @@ -169,6 +176,7 @@
  1473. if(!overwrite_widget){
  1474. rsu->set_undo_parameters(SP_VERB_DIALOG_LIVE_PATH_EFFECT, _("Change scalar parameter"));
  1475. }
  1476. + param_effect->upd_params = false;
  1477. return dynamic_cast<Gtk::Widget *> (rsu);
  1478. } else {
  1479. return NULL;
  1480. @@ -178,12 +186,14 @@
  1481. void
  1482. ScalarParam::param_set_digits(unsigned digits)
  1483. {
  1484. + param_effect->upd_params = true;
  1485. this->digits = digits;
  1486. }
  1488. void
  1489. ScalarParam::param_set_increments(double step, double page)
  1490. {
  1491. + param_effect->upd_params = true;
  1492. inc_step = step;
  1493. inc_page = page;
  1494. }
  1496. === modified file 'src/live_effects/parameter/parameter.h'
  1497. --- src/live_effects/parameter/parameter.h 2015-10-18 19:13:13 +0000
  1498. +++ src/live_effects/parameter/parameter.h 2016-07-30 16:05:28 +0000
  1499. @@ -12,6 +12,7 @@
  1500. #include <glibmm/ustring.h>
  1501. #include <2geom/forward.h>
  1502. #include <2geom/pathvector.h>
  1503. +#include "ui/widget/registered-widget.h"
  1505. // In gtk2, this wasn't an issue; we could toss around
  1506. // G_MAXDOUBLE and not worry about size allocations. But
  1507. @@ -110,12 +111,12 @@
  1508. virtual gchar * param_getSVGValue() const;
  1510. virtual void param_set_default();
  1511. + void param_update_default(gdouble default_value);
  1512. void param_set_value(gdouble val);
  1513. void param_make_integer(bool yes = true);
  1514. void param_set_range(gdouble min, gdouble max);
  1515. void param_set_digits(unsigned digits);
  1516. void param_set_increments(double step, double page);
  1517. -
  1518. void addSlider(bool add_slider_widget) { add_slider = add_slider_widget; };
  1520. void param_overwrite_widget(bool overwrite_widget);
  1522. === modified file 'src/live_effects/parameter/point.cpp'
  1523. --- src/live_effects/parameter/point.cpp 2016-01-17 19:18:53 +0000
  1524. +++ src/live_effects/parameter/point.cpp 2016-07-29 09:36:40 +0000
  1525. @@ -4,7 +4,6 @@
  1526. * Released under GNU GPL, read the file 'COPYING' for more information
  1527. */
  1529. -#include "ui/widget/registered-widget.h"
  1530. #include "live_effects/parameter/point.h"
  1531. #include "live_effects/effect.h"
  1532. #include "svg/svg.h"
  1533. @@ -30,7 +29,8 @@
  1534. : Parameter(label, tip, key, wr, effect),
  1535. defvalue(default_value),
  1536. liveupdate(live_update),
  1537. - knoth(NULL)
  1538. + knoth(NULL),
  1539. + _pointwdg(NULL)
  1540. {
  1541. knot_shape = SP_KNOT_SHAPE_DIAMOND;
  1542. knot_mode = SP_KNOT_MODE_XOR;
  1543. @@ -62,9 +62,9 @@
  1544. }
  1546. void
  1547. -PointParam::param_update_default(Geom::Point newpoint)
  1548. +PointParam::param_update_default(const Geom::Point default_point)
  1549. {
  1550. - defvalue = newpoint;
  1551. + defvalue = default_point;
  1552. }
  1554. void
  1555. @@ -81,6 +81,9 @@
  1556. if(knoth && liveupdate){
  1557. knoth->update_knots();
  1558. }
  1559. + if (_pointwdg) {
  1560. + _pointwdg->setValue( newpoint );
  1561. + }
  1562. }
  1564. bool
  1565. @@ -116,7 +119,7 @@
  1566. Gtk::Widget *
  1567. PointParam::param_newWidget()
  1568. {
  1569. - Inkscape::UI::Widget::RegisteredTransformedPoint * pointwdg = Gtk::manage(
  1570. + _pointwdg = Gtk::manage(
  1571. new Inkscape::UI::Widget::RegisteredTransformedPoint( param_label,
  1572. param_tooltip,
  1573. param_key,
  1574. @@ -126,15 +129,15 @@
  1575. // TODO: fix to get correct desktop (don't use SP_ACTIVE_DESKTOP)
  1576. SPDesktop *desktop = SP_ACTIVE_DESKTOP;
  1577. Geom::Affine transf = desktop->doc2dt();
  1578. - pointwdg->setTransform(transf);
  1579. - pointwdg->setValue( *this );
  1580. - pointwdg->clearProgrammatically();
  1581. - pointwdg->set_undo_parameters(SP_VERB_DIALOG_LIVE_PATH_EFFECT, _("Change point parameter"));
  1582. + _pointwdg->setTransform(transf);
  1583. + _pointwdg->setValue( *this );
  1584. + _pointwdg->clearProgrammatically();
  1585. + _pointwdg->set_undo_parameters(SP_VERB_DIALOG_LIVE_PATH_EFFECT, _("Change point parameter"));
  1587. Gtk::HBox * hbox = Gtk::manage( new Gtk::HBox() );
  1588. - static_cast<Gtk::HBox*>(hbox)->pack_start(*pointwdg, true, true);
  1589. + static_cast<Gtk::HBox*>(hbox)->pack_start(*_pointwdg, true, true);
  1590. static_cast<Gtk::HBox*>(hbox)->show_all_children();
  1591. -
  1592. + param_effect->upd_params = false;
  1593. return dynamic_cast<Gtk::Widget *> (hbox);
  1594. }
  1596. @@ -191,13 +194,13 @@
  1597. PointParamKnotHolderEntity::knot_click(guint state)
  1598. {
  1599. if (state & GDK_CONTROL_MASK) {
  1600. - if (state & GDK_MOD1_MASK) {
  1601. - this->pparam->param_set_default();
  1602. - SPLPEItem * splpeitem = dynamic_cast<SPLPEItem *>(item);
  1603. - if(splpeitem){
  1604. - sp_lpe_item_update_patheffect(splpeitem, false, false);
  1605. - }
  1606. + if (state & GDK_MOD1_MASK) {
  1607. + this->pparam->param_set_default();
  1608. + SPLPEItem * splpeitem = dynamic_cast<SPLPEItem *>(item);
  1609. + if(splpeitem){
  1610. + sp_lpe_item_update_patheffect(splpeitem, false, false);
  1611. }
  1612. + }
  1613. }
  1614. }
  1617. === modified file 'src/live_effects/parameter/point.h'
  1618. --- src/live_effects/parameter/point.h 2016-01-17 19:18:53 +0000
  1619. +++ src/live_effects/parameter/point.h 2016-07-29 09:28:12 +0000
  1620. @@ -11,7 +11,7 @@
  1622. #include <glib.h>
  1623. #include <2geom/point.h>
  1624. -
  1625. +#include "ui/widget/registered-widget.h"
  1626. #include "live_effects/parameter/parameter.h"
  1628. #include "knot-holder-entity.h"
  1629. @@ -43,7 +43,7 @@
  1630. void param_set_default();
  1631. Geom::Point param_get_default() const;
  1632. void param_set_liveupdate(bool live_update);
  1633. - void param_update_default(Geom::Point newpoint);
  1634. + void param_update_default(const Geom::Point default_point);
  1635. virtual void param_transform_multiply(Geom::Affine const& /*postmul*/, bool /*set*/);
  1637. void set_oncanvas_looks(SPKnotShapeType shape, SPKnotModeType mode, guint32 color);
  1638. @@ -62,6 +62,7 @@
  1639. SPKnotModeType knot_mode;
  1640. guint32 knot_color;
  1641. gchar *handle_tip;
  1642. + Inkscape::UI::Widget::RegisteredTransformedPoint * _pointwdg;
  1643. };
  1647. === modified file 'src/live_effects/parameter/text.cpp'
  1648. --- src/live_effects/parameter/text.cpp 2014-12-21 21:58:32 +0000
  1649. +++ src/live_effects/parameter/text.cpp 2016-07-31 22:44:32 +0000
  1650. @@ -31,12 +31,16 @@
  1651. Effect* effect, const Glib::ustring default_value )
  1652. : Parameter(label, tip, key, wr, effect),
  1653. value(default_value),
  1654. - defvalue(default_value)
  1655. + defvalue(default_value),
  1656. + _hide_canvas_text(false)
  1657. {
  1658. - SPDesktop *desktop = SP_ACTIVE_DESKTOP; // FIXME: we shouldn't use this!
  1659. - canvas_text = (SPCanvasText *) sp_canvastext_new(desktop->getTempGroup(), desktop, Geom::Point(0,0), "");
  1660. - sp_canvastext_set_text (canvas_text, default_value.c_str());
  1661. - sp_canvastext_set_coords (canvas_text, 0, 0);
  1662. + if (SPDesktop *desktop = SP_ACTIVE_DESKTOP) { // FIXME: we shouldn't use this!
  1663. + canvas_text = (SPCanvasText *) sp_canvastext_new(desktop->getTempGroup(), desktop, Geom::Point(0,0), "");
  1664. + sp_canvastext_set_text (canvas_text, default_value.c_str());
  1665. + sp_canvastext_set_coords (canvas_text, 0, 0);
  1666. + } else {
  1667. + _hide_canvas_text = true;
  1668. + }
  1669. }
  1671. void
  1672. @@ -46,9 +50,26 @@
  1673. }
  1675. void
  1676. +TextParam::param_update_default(Glib::ustring default_value)
  1677. +{
  1678. + defvalue = default_value;
  1679. +}
  1680. +
  1681. +void
  1682. +TextParam::param_hide_canvas_text()
  1683. +{
  1684. + if (!_hide_canvas_text) {
  1685. + sp_canvastext_set_text(canvas_text, " ");
  1686. + _hide_canvas_text = true;
  1687. + }
  1688. +}
  1689. +
  1690. +void
  1691. TextParam::setPos(Geom::Point pos)
  1692. {
  1693. - sp_canvastext_set_coords (canvas_text, pos);
  1694. + if (!_hide_canvas_text) {
  1695. + sp_canvastext_set_coords (canvas_text, pos);
  1696. + }
  1697. }
  1699. void
  1700. @@ -63,9 +84,10 @@
  1701. Point dir = unit_vector(derivative(pwd2_reparam).valueAt(t_reparam));
  1702. Point n = -rot90(dir);
  1703. double angle = Geom::angle_between(dir, Point(1,0));
  1704. -
  1705. - sp_canvastext_set_coords(canvas_text, pos + n * length);
  1706. - sp_canvastext_set_anchor_manually(canvas_text, std::sin(angle), -std::cos(angle));
  1707. + if (!_hide_canvas_text) {
  1708. + sp_canvastext_set_coords(canvas_text, pos + n * length);
  1709. + sp_canvastext_set_anchor_manually(canvas_text, std::sin(angle), -std::cos(angle));
  1710. + }
  1711. }
  1713. void
  1714. @@ -73,7 +95,9 @@
  1715. {
  1716. anchor_x = x_value;
  1717. anchor_y = y_value;
  1718. - sp_canvastext_set_anchor_manually (canvas_text, anchor_x, anchor_y);
  1719. + if (!_hide_canvas_text) {
  1720. + sp_canvastext_set_anchor_manually (canvas_text, anchor_x, anchor_y);
  1721. + }
  1722. }
  1724. bool
  1725. @@ -94,8 +118,7 @@
  1726. {
  1727. Inkscape::UI::Widget::RegisteredText *rsu = Gtk::manage(new Inkscape::UI::Widget::RegisteredText(
  1728. param_label, param_tooltip, param_key, *param_wr, param_effect->getRepr(), param_effect->getSPDoc()));
  1729. -
  1730. - rsu->setText(value.c_str());
  1731. + rsu->setText(value);
  1732. rsu->setProgrammatically = false;
  1734. rsu->set_undo_parameters(SP_VERB_DIALOG_LIVE_PATH_EFFECT, _("Change text parameter"));
  1735. @@ -107,8 +130,9 @@
  1736. TextParam::param_setValue(const Glib::ustring newvalue)
  1737. {
  1738. value = newvalue;
  1739. -
  1740. - sp_canvastext_set_text (canvas_text, newvalue.c_str());
  1741. + if (!_hide_canvas_text) {
  1742. + sp_canvastext_set_text (canvas_text, newvalue.c_str());
  1743. + }
  1744. }
  1746. } /* namespace LivePathEffect */
  1748. === modified file 'src/live_effects/parameter/text.h'
  1749. --- src/live_effects/parameter/text.h 2014-03-27 01:33:44 +0000
  1750. +++ src/live_effects/parameter/text.h 2016-07-31 02:24:55 +0000
  1751. @@ -40,7 +40,9 @@
  1752. virtual gchar * param_getSVGValue() const;
  1754. void param_setValue(const Glib::ustring newvalue);
  1755. + void param_hide_canvas_text();
  1756. virtual void param_set_default();
  1757. + void param_update_default(Glib::ustring default_value);
  1758. void setPos(Geom::Point pos);
  1759. void setPosAndAnchor(const Geom::Piecewise<Geom::D2<Geom::SBasis> > &pwd2,
  1760. const double t, const double length, bool use_curvature = false);
  1761. @@ -53,7 +55,7 @@
  1762. TextParam& operator=(const TextParam&);
  1763. double anchor_x;
  1764. double anchor_y;
  1765. -
  1766. + bool _hide_canvas_text;
  1767. Glib::ustring value;
  1768. Glib::ustring defvalue;
  1771. === modified file 'src/live_effects/parameter/togglebutton.cpp'
  1772. --- src/live_effects/parameter/togglebutton.cpp 2016-07-24 15:05:29 +0000
  1773. +++ src/live_effects/parameter/togglebutton.cpp 2016-07-24 16:53:55 +0000
  1774. @@ -12,6 +12,7 @@
  1775. #include "live_effects/effect.h"
  1776. #include "svg/svg.h"
  1777. #include "svg/stringstream.h"
  1778. +#include "selection.h"
  1779. #include "widgets/icon.h"
  1780. #include "inkscape.h"
  1781. #include "verbs.h"
  1782. @@ -108,13 +109,14 @@
  1783. }else{
  1784. gtk_box_pack_start (GTK_BOX(box_button), label_button, false, false, 1);
  1785. }
  1786. +
  1787. checkwdg->add(*Gtk::manage(Glib::wrap(box_button)));
  1788. checkwdg->setActive(value);
  1789. checkwdg->setProgrammatically = false;
  1790. checkwdg->set_undo_parameters(SP_VERB_DIALOG_LIVE_PATH_EFFECT, _("Change togglebutton parameter"));
  1792. _toggled_connection = checkwdg->signal_toggled().connect(sigc::mem_fun(*this, &ToggleButtonParam::toggled));
  1793. -
  1794. + param_effect->upd_params = false;
  1795. return checkwdg;
  1796. }
  1798. @@ -161,6 +163,12 @@
  1800. void
  1801. ToggleButtonParam::toggled() {
  1802. + //Force redraw for update widgets
  1803. + param_effect->upd_params = true;
  1804. + if (SP_ACTIVE_DESKTOP) {
  1805. + Inkscape::Selection *selection = SP_ACTIVE_DESKTOP->getSelection();
  1806. + selection ->emitModified();
  1807. + }
  1808. _signal_toggled.emit();
  1809. }
  1812. === modified file 'src/live_effects/parameter/unit.cpp'
  1813. --- src/live_effects/parameter/unit.cpp 2014-03-27 01:33:44 +0000
  1814. +++ src/live_effects/parameter/unit.cpp 2016-07-24 23:34:35 +0000
  1815. @@ -54,6 +54,12 @@
  1816. param_set_value(*defunit);
  1817. }
  1819. +void
  1820. +UnitParam::param_update_default(const Glib::ustring default_unit)
  1821. +{
  1822. + defunit = unit_table.getUnit(default_unit);
  1823. +}
  1824. +
  1825. void
  1826. UnitParam::param_set_value(Inkscape::Util::Unit const &val)
  1827. {
  1829. === modified file 'src/live_effects/parameter/unit.h'
  1830. --- src/live_effects/parameter/unit.h 2014-03-27 01:33:44 +0000
  1831. +++ src/live_effects/parameter/unit.h 2016-07-24 23:34:56 +0000
  1832. @@ -33,6 +33,7 @@
  1833. virtual gchar * param_getSVGValue() const;
  1834. virtual void param_set_default();
  1835. void param_set_value(Inkscape::Util::Unit const &val);
  1836. + void param_update_default(const Glib::ustring default_unit);
  1837. const gchar *get_abbreviation() const;
  1839. virtual Gtk::Widget * param_newWidget();
  1841. === modified file 'src/selection.cpp'
  1842. --- src/selection.cpp 2016-07-28 11:26:17 +0000
  1843. +++ src/selection.cpp 2016-07-24 16:00:12 +0000
  1844. @@ -282,6 +282,11 @@
  1845. _emitChanged();
  1846. }
  1848. +void Selection::emitModified()
  1849. +{
  1850. + _emitChanged();
  1851. +}
  1852. +
  1853. std::vector<SPObject*> const &Selection::list() {
  1854. if(!_objs_vector.empty())
  1855. return _objs_vector;
  1857. === modified file 'src/selection.h'
  1858. --- src/selection.h 2016-07-28 11:26:17 +0000
  1859. +++ src/selection.h 2016-07-24 16:00:12 +0000
  1860. @@ -192,6 +192,11 @@
  1861. void clear();
  1863. /**
  1864. + * Emmit modified signal
  1865. + */
  1866. + void emitModified();
  1867. +
  1868. + /**
  1869. * Returns true if no items are selected.
  1870. */
  1871. bool isEmpty() const { return _objs.empty(); }
  1873. === modified file 'src/ui/CMakeLists.txt'
  1874. --- src/ui/CMakeLists.txt 2016-02-07 15:49:01 +0000
  1875. +++ src/ui/CMakeLists.txt 2016-07-29 21:24:51 +0000
  1876. @@ -128,6 +128,7 @@
  1877. widget/entity-entry.cpp
  1878. widget/entry.cpp
  1879. widget/filter-effect-chooser.cpp
  1880. + widget/font-button.cpp
  1881. widget/font-variants.cpp
  1882. widget/frame.cpp
  1883. widget/gimpcolorwheel.c
  1884. @@ -312,6 +313,7 @@
  1885. widget/entity-entry.h
  1886. widget/entry.h
  1887. widget/filter-effect-chooser.h
  1888. + widget/font-button.h
  1889. widget/font-variants.h
  1890. widget/frame.h
  1891. widget/gimpspinscale.h
  1893. === modified file 'src/ui/dialog/livepatheffect-editor.cpp'
  1894. --- src/ui/dialog/livepatheffect-editor.cpp 2016-07-28 11:26:17 +0000
  1895. +++ src/ui/dialog/livepatheffect-editor.cpp 2016-07-30 17:02:04 +0000
  1896. @@ -61,7 +61,7 @@
  1897. {
  1898. LivePathEffectEditor *lpeeditor = static_cast<LivePathEffectEditor *>(data);
  1899. lpeeditor->lpe_list_locked = false;
  1900. - lpeeditor->onSelectionChanged(selection);
  1901. + lpeeditor->onSelectionChanged(selection, true);
  1902. }
  1904. static void lpeeditor_selection_modified (Inkscape::Selection * selection, guint /*flags*/, gpointer data)
  1905. @@ -98,7 +98,8 @@
  1906. button_up(),
  1907. button_down(),
  1908. current_desktop(NULL),
  1909. - current_lpeitem(NULL)
  1910. + current_lpeitem(NULL),
  1911. + current_lperef(NULL)
  1912. {
  1913. Gtk::Box *contents = _getContents();
  1914. contents->set_spacing(4);
  1915. @@ -206,6 +207,10 @@
  1916. void
  1917. LivePathEffectEditor::showParams(LivePathEffect::Effect& effect)
  1918. {
  1919. + if ( ! effect.upd_params ) {
  1920. + return;
  1921. + }
  1922. +
  1923. if (effectwidget) {
  1924. effectcontrol_vbox.remove(*effectwidget);
  1925. delete effectwidget;
  1926. @@ -265,9 +270,8 @@
  1927. button_down.set_sensitive(sensitive);
  1928. }
  1930. -
  1931. void
  1932. -LivePathEffectEditor::onSelectionChanged(Inkscape::Selection *sel)
  1933. +LivePathEffectEditor::onSelectionChanged(Inkscape::Selection *sel, bool upd_params)
  1934. {
  1935. if (lpe_list_locked) {
  1936. // this was triggered by selecting a row in the list, so skip reloading
  1937. @@ -291,6 +295,9 @@
  1938. if ( lpeitem->hasPathEffect() ) {
  1939. Inkscape::LivePathEffect::Effect *lpe = lpeitem->getCurrentLPE();
  1940. if (lpe) {
  1941. + if (upd_params) {
  1942. + lpe->upd_params = true;
  1943. + }
  1944. showParams(*lpe);
  1945. lpe_list_locked = true;
  1946. selectInList(lpe);
  1947. @@ -494,6 +501,12 @@
  1948. SPItem *item = sel->singleItem();
  1949. SPLPEItem *lpeitem = dynamic_cast<SPLPEItem *>(item);
  1950. if ( lpeitem ) {
  1951. + if (current_lperef && current_lperef->lpeobject) {
  1952. + LivePathEffect::Effect * effect = current_lperef->lpeobject->get_lpe();
  1953. + if (effect) {
  1954. + effect->upd_params = true;
  1955. + }
  1956. + }
  1957. lpeitem->removeCurrentPathEffect(false);
  1959. DocumentUndo::done( current_desktop->getDocument(), SP_VERB_DIALOG_LIVE_PATH_EFFECT,
  1960. @@ -548,11 +561,17 @@
  1961. Gtk::TreeModel::iterator it = sel->get_selected();
  1962. LivePathEffect::LPEObjectReference * lperef = (*it)[columns.lperef];
  1964. - if (lperef && current_lpeitem) {
  1965. + if (lperef && current_lpeitem && current_lperef != lperef) {
  1966. + //The last condition ignore Gtk::TreeModel may occasionally be changed emitted when nothing has happened
  1967. if (lperef->lpeobject->get_lpe()) {
  1968. lpe_list_locked = true; // prevent reload of the list which would lose selection
  1969. current_lpeitem->setCurrentPathEffect(lperef);
  1970. - showParams(*lperef->lpeobject->get_lpe());
  1971. + current_lperef = lperef;
  1972. + LivePathEffect::Effect * effect = lperef->lpeobject->get_lpe();
  1973. + if (effect) {
  1974. + effect->upd_params = true;
  1975. + showParams(*effect);
  1976. + }
  1977. }
  1978. }
  1979. }
  1980. @@ -570,6 +589,14 @@
  1981. /* FIXME: this explicit writing to SVG is wrong. The lpe_item should have a method to disable/enable an effect within its stack.
  1982. * So one can call: lpe_item->setActive(lpeobjref->lpeobject); */
  1983. lpeobjref->lpeobject->get_lpe()->getRepr()->setAttribute("is_visible", newValue ? "true" : "false");
  1984. + Inkscape::Selection *sel = _getSelection();
  1985. + if ( sel && !sel->isEmpty() ) {
  1986. + SPItem *item = sel->singleItem();
  1987. + SPLPEItem *lpeitem = dynamic_cast<SPLPEItem *>(item);
  1988. + if ( lpeitem ) {
  1989. + lpeobjref->lpeobject->get_lpe()->doOnVisibilityToggled(lpeitem);
  1990. + }
  1991. + }
  1992. DocumentUndo::done( current_desktop->getDocument(), SP_VERB_DIALOG_LIVE_PATH_EFFECT,
  1993. newValue ? _("Activate path effect") : _("Deactivate path effect"));
  1994. }
  1996. === modified file 'src/ui/dialog/livepatheffect-editor.h'
  1997. --- src/ui/dialog/livepatheffect-editor.h 2014-03-27 01:33:44 +0000
  1998. +++ src/ui/dialog/livepatheffect-editor.h 2016-07-24 16:00:12 +0000
  1999. @@ -45,7 +45,8 @@
  2001. static LivePathEffectEditor &getInstance() { return *new LivePathEffectEditor(); }
  2003. - void onSelectionChanged(Inkscape::Selection *sel);
  2004. + void onSelectionChanged(Inkscape::Selection *sel, bool upd_params = false);
  2005. + void onSelectionModified(Inkscape::Selection *sel);
  2006. virtual void on_effect_selection_changed();
  2007. void setDesktop(SPDesktop *desktop);
  2009. @@ -126,6 +127,8 @@
  2011. SPLPEItem * current_lpeitem;
  2013. + LivePathEffect::LPEObjectReference * current_lperef;
  2014. +
  2015. friend void lpeeditor_selection_changed (Inkscape::Selection * selection, gpointer data);
  2017. LivePathEffectEditor(LivePathEffectEditor const &d);
  2019. === modified file 'src/ui/widget/Makefile_insert'
  2020. --- src/ui/widget/Makefile_insert 2015-05-17 09:20:36 +0000
  2021. +++ src/ui/widget/Makefile_insert 2016-07-29 21:25:30 +0000
  2022. @@ -33,6 +33,8 @@
  2023. ui/widget/entry.h \
  2024. ui/widget/filter-effect-chooser.h \
  2025. ui/widget/filter-effect-chooser.cpp \
  2026. + ui/widget/font-button.h \
  2027. + ui/widget/font-button.cpp \
  2028. ui/widget/font-variants.h \
  2029. ui/widget/font-variants.cpp \
  2030. ui/widget/gimpspinscale.c \
  2032. === modified file 'src/ui/widget/combo-enums.h'
  2033. --- src/ui/widget/combo-enums.h 2012-02-15 11:19:00 +0000
  2034. +++ src/ui/widget/combo-enums.h 2016-07-29 18:13:37 +0000
  2035. @@ -16,7 +16,6 @@
  2036. #include <gtkmm/liststore.h>
  2037. #include "attr-widget.h"
  2038. #include "util/enums.h"
  2039. -
  2040. #include <glibmm/i18n.h>
  2042. namespace Inkscape {
  2043. @@ -190,9 +189,11 @@
  2044. const Util::EnumDataConverter<E>& c,
  2045. Glib::ustring const &suffix = "",
  2046. Glib::ustring const &icon = "",
  2047. - bool mnemonic = true)
  2048. - : Labelled(label, tooltip, new ComboBoxEnum<E>(c), suffix, icon, mnemonic)
  2049. - { }
  2050. + bool mnemonic = true,
  2051. + bool sorted = true)
  2052. + : Labelled(label, tooltip, new ComboBoxEnum<E>(c, SP_ATTR_INVALID, sorted), suffix, icon, mnemonic)
  2053. + {
  2054. + }
  2056. ComboBoxEnum<E>* getCombobox() {
  2057. return static_cast< ComboBoxEnum<E>* > (_widget);
  2059. === added file 'src/ui/widget/font-button.cpp'
  2060. --- src/ui/widget/font-button.cpp 1970-01-01 00:00:00 +0000
  2061. +++ src/ui/widget/font-button.cpp 2016-07-30 00:01:38 +0000
  2062. @@ -0,0 +1,58 @@
  2063. +/*
  2064. + *
  2065. + * Released under GNU GPL. Read the file 'COPYING' for more information.
  2066. + */
  2067. +
  2068. +#ifdef HAVE_CONFIG_H
  2069. +# include <config.h>
  2070. +#endif
  2071. +
  2072. +#include "font-button.h"
  2073. +#include <glibmm/i18n.h>
  2074. +
  2075. +namespace Inkscape {
  2076. +namespace UI {
  2077. +namespace Widget {
  2078. +
  2079. +FontButton::FontButton(Glib::ustring const &label, Glib::ustring const &tooltip,
  2080. + Glib::ustring const &suffix,
  2081. + Glib::ustring const &icon,
  2082. + bool mnemonic)
  2083. + : Labelled(label, tooltip, new Gtk::FontButton("Sans 10"), suffix, icon, mnemonic)
  2084. +{
  2085. +}
  2086. +
  2087. +Glib::ustring FontButton::getValue() const
  2088. +{
  2089. + g_assert(_widget != NULL);
  2090. + return static_cast<Gtk::FontButton*>(_widget)->get_font_name();
  2091. +}
  2092. +
  2093. +
  2094. +void FontButton::setValue (Glib::ustring fontspec)
  2095. +{
  2096. + g_assert(_widget != NULL);
  2097. + static_cast<Gtk::FontButton*>(_widget)->set_font_name(fontspec);
  2098. +}
  2099. +
  2100. +Glib::SignalProxy0<void> FontButton::signal_font_value_changed()
  2101. +{
  2102. + g_assert(_widget != NULL);
  2103. + return static_cast<Gtk::FontButton*>(_widget)->signal_font_set();
  2104. +}
  2105. +
  2106. +
  2107. +} // namespace Widget
  2108. +} // namespace UI
  2109. +} // namespace Inkscape
  2110. +
  2111. +/*
  2112. + Local Variables:
  2113. + mode:c++
  2114. + c-file-style:"stroustrup"
  2115. + c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
  2116. + indent-tabs-mode:nil
  2117. + fill-column:99
  2118. + End:
  2119. +*/
  2120. +// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:fileencoding=utf-8:textwidth=99 :
  2122. === added file 'src/ui/widget/font-button.h'
  2123. --- src/ui/widget/font-button.h 1970-01-01 00:00:00 +0000
  2124. +++ src/ui/widget/font-button.h 2016-07-29 22:58:22 +0000
  2125. @@ -0,0 +1,63 @@
  2126. +/*
  2127. + *
  2128. + * Copyright (C) 2007 Author
  2129. + *
  2130. + * Released under GNU GPL. Read the file 'COPYING' for more information.
  2131. + */
  2132. +
  2133. +#ifndef INKSCAPE_UI_WIDGET_FONT_BUTTON_H
  2134. +#define INKSCAPE_UI_WIDGET_FONT_BUTTON_H
  2135. +
  2136. +#include <gtkmm.h>
  2137. +#include "labelled.h"
  2138. +
  2139. +namespace Inkscape {
  2140. +namespace UI {
  2141. +namespace Widget {
  2142. +
  2143. +/**
  2144. + * A labelled font button for entering font values
  2145. + */
  2146. +class FontButton : public Labelled
  2147. +{
  2148. +public:
  2149. + /**
  2150. + * Construct a FontButton Widget.
  2151. + *
  2152. + * @param label Label.
  2153. + * @param suffix Suffix, placed after the widget (defaults to "").
  2154. + * @param icon Icon filename, placed before the label (defaults to "").
  2155. + * @param mnemonic Mnemonic toggle; if true, an underscore (_) in the label
  2156. + * indicates the next character should be used for the
  2157. + * mnemonic accelerator key (defaults to false).
  2158. + */
  2159. + FontButton( Glib::ustring const &label,
  2160. + Glib::ustring const &tooltip,
  2161. + Glib::ustring const &suffix = "",
  2162. + Glib::ustring const &icon = "",
  2163. + bool mnemonic = true);
  2164. +
  2165. + Glib::ustring getValue() const;
  2166. + void setValue (Glib::ustring fontspec);
  2167. + /**
  2168. + * Signal raised when the font button's value changes.
  2169. + */
  2170. + Glib::SignalProxy0<void> signal_font_value_changed();
  2171. +};
  2172. +
  2173. +} // namespace Widget
  2174. +} // namespace UI
  2175. +} // namespace Inkscape
  2176. +
  2177. +#endif // INKSCAPE_UI_WIDGET_RANDOM_H
  2178. +
  2179. +/*
  2180. + Local Variables:
  2181. + mode:c++
  2182. + c-file-style:"stroustrup"
  2183. + c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
  2184. + indent-tabs-mode:nil
  2185. + fill-column:99
  2186. + End:
  2187. +*/
  2188. +// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:fileencoding=utf-8:textwidth=99 :
  2190. === modified file 'src/ui/widget/registered-enums.h'
  2191. --- src/ui/widget/registered-enums.h 2011-10-25 07:45:35 +0000
  2192. +++ src/ui/widget/registered-enums.h 2016-07-29 18:13:43 +0000
  2193. @@ -33,11 +33,11 @@
  2194. const Util::EnumDataConverter<E>& c,
  2195. Registry& wr,
  2196. Inkscape::XML::Node* repr_in = NULL,
  2197. - SPDocument *doc_in = NULL )
  2198. - : RegisteredWidget< LabelledComboBoxEnum<E> >(label, tip, c)
  2199. + SPDocument *doc_in = NULL,
  2200. + bool sorted = true )
  2201. + : RegisteredWidget< LabelledComboBoxEnum<E> >(label, tip, c, (const Glib::ustring &)"", (const Glib::ustring &)"", true, sorted)
  2202. {
  2203. RegisteredWidget< LabelledComboBoxEnum<E> >::init_parent(key, wr, repr_in, doc_in);
  2204. -
  2205. _changed_connection = combobox()->signal_changed().connect (sigc::mem_fun (*this, &RegisteredEnum::on_changed));
  2206. }
  2209. === modified file 'src/ui/widget/registered-widget.cpp'
  2210. --- src/ui/widget/registered-widget.cpp 2016-07-28 11:26:17 +0000
  2211. +++ src/ui/widget/registered-widget.cpp 2016-08-01 15:29:19 +0000
  2212. @@ -25,6 +25,7 @@
  2213. #include "ui/widget/scalar-unit.h"
  2214. #include "ui/widget/point.h"
  2215. #include "ui/widget/random.h"
  2216. +#include "ui/widget/font-button.h"
  2217. #include "widgets/spinbutton-events.h"
  2219. #include "xml/repr.h"
  2220. @@ -297,7 +298,6 @@
  2221. setProgrammatically = false;
  2222. return;
  2223. }
  2224. -
  2225. if (_wr->isUpdating()) {
  2226. return;
  2227. }
  2228. @@ -331,8 +331,6 @@
  2229. init_parent(key, wr, repr_in, doc_in);
  2231. setProgrammatically = false;
  2232. -
  2233. - setText("");
  2234. _activate_connection = signal_activate().connect (sigc::mem_fun (*this, &RegisteredText::on_activate));
  2235. }
  2237. @@ -348,16 +346,12 @@
  2238. return;
  2239. }
  2240. _wr->setUpdating (true);
  2241. -
  2242. + Glib::ustring str(getText());
  2243. + set_sensitive(false);
  2244. Inkscape::SVGOStringStream os;
  2245. - os << getText();
  2246. -
  2247. - set_sensitive(false);
  2248. + os << str;
  2249. write_to_xml(os.str().c_str());
  2250. set_sensitive(true);
  2251. -
  2252. - setText(os.str().c_str());
  2253. -
  2254. _wr->setUpdating (false);
  2255. }
  2257. @@ -803,6 +797,47 @@
  2258. _wr->setUpdating (false);
  2259. }
  2261. +/*#########################################
  2262. + * Registered FONT-BUTTON
  2263. + */
  2264. +
  2265. +RegisteredFontButton::~RegisteredFontButton()
  2266. +{
  2267. + _signal_font_set.disconnect();
  2268. +}
  2269. +
  2270. +RegisteredFontButton::RegisteredFontButton ( const Glib::ustring& label, const Glib::ustring& tip,
  2271. + const Glib::ustring& key, Registry& wr, Inkscape::XML::Node* repr_in,
  2272. + SPDocument* doc_in )
  2273. + : RegisteredWidget<FontButton>(label, tip)
  2274. +{
  2275. + init_parent(key, wr, repr_in, doc_in);
  2276. + _signal_font_set = signal_font_value_changed().connect (sigc::mem_fun (*this, &RegisteredFontButton::on_value_changed));
  2277. +}
  2278. +
  2279. +void
  2280. +RegisteredFontButton::setValue (Glib::ustring fontspec)
  2281. +{
  2282. + FontButton::setValue(fontspec);
  2283. +}
  2284. +
  2285. +void
  2286. +RegisteredFontButton::on_value_changed()
  2287. +{
  2288. +
  2289. + if (_wr->isUpdating())
  2290. + return;
  2291. +
  2292. + _wr->setUpdating (true);
  2293. +
  2294. + Inkscape::SVGOStringStream os;
  2295. + os << getValue();
  2296. +
  2297. + write_to_xml(os.str().c_str());
  2298. +
  2299. + _wr->setUpdating (false);
  2300. +}
  2301. +
  2302. } // namespace Dialog
  2303. } // namespace UI
  2304. } // namespace Inkscape
  2306. === modified file 'src/ui/widget/registered-widget.h'
  2307. --- src/ui/widget/registered-widget.h 2016-07-24 15:05:29 +0000
  2308. +++ src/ui/widget/registered-widget.h 2016-07-29 22:45:14 +0000
  2309. @@ -22,6 +22,7 @@
  2310. #include "ui/widget/text.h"
  2311. #include "ui/widget/random.h"
  2312. #include "ui/widget/unit-menu.h"
  2313. +#include "ui/widget/font-button.h"
  2314. #include "ui/widget/color-picker.h"
  2315. #include "inkscape.h"
  2317. @@ -77,6 +78,8 @@
  2318. RegisteredWidget( A& a, B& b, C c, D d ): W( a, b, c, d ) { construct(); }
  2319. template< typename A, typename B, typename C, typename D, typename E , typename F>
  2320. RegisteredWidget( A& a, B& b, C c, D& d, E& e, F* f): W( a, b, c, d, e, f) { construct(); }
  2321. + template< typename A, typename B, typename C, typename D, typename E , typename F, typename G>
  2322. + RegisteredWidget( A& a, B& b, C& c, D& d, E& e, F f, G& g): W( a, b, c, d, e, f, g) { construct(); }
  2324. virtual ~RegisteredWidget() {};
  2326. @@ -418,6 +421,23 @@
  2327. void on_value_changed();
  2328. };
  2330. +class RegisteredFontButton : public RegisteredWidget<FontButton> {
  2331. +public:
  2332. + virtual ~RegisteredFontButton();
  2333. + RegisteredFontButton ( const Glib::ustring& label,
  2334. + const Glib::ustring& tip,
  2335. + const Glib::ustring& key,
  2336. + Registry& wr,
  2337. + Inkscape::XML::Node* repr_in = NULL,
  2338. + SPDocument *doc_in = NULL);
  2339. +
  2340. + void setValue (Glib::ustring fontspec);
  2341. +
  2342. +protected:
  2343. + sigc::connection _signal_font_set;
  2344. + void on_value_changed();
  2345. +};
  2346. +
  2347. } // namespace Widget
  2348. } // namespace UI
  2349. } // namespace Inkscape
  2351. === modified file 'src/ui/widget/scalar.cpp'
  2352. --- src/ui/widget/scalar.cpp 2014-03-27 01:33:44 +0000
  2353. +++ src/ui/widget/scalar.cpp 2016-07-30 15:23:12 +0000
  2354. @@ -126,10 +126,12 @@
  2355. static_cast<SpinButton*>(_widget)->set_range(min, max);
  2356. }
  2358. -void Scalar::setValue(double value)
  2359. +void Scalar::setValue(double value, bool setProg)
  2360. {
  2361. g_assert(_widget != NULL);
  2362. - setProgrammatically = true; // callback is supposed to reset back, if it cares
  2363. + if (setProg) {
  2364. + setProgrammatically = true; // callback is supposed to reset back, if it cares
  2365. + }
  2366. static_cast<SpinButton*>(_widget)->set_value(value);
  2367. }
  2370. === modified file 'src/ui/widget/scalar.h'
  2371. --- src/ui/widget/scalar.h 2012-04-30 22:04:12 +0000
  2372. +++ src/ui/widget/scalar.h 2016-07-30 15:23:27 +0000
  2373. @@ -139,7 +139,7 @@
  2374. /**
  2375. * Sets the value of the spin button.
  2376. */
  2377. - void setValue(double value);
  2378. + void setValue(double value, bool setProg = true);
  2380. /**
  2381. * Manually forces an update of the spin button.
  2383. === modified file 'src/ui/widget/text.cpp'
  2384. --- src/ui/widget/text.cpp 2012-02-26 16:54:08 +0000
  2385. +++ src/ui/widget/text.cpp 2016-07-31 21:49:31 +0000
  2386. @@ -28,13 +28,13 @@
  2387. {
  2388. }
  2390. -const char *Text::getText() const
  2391. +Glib::ustring const Text::getText() const
  2392. {
  2393. g_assert(_widget != NULL);
  2394. - return static_cast<Gtk::Entry*>(_widget)->get_text().c_str();
  2395. + return static_cast<Gtk::Entry*>(_widget)->get_text();
  2396. }
  2398. -void Text::setText(const char* text)
  2399. +void Text::setText(Glib::ustring const text)
  2400. {
  2401. g_assert(_widget != NULL);
  2402. setProgrammatically = true; // callback is supposed to reset back, if it cares
  2404. === modified file 'src/ui/widget/text.h'
  2405. --- src/ui/widget/text.h 2012-02-26 16:54:08 +0000
  2406. +++ src/ui/widget/text.h 2016-07-31 21:49:59 +0000
  2407. @@ -44,12 +44,12 @@
  2408. /**
  2409. * Get the text in the entry.
  2410. */
  2411. - const char* getText() const;
  2412. + Glib::ustring const getText() const;
  2414. /**
  2415. * Sets the text of the text entry.
  2416. */
  2417. - void setText(const char* text);
  2418. + void setText(Glib::ustring const text);
  2420. void update();
  2423. === modified file 'src/widgets/font-selector.cpp'
  2424. --- src/widgets/font-selector.cpp 2016-07-28 11:26:17 +0000
  2425. +++ src/widgets/font-selector.cpp 2016-07-22 19:59:31 +0000
  2426. @@ -19,9 +19,6 @@
  2427. # include "config.h"
  2428. #endif
  2430. -#include <libnrtype/font-lister.h>
  2431. -#include <libnrtype/font-instance.h>
  2432. -
  2433. #include <2geom/transforms.h>
  2435. #include <gtk/gtk.h>
  2436. @@ -34,29 +31,7 @@
  2438. /* SPFontSelector */
  2440. -struct SPFontSelector
  2441. -{
  2442. -#if GTK_CHECK_VERSION(3,0,0)
  2443. - GtkBox hbox;
  2444. -#else
  2445. - GtkHBox hbox;
  2446. -#endif
  2447. -
  2448. - unsigned int block_emit : 1;
  2449. -
  2450. - GtkWidget *family;
  2451. - GtkWidget *style;
  2452. - GtkWidget *size;
  2453. -
  2454. - GtkWidget *family_treeview;
  2455. - GtkWidget *style_treeview;
  2456. -
  2457. - NRNameList families;
  2458. - NRStyleList styles;
  2459. - gfloat fontsize;
  2460. - bool fontsize_dirty;
  2461. - Glib::ustring *fontspec;
  2462. -};
  2463. +
  2466. struct SPFontSelectorClass
  2467. @@ -274,6 +249,7 @@
  2469. if (fsel->fontspec) {
  2470. delete fsel->fontspec;
  2471. + fsel->fontspec = 0;
  2472. }
  2474. if (fsel->families.length > 0) {
  2476. === modified file 'src/widgets/font-selector.h'
  2477. --- src/widgets/font-selector.h 2014-08-18 20:19:55 +0000
  2478. +++ src/widgets/font-selector.h 2016-07-22 19:59:29 +0000
  2479. @@ -15,10 +15,33 @@
  2480. *
  2481. * Released under GNU GPL, read the file 'COPYING' for more information
  2482. */
  2483. -
  2484. +#include <libnrtype/font-lister.h>
  2485. +#include <libnrtype/font-instance.h>
  2486. #include <glib.h>
  2488. -struct SPFontSelector;
  2489. +struct SPFontSelector
  2490. +{
  2491. +#if GTK_CHECK_VERSION(3,0,0)
  2492. + GtkBox hbox;
  2493. +#else
  2494. + GtkHBox hbox;
  2495. +#endif
  2496. +
  2497. + unsigned int block_emit : 1;
  2498. +
  2499. + GtkWidget *family;
  2500. + GtkWidget *style;
  2501. + GtkWidget *size;
  2502. +
  2503. + GtkWidget *family_treeview;
  2504. + GtkWidget *style_treeview;
  2505. +
  2506. + NRNameList families;
  2507. + NRStyleList styles;
  2508. + gfloat fontsize;
  2509. + bool fontsize_dirty;
  2510. + Glib::ustring *fontspec;
  2511. +};
  2513. #define SP_TYPE_FONT_SELECTOR (sp_font_selector_get_type ())
  2514. #define SP_FONT_SELECTOR(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), SP_TYPE_FONT_SELECTOR, SPFontSelector))
  1. More ...
 
 

17

 

847

Measure Line DIFF r.15051

by Jabiertxo Arraiza Cenoz

-

PasteBin

Lines
2514
Words
8262
Size
93.3 KB
Created
Type
text/plain
General Public License v2 (GPLv2)
Please log in to leave a comment!

Inkscape is Free and Open Source Software licensed under the GPL.