Accueil » Jabiertxo Arraiza Cenoz » Ressources » PasteBin » Measure LIne LPE DIFF V.15033
  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-07-31 12:27:36 +0000
  213. @@ -0,0 +1,574 @@
  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. + * Copyright (C) 2014 Author(s)
  220. +
  221. + * Released under GNU GPL, read the file 'COPYING' for more information
  222. + */
  223. +#include "live_effects/lpe-measure-line.h"
  224. +#include <pangomm/fontdescription.h>
  225. +#include <libnrtype/font-lister.h>
  226. +#include "inkscape.h"
  227. +#include "xml/node.h"
  228. +#include "uri.h"
  229. +#include "uri-references.h"
  230. +#include "preferences.h"
  231. +#include "util/units.h"
  232. +#include "svg/svg-length.h"
  233. +#include "svg/svg-color.h"
  234. +#include "svg/svg.h"
  235. +#include "display/curve.h"
  236. +#include <2geom/affine.h>
  237. +#include "style.h"
  238. +#include "sp-root.h"
  239. +#include "sp-defs.h"
  240. +#include "sp-item.h"
  241. +#include "sp-shape.h"
  242. +#include "sp-path.h"
  243. +#include "desktop.h"
  244. +#include "document.h"
  245. +#include <iomanip>
  246. +
  247. +// TODO due to internal breakage in glibmm headers, this must be last:
  248. +#include <glibmm/i18n.h>
  249. +
  250. +using namespace Geom;
  251. +namespace Inkscape {
  252. +namespace LivePathEffect {
  253. +
  254. +static const Util::EnumData<OrientationMethod> OrientationMethodData[] = {
  255. + { OM_HORIZONTAL, N_("Horizontal"), "horizontal" },
  256. + { OM_VERTICAL, N_("Vertical"), "vertical" },
  257. + { OM_PARALLEL, N_("Parallel"), "parallel" }
  258. +};
  259. +static const Util::EnumDataConverter<OrientationMethod> OMConverter(OrientationMethodData, OM_END);
  260. +
  261. +LPEMeasureLine::LPEMeasureLine(LivePathEffectObject *lpeobject) :
  262. + Effect(lpeobject),
  263. + fontbutton(_("Font*"), _("Font Selector"), "fontbutton", &wr, this),
  264. + orientation(_("Orientation"), _("Orientation method"), "orientation", OMConverter, &wr, this, OM_PARALLEL, false),
  265. + curve_linked(_("Curve on origin"), _("Curve on origin, set 0 to start/end"), "curve_linked", &wr, this, 1),
  266. + scale(_("Scale*"), _("Scaling factor"), "scale", &wr, this, 1.0),
  267. + precision(_("Precision*"), _("Precision"), "precision", &wr, this, 2),
  268. + position(_("Positon*"), _("Positon"), "position", &wr, this, 5),
  269. + text_distance(_("Text distance*"), _("Text distance"), "text_distance", &wr, this, 12),
  270. + helpline_distance(_("Helpline distance*"), _("Helpline distance"), "helpline_distance", &wr, this, 0.0),
  271. + helpline_overlap(_("Helpline overlap*"), _("Helpline overlap"), "helpline_overlap", &wr, this, 2.0),
  272. + unit(_("Unit*"), _("Unit"), "unit", &wr, this),
  273. + format(_("Format*"), _("Format the number ex:measure+ +unit"), "format", &wr, this, "measure+unit"),
  274. + arrows_outside(_("Arrows outside"), _("Arrows outside"), "arrows_outside", &wr, this, false),
  275. + flip_side(_("Flip side*"), _("Flip side"), "flip_side", &wr, this, false),
  276. + scale_insensitive(_("Scale insensitive*"), _("Scale insensitive to transforms in element, parents..."), "scale_insensitive", &wr, this, true),
  277. + local_locale(_("Local Number Format*"), _("Local number format"), "local_locale", &wr, this, true),
  278. + line_group_05(_("Line Group 0.5*"), _("Line Group 0.5, from 0.7"), "line_group_05", &wr, this, true),
  279. + rotate_anotation(_("Rotate Anotation*"), _("Rotate Anotation"), "rotate_anotation", &wr, this, true)
  280. +{
  281. + registerParameter(&fontbutton);
  282. + registerParameter(&orientation);
  283. + registerParameter(&curve_linked);
  284. + registerParameter(&scale);
  285. + registerParameter(&precision);
  286. + registerParameter(&position);
  287. + registerParameter(&text_distance);
  288. + registerParameter(&helpline_distance);
  289. + registerParameter(&helpline_overlap);
  290. + registerParameter(&unit);
  291. + registerParameter(&format);
  292. + registerParameter(&arrows_outside);
  293. + registerParameter(&flip_side);
  294. + registerParameter(&scale_insensitive);
  295. + registerParameter(&local_locale);
  296. + registerParameter(&line_group_05);
  297. + registerParameter(&rotate_anotation);
  298. + Inkscape::Preferences *prefs = Inkscape::Preferences::get();
  299. + fontbutton.param_update_default(prefs->getString("/live_effects/measure-line/fontbutton"));
  300. + scale.param_update_default(prefs->getDouble("/live_effects/measure-line/scale", 1.0));
  301. + precision.param_update_default(prefs->getInt("/live_effects/measure-line/precision", 2));
  302. + position.param_update_default(prefs->getDouble("/live_effects/measure-line/position", 10.0));
  303. + text_distance.param_update_default(prefs->getDouble("/live_effects/measure-line/text_distance", 5.0));
  304. + helpline_distance.param_update_default(prefs->getDouble("/live_effects/measure-line/helpline_distance", 0.0));
  305. + helpline_overlap.param_update_default(prefs->getDouble("/live_effects/measure-line/helpline_overlap", 0.0));
  306. + unit.param_update_default(prefs->getString("/live_effects/measure-line/unit"));
  307. + format.param_update_default(prefs->getString("/live_effects/measure-line/format"));
  308. + flip_side.param_update_default(prefs->getBool("/live_effects/measure-line/flip_side"));
  309. + scale_insensitive.param_update_default(prefs->getBool("/live_effects/measure-line/scale_insensitive"));
  310. + local_locale.param_update_default(prefs->getBool("/live_effects/measure-line/local_locale"));
  311. + line_group_05.param_update_default(prefs->getBool("/live_effects/measure-line/line_group_05"));
  312. + rotate_anotation.param_update_default(prefs->getBool("/live_effects/measure-line/rotate_anotation"));
  313. + format.param_hide_canvas_text();
  314. + precision.param_set_range(0, 100);
  315. + precision.param_set_increments(1, 1);
  316. + precision.param_set_digits(0);
  317. + precision.param_make_integer(true);
  318. + curve_linked.param_set_range(0, 999);
  319. + curve_linked.param_set_increments(1, 1);
  320. + curve_linked.param_set_digits(0);
  321. + curve_linked.param_make_integer(true);
  322. + precision.param_make_integer(true);
  323. + position.param_set_range(-999999.0, 999999.0);
  324. + position.param_set_increments(1, 1);
  325. + position.param_set_digits(2);
  326. + text_distance.param_set_range(-999999.0, 999999.0);
  327. + text_distance.param_set_increments(1, 1);
  328. + text_distance.param_set_digits(2);
  329. + helpline_distance.param_set_range(-999999.0, 999999.0);
  330. + helpline_distance.param_set_increments(1, 1);
  331. + helpline_distance.param_set_digits(2);
  332. + helpline_overlap.param_set_range(-999999.0, 999999.0);
  333. + helpline_overlap.param_set_increments(1, 1);
  334. + helpline_overlap.param_set_digits(2);
  335. +}
  336. +
  337. +LPEMeasureLine::~LPEMeasureLine() {}
  338. +
  339. +void
  340. +LPEMeasureLine::doOnApply(SPLPEItem const* lpeitem)
  341. +{
  342. + if (!SP_IS_SHAPE(lpeitem)) {
  343. + g_warning("LPE measure line can only be applied to shapes (not groups).");
  344. + SPLPEItem * item = const_cast<SPLPEItem*>(lpeitem);
  345. + item->removeCurrentPathEffect(false);
  346. + }
  347. +}
  348. +
  349. +void
  350. +LPEMeasureLine::doOnVisibilityToggled(SPLPEItem const* /*lpeitem*/)
  351. +{
  352. + if (SPDesktop *desktop = SP_ACTIVE_DESKTOP) {
  353. + Inkscape::URI SVGElem_uri(((Glib::ustring)"#" + (Glib::ustring)"text-on-" + (Glib::ustring)this->getRepr()->attribute("id")).c_str());
  354. + Inkscape::URIReference* SVGElemRef = new Inkscape::URIReference(desktop->doc());
  355. + SVGElemRef->attach(SVGElem_uri);
  356. + SPObject *elemref = NULL;
  357. + Inkscape::XML::Node *rtext = NULL;
  358. + if (elemref = SVGElemRef->getObject()) {
  359. + rtext = elemref->getRepr();
  360. + if (!this->isVisible()) {
  361. + rtext->setAttribute("style", "display:none");
  362. + } else {
  363. + rtext->setAttribute("style", NULL);
  364. + }
  365. + }
  366. + }
  367. +}
  368. +
  369. +void
  370. +LPEMeasureLine::createArrowMarker(Glib::ustring mode)
  371. +{
  372. + if (SPDesktop *desktop = SP_ACTIVE_DESKTOP) {
  373. + Inkscape::XML::Document *xml_doc = desktop->doc()->getReprDoc();
  374. + Inkscape::URI SVGElem_uri(((Glib::ustring)"#" + mode).c_str());
  375. + Inkscape::URIReference* SVGElemRef = new Inkscape::URIReference(desktop->doc());
  376. + SVGElemRef->attach(SVGElem_uri);
  377. + SPObject *elemref = NULL;
  378. + Inkscape::XML::Node *arrow = NULL;
  379. + if (!(elemref = SVGElemRef->getObject())) {
  380. + arrow = xml_doc->createElement("svg:marker");
  381. + arrow->setAttribute("id", mode.c_str());
  382. + arrow->setAttribute("inkscape:stockid", mode.c_str());
  383. + arrow->setAttribute("orient", "auto");
  384. + arrow->setAttribute("refX", "0.0");
  385. + arrow->setAttribute("refY", "0.0");
  386. + arrow->setAttribute("style", "overflow:visible");
  387. + /* Create <path> */
  388. + Inkscape::XML::Node *arrow_path = xml_doc->createElement("svg:path");
  389. + if (mode == (Glib::ustring)"ArrowDIN-start") {
  390. + arrow_path->setAttribute("d", "M -8,0 8,-2.11 8,2.11 z");
  391. + } else if (mode == (Glib::ustring)"ArrowDIN-end") {
  392. + arrow_path->setAttribute("d", "M 8,0 -8,2.11 -8,-2.11 z");
  393. + } else if (mode == (Glib::ustring)"ArrowDINout-start") {
  394. + 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");
  395. + } else {
  396. + 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");
  397. + }
  398. + arrow_path->setAttribute("id", (mode + (Glib::ustring)"_path").c_str());
  399. + arrow_path->setAttribute("style", "fill:#000000;stroke:none");
  400. + arrow->addChild(arrow_path, NULL);
  401. + Inkscape::GC::release(arrow_path);
  402. + SPObject * arrow_obj = SP_OBJECT(desktop->getDocument()->getDefs()->appendChildRepr(arrow));
  403. + Inkscape::GC::release(arrow);
  404. + }
  405. + }
  406. +}
  407. +
  408. +void
  409. +LPEMeasureLine::createTextLabel(Geom::Point pos, double length, Geom::Coord angle, double fontsize, bool remove)
  410. +{
  411. + if (SPDesktop *desktop = SP_ACTIVE_DESKTOP) {
  412. + Inkscape::XML::Document *xml_doc = desktop->doc()->getReprDoc();
  413. + Inkscape::XML::Node *rtext = NULL;
  414. + doc_unit = Inkscape::Util::unit_table.getUnit(desktop->doc()->getRoot()->height.unit)->abbr;
  415. + if (doc_unit.empty()) {
  416. + doc_unit = "px";
  417. + }
  418. + Inkscape::URI SVGElem_uri(((Glib::ustring)"#" + (Glib::ustring)"text-on-" + (Glib::ustring)this->getRepr()->attribute("id")).c_str());
  419. + Inkscape::URIReference* SVGElemRef = new Inkscape::URIReference(desktop->doc());
  420. + SVGElemRef->attach(SVGElem_uri);
  421. + SPObject *elemref = NULL;
  422. + Inkscape::XML::Node *rtspan = NULL;
  423. + if (elemref = SVGElemRef->getObject()) {
  424. + if (remove) {
  425. + elemref->deleteObject();
  426. + return;
  427. + }
  428. + rtext = elemref->getRepr();
  429. + sp_repr_set_svg_double(rtext, "x", pos[Geom::X]);
  430. + sp_repr_set_svg_double(rtext, "y", pos[Geom::Y]);
  431. + } else {
  432. + if (remove) {
  433. + return;
  434. + }
  435. + rtext = xml_doc->createElement("svg:text");
  436. + rtext->setAttribute("xml:space", "preserve");
  437. + rtext->setAttribute("id", ( (Glib::ustring)"text-on-" + (Glib::ustring)this->getRepr()->attribute("id")).c_str());
  438. + sp_repr_set_svg_double(rtext, "x", pos[Geom::X]);
  439. + sp_repr_set_svg_double(rtext, "y", pos[Geom::Y]);
  440. + rtspan = xml_doc->createElement("svg:tspan");
  441. + rtspan->setAttribute("sodipodi:role", "line");
  442. + }
  443. + gchar * transform;
  444. + if (rotate_anotation) {
  445. + Geom::Affine affine = Geom::Affine(Geom::Translate(pos).inverse());
  446. + affine *= Geom::Rotate(angle);
  447. + affine *= Geom::Translate(pos);
  448. + transform = sp_svg_transform_write(affine);
  449. + } else {
  450. + transform = NULL;
  451. + }
  452. + rtext->setAttribute("transform", transform);
  453. + SPCSSAttr *css = sp_repr_css_attr_new();
  454. + Inkscape::FontLister *fontlister = Inkscape::FontLister::get_instance();
  455. + fontlister->fill_css( css, (Glib::ustring)fontbutton.param_getSVGValue() );
  456. + std::stringstream font_size;
  457. + font_size.imbue(std::locale::classic());
  458. + font_size << fontsize << "pt";
  459. + sp_repr_css_set_property (css, "font-size", font_size.str().c_str());
  460. + sp_repr_css_set_property (css, "line-height", "125%");
  461. + sp_repr_css_set_property (css, "letter-spacing", "0");
  462. + sp_repr_css_set_property (css, "word-spacing", "0");
  463. + sp_repr_css_set_property (css, "text-align", "center");
  464. + sp_repr_css_set_property (css, "text-anchor", "middle");
  465. + sp_repr_css_set_property (css, "fill", "#000000");
  466. + sp_repr_css_set_property (css, "fill-opacity", "1");
  467. + sp_repr_css_set_property (css, "stroke", "none");
  468. + Glib::ustring css_str;
  469. + sp_repr_css_write_string(css,css_str);
  470. + if (!rtspan) {
  471. + rtspan = rtext->firstChild();
  472. + }
  473. + rtspan->setAttribute("style", css_str.c_str());
  474. + sp_repr_css_attr_unref (css);
  475. + if (!elemref) {
  476. + rtext->addChild(rtspan, NULL);
  477. + Inkscape::GC::release(rtspan);
  478. + }
  479. + length = Inkscape::Util::Quantity::convert(length, doc_unit.c_str(), unit.get_abbreviation());
  480. + std::stringstream length_str;
  481. + length_str.precision(precision);
  482. + length_str.setf(std::ios::fixed, std::ios::floatfield);
  483. + if (local_locale) {
  484. + length_str.imbue(std::locale(""));
  485. + } else {
  486. + length_str.imbue(std::locale::classic());
  487. + }
  488. + length_str << std::fixed << length;
  489. + length_str << unit.get_abbreviation();
  490. + Inkscape::XML::Node *rstring = NULL;
  491. + if (!elemref) {
  492. + rstring = xml_doc->createTextNode(length_str.str().c_str());
  493. + rtspan->addChild(rstring, NULL);
  494. + Inkscape::GC::release(rstring);
  495. + } else {
  496. + rstring = rtspan->firstChild();
  497. + rstring->setContent(length_str.str().c_str());
  498. + }
  499. + SPObject * text_obj = NULL;
  500. + if (!elemref) {
  501. + text_obj = SP_OBJECT(desktop->currentLayer()->appendChildRepr(rtext));
  502. + Inkscape::GC::release(rtext);
  503. + }
  504. + }
  505. +}
  506. +
  507. +void
  508. +LPEMeasureLine::createLine(Geom::Point start,Geom::Point end, Glib::ustring id, bool main, bool remove)
  509. +{
  510. + if (SPDesktop *desktop = SP_ACTIVE_DESKTOP) {
  511. + Inkscape::XML::Document *xml_doc = desktop->doc()->getReprDoc();
  512. + Inkscape::URI SVGElem_uri(((Glib::ustring)"#" + id).c_str());
  513. + Inkscape::URIReference* SVGElemRef = new Inkscape::URIReference(desktop->doc());
  514. + SVGElemRef->attach(SVGElem_uri);
  515. + SPObject *elemref = NULL;
  516. + Inkscape::XML::Node *line = NULL;
  517. + if (!main) {
  518. + Geom::Ray ray(start, end);
  519. + Geom::Coord angle = ray.angle();
  520. + start = start + Point::polar(angle, helpline_distance );
  521. + end = end + Point::polar(angle, helpline_overlap );
  522. + }
  523. + Geom::Path line_path;
  524. + line_path.start(start);
  525. + line_path.appendNew<Geom::LineSegment>(end);
  526. + Geom::PathVector line_pathv;
  527. + line_pathv.push_back(line_path);
  528. + gchar * line_str = sp_svg_write_path( line_pathv );
  529. + line_pathv.clear();
  530. + if (elemref = SVGElemRef->getObject()) {
  531. + if (remove) {
  532. + elemref->deleteObject();
  533. + return;
  534. + }
  535. + line = elemref->getRepr();
  536. + line->setAttribute("d" , line_str);
  537. + } else {
  538. + if (remove) {
  539. + return;
  540. + }
  541. + line = xml_doc->createElement("svg:path");
  542. + line->setAttribute("id", id.c_str());
  543. + line->setAttribute("d" , line_str);
  544. + }
  545. + Glib::ustring style = (Glib::ustring)"stroke:#000000;fill:none;";
  546. + if (main) {
  547. + line->setAttribute("inkscape:label", "dinline");
  548. + if (arrows_outside) {
  549. + style = style + (Glib::ustring)"marker-start:url(#ArrowDINout-start);marker-end:url(#ArrowDINout-end);";
  550. + } else {
  551. + style = style + (Glib::ustring)"marker-start:url(#ArrowDIN-start);marker-end:url(#ArrowDIN-end);";
  552. + }
  553. + } else {
  554. + line->setAttribute("inkscape:label", "dinhelpline");
  555. + }
  556. + std::stringstream stroke_w;
  557. + stroke_w.imbue(std::locale::classic());
  558. + if (line_group_05) {
  559. + double stroke_width = Inkscape::Util::Quantity::convert(0.25, "mm", doc_unit.c_str());
  560. + stroke_w << stroke_width;
  561. + style = style + (Glib::ustring)"stroke-width:" + (Glib::ustring)stroke_w.str();
  562. + } else {
  563. + double stroke_width = Inkscape::Util::Quantity::convert(0.35, "mm", doc_unit.c_str());
  564. + stroke_w << stroke_width;
  565. + style = style + (Glib::ustring)"stroke-width:" + (Glib::ustring)stroke_w.str();
  566. + }
  567. + line->setAttribute("style", style.c_str());
  568. + SPObject * line_obj = NULL;
  569. + if (!elemref) {
  570. + line_obj = SP_OBJECT(desktop->currentLayer()->appendChildRepr(line));
  571. + Inkscape::GC::release(line);
  572. + }
  573. + }
  574. +}
  575. +
  576. +void
  577. +LPEMeasureLine::doBeforeEffect (SPLPEItem const* lpeitem)
  578. +{
  579. + SPLPEItem * splpeitem = const_cast<SPLPEItem *>(lpeitem);
  580. + SPPath *sp_path = dynamic_cast<SPPath *>(splpeitem);
  581. + if (sp_path) {
  582. + Geom::PathVector pathvector = sp_path->get_original_curve()->get_pathvector();
  583. + if (arrows_outside) {
  584. + createArrowMarker((Glib::ustring)"ArrowDINout-start");
  585. + createArrowMarker((Glib::ustring)"ArrowDINout-end");
  586. + } else {
  587. + createArrowMarker((Glib::ustring)"ArrowDIN-start");
  588. + createArrowMarker((Glib::ustring)"ArrowDIN-end");
  589. + }
  590. + if (SPDesktop *desktop = SP_ACTIVE_DESKTOP) {
  591. + size_t ncurves = pathvector.curveCount();
  592. + curve_linked.param_set_range(0, ncurves);
  593. + Geom::Point start = pathvector.initialPoint();
  594. + Geom::Point end = pathvector.finalPoint();
  595. + if (curve_linked) { //!0
  596. + start = pathvector.pointAt(curve_linked -1);
  597. + end = pathvector.pointAt(curve_linked);
  598. + }
  599. + Geom::Point hstart = start;
  600. + Geom::Point hend = end;
  601. + bool remove = false;
  602. + if (Geom::are_near(hstart, hend)) {
  603. + remove = true;
  604. + }
  605. + if (orientation == OM_VERTICAL) {
  606. + Coord xpos = std::max(hstart[Geom::X],hend[Geom::X]);
  607. + if (flip_side) {
  608. + xpos = std::min(hstart[Geom::X],hend[Geom::X]);
  609. + }
  610. + hstart[Geom::X] = xpos;
  611. + hend[Geom::X] = xpos;
  612. + if (hstart[Geom::Y] > hend[Geom::Y]) {
  613. + swap(hstart,hend);
  614. + swap(start,end);
  615. + }
  616. + if (Geom::are_near(hstart[Geom::Y], hend[Geom::Y])) {
  617. + remove = true;
  618. + }
  619. + }
  620. + if (orientation == OM_HORIZONTAL) {
  621. + Coord ypos = std::max(hstart[Geom::Y],hend[Geom::Y]);
  622. + if (flip_side) {
  623. + ypos = std::min(hstart[Geom::Y],hend[Geom::Y]);
  624. + }
  625. + hstart[Geom::Y] = ypos;
  626. + hend[Geom::Y] = ypos;
  627. + if (hstart[Geom::X] < hend[Geom::X]) {
  628. + swap(hstart,hend);
  629. + swap(start,end);
  630. + }
  631. + if (Geom::are_near(hstart[Geom::X], hend[Geom::X])) {
  632. + remove = true;
  633. + }
  634. + }
  635. + double length = Geom::distance(start,end) * scale;
  636. + Geom::Point pos = Geom::middle_point(hstart,hend);
  637. + Geom::Ray ray(hstart,hend);
  638. + Geom::Coord angle = ray.angle();
  639. + if (flip_side) {
  640. + angle = std::fmod(angle + rad_from_deg(180), 2*M_PI);
  641. + if (angle < 0) angle += 2*M_PI;
  642. + }
  643. + Geom::Coord angle_cross = std::fmod(angle + rad_from_deg(90), 2*M_PI);
  644. + if (angle_cross < 0) angle_cross += 2*M_PI;
  645. + //We get the font size to offset the text to the middle
  646. + Pango::FontDescription fontdesc((Glib::ustring)fontbutton.param_getSVGValue());
  647. + double fontsize = fontdesc.get_size()/Pango::SCALE;
  648. + pos = pos - Point::polar(angle_cross, (position + text_distance) - fontsize/2.0);
  649. + if (!scale_insensitive) {
  650. + Geom::Affine affinetransform = i2anc_affine(SP_OBJECT(lpeitem), SP_OBJECT(desktop->doc()->getRoot()));
  651. + length *= (affinetransform.expansionX() + affinetransform.expansionY()) / 2.0;
  652. + }
  653. + createTextLabel(pos, length, angle, fontsize, remove);
  654. + //LINE
  655. + double arrow_gap = 8 * Inkscape::Util::Quantity::convert(0.35, "mm", doc_unit.c_str());
  656. + if (line_group_05) {
  657. + arrow_gap = 8 * Inkscape::Util::Quantity::convert(0.25, "mm", doc_unit.c_str());
  658. + }
  659. + if (flip_side) {
  660. + arrow_gap *= -1;
  661. + }
  662. + angle_cross = std::fmod(angle + rad_from_deg(90), 2*M_PI);
  663. + if (angle_cross < 0) angle_cross += 2*M_PI;
  664. + hstart = hstart - Point::polar(angle_cross, position);
  665. + Glib::ustring id = (Glib::ustring)"infoline-on-start-" + (Glib::ustring)this->getRepr()->attribute("id");
  666. + createLine(start, hstart, id, false, remove);
  667. + hend = hend - Point::polar(angle_cross, position);
  668. + id = (Glib::ustring)"infoline-on-end-" + (Glib::ustring)this->getRepr()->attribute("id");
  669. + createLine(end, hend, id, false, remove);
  670. + if (!arrows_outside) {
  671. + hstart = hstart + Point::polar(angle, arrow_gap);
  672. + hend = hend - Point::polar(angle, arrow_gap );
  673. + }
  674. + id = (Glib::ustring)"infoline-" + (Glib::ustring)this->getRepr()->attribute("id");
  675. + createLine(hstart, hend, id, true, remove);
  676. + }
  677. + }
  678. +}
  679. +
  680. +void LPEMeasureLine::doOnRemove (SPLPEItem const* lpeitem)
  681. +{
  682. + if (SPDesktop *desktop = SP_ACTIVE_DESKTOP) {
  683. + SPLPEItem * splpeitem = const_cast<SPLPEItem *>(lpeitem);
  684. + Inkscape::URI SVGElem_uri(( (Glib::ustring)"text-on-" + (Glib::ustring)this->getRepr()->attribute("id")).c_str());
  685. + Inkscape::URIReference* SVGElemRef = new Inkscape::URIReference(desktop->doc());
  686. + SVGElemRef->attach(SVGElem_uri);
  687. + SPObject *elemref = NULL;
  688. + if (elemref = SVGElemRef->getObject()) {
  689. + elemref->deleteObject();
  690. + }
  691. + Inkscape::URI SVGElem_uri2(( (Glib::ustring)"infoline-on-end-" + (Glib::ustring)this->getRepr()->attribute("id")).c_str());
  692. + SVGElemRef->attach(SVGElem_uri2);
  693. + elemref = NULL;
  694. + if (elemref = SVGElemRef->getObject()) {
  695. + elemref->deleteObject();
  696. + }
  697. + Inkscape::URI SVGElem_uri3(( (Glib::ustring)"infoline-on-start-" + (Glib::ustring)this->getRepr()->attribute("id")).c_str());
  698. + SVGElemRef->attach(SVGElem_uri3);
  699. + elemref = NULL;
  700. + if (elemref = SVGElemRef->getObject()) {
  701. + elemref->deleteObject();
  702. + }
  703. + Inkscape::URI SVGElem_uri4(( (Glib::ustring)"infoline-" + (Glib::ustring)this->getRepr()->attribute("id")).c_str());
  704. + SVGElemRef->attach(SVGElem_uri4);
  705. + elemref = NULL;
  706. + if (elemref = SVGElemRef->getObject()) {
  707. + elemref->deleteObject();
  708. + }
  709. + }
  710. +}
  711. +
  712. +Gtk::Widget *LPEMeasureLine::newWidget()
  713. +{
  714. + // use manage here, because after deletion of Effect object, others might
  715. + // still be pointing to this widget.
  716. + Gtk::VBox *vbox = Gtk::manage(new Gtk::VBox(Effect::newWidget()));
  717. +
  718. + vbox->set_border_width(5);
  719. + vbox->set_homogeneous(false);
  720. + vbox->set_spacing(2);
  721. +
  722. + std::vector<Parameter *>::iterator it = param_vector.begin();
  723. + Gtk::HBox * button1 = Gtk::manage(new Gtk::HBox(true,0));
  724. + while (it != param_vector.end()) {
  725. + if ((*it)->widget_is_visible) {
  726. + Parameter *param = *it;
  727. + Gtk::Widget *widg = dynamic_cast<Gtk::Widget *>(param->param_newWidget());
  728. + Glib::ustring *tip = param->param_getTooltip();
  729. + if (widg) {
  730. + vbox->pack_start(*widg, true, true, 2);
  731. + if (tip) {
  732. + widg->set_tooltip_text(*tip);
  733. + } else {
  734. + widg->set_tooltip_text("");
  735. + widg->set_has_tooltip(false);
  736. + }
  737. + }
  738. + }
  739. +
  740. + ++it;
  741. + }
  742. + Gtk::Button *save_default = Gtk::manage(new Gtk::Button(Glib::ustring(_("Save '*' as default"))));
  743. + save_default->signal_clicked().connect(sigc::mem_fun(*this, &LPEMeasureLine::saveDefault));
  744. + button1->pack_start(*save_default, true, true, 2);
  745. + vbox->pack_start(*button1, true, true, 2);
  746. + return dynamic_cast<Gtk::Widget *>(vbox);
  747. +}
  748. +
  749. +Geom::PathVector
  750. +LPEMeasureLine::doEffect_path(Geom::PathVector const &path_in)
  751. +{
  752. + return path_in;
  753. +}
  754. +
  755. +void
  756. +LPEMeasureLine::saveDefault()
  757. +{
  758. + Inkscape::Preferences *prefs = Inkscape::Preferences::get();
  759. + prefs->setString("/live_effects/measure-line/fontbutton", (Glib::ustring)fontbutton.param_getSVGValue());
  760. + prefs->setDouble("/live_effects/measure-line/scale", scale);
  761. + prefs->setInt("/live_effects/measure-line/precision", precision);
  762. + prefs->setDouble("/live_effects/measure-line/position", position);
  763. + prefs->setDouble("/live_effects/measure-line/text_distance", text_distance);
  764. + prefs->setDouble("/live_effects/measure-line/helpline_distance", helpline_distance);
  765. + prefs->setDouble("/live_effects/measure-line/helpline_overlap", helpline_overlap);
  766. + prefs->setString("/live_effects/measure-line/unit", (Glib::ustring)unit.get_abbreviation());
  767. + prefs->setString("/live_effects/measure-line/format", (Glib::ustring)format.param_getSVGValue());
  768. + prefs->setBool("/live_effects/measure-line/flip_side", flip_side);
  769. + prefs->setBool("/live_effects/measure-line/scale_insensitive", scale_insensitive);
  770. + prefs->setBool("/live_effects/measure-line/local_locale", local_locale);
  771. + prefs->setBool("/live_effects/measure-line/line_group_05", line_group_05);
  772. + prefs->setBool("/live_effects/measure-line/rotate_anotation", rotate_anotation);
  773. +}
  774. +
  775. +}; //namespace LivePathEffect
  776. +}; /* namespace Inkscape */
  777. +
  778. +/*
  779. + Local Variables:
  780. + mode:c++
  781. + c-file-style:"stroustrup"
  782. + c-file-offset:((innamespace . 0)(inline-open . 0)(case-label . +))
  783. + indent-tabs-mode:nil
  784. + fill-column:99
  785. + End:
  786. +*/
  787. +// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4 :
  789. === added file 'src/live_effects/lpe-measure-line.h'
  790. --- src/live_effects/lpe-measure-line.h 1970-01-01 00:00:00 +0000
  791. +++ src/live_effects/lpe-measure-line.h 2016-07-31 03:43:53 +0000
  792. @@ -0,0 +1,88 @@
  793. +#ifndef INKSCAPE_LPE_MEASURE_LINE_H
  794. +#define INKSCAPE_LPE_MEASURE_LINE_H
  795. +
  796. +/*
  797. + * Author(s):
  798. + * Jabiertxo Arraiza Cenoz <jabier.arraiza@marker.es>
  799. + *
  800. + * Copyright (C) 2014 Author(s)
  801. + *
  802. + * Released under GNU GPL, read the file 'COPYING' for more information
  803. + */
  804. +
  805. +#include "live_effects/effect.h"
  806. +#include "live_effects/parameter/enum.h"
  807. +#include "live_effects/parameter/fontbutton.h"
  808. +#include "live_effects/parameter/text.h"
  809. +#include "live_effects/parameter/unit.h"
  810. +#include "live_effects/parameter/bool.h"
  811. +#include "live_effects/parameter/originalpath.h"
  812. +#include <libnrtype/font-lister.h>
  813. +#include <2geom/angle.h>
  814. +#include <2geom/ray.h>
  815. +#include <2geom/point.h>
  816. +
  817. +namespace Inkscape {
  818. +namespace LivePathEffect {
  819. +
  820. +enum OrientationMethod {
  821. + OM_HORIZONTAL,
  822. + OM_VERTICAL,
  823. + OM_PARALLEL,
  824. + OM_END
  825. +};
  826. +
  827. +class LPEMeasureLine : public Effect {
  828. +public:
  829. + LPEMeasureLine(LivePathEffectObject *lpeobject);
  830. + virtual ~LPEMeasureLine();
  831. + virtual void doBeforeEffect (SPLPEItem const* lpeitem);
  832. + virtual void doOnApply(SPLPEItem const* lpeitem);
  833. + virtual void doOnRemove (SPLPEItem const* lpeitem);
  834. + virtual void doOnVisibilityToggled(SPLPEItem const* /*lpeitem*/);
  835. + virtual Geom::PathVector doEffect_path(Geom::PathVector const &path_in);
  836. + void createLine(Geom::Point start,Geom::Point end,Glib::ustring id, bool main, bool remove);
  837. + void createTextLabel(Geom::Point pos, double length, Geom::Coord angle, double fontsize, bool remove);
  838. + void createArrowMarker(Glib::ustring mode);
  839. + void saveDefault();
  840. + virtual Gtk::Widget *newWidget();
  841. +private:
  842. + FontButtonParam fontbutton;
  843. + EnumParam<OrientationMethod> orientation;
  844. + ScalarParam curve_linked;
  845. + ScalarParam scale;
  846. + ScalarParam precision;
  847. + ScalarParam position;
  848. + ScalarParam text_distance;
  849. + ScalarParam helpline_distance;
  850. + ScalarParam helpline_overlap;
  851. + UnitParam unit;
  852. + TextParam format;
  853. + BoolParam arrows_outside;
  854. + BoolParam flip_side;
  855. + BoolParam scale_insensitive;
  856. + BoolParam local_locale;
  857. + BoolParam line_group_05;
  858. + BoolParam rotate_anotation;
  859. + Glib::ustring doc_unit;
  860. +/* Geom::Affine affine_over;*/
  861. + LPEMeasureLine(const LPEMeasureLine &);
  862. + LPEMeasureLine &operator=(const LPEMeasureLine &);
  863. +
  864. +};
  865. +
  866. +} //namespace LivePathEffect
  867. +} //namespace Inkscape
  868. +
  869. +#endif
  870. +
  871. +/*
  872. + Local Variables:
  873. + mode:c++
  874. + c-file-style:"stroustrup"
  875. + c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
  876. + indent-tabs-mode:nil
  877. + fill-column:99
  878. + End:
  879. +*/
  880. +// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4 :
  882. === modified file 'src/live_effects/lpe-transform_2pts.cpp'
  883. --- src/live_effects/lpe-transform_2pts.cpp 2016-07-28 11:26:17 +0000
  884. +++ src/live_effects/lpe-transform_2pts.cpp 2016-07-24 16:00:12 +0000
  885. @@ -90,7 +90,6 @@
  886. {
  887. using namespace Geom;
  888. original_bbox(lpeitem);
  889. -
  890. point_a = Point(boundingbox_X.min(), boundingbox_Y.middle());
  891. point_b = Point(boundingbox_X.max(), boundingbox_Y.middle());
  892. SPLPEItem * splpeitem = const_cast<SPLPEItem *>(lpeitem);
  894. === modified file 'src/live_effects/parameter/Makefile_insert'
  895. --- src/live_effects/parameter/Makefile_insert 2015-03-02 01:29:50 +0000
  896. +++ src/live_effects/parameter/Makefile_insert 2016-07-29 21:24:09 +0000
  897. @@ -11,6 +11,8 @@
  898. live_effects/parameter/random.h \
  899. live_effects/parameter/point.cpp \
  900. live_effects/parameter/point.h \
  901. + live_effects/parameter/fontbutton.cpp \
  902. + live_effects/parameter/fontbutton.h \
  903. live_effects/parameter/enum.h \
  904. live_effects/parameter/path-reference.cpp \
  905. live_effects/parameter/path-reference.h \
  907. === modified file 'src/live_effects/parameter/bool.cpp'
  908. --- src/live_effects/parameter/bool.cpp 2015-10-18 19:13:13 +0000
  909. +++ src/live_effects/parameter/bool.cpp 2016-07-24 23:27:14 +0000
  910. @@ -36,6 +36,12 @@
  911. param_setValue(defvalue);
  912. }
  914. +void
  915. +BoolParam::param_update_default(bool const default_value)
  916. +{
  917. + defvalue = default_value;
  918. +}
  919. +
  920. bool
  921. BoolParam::param_readSVGValue(const gchar * strvalue)
  922. {
  924. === modified file 'src/live_effects/parameter/bool.h'
  925. --- src/live_effects/parameter/bool.h 2015-10-18 19:13:13 +0000
  926. +++ src/live_effects/parameter/bool.h 2016-07-24 23:26:29 +0000
  927. @@ -36,7 +36,7 @@
  929. void param_setValue(bool newvalue);
  930. virtual void param_set_default();
  931. -
  932. + void param_update_default(bool const default_value);
  933. bool get_value() const { return value; };
  935. inline operator bool() const { return value; };
  937. === modified file 'src/live_effects/parameter/enum.h'
  938. --- src/live_effects/parameter/enum.h 2014-03-27 01:33:44 +0000
  939. +++ src/live_effects/parameter/enum.h 2016-07-29 18:13:50 +0000
  940. @@ -27,12 +27,14 @@
  941. const Util::EnumDataConverter<E>& c,
  942. Inkscape::UI::Widget::Registry* wr,
  943. Effect* effect,
  944. - E default_value)
  945. + E default_value,
  946. + bool sort = true)
  947. : Parameter(label, tip, key, wr, effect)
  948. {
  949. enumdataconv = &c;
  950. defvalue = default_value;
  951. value = defvalue;
  952. + sorted = sort;
  953. };
  955. virtual ~EnumParam() { };
  956. @@ -40,12 +42,11 @@
  957. virtual Gtk::Widget * param_newWidget() {
  958. Inkscape::UI::Widget::RegisteredEnum<E> *regenum = Gtk::manage (
  959. new Inkscape::UI::Widget::RegisteredEnum<E>( param_label, param_tooltip,
  960. - param_key, *enumdataconv, *param_wr, param_effect->getRepr(), param_effect->getSPDoc() ) );
  961. + param_key, *enumdataconv, *param_wr, param_effect->getRepr(), param_effect->getSPDoc(), sorted ) );
  963. regenum->set_active_by_id(value);
  964. regenum->combobox()->setProgrammatically = false;
  965. regenum->set_undo_parameters(SP_VERB_DIALOG_LIVE_PATH_EFFECT, _("Change enumeration parameter"));
  966. -
  967. return dynamic_cast<Gtk::Widget *> (regenum);
  968. };
  970. @@ -86,6 +87,7 @@
  972. E value;
  973. E defvalue;
  974. + bool sorted;
  976. const Util::EnumDataConverter<E> * enumdataconv;
  977. };
  979. === added file 'src/live_effects/parameter/fontbutton.cpp'
  980. --- src/live_effects/parameter/fontbutton.cpp 1970-01-01 00:00:00 +0000
  981. +++ src/live_effects/parameter/fontbutton.cpp 2016-07-29 21:26:48 +0000
  982. @@ -0,0 +1,92 @@
  983. +/*
  984. + * Authors:
  985. + *
  986. + * Released under GNU GPL, read the file 'COPYING' for more information
  987. + */
  988. +
  989. +
  990. +#include "ui/widget/registered-widget.h"
  991. +#include "live_effects/parameter/fontbutton.h"
  992. +#include "live_effects/effect.h"
  993. +#include "ui/widget/font-button.h"
  994. +#include "svg/svg.h"
  995. +#include "svg/stringstream.h"
  996. +#include "verbs.h"
  997. +
  998. +#include <glibmm/i18n.h>
  999. +
  1000. +namespace Inkscape {
  1001. +
  1002. +namespace LivePathEffect {
  1003. +
  1004. +FontButtonParam::FontButtonParam( const Glib::ustring& label, const Glib::ustring& tip,
  1005. + const Glib::ustring& key, Inkscape::UI::Widget::Registry* wr,
  1006. + Effect* effect, const Glib::ustring default_value )
  1007. + : Parameter(label, tip, key, wr, effect),
  1008. + value(default_value),
  1009. + defvalue(default_value)
  1010. +{
  1011. +}
  1012. +
  1013. +void
  1014. +FontButtonParam::param_set_default()
  1015. +{
  1016. + param_setValue(defvalue);
  1017. +}
  1018. +void
  1019. +FontButtonParam::param_update_default(const Glib::ustring default_value){
  1020. + defvalue = default_value;
  1021. +}
  1022. +
  1023. +bool
  1024. +FontButtonParam::param_readSVGValue(const gchar * strvalue)
  1025. +{
  1026. + Inkscape::SVGOStringStream os;
  1027. + os << strvalue;
  1028. + param_setValue((Glib::ustring)os.str());
  1029. + return true;
  1030. +}
  1031. +
  1032. +gchar *
  1033. +FontButtonParam::param_getSVGValue() const
  1034. +{
  1035. + return g_strdup(value.c_str());
  1036. +}
  1037. +
  1038. +Gtk::Widget *
  1039. +FontButtonParam::param_newWidget()
  1040. +{
  1041. + Inkscape::UI::Widget::RegisteredFontButton * fontbuttonwdg = Gtk::manage(
  1042. + new Inkscape::UI::Widget::RegisteredFontButton( param_label,
  1043. + param_tooltip,
  1044. + param_key,
  1045. + *param_wr,
  1046. + param_effect->getRepr(),
  1047. + param_effect->getSPDoc() ) );
  1048. + Glib::ustring fontspec = param_getSVGValue();
  1049. + fontbuttonwdg->setValue( fontspec);
  1050. + fontbuttonwdg->set_undo_parameters(SP_VERB_DIALOG_LIVE_PATH_EFFECT, _("Change font button parameter"));
  1051. + param_effect->upd_params = false;
  1052. + return dynamic_cast<Gtk::Widget *> (fontbuttonwdg);
  1053. +}
  1054. +
  1055. +void
  1056. +FontButtonParam::param_setValue(const Glib::ustring newvalue)
  1057. +{
  1058. + value = newvalue;
  1059. +}
  1060. +
  1061. +} /* namespace LivePathEffect */
  1062. +
  1063. +} /* namespace Inkscape */
  1064. +
  1065. +/*
  1066. + Local Variables:
  1067. + mode:c++
  1068. + c-file-style:"stroustrup"
  1069. + c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
  1070. + indent-tabs-mode:nil
  1071. + fill-column:99
  1072. + End:
  1073. +*/
  1074. +// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4 :
  1076. === added file 'src/live_effects/parameter/fontbutton.h'
  1077. --- src/live_effects/parameter/fontbutton.h 1970-01-01 00:00:00 +0000
  1078. +++ src/live_effects/parameter/fontbutton.h 2016-07-29 20:44:37 +0000
  1079. @@ -0,0 +1,62 @@
  1080. +#ifndef INKSCAPE_LIVEPATHEFFECT_PARAMETER_FONT_H
  1081. +#define INKSCAPE_LIVEPATHEFFECT_PARAMETER_FONT_H
  1082. +
  1083. +/*
  1084. + * Inkscape::LivePathEffectParameters
  1085. + *
  1086. + * Authors:
  1087. + * Released under GNU GPL, read the file 'COPYING' for more information
  1088. + */
  1089. +#include <glib.h>
  1090. +#include <gtkmm.h>
  1091. +#include "live_effects/parameter/parameter.h"
  1092. +
  1093. +namespace Inkscape {
  1094. +
  1095. +namespace LivePathEffect {
  1096. +
  1097. +class FontButtonParam : public Parameter {
  1098. +public:
  1099. + FontButtonParam( const Glib::ustring& label,
  1100. + const Glib::ustring& tip,
  1101. + const Glib::ustring& key,
  1102. + Inkscape::UI::Widget::Registry* wr,
  1103. + Effect* effect,
  1104. + const Glib::ustring default_value = "");
  1105. + virtual ~FontButtonParam() {}
  1106. +
  1107. + virtual Gtk::Widget * param_newWidget();
  1108. + virtual bool param_readSVGValue(const gchar * strvalue);
  1109. + void param_update_default(const Glib::ustring defvalue);
  1110. + virtual gchar * param_getSVGValue() const;
  1111. +
  1112. + void param_setValue(const Glib::ustring newvalue);
  1113. +
  1114. + virtual void param_set_default();
  1115. +
  1116. + const Glib::ustring get_value() const { return defvalue; };
  1117. +
  1118. +private:
  1119. + FontButtonParam(const FontButtonParam&);
  1120. + FontButtonParam& operator=(const FontButtonParam&);
  1121. + Glib::ustring value;
  1122. + Glib::ustring defvalue;
  1123. +
  1124. +};
  1125. +
  1126. +} //namespace LivePathEffect
  1127. +
  1128. +} //namespace Inkscape
  1129. +
  1130. +#endif
  1131. +
  1132. +/*
  1133. + Local Variables:
  1134. + mode:c++
  1135. + c-file-style:"stroustrup"
  1136. + c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
  1137. + indent-tabs-mode:nil
  1138. + fill-column:99
  1139. + End:
  1140. +*/
  1141. +// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4 :
  1143. === modified file 'src/live_effects/parameter/parameter.cpp'
  1144. --- src/live_effects/parameter/parameter.cpp 2015-10-18 19:13:13 +0000
  1145. +++ src/live_effects/parameter/parameter.cpp 2016-07-30 16:08:21 +0000
  1146. @@ -4,11 +4,9 @@
  1147. * Released under GNU GPL, read the file 'COPYING' for more information
  1148. */
  1150. -#include "ui/widget/registered-widget.h"
  1151. -#include <glibmm/i18n.h>
  1153. +#include "live_effects/effect.h"
  1154. #include "live_effects/parameter/parameter.h"
  1155. -#include "live_effects/effect.h"
  1156. #include "svg/svg.h"
  1157. #include "xml/repr.h"
  1159. @@ -16,6 +14,8 @@
  1161. #include "verbs.h"
  1163. +#include <glibmm/i18n.h>
  1164. +
  1165. #define noLPEREALPARAM_DEBUG
  1167. namespace Inkscape {
  1168. @@ -101,9 +101,16 @@
  1169. param_set_value(defvalue);
  1170. }
  1172. +void
  1173. +ScalarParam::param_update_default(gdouble default_value)
  1174. +{
  1175. + defvalue = default_value;
  1176. +}
  1177. +
  1178. void
  1179. ScalarParam::param_set_value(gdouble val)
  1180. {
  1181. + param_effect->upd_params = true;
  1182. value = val;
  1183. if (integer)
  1184. value = round(value);
  1185. @@ -121,7 +128,7 @@
  1186. // Once again, in gtk2, this is not a problem. But in gtk3,
  1187. // widgets get allocated the amount of size they ask for,
  1188. // leading to excessively long widgets.
  1189. -
  1190. + param_effect->upd_params = true;
  1191. if (min >= -SCALARPARAM_G_MAXDOUBLE) {
  1192. this->min = min;
  1193. } else {
  1194. @@ -130,15 +137,15 @@
  1195. if (max <= SCALARPARAM_G_MAXDOUBLE) {
  1196. this->max = max;
  1197. } else {
  1198. - this->max = SCALARPARAM_G_MAXDOUBLE;
  1199. + this->max = SCALARPARAM_G_MAXDOUBLE;
  1200. }
  1201. -
  1202. param_set_value(value); // reset value to see whether it is in ranges
  1203. }
  1205. void
  1206. ScalarParam::param_make_integer(bool yes)
  1207. {
  1208. + param_effect->upd_params = true;
  1209. integer = yes;
  1210. digits = 0;
  1211. inc_step = 1;
  1212. @@ -169,6 +176,7 @@
  1213. if(!overwrite_widget){
  1214. rsu->set_undo_parameters(SP_VERB_DIALOG_LIVE_PATH_EFFECT, _("Change scalar parameter"));
  1215. }
  1216. + param_effect->upd_params = false;
  1217. return dynamic_cast<Gtk::Widget *> (rsu);
  1218. } else {
  1219. return NULL;
  1220. @@ -178,12 +186,14 @@
  1221. void
  1222. ScalarParam::param_set_digits(unsigned digits)
  1223. {
  1224. + param_effect->upd_params = true;
  1225. this->digits = digits;
  1226. }
  1228. void
  1229. ScalarParam::param_set_increments(double step, double page)
  1230. {
  1231. + param_effect->upd_params = true;
  1232. inc_step = step;
  1233. inc_page = page;
  1234. }
  1236. === modified file 'src/live_effects/parameter/parameter.h'
  1237. --- src/live_effects/parameter/parameter.h 2015-10-18 19:13:13 +0000
  1238. +++ src/live_effects/parameter/parameter.h 2016-07-30 16:05:28 +0000
  1239. @@ -12,6 +12,7 @@
  1240. #include <glibmm/ustring.h>
  1241. #include <2geom/forward.h>
  1242. #include <2geom/pathvector.h>
  1243. +#include "ui/widget/registered-widget.h"
  1245. // In gtk2, this wasn't an issue; we could toss around
  1246. // G_MAXDOUBLE and not worry about size allocations. But
  1247. @@ -110,12 +111,12 @@
  1248. virtual gchar * param_getSVGValue() const;
  1250. virtual void param_set_default();
  1251. + void param_update_default(gdouble default_value);
  1252. void param_set_value(gdouble val);
  1253. void param_make_integer(bool yes = true);
  1254. void param_set_range(gdouble min, gdouble max);
  1255. void param_set_digits(unsigned digits);
  1256. void param_set_increments(double step, double page);
  1257. -
  1258. void addSlider(bool add_slider_widget) { add_slider = add_slider_widget; };
  1260. void param_overwrite_widget(bool overwrite_widget);
  1262. === modified file 'src/live_effects/parameter/point.cpp'
  1263. --- src/live_effects/parameter/point.cpp 2016-01-17 19:18:53 +0000
  1264. +++ src/live_effects/parameter/point.cpp 2016-07-29 09:36:40 +0000
  1265. @@ -4,7 +4,6 @@
  1266. * Released under GNU GPL, read the file 'COPYING' for more information
  1267. */
  1269. -#include "ui/widget/registered-widget.h"
  1270. #include "live_effects/parameter/point.h"
  1271. #include "live_effects/effect.h"
  1272. #include "svg/svg.h"
  1273. @@ -30,7 +29,8 @@
  1274. : Parameter(label, tip, key, wr, effect),
  1275. defvalue(default_value),
  1276. liveupdate(live_update),
  1277. - knoth(NULL)
  1278. + knoth(NULL),
  1279. + _pointwdg(NULL)
  1280. {
  1281. knot_shape = SP_KNOT_SHAPE_DIAMOND;
  1282. knot_mode = SP_KNOT_MODE_XOR;
  1283. @@ -62,9 +62,9 @@
  1284. }
  1286. void
  1287. -PointParam::param_update_default(Geom::Point newpoint)
  1288. +PointParam::param_update_default(const Geom::Point default_point)
  1289. {
  1290. - defvalue = newpoint;
  1291. + defvalue = default_point;
  1292. }
  1294. void
  1295. @@ -81,6 +81,9 @@
  1296. if(knoth && liveupdate){
  1297. knoth->update_knots();
  1298. }
  1299. + if (_pointwdg) {
  1300. + _pointwdg->setValue( newpoint );
  1301. + }
  1302. }
  1304. bool
  1305. @@ -116,7 +119,7 @@
  1306. Gtk::Widget *
  1307. PointParam::param_newWidget()
  1308. {
  1309. - Inkscape::UI::Widget::RegisteredTransformedPoint * pointwdg = Gtk::manage(
  1310. + _pointwdg = Gtk::manage(
  1311. new Inkscape::UI::Widget::RegisteredTransformedPoint( param_label,
  1312. param_tooltip,
  1313. param_key,
  1314. @@ -126,15 +129,15 @@
  1315. // TODO: fix to get correct desktop (don't use SP_ACTIVE_DESKTOP)
  1316. SPDesktop *desktop = SP_ACTIVE_DESKTOP;
  1317. Geom::Affine transf = desktop->doc2dt();
  1318. - pointwdg->setTransform(transf);
  1319. - pointwdg->setValue( *this );
  1320. - pointwdg->clearProgrammatically();
  1321. - pointwdg->set_undo_parameters(SP_VERB_DIALOG_LIVE_PATH_EFFECT, _("Change point parameter"));
  1322. + _pointwdg->setTransform(transf);
  1323. + _pointwdg->setValue( *this );
  1324. + _pointwdg->clearProgrammatically();
  1325. + _pointwdg->set_undo_parameters(SP_VERB_DIALOG_LIVE_PATH_EFFECT, _("Change point parameter"));
  1327. Gtk::HBox * hbox = Gtk::manage( new Gtk::HBox() );
  1328. - static_cast<Gtk::HBox*>(hbox)->pack_start(*pointwdg, true, true);
  1329. + static_cast<Gtk::HBox*>(hbox)->pack_start(*_pointwdg, true, true);
  1330. static_cast<Gtk::HBox*>(hbox)->show_all_children();
  1331. -
  1332. + param_effect->upd_params = false;
  1333. return dynamic_cast<Gtk::Widget *> (hbox);
  1334. }
  1336. @@ -191,13 +194,13 @@
  1337. PointParamKnotHolderEntity::knot_click(guint state)
  1338. {
  1339. if (state & GDK_CONTROL_MASK) {
  1340. - if (state & GDK_MOD1_MASK) {
  1341. - this->pparam->param_set_default();
  1342. - SPLPEItem * splpeitem = dynamic_cast<SPLPEItem *>(item);
  1343. - if(splpeitem){
  1344. - sp_lpe_item_update_patheffect(splpeitem, false, false);
  1345. - }
  1346. + if (state & GDK_MOD1_MASK) {
  1347. + this->pparam->param_set_default();
  1348. + SPLPEItem * splpeitem = dynamic_cast<SPLPEItem *>(item);
  1349. + if(splpeitem){
  1350. + sp_lpe_item_update_patheffect(splpeitem, false, false);
  1351. }
  1352. + }
  1353. }
  1354. }
  1357. === modified file 'src/live_effects/parameter/point.h'
  1358. --- src/live_effects/parameter/point.h 2016-01-17 19:18:53 +0000
  1359. +++ src/live_effects/parameter/point.h 2016-07-29 09:28:12 +0000
  1360. @@ -11,7 +11,7 @@
  1362. #include <glib.h>
  1363. #include <2geom/point.h>
  1364. -
  1365. +#include "ui/widget/registered-widget.h"
  1366. #include "live_effects/parameter/parameter.h"
  1368. #include "knot-holder-entity.h"
  1369. @@ -43,7 +43,7 @@
  1370. void param_set_default();
  1371. Geom::Point param_get_default() const;
  1372. void param_set_liveupdate(bool live_update);
  1373. - void param_update_default(Geom::Point newpoint);
  1374. + void param_update_default(const Geom::Point default_point);
  1375. virtual void param_transform_multiply(Geom::Affine const& /*postmul*/, bool /*set*/);
  1377. void set_oncanvas_looks(SPKnotShapeType shape, SPKnotModeType mode, guint32 color);
  1378. @@ -62,6 +62,7 @@
  1379. SPKnotModeType knot_mode;
  1380. guint32 knot_color;
  1381. gchar *handle_tip;
  1382. + Inkscape::UI::Widget::RegisteredTransformedPoint * _pointwdg;
  1383. };
  1387. === modified file 'src/live_effects/parameter/text.cpp'
  1388. --- src/live_effects/parameter/text.cpp 2014-12-21 21:58:32 +0000
  1389. +++ src/live_effects/parameter/text.cpp 2016-07-31 02:24:26 +0000
  1390. @@ -31,7 +31,8 @@
  1391. Effect* effect, const Glib::ustring default_value )
  1392. : Parameter(label, tip, key, wr, effect),
  1393. value(default_value),
  1394. - defvalue(default_value)
  1395. + defvalue(default_value),
  1396. + _hide_canvas_text(false)
  1397. {
  1398. SPDesktop *desktop = SP_ACTIVE_DESKTOP; // FIXME: we shouldn't use this!
  1399. canvas_text = (SPCanvasText *) sp_canvastext_new(desktop->getTempGroup(), desktop, Geom::Point(0,0), "");
  1400. @@ -46,9 +47,24 @@
  1401. }
  1403. void
  1404. +TextParam::param_update_default(Glib::ustring default_value)
  1405. +{
  1406. + defvalue = default_value;
  1407. +}
  1408. +
  1409. +void
  1410. +TextParam::param_hide_canvas_text()
  1411. +{
  1412. + _hide_canvas_text = true;
  1413. + sp_canvastext_set_text (canvas_text,"");
  1414. +}
  1415. +
  1416. +void
  1417. TextParam::setPos(Geom::Point pos)
  1418. {
  1419. - sp_canvastext_set_coords (canvas_text, pos);
  1420. + if (!_hide_canvas_text) {
  1421. + sp_canvastext_set_coords (canvas_text, pos);
  1422. + }
  1423. }
  1425. void
  1426. @@ -63,9 +79,10 @@
  1427. Point dir = unit_vector(derivative(pwd2_reparam).valueAt(t_reparam));
  1428. Point n = -rot90(dir);
  1429. double angle = Geom::angle_between(dir, Point(1,0));
  1430. -
  1431. - sp_canvastext_set_coords(canvas_text, pos + n * length);
  1432. - sp_canvastext_set_anchor_manually(canvas_text, std::sin(angle), -std::cos(angle));
  1433. + if (!_hide_canvas_text) {
  1434. + sp_canvastext_set_coords(canvas_text, pos + n * length);
  1435. + sp_canvastext_set_anchor_manually(canvas_text, std::sin(angle), -std::cos(angle));
  1436. + }
  1437. }
  1439. void
  1440. @@ -73,7 +90,9 @@
  1441. {
  1442. anchor_x = x_value;
  1443. anchor_y = y_value;
  1444. - sp_canvastext_set_anchor_manually (canvas_text, anchor_x, anchor_y);
  1445. + if (!_hide_canvas_text) {
  1446. + sp_canvastext_set_anchor_manually (canvas_text, anchor_x, anchor_y);
  1447. + }
  1448. }
  1450. bool
  1451. @@ -107,8 +126,9 @@
  1452. TextParam::param_setValue(const Glib::ustring newvalue)
  1453. {
  1454. value = newvalue;
  1455. -
  1456. - sp_canvastext_set_text (canvas_text, newvalue.c_str());
  1457. + if (!_hide_canvas_text) {
  1458. + sp_canvastext_set_text (canvas_text, newvalue.c_str());
  1459. + }
  1460. }
  1462. } /* namespace LivePathEffect */
  1464. === modified file 'src/live_effects/parameter/text.h'
  1465. --- src/live_effects/parameter/text.h 2014-03-27 01:33:44 +0000
  1466. +++ src/live_effects/parameter/text.h 2016-07-31 02:24:55 +0000
  1467. @@ -40,7 +40,9 @@
  1468. virtual gchar * param_getSVGValue() const;
  1470. void param_setValue(const Glib::ustring newvalue);
  1471. + void param_hide_canvas_text();
  1472. virtual void param_set_default();
  1473. + void param_update_default(Glib::ustring default_value);
  1474. void setPos(Geom::Point pos);
  1475. void setPosAndAnchor(const Geom::Piecewise<Geom::D2<Geom::SBasis> > &pwd2,
  1476. const double t, const double length, bool use_curvature = false);
  1477. @@ -53,7 +55,7 @@
  1478. TextParam& operator=(const TextParam&);
  1479. double anchor_x;
  1480. double anchor_y;
  1481. -
  1482. + bool _hide_canvas_text;
  1483. Glib::ustring value;
  1484. Glib::ustring defvalue;
  1487. === modified file 'src/live_effects/parameter/togglebutton.cpp'
  1488. --- src/live_effects/parameter/togglebutton.cpp 2016-07-24 15:05:29 +0000
  1489. +++ src/live_effects/parameter/togglebutton.cpp 2016-07-24 16:53:55 +0000
  1490. @@ -12,6 +12,7 @@
  1491. #include "live_effects/effect.h"
  1492. #include "svg/svg.h"
  1493. #include "svg/stringstream.h"
  1494. +#include "selection.h"
  1495. #include "widgets/icon.h"
  1496. #include "inkscape.h"
  1497. #include "verbs.h"
  1498. @@ -108,13 +109,14 @@
  1499. }else{
  1500. gtk_box_pack_start (GTK_BOX(box_button), label_button, false, false, 1);
  1501. }
  1502. +
  1503. checkwdg->add(*Gtk::manage(Glib::wrap(box_button)));
  1504. checkwdg->setActive(value);
  1505. checkwdg->setProgrammatically = false;
  1506. checkwdg->set_undo_parameters(SP_VERB_DIALOG_LIVE_PATH_EFFECT, _("Change togglebutton parameter"));
  1508. _toggled_connection = checkwdg->signal_toggled().connect(sigc::mem_fun(*this, &ToggleButtonParam::toggled));
  1509. -
  1510. + param_effect->upd_params = false;
  1511. return checkwdg;
  1512. }
  1514. @@ -161,6 +163,12 @@
  1516. void
  1517. ToggleButtonParam::toggled() {
  1518. + //Force redraw for update widgets
  1519. + param_effect->upd_params = true;
  1520. + if (SP_ACTIVE_DESKTOP) {
  1521. + Inkscape::Selection *selection = SP_ACTIVE_DESKTOP->getSelection();
  1522. + selection ->emitModified();
  1523. + }
  1524. _signal_toggled.emit();
  1525. }
  1528. === modified file 'src/live_effects/parameter/unit.cpp'
  1529. --- src/live_effects/parameter/unit.cpp 2014-03-27 01:33:44 +0000
  1530. +++ src/live_effects/parameter/unit.cpp 2016-07-24 23:34:35 +0000
  1531. @@ -54,6 +54,12 @@
  1532. param_set_value(*defunit);
  1533. }
  1535. +void
  1536. +UnitParam::param_update_default(const Glib::ustring default_unit)
  1537. +{
  1538. + defunit = unit_table.getUnit(default_unit);
  1539. +}
  1540. +
  1541. void
  1542. UnitParam::param_set_value(Inkscape::Util::Unit const &val)
  1543. {
  1545. === modified file 'src/live_effects/parameter/unit.h'
  1546. --- src/live_effects/parameter/unit.h 2014-03-27 01:33:44 +0000
  1547. +++ src/live_effects/parameter/unit.h 2016-07-24 23:34:56 +0000
  1548. @@ -33,6 +33,7 @@
  1549. virtual gchar * param_getSVGValue() const;
  1550. virtual void param_set_default();
  1551. void param_set_value(Inkscape::Util::Unit const &val);
  1552. + void param_update_default(const Glib::ustring default_unit);
  1553. const gchar *get_abbreviation() const;
  1555. virtual Gtk::Widget * param_newWidget();
  1557. === modified file 'src/selection.cpp'
  1558. --- src/selection.cpp 2016-07-28 11:26:17 +0000
  1559. +++ src/selection.cpp 2016-07-24 16:00:12 +0000
  1560. @@ -282,6 +282,11 @@
  1561. _emitChanged();
  1562. }
  1564. +void Selection::emitModified()
  1565. +{
  1566. + _emitChanged();
  1567. +}
  1568. +
  1569. std::vector<SPObject*> const &Selection::list() {
  1570. if(!_objs_vector.empty())
  1571. return _objs_vector;
  1573. === modified file 'src/selection.h'
  1574. --- src/selection.h 2016-07-28 11:26:17 +0000
  1575. +++ src/selection.h 2016-07-24 16:00:12 +0000
  1576. @@ -192,6 +192,11 @@
  1577. void clear();
  1579. /**
  1580. + * Emmit modified signal
  1581. + */
  1582. + void emitModified();
  1583. +
  1584. + /**
  1585. * Returns true if no items are selected.
  1586. */
  1587. bool isEmpty() const { return _objs.empty(); }
  1589. === modified file 'src/ui/CMakeLists.txt'
  1590. --- src/ui/CMakeLists.txt 2016-02-07 15:49:01 +0000
  1591. +++ src/ui/CMakeLists.txt 2016-07-29 21:24:51 +0000
  1592. @@ -128,6 +128,7 @@
  1593. widget/entity-entry.cpp
  1594. widget/entry.cpp
  1595. widget/filter-effect-chooser.cpp
  1596. + widget/font-button.cpp
  1597. widget/font-variants.cpp
  1598. widget/frame.cpp
  1599. widget/gimpcolorwheel.c
  1600. @@ -312,6 +313,7 @@
  1601. widget/entity-entry.h
  1602. widget/entry.h
  1603. widget/filter-effect-chooser.h
  1604. + widget/font-button.h
  1605. widget/font-variants.h
  1606. widget/frame.h
  1607. widget/gimpspinscale.h
  1609. === modified file 'src/ui/dialog/livepatheffect-editor.cpp'
  1610. --- src/ui/dialog/livepatheffect-editor.cpp 2016-07-28 11:26:17 +0000
  1611. +++ src/ui/dialog/livepatheffect-editor.cpp 2016-07-30 17:02:04 +0000
  1612. @@ -61,7 +61,7 @@
  1613. {
  1614. LivePathEffectEditor *lpeeditor = static_cast<LivePathEffectEditor *>(data);
  1615. lpeeditor->lpe_list_locked = false;
  1616. - lpeeditor->onSelectionChanged(selection);
  1617. + lpeeditor->onSelectionChanged(selection, true);
  1618. }
  1620. static void lpeeditor_selection_modified (Inkscape::Selection * selection, guint /*flags*/, gpointer data)
  1621. @@ -98,7 +98,8 @@
  1622. button_up(),
  1623. button_down(),
  1624. current_desktop(NULL),
  1625. - current_lpeitem(NULL)
  1626. + current_lpeitem(NULL),
  1627. + current_lperef(NULL)
  1628. {
  1629. Gtk::Box *contents = _getContents();
  1630. contents->set_spacing(4);
  1631. @@ -206,6 +207,10 @@
  1632. void
  1633. LivePathEffectEditor::showParams(LivePathEffect::Effect& effect)
  1634. {
  1635. + if ( ! effect.upd_params ) {
  1636. + return;
  1637. + }
  1638. +
  1639. if (effectwidget) {
  1640. effectcontrol_vbox.remove(*effectwidget);
  1641. delete effectwidget;
  1642. @@ -265,9 +270,8 @@
  1643. button_down.set_sensitive(sensitive);
  1644. }
  1646. -
  1647. void
  1648. -LivePathEffectEditor::onSelectionChanged(Inkscape::Selection *sel)
  1649. +LivePathEffectEditor::onSelectionChanged(Inkscape::Selection *sel, bool upd_params)
  1650. {
  1651. if (lpe_list_locked) {
  1652. // this was triggered by selecting a row in the list, so skip reloading
  1653. @@ -291,6 +295,9 @@
  1654. if ( lpeitem->hasPathEffect() ) {
  1655. Inkscape::LivePathEffect::Effect *lpe = lpeitem->getCurrentLPE();
  1656. if (lpe) {
  1657. + if (upd_params) {
  1658. + lpe->upd_params = true;
  1659. + }
  1660. showParams(*lpe);
  1661. lpe_list_locked = true;
  1662. selectInList(lpe);
  1663. @@ -494,6 +501,12 @@
  1664. SPItem *item = sel->singleItem();
  1665. SPLPEItem *lpeitem = dynamic_cast<SPLPEItem *>(item);
  1666. if ( lpeitem ) {
  1667. + if (current_lperef && current_lperef->lpeobject) {
  1668. + LivePathEffect::Effect * effect = current_lperef->lpeobject->get_lpe();
  1669. + if (effect) {
  1670. + effect->upd_params = true;
  1671. + }
  1672. + }
  1673. lpeitem->removeCurrentPathEffect(false);
  1675. DocumentUndo::done( current_desktop->getDocument(), SP_VERB_DIALOG_LIVE_PATH_EFFECT,
  1676. @@ -548,11 +561,17 @@
  1677. Gtk::TreeModel::iterator it = sel->get_selected();
  1678. LivePathEffect::LPEObjectReference * lperef = (*it)[columns.lperef];
  1680. - if (lperef && current_lpeitem) {
  1681. + if (lperef && current_lpeitem && current_lperef != lperef) {
  1682. + //The last condition ignore Gtk::TreeModel may occasionally be changed emitted when nothing has happened
  1683. if (lperef->lpeobject->get_lpe()) {
  1684. lpe_list_locked = true; // prevent reload of the list which would lose selection
  1685. current_lpeitem->setCurrentPathEffect(lperef);
  1686. - showParams(*lperef->lpeobject->get_lpe());
  1687. + current_lperef = lperef;
  1688. + LivePathEffect::Effect * effect = lperef->lpeobject->get_lpe();
  1689. + if (effect) {
  1690. + effect->upd_params = true;
  1691. + showParams(*effect);
  1692. + }
  1693. }
  1694. }
  1695. }
  1696. @@ -570,6 +589,14 @@
  1697. /* FIXME: this explicit writing to SVG is wrong. The lpe_item should have a method to disable/enable an effect within its stack.
  1698. * So one can call: lpe_item->setActive(lpeobjref->lpeobject); */
  1699. lpeobjref->lpeobject->get_lpe()->getRepr()->setAttribute("is_visible", newValue ? "true" : "false");
  1700. + Inkscape::Selection *sel = _getSelection();
  1701. + if ( sel && !sel->isEmpty() ) {
  1702. + SPItem *item = sel->singleItem();
  1703. + SPLPEItem *lpeitem = dynamic_cast<SPLPEItem *>(item);
  1704. + if ( lpeitem ) {
  1705. + lpeobjref->lpeobject->get_lpe()->doOnVisibilityToggled(lpeitem);
  1706. + }
  1707. + }
  1708. DocumentUndo::done( current_desktop->getDocument(), SP_VERB_DIALOG_LIVE_PATH_EFFECT,
  1709. newValue ? _("Activate path effect") : _("Deactivate path effect"));
  1710. }
  1712. === modified file 'src/ui/dialog/livepatheffect-editor.h'
  1713. --- src/ui/dialog/livepatheffect-editor.h 2014-03-27 01:33:44 +0000
  1714. +++ src/ui/dialog/livepatheffect-editor.h 2016-07-24 16:00:12 +0000
  1715. @@ -45,7 +45,8 @@
  1717. static LivePathEffectEditor &getInstance() { return *new LivePathEffectEditor(); }
  1719. - void onSelectionChanged(Inkscape::Selection *sel);
  1720. + void onSelectionChanged(Inkscape::Selection *sel, bool upd_params = false);
  1721. + void onSelectionModified(Inkscape::Selection *sel);
  1722. virtual void on_effect_selection_changed();
  1723. void setDesktop(SPDesktop *desktop);
  1725. @@ -126,6 +127,8 @@
  1727. SPLPEItem * current_lpeitem;
  1729. + LivePathEffect::LPEObjectReference * current_lperef;
  1730. +
  1731. friend void lpeeditor_selection_changed (Inkscape::Selection * selection, gpointer data);
  1733. LivePathEffectEditor(LivePathEffectEditor const &d);
  1735. === modified file 'src/ui/widget/Makefile_insert'
  1736. --- src/ui/widget/Makefile_insert 2015-05-17 09:20:36 +0000
  1737. +++ src/ui/widget/Makefile_insert 2016-07-29 21:25:30 +0000
  1738. @@ -33,6 +33,8 @@
  1739. ui/widget/entry.h \
  1740. ui/widget/filter-effect-chooser.h \
  1741. ui/widget/filter-effect-chooser.cpp \
  1742. + ui/widget/font-button.h \
  1743. + ui/widget/font-button.cpp \
  1744. ui/widget/font-variants.h \
  1745. ui/widget/font-variants.cpp \
  1746. ui/widget/gimpspinscale.c \
  1748. === modified file 'src/ui/widget/combo-enums.h'
  1749. --- src/ui/widget/combo-enums.h 2012-02-15 11:19:00 +0000
  1750. +++ src/ui/widget/combo-enums.h 2016-07-29 18:13:37 +0000
  1751. @@ -16,7 +16,6 @@
  1752. #include <gtkmm/liststore.h>
  1753. #include "attr-widget.h"
  1754. #include "util/enums.h"
  1755. -
  1756. #include <glibmm/i18n.h>
  1758. namespace Inkscape {
  1759. @@ -190,9 +189,11 @@
  1760. const Util::EnumDataConverter<E>& c,
  1761. Glib::ustring const &suffix = "",
  1762. Glib::ustring const &icon = "",
  1763. - bool mnemonic = true)
  1764. - : Labelled(label, tooltip, new ComboBoxEnum<E>(c), suffix, icon, mnemonic)
  1765. - { }
  1766. + bool mnemonic = true,
  1767. + bool sorted = true)
  1768. + : Labelled(label, tooltip, new ComboBoxEnum<E>(c, SP_ATTR_INVALID, sorted), suffix, icon, mnemonic)
  1769. + {
  1770. + }
  1772. ComboBoxEnum<E>* getCombobox() {
  1773. return static_cast< ComboBoxEnum<E>* > (_widget);
  1775. === added file 'src/ui/widget/font-button.cpp'
  1776. --- src/ui/widget/font-button.cpp 1970-01-01 00:00:00 +0000
  1777. +++ src/ui/widget/font-button.cpp 2016-07-30 00:01:38 +0000
  1778. @@ -0,0 +1,58 @@
  1779. +/*
  1780. + *
  1781. + * Released under GNU GPL. Read the file 'COPYING' for more information.
  1782. + */
  1783. +
  1784. +#ifdef HAVE_CONFIG_H
  1785. +# include <config.h>
  1786. +#endif
  1787. +
  1788. +#include "font-button.h"
  1789. +#include <glibmm/i18n.h>
  1790. +
  1791. +namespace Inkscape {
  1792. +namespace UI {
  1793. +namespace Widget {
  1794. +
  1795. +FontButton::FontButton(Glib::ustring const &label, Glib::ustring const &tooltip,
  1796. + Glib::ustring const &suffix,
  1797. + Glib::ustring const &icon,
  1798. + bool mnemonic)
  1799. + : Labelled(label, tooltip, new Gtk::FontButton("Sans 10"), suffix, icon, mnemonic)
  1800. +{
  1801. +}
  1802. +
  1803. +Glib::ustring FontButton::getValue() const
  1804. +{
  1805. + g_assert(_widget != NULL);
  1806. + return static_cast<Gtk::FontButton*>(_widget)->get_font_name();
  1807. +}
  1808. +
  1809. +
  1810. +void FontButton::setValue (Glib::ustring fontspec)
  1811. +{
  1812. + g_assert(_widget != NULL);
  1813. + static_cast<Gtk::FontButton*>(_widget)->set_font_name(fontspec);
  1814. +}
  1815. +
  1816. +Glib::SignalProxy0<void> FontButton::signal_font_value_changed()
  1817. +{
  1818. + g_assert(_widget != NULL);
  1819. + return static_cast<Gtk::FontButton*>(_widget)->signal_font_set();
  1820. +}
  1821. +
  1822. +
  1823. +} // namespace Widget
  1824. +} // namespace UI
  1825. +} // namespace Inkscape
  1826. +
  1827. +/*
  1828. + Local Variables:
  1829. + mode:c++
  1830. + c-file-style:"stroustrup"
  1831. + c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
  1832. + indent-tabs-mode:nil
  1833. + fill-column:99
  1834. + End:
  1835. +*/
  1836. +// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:fileencoding=utf-8:textwidth=99 :
  1838. === added file 'src/ui/widget/font-button.h'
  1839. --- src/ui/widget/font-button.h 1970-01-01 00:00:00 +0000
  1840. +++ src/ui/widget/font-button.h 2016-07-29 22:58:22 +0000
  1841. @@ -0,0 +1,63 @@
  1842. +/*
  1843. + *
  1844. + * Copyright (C) 2007 Author
  1845. + *
  1846. + * Released under GNU GPL. Read the file 'COPYING' for more information.
  1847. + */
  1848. +
  1849. +#ifndef INKSCAPE_UI_WIDGET_FONT_BUTTON_H
  1850. +#define INKSCAPE_UI_WIDGET_FONT_BUTTON_H
  1851. +
  1852. +#include <gtkmm.h>
  1853. +#include "labelled.h"
  1854. +
  1855. +namespace Inkscape {
  1856. +namespace UI {
  1857. +namespace Widget {
  1858. +
  1859. +/**
  1860. + * A labelled font button for entering font values
  1861. + */
  1862. +class FontButton : public Labelled
  1863. +{
  1864. +public:
  1865. + /**
  1866. + * Construct a FontButton Widget.
  1867. + *
  1868. + * @param label Label.
  1869. + * @param suffix Suffix, placed after the widget (defaults to "").
  1870. + * @param icon Icon filename, placed before the label (defaults to "").
  1871. + * @param mnemonic Mnemonic toggle; if true, an underscore (_) in the label
  1872. + * indicates the next character should be used for the
  1873. + * mnemonic accelerator key (defaults to false).
  1874. + */
  1875. + FontButton( Glib::ustring const &label,
  1876. + Glib::ustring const &tooltip,
  1877. + Glib::ustring const &suffix = "",
  1878. + Glib::ustring const &icon = "",
  1879. + bool mnemonic = true);
  1880. +
  1881. + Glib::ustring getValue() const;
  1882. + void setValue (Glib::ustring fontspec);
  1883. + /**
  1884. + * Signal raised when the font button's value changes.
  1885. + */
  1886. + Glib::SignalProxy0<void> signal_font_value_changed();
  1887. +};
  1888. +
  1889. +} // namespace Widget
  1890. +} // namespace UI
  1891. +} // namespace Inkscape
  1892. +
  1893. +#endif // INKSCAPE_UI_WIDGET_RANDOM_H
  1894. +
  1895. +/*
  1896. + Local Variables:
  1897. + mode:c++
  1898. + c-file-style:"stroustrup"
  1899. + c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
  1900. + indent-tabs-mode:nil
  1901. + fill-column:99
  1902. + End:
  1903. +*/
  1904. +// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:fileencoding=utf-8:textwidth=99 :
  1906. === modified file 'src/ui/widget/registered-enums.h'
  1907. --- src/ui/widget/registered-enums.h 2011-10-25 07:45:35 +0000
  1908. +++ src/ui/widget/registered-enums.h 2016-07-29 18:13:43 +0000
  1909. @@ -33,11 +33,11 @@
  1910. const Util::EnumDataConverter<E>& c,
  1911. Registry& wr,
  1912. Inkscape::XML::Node* repr_in = NULL,
  1913. - SPDocument *doc_in = NULL )
  1914. - : RegisteredWidget< LabelledComboBoxEnum<E> >(label, tip, c)
  1915. + SPDocument *doc_in = NULL,
  1916. + bool sorted = true )
  1917. + : RegisteredWidget< LabelledComboBoxEnum<E> >(label, tip, c, (const Glib::ustring &)"", (const Glib::ustring &)"", true, sorted)
  1918. {
  1919. RegisteredWidget< LabelledComboBoxEnum<E> >::init_parent(key, wr, repr_in, doc_in);
  1920. -
  1921. _changed_connection = combobox()->signal_changed().connect (sigc::mem_fun (*this, &RegisteredEnum::on_changed));
  1922. }
  1925. === modified file 'src/ui/widget/registered-widget.cpp'
  1926. --- src/ui/widget/registered-widget.cpp 2016-07-28 11:26:17 +0000
  1927. +++ src/ui/widget/registered-widget.cpp 2016-07-31 02:52:27 +0000
  1928. @@ -25,6 +25,7 @@
  1929. #include "ui/widget/scalar-unit.h"
  1930. #include "ui/widget/point.h"
  1931. #include "ui/widget/random.h"
  1932. +#include "ui/widget/font-button.h"
  1933. #include "widgets/spinbutton-events.h"
  1935. #include "xml/repr.h"
  1936. @@ -297,7 +298,6 @@
  1937. setProgrammatically = false;
  1938. return;
  1939. }
  1940. -
  1941. if (_wr->isUpdating()) {
  1942. return;
  1943. }
  1944. @@ -803,6 +803,47 @@
  1945. _wr->setUpdating (false);
  1946. }
  1948. +/*#########################################
  1949. + * Registered FONT-BUTTON
  1950. + */
  1951. +
  1952. +RegisteredFontButton::~RegisteredFontButton()
  1953. +{
  1954. + _signal_font_set.disconnect();
  1955. +}
  1956. +
  1957. +RegisteredFontButton::RegisteredFontButton ( const Glib::ustring& label, const Glib::ustring& tip,
  1958. + const Glib::ustring& key, Registry& wr, Inkscape::XML::Node* repr_in,
  1959. + SPDocument* doc_in )
  1960. + : RegisteredWidget<FontButton>(label, tip)
  1961. +{
  1962. + init_parent(key, wr, repr_in, doc_in);
  1963. + _signal_font_set = signal_font_value_changed().connect (sigc::mem_fun (*this, &RegisteredFontButton::on_value_changed));
  1964. +}
  1965. +
  1966. +void
  1967. +RegisteredFontButton::setValue (Glib::ustring fontspec)
  1968. +{
  1969. + FontButton::setValue(fontspec);
  1970. +}
  1971. +
  1972. +void
  1973. +RegisteredFontButton::on_value_changed()
  1974. +{
  1975. +
  1976. + if (_wr->isUpdating())
  1977. + return;
  1978. +
  1979. + _wr->setUpdating (true);
  1980. +
  1981. + Inkscape::SVGOStringStream os;
  1982. + os << getValue();
  1983. +
  1984. + write_to_xml(os.str().c_str());
  1985. +
  1986. + _wr->setUpdating (false);
  1987. +}
  1988. +
  1989. } // namespace Dialog
  1990. } // namespace UI
  1991. } // namespace Inkscape
  1993. === modified file 'src/ui/widget/registered-widget.h'
  1994. --- src/ui/widget/registered-widget.h 2016-07-24 15:05:29 +0000
  1995. +++ src/ui/widget/registered-widget.h 2016-07-29 22:45:14 +0000
  1996. @@ -22,6 +22,7 @@
  1997. #include "ui/widget/text.h"
  1998. #include "ui/widget/random.h"
  1999. #include "ui/widget/unit-menu.h"
  2000. +#include "ui/widget/font-button.h"
  2001. #include "ui/widget/color-picker.h"
  2002. #include "inkscape.h"
  2004. @@ -77,6 +78,8 @@
  2005. RegisteredWidget( A& a, B& b, C c, D d ): W( a, b, c, d ) { construct(); }
  2006. template< typename A, typename B, typename C, typename D, typename E , typename F>
  2007. RegisteredWidget( A& a, B& b, C c, D& d, E& e, F* f): W( a, b, c, d, e, f) { construct(); }
  2008. + template< typename A, typename B, typename C, typename D, typename E , typename F, typename G>
  2009. + RegisteredWidget( A& a, B& b, C& c, D& d, E& e, F f, G& g): W( a, b, c, d, e, f, g) { construct(); }
  2011. virtual ~RegisteredWidget() {};
  2013. @@ -418,6 +421,23 @@
  2014. void on_value_changed();
  2015. };
  2017. +class RegisteredFontButton : public RegisteredWidget<FontButton> {
  2018. +public:
  2019. + virtual ~RegisteredFontButton();
  2020. + RegisteredFontButton ( const Glib::ustring& label,
  2021. + const Glib::ustring& tip,
  2022. + const Glib::ustring& key,
  2023. + Registry& wr,
  2024. + Inkscape::XML::Node* repr_in = NULL,
  2025. + SPDocument *doc_in = NULL);
  2026. +
  2027. + void setValue (Glib::ustring fontspec);
  2028. +
  2029. +protected:
  2030. + sigc::connection _signal_font_set;
  2031. + void on_value_changed();
  2032. +};
  2033. +
  2034. } // namespace Widget
  2035. } // namespace UI
  2036. } // namespace Inkscape
  2038. === modified file 'src/ui/widget/scalar.cpp'
  2039. --- src/ui/widget/scalar.cpp 2014-03-27 01:33:44 +0000
  2040. +++ src/ui/widget/scalar.cpp 2016-07-30 15:23:12 +0000
  2041. @@ -126,10 +126,12 @@
  2042. static_cast<SpinButton*>(_widget)->set_range(min, max);
  2043. }
  2045. -void Scalar::setValue(double value)
  2046. +void Scalar::setValue(double value, bool setProg)
  2047. {
  2048. g_assert(_widget != NULL);
  2049. - setProgrammatically = true; // callback is supposed to reset back, if it cares
  2050. + if (setProg) {
  2051. + setProgrammatically = true; // callback is supposed to reset back, if it cares
  2052. + }
  2053. static_cast<SpinButton*>(_widget)->set_value(value);
  2054. }
  2057. === modified file 'src/ui/widget/scalar.h'
  2058. --- src/ui/widget/scalar.h 2012-04-30 22:04:12 +0000
  2059. +++ src/ui/widget/scalar.h 2016-07-30 15:23:27 +0000
  2060. @@ -139,7 +139,7 @@
  2061. /**
  2062. * Sets the value of the spin button.
  2063. */
  2064. - void setValue(double value);
  2065. + void setValue(double value, bool setProg = true);
  2067. /**
  2068. * Manually forces an update of the spin button.
  2070. === modified file 'src/widgets/font-selector.cpp'
  2071. --- src/widgets/font-selector.cpp 2016-07-28 11:26:17 +0000
  2072. +++ src/widgets/font-selector.cpp 2016-07-22 19:59:31 +0000
  2073. @@ -19,9 +19,6 @@
  2074. # include "config.h"
  2075. #endif
  2077. -#include <libnrtype/font-lister.h>
  2078. -#include <libnrtype/font-instance.h>
  2079. -
  2080. #include <2geom/transforms.h>
  2082. #include <gtk/gtk.h>
  2083. @@ -34,29 +31,7 @@
  2085. /* SPFontSelector */
  2087. -struct SPFontSelector
  2088. -{
  2089. -#if GTK_CHECK_VERSION(3,0,0)
  2090. - GtkBox hbox;
  2091. -#else
  2092. - GtkHBox hbox;
  2093. -#endif
  2094. -
  2095. - unsigned int block_emit : 1;
  2096. -
  2097. - GtkWidget *family;
  2098. - GtkWidget *style;
  2099. - GtkWidget *size;
  2100. -
  2101. - GtkWidget *family_treeview;
  2102. - GtkWidget *style_treeview;
  2103. -
  2104. - NRNameList families;
  2105. - NRStyleList styles;
  2106. - gfloat fontsize;
  2107. - bool fontsize_dirty;
  2108. - Glib::ustring *fontspec;
  2109. -};
  2110. +
  2113. struct SPFontSelectorClass
  2114. @@ -274,6 +249,7 @@
  2116. if (fsel->fontspec) {
  2117. delete fsel->fontspec;
  2118. + fsel->fontspec = 0;
  2119. }
  2121. if (fsel->families.length > 0) {
  2123. === modified file 'src/widgets/font-selector.h'
  2124. --- src/widgets/font-selector.h 2014-08-18 20:19:55 +0000
  2125. +++ src/widgets/font-selector.h 2016-07-22 19:59:29 +0000
  2126. @@ -15,10 +15,33 @@
  2127. *
  2128. * Released under GNU GPL, read the file 'COPYING' for more information
  2129. */
  2130. -
  2131. +#include <libnrtype/font-lister.h>
  2132. +#include <libnrtype/font-instance.h>
  2133. #include <glib.h>
  2135. -struct SPFontSelector;
  2136. +struct SPFontSelector
  2137. +{
  2138. +#if GTK_CHECK_VERSION(3,0,0)
  2139. + GtkBox hbox;
  2140. +#else
  2141. + GtkHBox hbox;
  2142. +#endif
  2143. +
  2144. + unsigned int block_emit : 1;
  2145. +
  2146. + GtkWidget *family;
  2147. + GtkWidget *style;
  2148. + GtkWidget *size;
  2149. +
  2150. + GtkWidget *family_treeview;
  2151. + GtkWidget *style_treeview;
  2152. +
  2153. + NRNameList families;
  2154. + NRStyleList styles;
  2155. + gfloat fontsize;
  2156. + bool fontsize_dirty;
  2157. + Glib::ustring *fontspec;
  2158. +};
  2160. #define SP_TYPE_FONT_SELECTOR (sp_font_selector_get_type ())
  2161. #define SP_FONT_SELECTOR(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), SP_TYPE_FONT_SELECTOR, SPFontSelector))
  1. More ...
 
 

101

 

859

Measure LIne LPE DIFF V.15033

par Jabiertxo Arraiza Cenoz

-

PasteBin

Lignes
2161
Mots
6863
Taille
76,4 Kio
Créé le
Type
text/plain
General Public License v2 (GPLv2)
Connectez-vous pour ajouter un commentaire !

Inkscape est un logiciel libre et open source sous licence GPL.