lpe-pts2ellipse: added perspective circle from 4 points

improved tool-tips for better usability

2 files changed, 94 insertions, 130 deletions

diff --git a/src/live_effects/parameter/parameter.cpp b/src/live_effects/parameter/parameter.cpp
index a235e6076..50137ec36 100644
--- a/src/live_effects/parameter/parameter.cpp
+++ b/src/live_effects/parameter/parameter.cpp
@@ -6,8 +6,8 @@
  */
 
 
-#include "live_effects/effect.h"
 #include "live_effects/parameter/parameter.h"
+#include "live_effects/effect.h"
 #include "svg/svg.h"
 #include "xml/repr.h"
 
@@ -26,29 +26,27 @@ namespace Inkscape {
 namespace LivePathEffect {
 
 
-Parameter::Parameter( Glib::ustring  label, Glib::ustring  tip,
-                      Glib::ustring  key, Inkscape::UI::Widget::Registry* wr,
-                      Effect* effect )
-    : param_key(std::move(key)),
-      param_wr(wr),
-      param_label(std::move(label)),
-      oncanvas_editable(false),
-      widget_is_visible(true),
-      widget_is_enabled(true),
-      param_tooltip(std::move(tip)),
-      param_effect(effect)
+Parameter::Parameter(Glib::ustring label, Glib::ustring tip, Glib::ustring key, Inkscape::UI::Widget::Registry *wr,
+                     Effect *effect)
+    : param_key(std::move(key))
+    , param_wr(wr)
+    , param_label(std::move(label))
+    , oncanvas_editable(false)
+    , widget_is_visible(true)
+    , widget_is_enabled(true)
+    , param_tooltip(std::move(tip))
+    , param_effect(effect)
 {
 }
 
-void
-Parameter::param_write_to_repr(const char * svgd)
+void Parameter::param_write_to_repr(const char *svgd)
 {
     param_effect->getRepr()->setAttribute(param_key.c_str(), svgd);
 }
 
 void Parameter::write_to_SVG()
 {
-    gchar * str = param_getSVGValue();
+    gchar *str = param_getSVGValue();
     param_write_to_repr(str);
     g_free(str);
 }
@@ -56,28 +54,25 @@ void Parameter::write_to_SVG()
 /*###########################################
  *   REAL PARAM
  */
-ScalarParam::ScalarParam( const Glib::ustring& label, const Glib::ustring& tip,
-                      const Glib::ustring& key, Inkscape::UI::Widget::Registry* wr,
-                      Effect* effect, gdouble default_value)
-    : Parameter(label, tip, key, wr, effect),
-      value(default_value),
-      min(-SCALARPARAM_G_MAXDOUBLE),
-      max(SCALARPARAM_G_MAXDOUBLE),
-      integer(false),
-      defvalue(default_value),
-      digits(2),
-      inc_step(0.1),
-      inc_page(1),
-      add_slider(false),
-      _set_undo(true)
+ScalarParam::ScalarParam(const Glib::ustring &label, const Glib::ustring &tip, const Glib::ustring &key,
+                         Inkscape::UI::Widget::Registry *wr, Effect *effect, gdouble default_value)
+    : Parameter(label, tip, key, wr, effect)
+    , value(default_value)
+    , min(-SCALARPARAM_G_MAXDOUBLE)
+    , max(SCALARPARAM_G_MAXDOUBLE)
+    , integer(false)
+    , defvalue(default_value)
+    , digits(2)
+    , inc_step(0.1)
+    , inc_page(1)
+    , add_slider(false)
+    , _set_undo(true)
 {
 }
 
-ScalarParam::~ScalarParam()
-= default;
+ScalarParam::~ScalarParam() = default;
 
-bool
-ScalarParam::param_readSVGValue(const gchar * strvalue)
+bool ScalarParam::param_readSVGValue(const gchar *strvalue)
 {
     double newval;
     unsigned int success = sp_svg_number_read_d(strvalue, &newval);
@@ -88,36 +83,25 @@ ScalarParam::param_readSVGValue(const gchar * strvalue)
     return false;
 }
 
-gchar *
-ScalarParam::param_getSVGValue() const
+gchar *ScalarParam::param_getSVGValue() const
 {
     Inkscape::SVGOStringStream os;
     os << value;
     return g_strdup(os.str().c_str());
 }
 
-gchar *
-ScalarParam::param_getDefaultSVGValue() const
+gchar *ScalarParam::param_getDefaultSVGValue() const
 {
     Inkscape::SVGOStringStream os;
     os << defvalue;
-    return  g_strdup(os.str().c_str());
+    return g_strdup(os.str().c_str());
 }
 
-void
-ScalarParam::param_set_default()
-{
-    param_set_value(defvalue);
-}
+void ScalarParam::param_set_default() { param_set_value(defvalue); }
 
-void 
-ScalarParam::param_update_default(gdouble default_value)
-{
-    defvalue = default_value;
-}
+void ScalarParam::param_update_default(gdouble default_value) { defvalue = default_value; }
 
-void 
-ScalarParam::param_update_default(const gchar * default_value)
+void ScalarParam::param_update_default(const gchar *default_value)
 {
     double newval;
     unsigned int success = sp_svg_number_read_d(default_value, &newval);
@@ -126,8 +110,7 @@ ScalarParam::param_update_default(const gchar * default_value)
     }
 }
 
-void
-ScalarParam::param_set_value(gdouble val)
+void ScalarParam::param_set_value(gdouble val)
 {
     value = val;
     if (integer)
@@ -138,8 +121,7 @@ ScalarParam::param_set_value(gdouble val)
         value = min;
 }
 
-void
-ScalarParam::param_set_range(gdouble min, gdouble max)
+void ScalarParam::param_set_range(gdouble min, gdouble max)
 {
     // if you look at client code, you'll see that many effects
     // has a tendency to set an upper range of Geom::infinity().
@@ -159,8 +141,7 @@ ScalarParam::param_set_range(gdouble min, gdouble max)
     param_set_value(value); // reset value to see whether it is in ranges
 }
 
-void
-ScalarParam::param_make_integer(bool yes)
+void ScalarParam::param_make_integer(bool yes)
 {
     integer = yes;
     digits = 0;
@@ -168,19 +149,14 @@ ScalarParam::param_make_integer(bool yes)
     inc_page = 10;
 }
 
-void
-ScalarParam::param_set_undo(bool set_undo)
-{
-    _set_undo = set_undo;
-}
+void ScalarParam::param_set_undo(bool set_undo) { _set_undo = set_undo; }
 
-Gtk::Widget *
-ScalarParam::param_newWidget()
+Gtk::Widget *ScalarParam::param_newWidget()
 {
     if (widget_is_visible) {
-        Inkscape::UI::Widget::RegisteredScalar *rsu = Gtk::manage( new Inkscape::UI::Widget::RegisteredScalar(
-            param_label, param_tooltip, param_key, *param_wr, param_effect->getRepr(), param_effect->getSPDoc() ) );
-        
+        Inkscape::UI::Widget::RegisteredScalar *rsu = Gtk::manage(new Inkscape::UI::Widget::RegisteredScalar(
+            param_label, param_tooltip, param_key, *param_wr, param_effect->getRepr(), param_effect->getSPDoc()));
+
         rsu->setValue(value);
         rsu->setDigits(digits);
         rsu->setIncrements(inc_step, inc_page);
@@ -189,23 +165,18 @@ ScalarParam::param_newWidget()
         if (add_slider) {
             rsu->addSlider();
         }
-        if(_set_undo){
+        if (_set_undo) {
             rsu->set_undo_parameters(SP_VERB_DIALOG_LIVE_PATH_EFFECT, _("Change scalar parameter"));
         }
-        return dynamic_cast<Gtk::Widget *> (rsu);
+        return dynamic_cast<Gtk::Widget *>(rsu);
     } else {
         return nullptr;
     }
 }
 
-void
-ScalarParam::param_set_digits(unsigned digits)
-{
-    this->digits = digits;
-}
+void ScalarParam::param_set_digits(unsigned digits) { this->digits = digits; }
 
-void
-ScalarParam::param_set_increments(double step, double page)
+void ScalarParam::param_set_increments(double step, double page)
 {
     inc_step = step;
     inc_page = page;
@@ -213,7 +184,6 @@ ScalarParam::param_set_increments(double step, double page)
 
 
 
-
 } /* namespace LivePathEffect */
 } /* namespace Inkscape */
 
diff --git a/src/live_effects/parameter/parameter.h b/src/live_effects/parameter/parameter.h
index 62684b730..b3cbc039e 100644
--- a/src/live_effects/parameter/parameter.h
+++ b/src/live_effects/parameter/parameter.h
@@ -10,17 +10,18 @@
  * Released under GNU GPL v2+, read the file 'COPYING' for more information.
  */
 
-#include <glibmm/ustring.h>
+#include "ui/widget/registered-widget.h"
 #include <2geom/forward.h>
 #include <2geom/pathvector.h>
-#include "ui/widget/registered-widget.h"
+#include <glibmm/ustring.h>
 
 // In gtk2, this wasn't an issue; we could toss around
 // G_MAXDOUBLE and not worry about size allocations. But
 // in gtk3, it is an issue: it allocates widget size for the maxmium
 // value you pass to it, leading to some insane lengths.
 // If you need this to be more, please be conservative about it.
-const double SCALARPARAM_G_MAXDOUBLE = 10000000000.0; // TODO fixme: using an arbitrary large number as a magic value seems fragile.
+const double SCALARPARAM_G_MAXDOUBLE =
+    10000000000.0; // TODO fixme: using an arbitrary large number as a magic value seems fragile.
 
 class KnotHolder;
 class SPLPEItem;
@@ -28,97 +29,90 @@ class SPDesktop;
 class SPItem;
 
 namespace Gtk {
-    class Widget;
+class Widget;
 }
 
 namespace Inkscape {
 
 namespace NodePath {
-    class Path ;
+class Path;
 }
 
 namespace UI {
 namespace Widget {
-    class Registry;
-}
+class Registry;
 }
+} // namespace UI
 
 namespace LivePathEffect {
 
 class Effect;
 
 class Parameter {
-public:
-    Parameter(  Glib::ustring  label,
-                Glib::ustring  tip,
-                Glib::ustring  key,
-                Inkscape::UI::Widget::Registry* wr,
-                Effect* effect);
-    virtual ~Parameter() = default;;
-
-    Parameter(const Parameter&) = delete;
-    Parameter& operator=(const Parameter&) = delete;
-
-    virtual bool param_readSVGValue(const gchar * strvalue) = 0;   // returns true if new value is valid / accepted.
-    virtual gchar * param_getSVGValue() const = 0;
-    virtual gchar * param_getDefaultSVGValue() const = 0;
-    virtual void param_widget_is_visible(bool is_visible) {widget_is_visible = is_visible;}
-    virtual void param_widget_is_enabled(bool is_enabled) {widget_is_enabled = is_enabled;}
+  public:
+    Parameter(Glib::ustring label, Glib::ustring tip, Glib::ustring key, Inkscape::UI::Widget::Registry *wr,
+              Effect *effect);
+    virtual ~Parameter() = default;
+    ;
+
+    Parameter(const Parameter &) = delete;
+    Parameter &operator=(const Parameter &) = delete;
+
+    virtual bool param_readSVGValue(const gchar *strvalue) = 0; // returns true if new value is valid / accepted.
+    virtual gchar *param_getSVGValue() const = 0;
+    virtual gchar *param_getDefaultSVGValue() const = 0;
+    virtual void param_widget_is_visible(bool is_visible) { widget_is_visible = is_visible; }
+    virtual void param_widget_is_enabled(bool is_enabled) { widget_is_enabled = is_enabled; }
     void write_to_SVG();
- 
+
     virtual void param_set_default() = 0;
-    virtual void param_update_default(const gchar * default_value) = 0;
+    virtual void param_update_default(const gchar *default_value) = 0;
     // This creates a new widget (newed with Gtk::manage(new ...);)
-    virtual Gtk::Widget * param_newWidget() = 0;
+    virtual Gtk::Widget *param_newWidget() = 0;
 
-    virtual Glib::ustring * param_getTooltip() { return &param_tooltip; };
+    virtual Glib::ustring *param_getTooltip() { return &param_tooltip; };
 
     // overload these for your particular parameter to make it provide knotholder handles or canvas helperpaths
     virtual bool providesKnotHolderEntities() const { return false; }
-    virtual void addKnotHolderEntities(KnotHolder */*knotholder*/, SPItem */*item*/) {};
-    virtual void addCanvasIndicators(SPLPEItem const*/*lpeitem*/, std::vector<Geom::PathVector> &/*hp_vec*/) {};
+    virtual void addKnotHolderEntities(KnotHolder * /*knotholder*/, SPItem * /*item*/){};
+    virtual void addCanvasIndicators(SPLPEItem const * /*lpeitem*/, std::vector<Geom::PathVector> & /*hp_vec*/){};
 
-    virtual void param_editOncanvas(SPItem * /*item*/, SPDesktop * /*dt*/) {};
-    virtual void param_setup_nodepath(Inkscape::NodePath::Path */*np*/) {};
+    virtual void param_editOncanvas(SPItem * /*item*/, SPDesktop * /*dt*/){};
+    virtual void param_setup_nodepath(Inkscape::NodePath::Path * /*np*/){};
 
-    virtual void param_transform_multiply(Geom::Affine const& /*postmul*/, bool /*set*/) {};
+    virtual void param_transform_multiply(Geom::Affine const & /*postmul*/, bool /*set*/){};
 
     Glib::ustring param_key;
     Glib::ustring param_tooltip;
-    Inkscape::UI::Widget::Registry * param_wr;
+    Inkscape::UI::Widget::Registry *param_wr;
     Glib::ustring param_label;
 
     bool oncanvas_editable;
     bool widget_is_visible;
     bool widget_is_enabled;
 
-protected:
-
-    Effect* param_effect;
+  protected:
+    Effect *param_effect;
 
-    void param_write_to_repr(const char * svgd);
+    void param_write_to_repr(const char *svgd);
 };
 
 
 class ScalarParam : public Parameter {
-public:
-    ScalarParam(  const Glib::ustring& label,
-                const Glib::ustring& tip,
-                const Glib::ustring& key,
-                Inkscape::UI::Widget::Registry* wr,
-                Effect* effect,
-                gdouble default_value = 1.0);
+  public:
+    ScalarParam(const Glib::ustring &label, const Glib::ustring &tip, const Glib::ustring &key,
+                Inkscape::UI::Widget::Registry *wr, Effect *effect, gdouble default_value = 1.0);
     ~ScalarParam() override;
-    ScalarParam(const ScalarParam&) = delete;
-    ScalarParam& operator=(const ScalarParam&) = delete;
+    ScalarParam(const ScalarParam &) = delete;
+    ScalarParam &operator=(const ScalarParam &) = delete;
 
-    bool param_readSVGValue(const gchar * strvalue) override;
-    gchar * param_getSVGValue() const override;
-    gchar * param_getDefaultSVGValue() const override;
+    bool param_readSVGValue(const gchar *strvalue) override;
+    gchar *param_getSVGValue() const override;
+    gchar *param_getDefaultSVGValue() const override;
 
     void param_set_default() override;
     void param_update_default(gdouble default_value);
-    void param_update_default(const gchar * default_value) override;
+    void param_update_default(const gchar *default_value) override;
     void param_set_value(gdouble val);
     void param_make_integer(bool yes = true);
     void param_set_range(gdouble min, gdouble max);
@@ -128,11 +122,11 @@ public:
     double param_get_max() { return max; };
     double param_get_min() { return min; };
     void param_set_undo(bool set_undo);
-    Gtk::Widget * param_newWidget() override;
+    Gtk::Widget *param_newWidget() override;
 
     inline operator gdouble() const { return value; };
 
-protected:
+  protected:
     gdouble value;
     gdouble min;
     gdouble max;
@@ -145,9 +139,9 @@ protected:
     bool _set_undo;
 };
 
-} //namespace LivePathEffect
+} // namespace LivePathEffect
 
-} //namespace Inkscape
+} // namespace Inkscape
 
 #endif