From 0459094999e0298341ecad677464043528d1036f Mon Sep 17 00:00:00 2001
From: "Jon A. Cruz" <jon@joncruz.org>
Date: Wed, 9 May 2012 00:54:48 -0700
Subject: Centralized line creation and enhanced visibility.

(bzr r11350)
---
 src/measure-context.cpp | 21 +++++++++++++--------
 1 file changed, 13 insertions(+), 8 deletions(-)

(limited to 'src/measure-context.cpp')

diff --git a/src/measure-context.cpp b/src/measure-context.cpp
index e522c44a5..f45e5e472 100644
--- a/src/measure-context.cpp
+++ b/src/measure-context.cpp
@@ -41,7 +41,9 @@
 #include "snap.h"
 #include "sp-namedview.h"
 #include "enums.h"
+#include "ui/control-manager.h"
 
+using Inkscape::ControlManager;
 
 static void sp_measure_context_class_init(SPMeasureContextClass *klass);
 static void sp_measure_context_init(SPMeasureContext *measure_context);
@@ -260,8 +262,7 @@ static gint sp_measure_context_root_handler(SPEventContext *event_context, GdkEv
 
 
                 //draw control line
-                SPCtrlLine *control_line = SP_CTRLLINE(sp_canvas_item_new(sp_desktop_tempgroup(desktop), SP_TYPE_CTRLLINE, NULL));
-                control_line->setCoords(start_point, end_point);
+                SPCtrlLine *control_line = ControlManager::getManager().createControlLine(sp_desktop_tempgroup(desktop), start_point, end_point);
                 measure_tmp_items.push_back(desktop->add_temporary_canvasitem(control_line, 0));
 
                 Geom::PathVector lineseg;
@@ -432,16 +433,20 @@ static gint sp_measure_context_root_handler(SPEventContext *event_context, GdkEv
 
                 Geom::Point normal = desktop->w2d(Geom::unit_vector(Geom::rot90(desktop->d2w(end_point - start_point))));
                 if (intersections.size() > 2) {
-                    control_line = SP_CTRLLINE(sp_canvas_item_new(sp_desktop_tempgroup (desktop), SP_TYPE_CTRLLINE, NULL));
-                    control_line->setCoords(desktop->doc2dt(intersections[0]) + normal*60, desktop->doc2dt(intersections[intersections.size()-1]) + normal*60);
+                    ControlManager &mgr = ControlManager::getManager();
+                    control_line = mgr.createControlLine(sp_desktop_tempgroup(desktop),
+                                                         desktop->doc2dt(intersections[0]) + normal * 60,
+                                                         desktop->doc2dt(intersections[intersections.size() - 1]) + normal * 60);
                     measure_tmp_items.push_back(desktop->add_temporary_canvasitem(control_line, 0));
 
-                    control_line = SP_CTRLLINE(sp_canvas_item_new(sp_desktop_tempgroup (desktop), SP_TYPE_CTRLLINE, NULL));
-                    control_line->setCoords(desktop->doc2dt(intersections[0]), desktop->doc2dt(intersections[0]) + normal*65);
+                    control_line = mgr.createControlLine(sp_desktop_tempgroup(desktop),
+                                                         desktop->doc2dt(intersections[0]),
+                                                         desktop->doc2dt(intersections[0]) + normal * 65);
                     measure_tmp_items.push_back(desktop->add_temporary_canvasitem(control_line, 0));
 
-                    control_line = SP_CTRLLINE(sp_canvas_item_new(sp_desktop_tempgroup (desktop), SP_TYPE_CTRLLINE, NULL));
-                    control_line->setCoords(desktop->doc2dt(intersections[intersections.size()-1]), desktop->doc2dt(intersections[intersections.size()-1]) + normal*65);
+                    control_line = mgr.createControlLine(sp_desktop_tempgroup(desktop),
+                                                         desktop->doc2dt(intersections[intersections.size() - 1]),
+                                                         desktop->doc2dt(intersections[intersections.size() - 1]) + normal * 65);
                     measure_tmp_items.push_back(desktop->add_temporary_canvasitem(control_line, 0));
 
                     double totallengthval = (intersections[intersections.size()-1] - intersections[0]).length();
-- 
cgit v1.2.3


From 34811f773f9cfaac08aa8973536fb05a8bf4bb7d Mon Sep 17 00:00:00 2001
From: "Jon A. Cruz" <jon@joncruz.org>
Date: Sun, 27 May 2012 15:54:53 -0700
Subject: Reorder measure context item painting for better legibility.

(bzr r11428)
---
 src/measure-context.cpp | 86 ++++++++++++++++++++++++++++---------------------
 1 file changed, 49 insertions(+), 37 deletions(-)

(limited to 'src/measure-context.cpp')

diff --git a/src/measure-context.cpp b/src/measure-context.cpp
index f45e5e472..4aa007464 100644
--- a/src/measure-context.cpp
+++ b/src/measure-context.cpp
@@ -261,10 +261,6 @@ static gint sp_measure_context_root_handler(SPEventContext *event_context, GdkEv
                 }
 
 
-                //draw control line
-                SPCtrlLine *control_line = ControlManager::getManager().createControlLine(sp_desktop_tempgroup(desktop), start_point, end_point);
-                measure_tmp_items.push_back(desktop->add_temporary_canvasitem(control_line, 0));
-
                 Geom::PathVector lineseg;
                 Geom::Path p;
                 p.start(desktop->dt2doc(start_point));
@@ -347,23 +343,6 @@ static gint sp_measure_context_root_handler(SPEventContext *event_context, GdkEv
                     std::sort(intersections.begin(), intersections.end(), GeomPointSortPredicate);
                 }
 
-                for (size_t idx = 0; idx < intersections.size(); ++idx) {
-                    // Display the intersection indicator (i.e. the cross)
-                    SPCanvasItem * canvasitem = NULL;
-                    canvasitem = sp_canvas_item_new(sp_desktop_tempgroup(desktop),
-                                                    SP_TYPE_CTRL,
-                                                    "anchor", SP_ANCHOR_CENTER,
-                                                    "size", 8.0,
-                                                    "stroked", TRUE,
-                                                    "stroke_color", 0xff0000ff,
-                                                    "mode", SP_KNOT_MODE_XOR,
-                                                    "shape", SP_KNOT_SHAPE_CROSS,
-                                                    NULL );
-
-                    SP_CTRL(canvasitem)->moveto(desktop->doc2dt(intersections[idx]));
-                    measure_tmp_items.push_back(desktop->add_temporary_canvasitem(canvasitem, 0));
-                }
-
                 SPUnitId unitid = static_cast<SPUnitId>(prefs->getInt("/tools/measure/unitid", SP_UNIT_PX));
                 SPUnit unit = sp_unit_get_by_id(unitid);
 
@@ -413,6 +392,7 @@ static gint sp_measure_context_root_handler(SPEventContext *event_context, GdkEv
                     measure_tmp_items.push_back(desktop->add_temporary_canvasitem(canvas_tooltip, 0));
                     free(angle_str);
                 }
+
                 {
                     double totallengthval = (end_point - start_point).length();
                     sp_convert_distance(&totallengthval, &sp_unit_get_by_id(SP_UNIT_PX), &unit);
@@ -431,24 +411,10 @@ static gint sp_measure_context_root_handler(SPEventContext *event_context, GdkEv
                     free(totallength_str);
                 }
 
+                // Normal will be used for lines and text
                 Geom::Point normal = desktop->w2d(Geom::unit_vector(Geom::rot90(desktop->d2w(end_point - start_point))));
-                if (intersections.size() > 2) {
-                    ControlManager &mgr = ControlManager::getManager();
-                    control_line = mgr.createControlLine(sp_desktop_tempgroup(desktop),
-                                                         desktop->doc2dt(intersections[0]) + normal * 60,
-                                                         desktop->doc2dt(intersections[intersections.size() - 1]) + normal * 60);
-                    measure_tmp_items.push_back(desktop->add_temporary_canvasitem(control_line, 0));
-
-                    control_line = mgr.createControlLine(sp_desktop_tempgroup(desktop),
-                                                         desktop->doc2dt(intersections[0]),
-                                                         desktop->doc2dt(intersections[0]) + normal * 65);
-                    measure_tmp_items.push_back(desktop->add_temporary_canvasitem(control_line, 0));
-
-                    control_line = mgr.createControlLine(sp_desktop_tempgroup(desktop),
-                                                         desktop->doc2dt(intersections[intersections.size() - 1]),
-                                                         desktop->doc2dt(intersections[intersections.size() - 1]) + normal * 65);
-                    measure_tmp_items.push_back(desktop->add_temporary_canvasitem(control_line, 0));
 
+                if (intersections.size() > 2) {
                     double totallengthval = (intersections[intersections.size()-1] - intersections[0]).length();
                     sp_convert_distance(&totallengthval, &sp_unit_get_by_id(SP_UNIT_PX), &unit);
 
@@ -468,6 +434,52 @@ static gint sp_measure_context_root_handler(SPEventContext *event_context, GdkEv
                     free(total_str);
                 }
 
+                // Now that text has been added, we can add lines and controls so that they go underneath
+
+                for (size_t idx = 0; idx < intersections.size(); ++idx) {
+                    // Display the intersection indicator (i.e. the cross)
+                    SPCanvasItem * canvasitem = NULL;
+                    canvasitem = sp_canvas_item_new(sp_desktop_tempgroup(desktop),
+                                                    SP_TYPE_CTRL,
+                                                    "anchor", SP_ANCHOR_CENTER,
+                                                    "size", 8.0,
+                                                    "stroked", TRUE,
+                                                    "stroke_color", 0xff0000ff,
+                                                    "mode", SP_KNOT_MODE_XOR,
+                                                    "shape", SP_KNOT_SHAPE_CROSS,
+                                                    NULL );
+
+                    SP_CTRL(canvasitem)->moveto(desktop->doc2dt(intersections[idx]));
+                    measure_tmp_items.push_back(desktop->add_temporary_canvasitem(canvasitem, 0));
+                }
+
+                // Since adding goes to the bottom, do all lines last.
+
+                if (intersections.size() > 2) {
+                    ControlManager &mgr = ControlManager::getManager();
+                    SPCtrlLine *control_line = 0;
+                    control_line = mgr.createControlLine(sp_desktop_tempgroup(desktop),
+                                                         desktop->doc2dt(intersections[0]) + normal * 60,
+                                                         desktop->doc2dt(intersections[intersections.size() - 1]) + normal * 60);
+                    measure_tmp_items.push_back(desktop->add_temporary_canvasitem(control_line, 0));
+
+                    control_line = mgr.createControlLine(sp_desktop_tempgroup(desktop),
+                                                         desktop->doc2dt(intersections[0]),
+                                                         desktop->doc2dt(intersections[0]) + normal * 65);
+                    measure_tmp_items.push_back(desktop->add_temporary_canvasitem(control_line, 0));
+
+                    control_line = mgr.createControlLine(sp_desktop_tempgroup(desktop),
+                                                         desktop->doc2dt(intersections[intersections.size() - 1]),
+                                                         desktop->doc2dt(intersections[intersections.size() - 1]) + normal * 65);
+                    measure_tmp_items.push_back(desktop->add_temporary_canvasitem(control_line, 0));
+                }
+
+                // draw main control line
+                {
+                    SPCtrlLine *control_line = ControlManager::getManager().createControlLine(sp_desktop_tempgroup(desktop), start_point, end_point);
+                    measure_tmp_items.push_back(desktop->add_temporary_canvasitem(control_line, 0));
+                }
+
                 gobble_motion_events(GDK_BUTTON1_MASK);
             }
             break;
-- 
cgit v1.2.3


From e9cec1110c7abef2d7c89161ca07d2819a7bdff1 Mon Sep 17 00:00:00 2001
From: "Jon A. Cruz" <jon@joncruz.org>
Date: Mon, 28 May 2012 00:27:39 -0700
Subject: Cleanup of measure text for moving away from overlap.

(bzr r11430)
---
 src/measure-context.cpp | 98 ++++++++++++++++++++++++++-----------------------
 1 file changed, 53 insertions(+), 45 deletions(-)

(limited to 'src/measure-context.cpp')

diff --git a/src/measure-context.cpp b/src/measure-context.cpp
index 4aa007464..db6183d71 100644
--- a/src/measure-context.cpp
+++ b/src/measure-context.cpp
@@ -353,6 +353,10 @@ static gint sp_measure_context_root_handler(SPEventContext *event_context, GdkEv
                     previous_point = intersections[0];
                 }
 
+
+                // Normal will be used for lines and text
+                Geom::Point normal = desktop->w2d(Geom::unit_vector(Geom::rot90(desktop->d2w(end_point - start_point))));
+
                 for (size_t idx = 1; idx < intersections.size(); ++idx) {
                     Geom::Point measure_text_pos = (previous_point + intersections[idx]) / 2;
 //TODO: shift label a few pixels in the y coordinate
@@ -361,77 +365,81 @@ static gint sp_measure_context_root_handler(SPEventContext *event_context, GdkEv
                     sp_convert_distance(&lengthval, &sp_unit_get_by_id(SP_UNIT_PX), &unit);
 
                     // TODO cleanup memory, Glib::ustring, etc.:
-                    char* measure_str = static_cast<char*>(malloc(20));
-                    sprintf(measure_str, "%.2f %s", lengthval, unit.abbr);
-                    SPCanvasItem *canvas_tooltip = sp_canvastext_new(sp_desktop_tempgroup(desktop), desktop, desktop->doc2dt(measure_text_pos), measure_str);
-
-                    sp_canvastext_set_fontsize(SP_CANVASTEXT(canvas_tooltip), fontsize);
-                    SP_CANVASTEXT(canvas_tooltip)->rgba = 0xffffffff;
-                    SP_CANVASTEXT(canvas_tooltip)->rgba_background = 0x0000007f;
-                    SP_CANVASTEXT(canvas_tooltip)->outline = false;
-                    SP_CANVASTEXT(canvas_tooltip)->background = true;
-                    SP_CANVASTEXT(canvas_tooltip)->anchor_position = TEXT_ANCHOR_CENTER;
+                    gchar *measure_str = g_strdup_printf("%.2f %s", lengthval, unit.abbr);
+                    SPCanvasText *canvas_tooltip = sp_canvastext_new(sp_desktop_tempgroup(desktop),
+                                                                     desktop,
+                                                                     desktop->doc2dt(measure_text_pos),
+                                                                     measure_str);
+                    sp_canvastext_set_fontsize(canvas_tooltip, fontsize);
+                    canvas_tooltip->rgba = 0xffffffff;
+                    canvas_tooltip->rgba_background = 0x0000007f;
+                    canvas_tooltip->outline = false;
+                    canvas_tooltip->background = true;
+                    canvas_tooltip->anchor_position = TEXT_ANCHOR_CENTER;
 
                     measure_tmp_items.push_back(desktop->add_temporary_canvasitem(canvas_tooltip, 0));
-                    free(measure_str);
+                    g_free(measure_str);
                     previous_point = intersections[idx];
                 }
 
                 {
                     // TODO cleanup memory, Glib::ustring, etc.:
-                    char* angle_str = static_cast<char*>(malloc(20));
-                    sprintf(angle_str, "%.2f °", angle * 180/M_PI);
-                    SPCanvasItem *canvas_tooltip = sp_canvastext_new(sp_desktop_tempgroup(desktop), desktop, end_point + desktop->w2d(Geom::Point(3*fontsize, fontsize)), angle_str);
-                    sp_canvastext_set_fontsize(SP_CANVASTEXT(canvas_tooltip), fontsize);
-                    SP_CANVASTEXT(canvas_tooltip)->rgba = 0xffffffff;
-                    SP_CANVASTEXT(canvas_tooltip)->rgba_background = 0x337f337f;
-                    SP_CANVASTEXT(canvas_tooltip)->outline = false;
-                    SP_CANVASTEXT(canvas_tooltip)->background = true;
-                    SP_CANVASTEXT(canvas_tooltip)->anchor_position = TEXT_ANCHOR_LEFT;
+                    gchar *angle_str = g_strdup_printf("%.2f °", angle * 180/M_PI);
+                    SPCanvasText *canvas_tooltip = sp_canvastext_new(sp_desktop_tempgroup(desktop),
+                                                                     desktop,
+                                                                     end_point + desktop->w2d(Geom::Point(3*fontsize, fontsize)),
+                                                                     angle_str);
+                    sp_canvastext_set_fontsize(canvas_tooltip, fontsize);
+                    canvas_tooltip->rgba = 0xffffffff;
+                    canvas_tooltip->rgba_background = 0x337f337f;
+                    canvas_tooltip->outline = false;
+                    canvas_tooltip->background = true;
+                    canvas_tooltip->anchor_position = TEXT_ANCHOR_LEFT;
 
                     measure_tmp_items.push_back(desktop->add_temporary_canvasitem(canvas_tooltip, 0));
-                    free(angle_str);
+                    g_free(angle_str);
                 }
 
                 {
                     double totallengthval = (end_point - start_point).length();
                     sp_convert_distance(&totallengthval, &sp_unit_get_by_id(SP_UNIT_PX), &unit);
 
-                    char* totallength_str = static_cast<char*>(malloc(20));
-                    sprintf(totallength_str, "%.2f %s", totallengthval, unit.abbr);
-                    SPCanvasItem *canvas_tooltip = sp_canvastext_new(sp_desktop_tempgroup(desktop), desktop, end_point + desktop->w2d(Geom::Point(3*fontsize, -fontsize)), totallength_str);
-                    sp_canvastext_set_fontsize(SP_CANVASTEXT(canvas_tooltip), fontsize);
-                    SP_CANVASTEXT(canvas_tooltip)->rgba = 0xffffffff;
-                    SP_CANVASTEXT(canvas_tooltip)->rgba_background = 0x3333337f;
-                    SP_CANVASTEXT(canvas_tooltip)->outline = false;
-                    SP_CANVASTEXT(canvas_tooltip)->background = true;
-                    SP_CANVASTEXT(canvas_tooltip)->anchor_position = TEXT_ANCHOR_LEFT;
+                    // TODO cleanup memory, Glib::ustring, etc.:
+                    gchar *totallength_str = g_strdup_printf("%.2f %s", totallengthval, unit.abbr);
+                    SPCanvasText *canvas_tooltip = sp_canvastext_new(sp_desktop_tempgroup(desktop),
+                                                                     desktop,
+                                                                     end_point + desktop->w2d(Geom::Point(3*fontsize, -fontsize)),
+                                                                     totallength_str);
+                    sp_canvastext_set_fontsize(canvas_tooltip, fontsize);
+                    canvas_tooltip->rgba = 0xffffffff;
+                    canvas_tooltip->rgba_background = 0x3333337f;
+                    canvas_tooltip->outline = false;
+                    canvas_tooltip->background = true;
+                    canvas_tooltip->anchor_position = TEXT_ANCHOR_LEFT;
 
                     measure_tmp_items.push_back(desktop->add_temporary_canvasitem(canvas_tooltip, 0));
-                    free(totallength_str);
+                    g_free(totallength_str);
                 }
 
-                // Normal will be used for lines and text
-                Geom::Point normal = desktop->w2d(Geom::unit_vector(Geom::rot90(desktop->d2w(end_point - start_point))));
-
                 if (intersections.size() > 2) {
                     double totallengthval = (intersections[intersections.size()-1] - intersections[0]).length();
                     sp_convert_distance(&totallengthval, &sp_unit_get_by_id(SP_UNIT_PX), &unit);
 
                     // TODO cleanup memory, Glib::ustring, etc.:
-                    char* total_str = static_cast<char*>(malloc(20));
-                    sprintf(total_str, "%.2f %s", totallengthval, unit.abbr);
-
-                    SPCanvasItem *canvas_tooltip = sp_canvastext_new(sp_desktop_tempgroup(desktop), desktop, desktop->doc2dt((intersections[0] + intersections[intersections.size()-1])/2) + normal*60, total_str);
-                    sp_canvastext_set_fontsize(SP_CANVASTEXT(canvas_tooltip), fontsize);
-                    SP_CANVASTEXT(canvas_tooltip)->rgba = 0xffffffff;
-                    SP_CANVASTEXT(canvas_tooltip)->rgba_background = 0x33337f7f;
-                    SP_CANVASTEXT(canvas_tooltip)->outline = false;
-                    SP_CANVASTEXT(canvas_tooltip)->background = true;
-                    SP_CANVASTEXT(canvas_tooltip)->anchor_position = TEXT_ANCHOR_CENTER;
+                    gchar *total_str = g_strdup_printf("%.2f %s", totallengthval, unit.abbr);
+                    SPCanvasText *canvas_tooltip = sp_canvastext_new(sp_desktop_tempgroup(desktop),
+                                                                     desktop,
+                                                                     desktop->doc2dt((intersections[0] + intersections[intersections.size()-1])/2) + normal * 60,
+                                                                     total_str);
+                    sp_canvastext_set_fontsize(canvas_tooltip, fontsize);
+                    canvas_tooltip->rgba = 0xffffffff;
+                    canvas_tooltip->rgba_background = 0x33337f7f;
+                    canvas_tooltip->outline = false;
+                    canvas_tooltip->background = true;
+                    canvas_tooltip->anchor_position = TEXT_ANCHOR_CENTER;
 
                     measure_tmp_items.push_back(desktop->add_temporary_canvasitem(canvas_tooltip, 0));
-                    free(total_str);
+                    g_free(total_str);
                 }
 
                 // Now that text has been added, we can add lines and controls so that they go underneath
-- 
cgit v1.2.3


From 0c69427acc95fa4756b43f6da1f7258125de7d04 Mon Sep 17 00:00:00 2001
From: "Jon A. Cruz" <jon@joncruz.org>
Date: Mon, 28 May 2012 15:21:20 -0700
Subject: Added basic offset and call-out lines for measurements.

(bzr r11434)
---
 src/measure-context.cpp | 42 ++++++++++++++++++++++++++++--------------
 1 file changed, 28 insertions(+), 14 deletions(-)

(limited to 'src/measure-context.cpp')

diff --git a/src/measure-context.cpp b/src/measure-context.cpp
index db6183d71..4f94c2660 100644
--- a/src/measure-context.cpp
+++ b/src/measure-context.cpp
@@ -44,6 +44,7 @@
 #include "ui/control-manager.h"
 
 using Inkscape::ControlManager;
+using Inkscape::CTLINE_SECONDARY;
 
 static void sp_measure_context_class_init(SPMeasureContextClass *klass);
 static void sp_measure_context_init(SPMeasureContext *measure_context);
@@ -64,6 +65,13 @@ Geom::Point start_point;
 
 std::vector<Inkscape::Display::TemporaryItem*> measure_tmp_items;
 
+namespace
+{
+
+gint const DIMENSION_OFFSET = 45;
+
+} // namespace
+
 GType sp_measure_context_get_type(void)
 {
     static GType type = 0;
@@ -348,27 +356,20 @@ static gint sp_measure_context_root_handler(SPEventContext *event_context, GdkEv
 
                 double fontsize = prefs->getInt("/tools/measure/fontsize");
 
-                Geom::Point previous_point;
-                if (!intersections.empty()) {
-                    previous_point = intersections[0];
-                }
-
-
                 // Normal will be used for lines and text
                 Geom::Point normal = desktop->w2d(Geom::unit_vector(Geom::rot90(desktop->d2w(end_point - start_point))));
 
                 for (size_t idx = 1; idx < intersections.size(); ++idx) {
-                    Geom::Point measure_text_pos = (previous_point + intersections[idx]) / 2;
-//TODO: shift label a few pixels in the y coordinate
+                    Geom::Point measure_text_pos = (intersections[idx - 1] + intersections[idx]) / 2;
 
-                    double lengthval = (intersections[idx] - previous_point).length();
+                    double lengthval = (intersections[idx] - intersections[idx - 1]).length();
                     sp_convert_distance(&lengthval, &sp_unit_get_by_id(SP_UNIT_PX), &unit);
 
                     // TODO cleanup memory, Glib::ustring, etc.:
                     gchar *measure_str = g_strdup_printf("%.2f %s", lengthval, unit.abbr);
                     SPCanvasText *canvas_tooltip = sp_canvastext_new(sp_desktop_tempgroup(desktop),
                                                                      desktop,
-                                                                     desktop->doc2dt(measure_text_pos),
+                                                                     desktop->doc2dt(measure_text_pos) - (normal * DIMENSION_OFFSET),
                                                                      measure_str);
                     sp_canvastext_set_fontsize(canvas_tooltip, fontsize);
                     canvas_tooltip->rgba = 0xffffffff;
@@ -379,7 +380,6 @@ static gint sp_measure_context_root_handler(SPEventContext *event_context, GdkEv
 
                     measure_tmp_items.push_back(desktop->add_temporary_canvasitem(canvas_tooltip, 0));
                     g_free(measure_str);
-                    previous_point = intersections[idx];
                 }
 
                 {
@@ -463,6 +463,12 @@ static gint sp_measure_context_root_handler(SPEventContext *event_context, GdkEv
 
                 // Since adding goes to the bottom, do all lines last.
 
+                // draw main control line
+                {
+                    SPCtrlLine *control_line = ControlManager::getManager().createControlLine(sp_desktop_tempgroup(desktop), start_point, end_point);
+                    measure_tmp_items.push_back(desktop->add_temporary_canvasitem(control_line, 0));
+                }
+
                 if (intersections.size() > 2) {
                     ControlManager &mgr = ControlManager::getManager();
                     SPCtrlLine *control_line = 0;
@@ -482,10 +488,18 @@ static gint sp_measure_context_root_handler(SPEventContext *event_context, GdkEv
                     measure_tmp_items.push_back(desktop->add_temporary_canvasitem(control_line, 0));
                 }
 
-                // draw main control line
+                // call-out lines
                 {
-                    SPCtrlLine *control_line = ControlManager::getManager().createControlLine(sp_desktop_tempgroup(desktop), start_point, end_point);
-                    measure_tmp_items.push_back(desktop->add_temporary_canvasitem(control_line, 0));
+                    for (size_t idx = 1; idx < intersections.size(); ++idx) {
+                        Geom::Point measure_text_pos = (intersections[idx - 1] + intersections[idx]) / 2;
+
+                        ControlManager &mgr = ControlManager::getManager();
+                        SPCtrlLine *control_line = mgr.createControlLine(sp_desktop_tempgroup(desktop),
+                                                                         desktop->doc2dt(measure_text_pos),
+                                                                         desktop->doc2dt(measure_text_pos) - (normal * DIMENSION_OFFSET),
+                                                                         CTLINE_SECONDARY);
+                        measure_tmp_items.push_back(desktop->add_temporary_canvasitem(control_line, 0));
+                    }
                 }
 
                 gobble_motion_events(GDK_BUTTON1_MASK);
-- 
cgit v1.2.3


From fc85854813d77dcbb59d0c808a70769823f5937b Mon Sep 17 00:00:00 2001
From: "Jon A. Cruz" <jon@joncruz.org>
Date: Wed, 30 May 2012 22:56:48 -0700
Subject: Make multiple measurement labels avoid overlapping each other.

(bzr r11441)
---
 src/measure-context.cpp | 133 ++++++++++++++++++++++++++++++++++++++++--------
 1 file changed, 111 insertions(+), 22 deletions(-)

(limited to 'src/measure-context.cpp')

diff --git a/src/measure-context.cpp b/src/measure-context.cpp
index 4f94c2660..09beefca1 100644
--- a/src/measure-context.cpp
+++ b/src/measure-context.cpp
@@ -65,13 +65,6 @@ Geom::Point start_point;
 
 std::vector<Inkscape::Display::TemporaryItem*> measure_tmp_items;
 
-namespace
-{
-
-gint const DIMENSION_OFFSET = 45;
-
-} // namespace
-
 GType sp_measure_context_get_type(void)
 {
     static GType type = 0;
@@ -93,6 +86,75 @@ GType sp_measure_context_get_type(void)
     return type;
 }
 
+namespace
+{
+
+gint const DIMENSION_OFFSET = 35;
+
+/**
+ * Simple class to use for removing label overlap.
+ */
+class LabelPlacement {
+public:
+
+    double lengthVal;
+    double offset;
+    Geom::Point start;
+    Geom::Point end;
+};
+
+bool SortLabelPlacement(LabelPlacement const &first, LabelPlacement const &second)
+{
+    if (first.end[Geom::Y] == second.end[Geom::Y]) {
+        return first.end[Geom::X] < second.end[Geom::X];
+    } else {
+        return first.end[Geom::Y] < second.end[Geom::Y];
+    }
+}
+
+void repositionOverlappingLabels(std::vector<LabelPlacement> &placements, SPDesktop *desktop, Geom::Point const &normal, double fontsize)
+{
+    std::sort(placements.begin(), placements.end(), SortLabelPlacement);
+
+    double border = 3;
+    Geom::Rect box;
+    {
+        Geom::Point tmp(fontsize * 8 + (border * 2), fontsize + (border * 2));
+        tmp = desktop->w2d(tmp);
+        box = Geom::Rect(-tmp[Geom::X] / 2, -tmp[Geom::Y] / 2, tmp[Geom::X] / 2, tmp[Geom::Y] / 2);
+    }
+
+    // Using index since vector may be re-ordered as we go.
+    // Starting at one, since the first item can't overlap itself
+    for (size_t i = 1; i < placements.size(); i++) {
+        LabelPlacement &place = placements[i];
+
+        bool changed = false;
+        do {
+            Geom::Rect current(box + place.end);
+
+            changed = false;
+            bool overlaps = false;
+            for (size_t j = i; (j > 0) && !overlaps; --j) {
+                LabelPlacement &otherPlace = placements[j - 1];
+                Geom::Rect target(box + otherPlace.end);
+                if (current.intersects(target)) {
+                    overlaps = true;
+                }
+            }
+            if (overlaps) {
+                place.offset += (fontsize + border);
+                place.end = place.start - desktop->w2d(normal * place.offset);
+                changed = true;
+            }
+        } while (changed);
+
+        std::sort(placements.begin(), placements.begin() + i + 1, SortLabelPlacement);
+    }
+}
+
+} // namespace
+
 static void sp_measure_context_class_init(SPMeasureContextClass *klass)
 {
     SPEventContextClass *event_context_class = reinterpret_cast<SPEventContextClass *>(klass);
@@ -154,28 +216,28 @@ bool GeomPointSortPredicate(const Geom::Point& p1, const Geom::Point& p2)
     }
 }
 
-void calculate_intersections(SPDesktop * /*desktop*/, SPItem* item, Geom::PathVector *lineseg, SPCurve *curve, std::vector<Geom::Point> *intersections)
+void calculate_intersections(SPDesktop * /*desktop*/, SPItem* item, Geom::PathVector const &lineseg, SPCurve *curve, std::vector<Geom::Point> &intersections)
 {
     curve->transform(item->i2doc_affine());
 
     // Find all intersections of the control-line with this shape
-    Geom::CrossingSet cs = Geom::crossings(*lineseg, curve->get_pathvector());
+    Geom::CrossingSet cs = Geom::crossings(lineseg, curve->get_pathvector());
 
     // Reconstruct and store the points of intersection
     for (Geom::Crossings::const_iterator m = cs[0].begin(); m != cs[0].end(); ++m) {
 #if 0
 //TODO: consider only visible intersections
-        Geom::Point intersection = (*lineseg)[0].pointAt((*m).ta);
+        Geom::Point intersection = lineseg[0].pointAt((*m).ta);
         double eps = 0.0001;
         SPDocument* doc = sp_desktop_document(desktop);
         if (((*m).ta > eps &&
-             item == doc->getItemAtPoint(desktop->dkey, (*lineseg)[0].pointAt((*m).ta - eps), false, NULL)) ||
+             item == doc->getItemAtPoint(desktop->dkey, lineseg[0].pointAt((*m).ta - eps), false, NULL)) ||
             ((*m).ta + eps < 1 &&
-             item == doc->getItemAtPoint(desktop->dkey, (*lineseg)[0].pointAt((*m).ta + eps), false, NULL)) ) {
-            intersections->push_back(intersection);
+             item == doc->getItemAtPoint(desktop->dkey, lineseg[0].pointAt((*m).ta + eps), false, NULL)) ) {
+            intersections.push_back(intersection);
         }
 #else
-        intersections->push_back((*lineseg)[0].pointAt((*m).ta));
+        intersections.push_back(lineseg[0].pointAt((*m).ta));
 #endif
     }
 }
@@ -302,12 +364,14 @@ static gint sp_measure_context_root_handler(SPEventContext *event_context, GdkEv
                     intersections.push_back(desktop->dt2doc(start_point));
                 }
 
+                std::vector<LabelPlacement> placements;
+
                 // TODO switch to a different variable name. The single letter 'l' is easy to misread.
                 for (GSList *l = items; l != NULL; l = l->next) {
                     SPItem *item = static_cast<SPItem*>(l->data);
 
                     if (SP_IS_SHAPE(item)) {
-                       calculate_intersections(desktop, item, &lineseg, SP_SHAPE(item)->getCurve(), &intersections);
+                       calculate_intersections(desktop, item, lineseg, SP_SHAPE(item)->getCurve(), intersections);
                     } else {
                         if (SP_IS_TEXT(item) || SP_IS_FLOWTEXT(item)) {
                             Inkscape::Text::Layout::iterator iter = te_get_layout(item)->begin();
@@ -332,7 +396,7 @@ static gint sp_measure_context_root_handler(SPEventContext *event_context, GdkEv
                                 curve->transform(item->i2doc_affine());
                                 Geom::PathVector pathv = curve->get_pathvector();
 
-                                calculate_intersections(desktop, item, &lineseg, curve, &intersections);
+                                calculate_intersections(desktop, item, lineseg, curve, intersections);
 
                                 if (iter == te_get_layout(item)->end()) {
                                     break;
@@ -357,19 +421,32 @@ static gint sp_measure_context_root_handler(SPEventContext *event_context, GdkEv
                 double fontsize = prefs->getInt("/tools/measure/fontsize");
 
                 // Normal will be used for lines and text
-                Geom::Point normal = desktop->w2d(Geom::unit_vector(Geom::rot90(desktop->d2w(end_point - start_point))));
+                Geom::Point windowNormal = Geom::unit_vector(Geom::rot90(desktop->d2w(end_point - start_point)));
+                Geom::Point normal = desktop->w2d(windowNormal);
 
                 for (size_t idx = 1; idx < intersections.size(); ++idx) {
-                    Geom::Point measure_text_pos = (intersections[idx - 1] + intersections[idx]) / 2;
+                    LabelPlacement placement;
+                    placement.lengthVal = (intersections[idx] - intersections[idx - 1]).length();
+                    sp_convert_distance(&placement.lengthVal, &sp_unit_get_by_id(SP_UNIT_PX), &unit);
+                    placement.offset = DIMENSION_OFFSET;
+                    placement.start = desktop->doc2dt( (intersections[idx - 1] + intersections[idx]) / 2 );
+                    placement.end = placement.start - (normal * placement.offset);
+
+                    placements.push_back(placement);
+                }
 
-                    double lengthval = (intersections[idx] - intersections[idx - 1]).length();
-                    sp_convert_distance(&lengthval, &sp_unit_get_by_id(SP_UNIT_PX), &unit);
+                // Adjust positions
+                repositionOverlappingLabels(placements, desktop, windowNormal, fontsize);
+
+                for (std::vector<LabelPlacement>::iterator it = placements.begin(); it != placements.end(); ++it)
+                {
+                    LabelPlacement &place = *it;
 
                     // TODO cleanup memory, Glib::ustring, etc.:
-                    gchar *measure_str = g_strdup_printf("%.2f %s", lengthval, unit.abbr);
+                    gchar *measure_str = g_strdup_printf("%.2f %s", place.lengthVal, unit.abbr);
                     SPCanvasText *canvas_tooltip = sp_canvastext_new(sp_desktop_tempgroup(desktop),
                                                                      desktop,
-                                                                     desktop->doc2dt(measure_text_pos) - (normal * DIMENSION_OFFSET),
+                                                                     place.end,
                                                                      measure_str);
                     sp_canvastext_set_fontsize(canvas_tooltip, fontsize);
                     canvas_tooltip->rgba = 0xffffffff;
@@ -489,6 +566,18 @@ static gint sp_measure_context_root_handler(SPEventContext *event_context, GdkEv
                 }
 
                 // call-out lines
+                for (std::vector<LabelPlacement>::iterator it = placements.begin(); it != placements.end(); ++it)
+                {
+                    LabelPlacement &place = *it;
+
+                    ControlManager &mgr = ControlManager::getManager();
+                    SPCtrlLine *control_line = mgr.createControlLine(sp_desktop_tempgroup(desktop),
+                                                                     place.start,
+                                                                     place.end,
+                                                                     CTLINE_SECONDARY);
+                    measure_tmp_items.push_back(desktop->add_temporary_canvasitem(control_line, 0));
+                }
+
                 {
                     for (size_t idx = 1; idx < intersections.size(); ++idx) {
                         Geom::Point measure_text_pos = (intersections[idx - 1] + intersections[idx]) / 2;
-- 
cgit v1.2.3


From 26a7eff51abad42e8c1c4d3af9af1da3947c8158 Mon Sep 17 00:00:00 2001
From: "Jon A. Cruz" <jon@joncruz.org>
Date: Fri, 1 Jun 2012 00:59:42 -0700
Subject: Adding baseline and arc to make angle measurement visualization
 easier.

(bzr r11449)
---
 src/measure-context.cpp | 37 ++++++++++++++++++++++++++++++++++++-
 1 file changed, 36 insertions(+), 1 deletion(-)

(limited to 'src/measure-context.cpp')

diff --git a/src/measure-context.cpp b/src/measure-context.cpp
index 09beefca1..31fda852b 100644
--- a/src/measure-context.cpp
+++ b/src/measure-context.cpp
@@ -542,8 +542,43 @@ static gint sp_measure_context_root_handler(SPEventContext *event_context, GdkEv
 
                 // draw main control line
                 {
-                    SPCtrlLine *control_line = ControlManager::getManager().createControlLine(sp_desktop_tempgroup(desktop), start_point, end_point);
+                    SPCtrlLine *control_line = ControlManager::getManager().createControlLine(sp_desktop_tempgroup(desktop),
+                                                                                              start_point,
+                                                                                              end_point);
                     measure_tmp_items.push_back(desktop->add_temporary_canvasitem(control_line, 0));
+
+                    if ((end_point[Geom::X] != start_point[Geom::X]) && (end_point[Geom::Y] != start_point[Geom::Y])) {
+                        Geom::Point anchorEnd = start_point;
+                        double length = std::abs((end_point - start_point).length());
+                        anchorEnd[Geom::X] += length;
+
+                        SPCtrlLine *control_line = ControlManager::getManager().createControlLine(sp_desktop_tempgroup(desktop),
+                                                                                                  start_point,
+                                                                                                  anchorEnd,
+                                                                                                  CTLINE_SECONDARY);
+                        measure_tmp_items.push_back(desktop->add_temporary_canvasitem(control_line, 0));
+
+                        // from Riskus
+                        double xc = start_point[Geom::X];
+                        double yc = start_point[Geom::Y];
+                        double ax = anchorEnd[Geom::X] - xc;
+                        double ay = anchorEnd[Geom::Y] - yc;
+                        double bx = end_point[Geom::X] - xc;
+                        double by = end_point[Geom::Y] - yc;
+                        double q1 = (ax * ax) + (ay * ay);
+                        double q2 = q1 + (ax * bx) + (ay * by);
+
+                        double k2 = (4.0 / 3.0) * (std::sqrt(2 * q1 * q2) - q2) / ((ax * by) - (ay * bx));
+                        
+                        Geom::Point p0 = anchorEnd;
+                        Geom::Point p1(xc + ax - (k2 * ay),
+                                       yc + ay  + (k2 * ax));
+                        Geom::Point p2(xc + bx + (k2 * by),
+                                       yc + by - (k2 * bx));
+                        Geom::Point p3 = end_point;
+                        SPCtrlCurve *curve = ControlManager::getManager().createControlCurve(sp_desktop_tempgroup(desktop), p0, p1, p2, p3, CTLINE_SECONDARY);
+                        measure_tmp_items.push_back(desktop->add_temporary_canvasitem(SP_CANVAS_ITEM(curve), 0, true));
+                    }
                 }
 
                 if (intersections.size() > 2) {
-- 
cgit v1.2.3


From 26c36ceb6c3ff02fa439ca1299da21e879fea81f Mon Sep 17 00:00:00 2001
From: "Jon A. Cruz" <jon@joncruz.org>
Date: Fri, 1 Jun 2012 01:56:31 -0700
Subject: Place angle measurement along the measure arc.

(bzr r11450)
---
 src/measure-context.cpp | 17 +++++++++++++++--
 1 file changed, 15 insertions(+), 2 deletions(-)

(limited to 'src/measure-context.cpp')

diff --git a/src/measure-context.cpp b/src/measure-context.cpp
index 31fda852b..460b3284b 100644
--- a/src/measure-context.cpp
+++ b/src/measure-context.cpp
@@ -462,16 +462,29 @@ static gint sp_measure_context_root_handler(SPEventContext *event_context, GdkEv
                 {
                     // TODO cleanup memory, Glib::ustring, etc.:
                     gchar *angle_str = g_strdup_printf("%.2f °", angle * 180/M_PI);
+
+                    CanvasTextAnchorPositionEnum anchor = TEXT_ANCHOR_LEFT;
+                    Geom::Point where = end_point;
+                    if (desktop->d2w(end_point - start_point).length() > 30) {
+                        Geom::Affine adjust = Geom::Affine(Geom::Translate(-start_point))
+                            * Geom::Affine(Geom::Rotate(-angle / 2))
+                            * Geom::Affine(Geom::Translate(start_point));
+                        where *= adjust;
+                        anchor = TEXT_ANCHOR_CENTER;
+                    } else {
+                        where += desktop->w2d(Geom::Point(3*fontsize, fontsize));
+                    }
+
                     SPCanvasText *canvas_tooltip = sp_canvastext_new(sp_desktop_tempgroup(desktop),
                                                                      desktop,
-                                                                     end_point + desktop->w2d(Geom::Point(3*fontsize, fontsize)),
+                                                                     where,
                                                                      angle_str);
                     sp_canvastext_set_fontsize(canvas_tooltip, fontsize);
                     canvas_tooltip->rgba = 0xffffffff;
                     canvas_tooltip->rgba_background = 0x337f337f;
                     canvas_tooltip->outline = false;
                     canvas_tooltip->background = true;
-                    canvas_tooltip->anchor_position = TEXT_ANCHOR_LEFT;
+                    canvas_tooltip->anchor_position = anchor;
 
                     measure_tmp_items.push_back(desktop->add_temporary_canvasitem(canvas_tooltip, 0));
                     g_free(angle_str);
-- 
cgit v1.2.3


From ec194f96ca4eba82f85a7457b5b89936275f1693 Mon Sep 17 00:00:00 2001
From: "Jon A. Cruz" <jon@joncruz.org>
Date: Fri, 1 Jun 2012 18:00:02 -0700
Subject: Add marker to initial point.

(bzr r11451)
---
 src/measure-context.cpp | 35 +++++++++++++++++++++++++----------
 1 file changed, 25 insertions(+), 10 deletions(-)

(limited to 'src/measure-context.cpp')

diff --git a/src/measure-context.cpp b/src/measure-context.cpp
index 460b3284b..563d8e5e9 100644
--- a/src/measure-context.cpp
+++ b/src/measure-context.cpp
@@ -536,16 +536,15 @@ static gint sp_measure_context_root_handler(SPEventContext *event_context, GdkEv
 
                 for (size_t idx = 0; idx < intersections.size(); ++idx) {
                     // Display the intersection indicator (i.e. the cross)
-                    SPCanvasItem * canvasitem = NULL;
-                    canvasitem = sp_canvas_item_new(sp_desktop_tempgroup(desktop),
-                                                    SP_TYPE_CTRL,
-                                                    "anchor", SP_ANCHOR_CENTER,
-                                                    "size", 8.0,
-                                                    "stroked", TRUE,
-                                                    "stroke_color", 0xff0000ff,
-                                                    "mode", SP_KNOT_MODE_XOR,
-                                                    "shape", SP_KNOT_SHAPE_CROSS,
-                                                    NULL );
+                    SPCanvasItem * canvasitem = sp_canvas_item_new(sp_desktop_tempgroup(desktop),
+                                                                   SP_TYPE_CTRL,
+                                                                   "anchor", SP_ANCHOR_CENTER,
+                                                                   "size", 8.0,
+                                                                   "stroked", TRUE,
+                                                                   "stroke_color", 0xff0000ff,
+                                                                   "mode", SP_KNOT_MODE_XOR,
+                                                                   "shape", SP_KNOT_SHAPE_CROSS,
+                                                                   NULL );
 
                     SP_CTRL(canvasitem)->moveto(desktop->doc2dt(intersections[idx]));
                     measure_tmp_items.push_back(desktop->add_temporary_canvasitem(canvasitem, 0));
@@ -639,6 +638,22 @@ static gint sp_measure_context_root_handler(SPEventContext *event_context, GdkEv
                     }
                 }
 
+                // Initial point
+                {
+                    SPCanvasItem * canvasitem = sp_canvas_item_new(sp_desktop_tempgroup(desktop),
+                                                                   SP_TYPE_CTRL,
+                                                                   "anchor", SP_ANCHOR_CENTER,
+                                                                   "size", 8.0,
+                                                                   "stroked", TRUE,
+                                                                   "stroke_color", 0xff0000ff,
+                                                                   "mode", SP_KNOT_MODE_XOR,
+                                                                   "shape", SP_KNOT_SHAPE_CROSS,
+                                                                   NULL );
+
+                    SP_CTRL(canvasitem)->moveto(start_point);
+                    measure_tmp_items.push_back(desktop->add_temporary_canvasitem(canvasitem, 0));
+                }
+
                 gobble_motion_events(GDK_BUTTON1_MASK);
             }
             break;
-- 
cgit v1.2.3


From fcc09d8b6a5e46d0e1b6067830f255baa4961d01 Mon Sep 17 00:00:00 2001
From: "Jon A. Cruz" <jon@joncruz.org>
Date: Sun, 3 Jun 2012 16:34:22 -0700
Subject: Limit angle label to show up within the desktop window. Also refactor
 arc drawing.

(bzr r11458)
---
 src/measure-context.cpp | 140 ++++++++++++++++++++++++++++++++++++------------
 1 file changed, 106 insertions(+), 34 deletions(-)

(limited to 'src/measure-context.cpp')

diff --git a/src/measure-context.cpp b/src/measure-context.cpp
index 563d8e5e9..b3ea82e3b 100644
--- a/src/measure-context.cpp
+++ b/src/measure-context.cpp
@@ -153,6 +153,105 @@ void repositionOverlappingLabels(std::vector<LabelPlacement> &placements, SPDesk
     }
 }
 
+/**
+ * Calculates where to place the anchor for the display text and arc.
+ *
+ * @param desktop the desktop that is being used.
+ * @param angle the angle to be displaying.
+ * @param startPoint the point that is the vertex of the selected angle.
+ * @param endPoint the point that is the end the user is manipulating for measurement.
+ * @param fontsize the size to display the text label at.
+ */
+Geom::Point calcAngleDisplayAnchor(SPDesktop *desktop, double angle,
+                                   Geom::Point const &startPoint, Geom::Point const &endPoint,
+                                   double fontsize)
+{
+    // Time for the trick work of figuring out where things should go, and how.
+    Geom::Point where = endPoint;
+    Geom::Affine adjust = Geom::Affine(Geom::Translate(-startPoint))
+        * Geom::Affine(Geom::Rotate(-angle / 2))
+        * Geom::Affine(Geom::Translate(startPoint));
+    where *= adjust;
+    // We now have the ideal position, but need to see if it will fit/work.
+
+    Geom::Rect visibleArea = desktop->get_display_area();
+    // Bring it in to "title safe" for the anchor point
+    Geom::Point textBox = desktop->w2d(Geom::Point(fontsize * 3, fontsize / 2));
+    textBox[Geom::Y] = std::abs(textBox[Geom::Y]);
+
+    visibleArea = Geom::Rect(visibleArea.min()[Geom::X] + textBox[Geom::X],
+                             visibleArea.min()[Geom::Y] + textBox[Geom::Y],
+                             visibleArea.max()[Geom::X] - textBox[Geom::X],
+                             visibleArea.max()[Geom::Y] - textBox[Geom::Y]);
+    std::vector<Geom::LineSegment> edges;
+    edges.push_back(Geom::LineSegment(Geom::Point(visibleArea.max()[Geom::X], visibleArea.min()[Geom::Y]),
+                                      visibleArea.max())); // right
+    edges.push_back(Geom::LineSegment(Geom::Point(visibleArea.min()[Geom::X], visibleArea.max()[Geom::Y]),
+                                      visibleArea.max())); // bottom
+    edges.push_back(Geom::LineSegment(visibleArea.min(),
+                                      Geom::Point(visibleArea.max()[Geom::X], visibleArea.min()[Geom::Y]))); // top
+    edges.push_back(Geom::LineSegment(visibleArea.min(),
+                                      Geom::Point(visibleArea.min()[Geom::X], visibleArea.max()[Geom::Y]))); // left
+
+    Geom::LineSegment dispLine(start_point, where);
+
+    for (std::vector<Geom::LineSegment>::iterator it = edges.begin(); it != edges.end(); ++it) {
+        try {
+            Geom::OptCrossing inters = Geom::intersection(dispLine, *it);
+            if (inters) {
+                where = dispLine.pointAt(inters->ta);
+                break;
+            }
+        } catch (Geom::InfiniteSolutions const & /*e*/) {
+            // don't fail.
+        }
+    }
+
+    return where;
+}
+
+/**
+ * Given an angle, the arc center and edge point, draw an arc segment centered around that edge point.
+ *
+ * @param desktop the desktop that is being used.
+ * @param center the center point for the arc.
+ * @param end the point that ends in the center of the arc segment.
+ * @param angle the angle of the arc segment to draw.
+ */
+void createAngleDisplayCurve(SPDesktop *desktop, Geom::Point const &center, Geom::Point const &end, double angle)
+{
+    // Given that we have a point on the arc's center and the angle of the arc, we need to get the two endpoints. 
+
+    // arc start
+    Geom::Point p1 = end * (Geom::Affine(Geom::Translate(-center))
+                            * Geom::Affine(Geom::Rotate(-angle / 2))
+                            * Geom::Affine(Geom::Translate(center)));
+    // arc end
+    Geom::Point p4 = end * (Geom::Affine(Geom::Translate(-center))
+                            * Geom::Affine(Geom::Rotate(angle / 2))
+                            * Geom::Affine(Geom::Translate(center)));
+
+    // from Riskus
+    double xc = center[Geom::X];
+    double yc = center[Geom::Y];
+    double ax = p1[Geom::X] - xc;
+    double ay = p1[Geom::Y] - yc;
+    double bx = p4[Geom::X] - xc;
+    double by = p4[Geom::Y] - yc;
+    double q1 = (ax * ax) + (ay * ay);
+    double q2 = q1 + (ax * bx) + (ay * by);
+
+    double k2 = (4.0 / 3.0) * (std::sqrt(2 * q1 * q2) - q2) / ((ax * by) - (ay * bx));
+
+    Geom::Point p2(xc + ax - (k2 * ay),
+                   yc + ay  + (k2 * ax));
+    Geom::Point p3(xc + bx + (k2 * by),
+                   yc + by - (k2 * bx));
+    SPCtrlCurve *curve = ControlManager::getManager().createControlCurve(sp_desktop_tempgroup(desktop), p1, p2, p3, p4, CTLINE_SECONDARY);
+
+    measure_tmp_items.push_back(desktop->add_temporary_canvasitem(SP_CANVAS_ITEM(curve), 0, true));
+}
+
 } // namespace
 
 static void sp_measure_context_class_init(SPMeasureContextClass *klass)
@@ -459,32 +558,24 @@ static gint sp_measure_context_root_handler(SPEventContext *event_context, GdkEv
                     g_free(measure_str);
                 }
 
+                Geom::Point angleDisplayPt = calcAngleDisplayAnchor(desktop, angle,
+                                                                    start_point, end_point,
+                                                                    fontsize);
+
                 {
                     // TODO cleanup memory, Glib::ustring, etc.:
                     gchar *angle_str = g_strdup_printf("%.2f °", angle * 180/M_PI);
 
-                    CanvasTextAnchorPositionEnum anchor = TEXT_ANCHOR_LEFT;
-                    Geom::Point where = end_point;
-                    if (desktop->d2w(end_point - start_point).length() > 30) {
-                        Geom::Affine adjust = Geom::Affine(Geom::Translate(-start_point))
-                            * Geom::Affine(Geom::Rotate(-angle / 2))
-                            * Geom::Affine(Geom::Translate(start_point));
-                        where *= adjust;
-                        anchor = TEXT_ANCHOR_CENTER;
-                    } else {
-                        where += desktop->w2d(Geom::Point(3*fontsize, fontsize));
-                    }
-
                     SPCanvasText *canvas_tooltip = sp_canvastext_new(sp_desktop_tempgroup(desktop),
                                                                      desktop,
-                                                                     where,
+                                                                     angleDisplayPt,
                                                                      angle_str);
                     sp_canvastext_set_fontsize(canvas_tooltip, fontsize);
                     canvas_tooltip->rgba = 0xffffffff;
                     canvas_tooltip->rgba_background = 0x337f337f;
                     canvas_tooltip->outline = false;
                     canvas_tooltip->background = true;
-                    canvas_tooltip->anchor_position = anchor;
+                    canvas_tooltip->anchor_position = TEXT_ANCHOR_CENTER;
 
                     measure_tmp_items.push_back(desktop->add_temporary_canvasitem(canvas_tooltip, 0));
                     g_free(angle_str);
@@ -570,26 +661,7 @@ static gint sp_measure_context_root_handler(SPEventContext *event_context, GdkEv
                                                                                                   CTLINE_SECONDARY);
                         measure_tmp_items.push_back(desktop->add_temporary_canvasitem(control_line, 0));
 
-                        // from Riskus
-                        double xc = start_point[Geom::X];
-                        double yc = start_point[Geom::Y];
-                        double ax = anchorEnd[Geom::X] - xc;
-                        double ay = anchorEnd[Geom::Y] - yc;
-                        double bx = end_point[Geom::X] - xc;
-                        double by = end_point[Geom::Y] - yc;
-                        double q1 = (ax * ax) + (ay * ay);
-                        double q2 = q1 + (ax * bx) + (ay * by);
-
-                        double k2 = (4.0 / 3.0) * (std::sqrt(2 * q1 * q2) - q2) / ((ax * by) - (ay * bx));
-                        
-                        Geom::Point p0 = anchorEnd;
-                        Geom::Point p1(xc + ax - (k2 * ay),
-                                       yc + ay  + (k2 * ax));
-                        Geom::Point p2(xc + bx + (k2 * by),
-                                       yc + by - (k2 * bx));
-                        Geom::Point p3 = end_point;
-                        SPCtrlCurve *curve = ControlManager::getManager().createControlCurve(sp_desktop_tempgroup(desktop), p0, p1, p2, p3, CTLINE_SECONDARY);
-                        measure_tmp_items.push_back(desktop->add_temporary_canvasitem(SP_CANVAS_ITEM(curve), 0, true));
+                        createAngleDisplayCurve(desktop, start_point, angleDisplayPt, angle);
                     }
                 }
 
-- 
cgit v1.2.3


From e49f8336142eda7a88587b85b78f4cad175aef28 Mon Sep 17 00:00:00 2001
From: "Jon A. Cruz" <jon@joncruz.org>
Date: Tue, 5 Jun 2012 01:12:11 -0700
Subject: Allow angle measurement base to be changed by tapping space.

(bzr r11459)
---
 src/measure-context.cpp | 55 ++++++++++++++++++++++++++++++++++++++++++-------
 1 file changed, 47 insertions(+), 8 deletions(-)

(limited to 'src/measure-context.cpp')

diff --git a/src/measure-context.cpp b/src/measure-context.cpp
index b3ea82e3b..8dfcb1441 100644
--- a/src/measure-context.cpp
+++ b/src/measure-context.cpp
@@ -12,6 +12,7 @@
 
 
 #include <gdk/gdkkeysyms.h>
+#include <boost/none_t.hpp>
 #include "helper/units.h"
 #include "macros.h"
 #include "display/curve.h"
@@ -62,6 +63,8 @@ static gint tolerance = 0;
 static bool within_tolerance = false;
 
 Geom::Point start_point;
+boost::optional<Geom::Point> explicitBase;
+boost::optional<Geom::Point> lastEnd;
 
 std::vector<Inkscape::Display::TemporaryItem*> measure_tmp_items;
 
@@ -158,20 +161,21 @@ void repositionOverlappingLabels(std::vector<LabelPlacement> &placements, SPDesk
  *
  * @param desktop the desktop that is being used.
  * @param angle the angle to be displaying.
+ * @param baseAngle the angle of the initial baseline.
  * @param startPoint the point that is the vertex of the selected angle.
  * @param endPoint the point that is the end the user is manipulating for measurement.
  * @param fontsize the size to display the text label at.
  */
-Geom::Point calcAngleDisplayAnchor(SPDesktop *desktop, double angle,
+Geom::Point calcAngleDisplayAnchor(SPDesktop *desktop, double angle, double baseAngle,
                                    Geom::Point const &startPoint, Geom::Point const &endPoint,
                                    double fontsize)
 {
     // Time for the trick work of figuring out where things should go, and how.
-    Geom::Point where = endPoint;
-    Geom::Affine adjust = Geom::Affine(Geom::Translate(-startPoint))
-        * Geom::Affine(Geom::Rotate(-angle / 2))
-        * Geom::Affine(Geom::Translate(startPoint));
-    where *= adjust;
+    double lengthVal = (endPoint - startPoint).length();
+    double effective = baseAngle + (angle / 2);
+    Geom::Point where(lengthVal, 0);
+    where *= Geom::Affine(Geom::Rotate(effective)) * Geom::Affine(Geom::Translate(startPoint));
+
     // We now have the ideal position, but need to see if it will fit/work.
 
     Geom::Rect visibleArea = desktop->get_display_area();
@@ -354,6 +358,8 @@ static gint sp_measure_context_root_handler(SPEventContext *event_context, GdkEv
         case GDK_BUTTON_PRESS:
         {
             Geom::Point const button_w(event->button.x, event->button.y);
+            explicitBase = boost::none;
+            lastEnd = boost::none;
             start_point = desktop->w2d(button_w);
             if (event->button.button == 1 && !event_context->space_panning) {
                 // save drag origin
@@ -376,6 +382,16 @@ static gint sp_measure_context_root_handler(SPEventContext *event_context, GdkEv
             break;
         }
 
+        case GDK_KEY_PRESS:
+        {
+            if ((event->key.keyval == GDK_KEY_Shift_L) || (event->key.keyval == GDK_KEY_Shift_R)) {
+                if (lastEnd) {
+                    explicitBase = lastEnd;
+                }
+            }
+            break;
+        }
+
         case GDK_MOTION_NOTIFY:
         {
             if (!((event->motion.state & GDK_BUTTON1_MASK) && !event_context->space_panning)) {
@@ -439,6 +455,20 @@ static gint sp_measure_context_root_handler(SPEventContext *event_context, GdkEv
                 double deltax = end_point[Geom::X] - start_point[Geom::X];
                 double deltay = end_point[Geom::Y] - start_point[Geom::Y];
                 double angle = atan2(deltay, deltax);
+                double baseAngle = 0;
+
+                if (explicitBase) {
+                    double deltax2 = explicitBase.get()[Geom::X] - start_point[Geom::X];
+                    double deltay2 = explicitBase.get()[Geom::Y] - start_point[Geom::Y];
+
+                    baseAngle = atan2(deltay2, deltax2);
+                    angle -= baseAngle;
+                    if (angle < -M_PI) {
+                        angle += 2 * M_PI;
+                    } else if (angle > M_PI) {
+                        angle -= 2 * M_PI;
+                    }
+                }
 
 //TODO: calculate NPOINTS
 //800 seems to be a good value for 800x600 resolution
@@ -558,7 +588,7 @@ static gint sp_measure_context_root_handler(SPEventContext *event_context, GdkEv
                     g_free(measure_str);
                 }
 
-                Geom::Point angleDisplayPt = calcAngleDisplayAnchor(desktop, angle,
+                Geom::Point angleDisplayPt = calcAngleDisplayAnchor(desktop, angle, baseAngle,
                                                                     start_point, end_point,
                                                                     fontsize);
 
@@ -651,9 +681,14 @@ static gint sp_measure_context_root_handler(SPEventContext *event_context, GdkEv
                     measure_tmp_items.push_back(desktop->add_temporary_canvasitem(control_line, 0));
 
                     if ((end_point[Geom::X] != start_point[Geom::X]) && (end_point[Geom::Y] != start_point[Geom::Y])) {
-                        Geom::Point anchorEnd = start_point;
                         double length = std::abs((end_point - start_point).length());
+                        Geom::Point anchorEnd = start_point;
                         anchorEnd[Geom::X] += length;
+                        if (explicitBase) {
+                            anchorEnd *= (Geom::Affine(Geom::Translate(-start_point))
+                                          * Geom::Affine(Geom::Rotate(baseAngle))
+                                          * Geom::Affine(Geom::Translate(start_point)));
+                        }
 
                         SPCtrlLine *control_line = ControlManager::getManager().createControlLine(sp_desktop_tempgroup(desktop),
                                                                                                   start_point,
@@ -726,6 +761,8 @@ static gint sp_measure_context_root_handler(SPEventContext *event_context, GdkEv
                     measure_tmp_items.push_back(desktop->add_temporary_canvasitem(canvasitem, 0));
                 }
 
+                lastEnd = end_point; // track in case we get a anchoring key-press later
+
                 gobble_motion_events(GDK_BUTTON1_MASK);
             }
             break;
@@ -734,6 +771,8 @@ static gint sp_measure_context_root_handler(SPEventContext *event_context, GdkEv
         case GDK_BUTTON_RELEASE:
         {
             sp_event_context_discard_delayed_snap_event(event_context);
+            explicitBase = boost::none;
+            lastEnd = boost::none;
 
             //clear all temporary canvas items related to the measurement tool.
             for (size_t idx = 0; idx < measure_tmp_items.size(); ++idx) {
-- 
cgit v1.2.3


From 49fca5d0f8f2ea6b0bad8ea6112018153492f27b Mon Sep 17 00:00:00 2001
From: "Jon A. Cruz" <jon@joncruz.org>
Date: Tue, 5 Jun 2012 23:58:40 -0700
Subject: Compatibility fix.

(bzr r11463)
---
 src/measure-context.cpp | 5 +++++
 1 file changed, 5 insertions(+)

(limited to 'src/measure-context.cpp')

diff --git a/src/measure-context.cpp b/src/measure-context.cpp
index 8dfcb1441..cd233eaa8 100644
--- a/src/measure-context.cpp
+++ b/src/measure-context.cpp
@@ -44,6 +44,11 @@
 #include "enums.h"
 #include "ui/control-manager.h"
 
+#if !GTK_CHECK_VERSION(2,22,0)
+#include "compat-key-syms.h"
+#endif
+
+
 using Inkscape::ControlManager;
 using Inkscape::CTLINE_SECONDARY;
 
-- 
cgit v1.2.3


From ac313fdf7fa645f153b224d3150a03ee270e286f Mon Sep 17 00:00:00 2001
From: "Jon A. Cruz" <jon@joncruz.org>
Date: Fri, 8 Jun 2012 07:51:41 -0700
Subject: Improve approach for keeping angle display string visible.

(bzr r11468)
---
 src/measure-context.cpp | 102 ++++++++++++++++++++++--------------------------
 1 file changed, 46 insertions(+), 56 deletions(-)

(limited to 'src/measure-context.cpp')

diff --git a/src/measure-context.cpp b/src/measure-context.cpp
index cd233eaa8..33650d8dd 100644
--- a/src/measure-context.cpp
+++ b/src/measure-context.cpp
@@ -192,29 +192,11 @@ Geom::Point calcAngleDisplayAnchor(SPDesktop *desktop, double angle, double base
                              visibleArea.min()[Geom::Y] + textBox[Geom::Y],
                              visibleArea.max()[Geom::X] - textBox[Geom::X],
                              visibleArea.max()[Geom::Y] - textBox[Geom::Y]);
-    std::vector<Geom::LineSegment> edges;
-    edges.push_back(Geom::LineSegment(Geom::Point(visibleArea.max()[Geom::X], visibleArea.min()[Geom::Y]),
-                                      visibleArea.max())); // right
-    edges.push_back(Geom::LineSegment(Geom::Point(visibleArea.min()[Geom::X], visibleArea.max()[Geom::Y]),
-                                      visibleArea.max())); // bottom
-    edges.push_back(Geom::LineSegment(visibleArea.min(),
-                                      Geom::Point(visibleArea.max()[Geom::X], visibleArea.min()[Geom::Y]))); // top
-    edges.push_back(Geom::LineSegment(visibleArea.min(),
-                                      Geom::Point(visibleArea.min()[Geom::X], visibleArea.max()[Geom::Y]))); // left
-
-    Geom::LineSegment dispLine(start_point, where);
-
-    for (std::vector<Geom::LineSegment>::iterator it = edges.begin(); it != edges.end(); ++it) {
-        try {
-            Geom::OptCrossing inters = Geom::intersection(dispLine, *it);
-            if (inters) {
-                where = dispLine.pointAt(inters->ta);
-                break;
-            }
-        } catch (Geom::InfiniteSolutions const & /*e*/) {
-            // don't fail.
-        }
-    }
+
+    where[Geom::X] = std::min(where[Geom::X], visibleArea.max()[Geom::X]);
+    where[Geom::X] = std::max(where[Geom::X], visibleArea.min()[Geom::X]);
+    where[Geom::Y] = std::min(where[Geom::Y], visibleArea.max()[Geom::Y]);
+    where[Geom::Y] = std::max(where[Geom::Y], visibleArea.min()[Geom::Y]);
 
     return where;
 }
@@ -224,41 +206,49 @@ Geom::Point calcAngleDisplayAnchor(SPDesktop *desktop, double angle, double base
  *
  * @param desktop the desktop that is being used.
  * @param center the center point for the arc.
- * @param end the point that ends in the center of the arc segment.
+ * @param end the point that ends at the edge of the arc segment.
+ * @param anchor the anchor point for displaying the text label.
  * @param angle the angle of the arc segment to draw.
  */
-void createAngleDisplayCurve(SPDesktop *desktop, Geom::Point const &center, Geom::Point const &end, double angle)
+void createAngleDisplayCurve(SPDesktop *desktop, Geom::Point const &center, Geom::Point const &end, Geom::Point const &anchor, double angle)
 {
-    // Given that we have a point on the arc's center and the angle of the arc, we need to get the two endpoints. 
-
-    // arc start
-    Geom::Point p1 = end * (Geom::Affine(Geom::Translate(-center))
-                            * Geom::Affine(Geom::Rotate(-angle / 2))
-                            * Geom::Affine(Geom::Translate(center)));
-    // arc end
-    Geom::Point p4 = end * (Geom::Affine(Geom::Translate(-center))
-                            * Geom::Affine(Geom::Rotate(angle / 2))
-                            * Geom::Affine(Geom::Translate(center)));
-
-    // from Riskus
-    double xc = center[Geom::X];
-    double yc = center[Geom::Y];
-    double ax = p1[Geom::X] - xc;
-    double ay = p1[Geom::Y] - yc;
-    double bx = p4[Geom::X] - xc;
-    double by = p4[Geom::Y] - yc;
-    double q1 = (ax * ax) + (ay * ay);
-    double q2 = q1 + (ax * bx) + (ay * by);
-
-    double k2 = (4.0 / 3.0) * (std::sqrt(2 * q1 * q2) - q2) / ((ax * by) - (ay * bx));
-
-    Geom::Point p2(xc + ax - (k2 * ay),
-                   yc + ay  + (k2 * ax));
-    Geom::Point p3(xc + bx + (k2 * by),
-                   yc + by - (k2 * bx));
-    SPCtrlCurve *curve = ControlManager::getManager().createControlCurve(sp_desktop_tempgroup(desktop), p1, p2, p3, p4, CTLINE_SECONDARY);
-
-    measure_tmp_items.push_back(desktop->add_temporary_canvasitem(SP_CANVAS_ITEM(curve), 0, true));
+    // Given that we have a point on the arc's edge and the angle of the arc, we need to get the two endpoints.
+
+    double textLen = std::abs((anchor - center).length());
+    double sideLen = std::abs((end - center).length());
+    if (sideLen > 0.0) {
+        double factor = std::min(1.0, textLen / sideLen);
+    
+        // arc start
+        Geom::Point p1 = end * (Geom::Affine(Geom::Translate(-center))
+                                * Geom::Affine(Geom::Scale(factor))
+                                * Geom::Affine(Geom::Translate(center)));
+
+        // arc end
+        Geom::Point p4 = p1 * (Geom::Affine(Geom::Translate(-center))
+                               * Geom::Affine(Geom::Rotate(-angle))
+                               * Geom::Affine(Geom::Translate(center)));
+
+        // from Riskus
+        double xc = center[Geom::X];
+        double yc = center[Geom::Y];
+        double ax = p1[Geom::X] - xc;
+        double ay = p1[Geom::Y] - yc;
+        double bx = p4[Geom::X] - xc;
+        double by = p4[Geom::Y] - yc;
+        double q1 = (ax * ax) + (ay * ay);
+        double q2 = q1 + (ax * bx) + (ay * by);
+
+        double k2 = (4.0 / 3.0) * (std::sqrt(2 * q1 * q2) - q2) / ((ax * by) - (ay * bx));
+
+        Geom::Point p2(xc + ax - (k2 * ay),
+                       yc + ay  + (k2 * ax));
+        Geom::Point p3(xc + bx + (k2 * by),
+                       yc + by - (k2 * bx));
+        SPCtrlCurve *curve = ControlManager::getManager().createControlCurve(sp_desktop_tempgroup(desktop), p1, p2, p3, p4, CTLINE_SECONDARY);
+
+        measure_tmp_items.push_back(desktop->add_temporary_canvasitem(SP_CANVAS_ITEM(curve), 0, true));
+    }
 }
 
 } // namespace
@@ -701,7 +691,7 @@ static gint sp_measure_context_root_handler(SPEventContext *event_context, GdkEv
                                                                                                   CTLINE_SECONDARY);
                         measure_tmp_items.push_back(desktop->add_temporary_canvasitem(control_line, 0));
 
-                        createAngleDisplayCurve(desktop, start_point, angleDisplayPt, angle);
+                        createAngleDisplayCurve(desktop, start_point, end_point, angleDisplayPt, angle);
                     }
                 }
 
-- 
cgit v1.2.3


From 277db7db94ce70f1642b7ad16d138f114c76310b Mon Sep 17 00:00:00 2001
From: "Jon A. Cruz" <jon@joncruz.org>
Date: Fri, 8 Jun 2012 08:23:34 -0700
Subject: Move measure angle string to keep it visible when angle is small.

(bzr r11469)
---
 src/measure-context.cpp | 6 ++++++
 1 file changed, 6 insertions(+)

(limited to 'src/measure-context.cpp')

diff --git a/src/measure-context.cpp b/src/measure-context.cpp
index 33650d8dd..a3ff816c3 100644
--- a/src/measure-context.cpp
+++ b/src/measure-context.cpp
@@ -181,6 +181,12 @@ Geom::Point calcAngleDisplayAnchor(SPDesktop *desktop, double angle, double base
     Geom::Point where(lengthVal, 0);
     where *= Geom::Affine(Geom::Rotate(effective)) * Geom::Affine(Geom::Translate(startPoint));
 
+    // When the angle is tight, the label would end up under the cursor and/or lines. Bump it
+    double scaledFontsize = std::abs(fontsize * desktop->w2d(Geom::Point(0, 1.0))[Geom::Y]);
+    if (std::abs((where - endPoint).length()) < scaledFontsize) {
+        where[Geom::Y] += scaledFontsize * 2;
+    }
+
     // We now have the ideal position, but need to see if it will fit/work.
 
     Geom::Rect visibleArea = desktop->get_display_area();
-- 
cgit v1.2.3


From 9abd33133650d77714fccf09d0c9ff27c9b75a78 Mon Sep 17 00:00:00 2001
From: Alex Valavanis <valavanisalex@gmail.com>
Date: Thu, 5 Jul 2012 22:39:08 +0100
Subject: Drop GTK+ 2.20 support.

Fixed bugs:
  - https://launchpad.net/bugs/1020494

(bzr r11529)
---
 src/measure-context.cpp | 5 -----
 1 file changed, 5 deletions(-)

(limited to 'src/measure-context.cpp')

diff --git a/src/measure-context.cpp b/src/measure-context.cpp
index a3ff816c3..cc6a9b04e 100644
--- a/src/measure-context.cpp
+++ b/src/measure-context.cpp
@@ -44,11 +44,6 @@
 #include "enums.h"
 #include "ui/control-manager.h"
 
-#if !GTK_CHECK_VERSION(2,22,0)
-#include "compat-key-syms.h"
-#endif
-
-
 using Inkscape::ControlManager;
 using Inkscape::CTLINE_SECONDARY;
 
-- 
cgit v1.2.3


From 370a3f5cc9e39352a081e5d5dd8c43676547a6e6 Mon Sep 17 00:00:00 2001
From: Campbell Barton <ideasman42@gmail.com>
Date: Thu, 4 Oct 2012 11:45:44 +1000
Subject: code cleanup: add own includes to cpp files or make the functions
 static if they are not used elsewhere.

(bzr r11735)
---
 src/measure-context.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'src/measure-context.cpp')

diff --git a/src/measure-context.cpp b/src/measure-context.cpp
index cc6a9b04e..7a04b9915 100644
--- a/src/measure-context.cpp
+++ b/src/measure-context.cpp
@@ -306,7 +306,7 @@ static gint sp_measure_context_item_handler(SPEventContext *event_context, SPIte
     return ret;
 }
 
-bool GeomPointSortPredicate(const Geom::Point& p1, const Geom::Point& p2)
+static bool GeomPointSortPredicate(const Geom::Point& p1, const Geom::Point& p2)
 {
     if (p1[Geom::Y] == p2[Geom::Y]) {
         return p1[Geom::X] < p2[Geom::X];
@@ -315,7 +315,7 @@ bool GeomPointSortPredicate(const Geom::Point& p1, const Geom::Point& p2)
     }
 }
 
-void calculate_intersections(SPDesktop * /*desktop*/, SPItem* item, Geom::PathVector const &lineseg, SPCurve *curve, std::vector<Geom::Point> &intersections)
+static void calculate_intersections(SPDesktop * /*desktop*/, SPItem* item, Geom::PathVector const &lineseg, SPCurve *curve, std::vector<Geom::Point> &intersections)
 {
     curve->transform(item->i2doc_affine());
 
-- 
cgit v1.2.3


From 55b2e59196c6e980bdb3f03379de6707dd91082b Mon Sep 17 00:00:00 2001
From: Alex Valavanis <valavanisalex@gmail.com>
Date: Sat, 26 Jan 2013 16:18:08 +0000
Subject: More GObject boilerplate reduction

(bzr r12064)
---
 src/measure-context.cpp | 39 +++++++--------------------------------
 1 file changed, 7 insertions(+), 32 deletions(-)

(limited to 'src/measure-context.cpp')

diff --git a/src/measure-context.cpp b/src/measure-context.cpp
index 7a04b9915..dc23cf5c6 100644
--- a/src/measure-context.cpp
+++ b/src/measure-context.cpp
@@ -47,16 +47,12 @@
 using Inkscape::ControlManager;
 using Inkscape::CTLINE_SECONDARY;
 
-static void sp_measure_context_class_init(SPMeasureContextClass *klass);
-static void sp_measure_context_init(SPMeasureContext *measure_context);
 static void sp_measure_context_setup(SPEventContext *ec);
 static void sp_measure_context_finish(SPEventContext *ec);
 
 static gint sp_measure_context_root_handler(SPEventContext *event_context, GdkEvent *event);
 static gint sp_measure_context_item_handler(SPEventContext *event_context, SPItem *item, GdkEvent *event);
 
-static SPEventContextClass *parent_class;
-
 static gint xp = 0; // where drag started
 static gint yp = 0;
 static gint tolerance = 0;
@@ -68,26 +64,7 @@ boost::optional<Geom::Point> lastEnd;
 
 std::vector<Inkscape::Display::TemporaryItem*> measure_tmp_items;
 
-GType sp_measure_context_get_type(void)
-{
-    static GType type = 0;
-
-    if (!type) {
-        GTypeInfo info = {
-            sizeof(SPMeasureContextClass),
-            NULL, NULL,
-            reinterpret_cast<GClassInitFunc>(sp_measure_context_class_init), // TODO needs two params?
-            NULL, NULL,
-            sizeof(SPMeasureContext),
-            4,
-            reinterpret_cast<GInstanceInitFunc>(sp_measure_context_init), // TODO needs two params?
-            NULL,       // value_table
-        };
-        type = g_type_register_static(SP_TYPE_EVENT_CONTEXT, "SPMeasureContext", &info, static_cast<GTypeFlags>(0));
-    }
-
-    return type;
-}
+G_DEFINE_TYPE(SPMeasureContext, sp_measure_context, SP_TYPE_EVENT_CONTEXT);
 
 namespace
 {
@@ -258,8 +235,6 @@ static void sp_measure_context_class_init(SPMeasureContextClass *klass)
 {
     SPEventContextClass *event_context_class = reinterpret_cast<SPEventContextClass *>(klass);
 
-    parent_class = static_cast<SPEventContextClass*>(g_type_class_peek_parent(klass));
-
     event_context_class->setup = sp_measure_context_setup;
     event_context_class->finish = sp_measure_context_finish;
 
@@ -290,8 +265,8 @@ static void sp_measure_context_finish(SPEventContext *ec)
 
 static void sp_measure_context_setup(SPEventContext *ec)
 {
-    if (parent_class->setup) {
-        parent_class->setup(ec);
+    if (SP_EVENT_CONTEXT_CLASS(sp_measure_context_parent_class)->setup) {
+        SP_EVENT_CONTEXT_CLASS(sp_measure_context_parent_class)->setup(ec);
     }
 }
 
@@ -299,8 +274,8 @@ static gint sp_measure_context_item_handler(SPEventContext *event_context, SPIte
 {
     gint ret = FALSE;
 
-    if (parent_class->item_handler) {
-        ret = parent_class->item_handler(event_context, item, event);
+    if (SP_EVENT_CONTEXT_CLASS(sp_measure_context_parent_class)->item_handler) {
+        ret = SP_EVENT_CONTEXT_CLASS(sp_measure_context_parent_class)->item_handler(event_context, item, event);
     }
 
     return ret;
@@ -789,8 +764,8 @@ static gint sp_measure_context_root_handler(SPEventContext *event_context, GdkEv
     }
 
     if (!ret) {
-        if (parent_class->root_handler) {
-            ret = parent_class->root_handler(event_context, event);
+        if (SP_EVENT_CONTEXT_CLASS(sp_measure_context_parent_class)->root_handler) {
+            ret = SP_EVENT_CONTEXT_CLASS(sp_measure_context_parent_class)->root_handler(event_context, event);
         }
     }
 
-- 
cgit v1.2.3


From 1d8f1753cd8cab38d19fcc26a4ad70ba2e794ac8 Mon Sep 17 00:00:00 2001
From: Markus Engel <markus.engel@tum.de>
Date: Tue, 9 Apr 2013 22:12:07 +0200
Subject: Added constructors to EventContext tree / some missing virtual pads.

(bzr r11608.1.90)
---
 src/measure-context.cpp | 73 +++++++++++++++++++++++++++++++++++++++----------
 1 file changed, 58 insertions(+), 15 deletions(-)

(limited to 'src/measure-context.cpp')

diff --git a/src/measure-context.cpp b/src/measure-context.cpp
index dc23cf5c6..8b0a3608f 100644
--- a/src/measure-context.cpp
+++ b/src/measure-context.cpp
@@ -235,15 +235,26 @@ static void sp_measure_context_class_init(SPMeasureContextClass *klass)
 {
     SPEventContextClass *event_context_class = reinterpret_cast<SPEventContextClass *>(klass);
 
-    event_context_class->setup = sp_measure_context_setup;
-    event_context_class->finish = sp_measure_context_finish;
+//    event_context_class->setup = sp_measure_context_setup;
+//    event_context_class->finish = sp_measure_context_finish;
+//
+//    event_context_class->root_handler = sp_measure_context_root_handler;
+//    event_context_class->item_handler = sp_measure_context_item_handler;
+}
 
-    event_context_class->root_handler = sp_measure_context_root_handler;
-    event_context_class->item_handler = sp_measure_context_item_handler;
+CMeasureContext::CMeasureContext(SPMeasureContext* measurecontext) : CEventContext(measurecontext) {
+	this->spmeasurecontext = measurecontext;
 }
 
-static void sp_measure_context_init(SPMeasureContext *measure_context)
-{
+SPMeasureContext::SPMeasureContext() : SPEventContext() {
+	SPMeasureContext* measure_context = this;
+
+	measure_context->cmeasurecontext = new CMeasureContext(measure_context);
+	delete measure_context->ceventcontext;
+	measure_context->ceventcontext = measure_context->cmeasurecontext;
+
+	measure_context->grabbed = 0;
+
     SPEventContext *event_context = SP_EVENT_CONTEXT(measure_context);
 
     event_context->cursor_shape = cursor_measure_xpm;
@@ -251,8 +262,19 @@ static void sp_measure_context_init(SPMeasureContext *measure_context)
     event_context->hot_y = 4;
 }
 
+static void sp_measure_context_init(SPMeasureContext *measure_context)
+{
+	new (measure_context) SPMeasureContext();
+}
+
 static void sp_measure_context_finish(SPEventContext *ec)
 {
+	ec->ceventcontext->finish();
+}
+
+void CMeasureContext::finish() {
+	SPEventContext* ec = this->speventcontext;
+
     SPMeasureContext *mc = SP_MEASURE_CONTEXT(ec);
 
     ec->enableGrDrag(false);
@@ -265,18 +287,32 @@ static void sp_measure_context_finish(SPEventContext *ec)
 
 static void sp_measure_context_setup(SPEventContext *ec)
 {
-    if (SP_EVENT_CONTEXT_CLASS(sp_measure_context_parent_class)->setup) {
-        SP_EVENT_CONTEXT_CLASS(sp_measure_context_parent_class)->setup(ec);
-    }
+	ec->ceventcontext->setup();
+}
+
+void CMeasureContext::setup() {
+	SPEventContext* ec = this->speventcontext;
+
+//    if (SP_EVENT_CONTEXT_CLASS(sp_measure_context_parent_class)->setup) {
+//        SP_EVENT_CONTEXT_CLASS(sp_measure_context_parent_class)->setup(ec);
+//    }
+	CEventContext::setup();
 }
 
 static gint sp_measure_context_item_handler(SPEventContext *event_context, SPItem *item, GdkEvent *event)
 {
+	return event_context->ceventcontext->item_handler(item, event);
+}
+
+gint CMeasureContext::item_handler(SPItem* item, GdkEvent* event) {
+	SPEventContext* event_context = this->speventcontext;
+
     gint ret = FALSE;
 
-    if (SP_EVENT_CONTEXT_CLASS(sp_measure_context_parent_class)->item_handler) {
-        ret = SP_EVENT_CONTEXT_CLASS(sp_measure_context_parent_class)->item_handler(event_context, item, event);
-    }
+//    if (SP_EVENT_CONTEXT_CLASS(sp_measure_context_parent_class)->item_handler) {
+//        ret = SP_EVENT_CONTEXT_CLASS(sp_measure_context_parent_class)->item_handler(event_context, item, event);
+//    }
+    ret = CEventContext::item_handler(item, event);
 
     return ret;
 }
@@ -318,6 +354,12 @@ static void calculate_intersections(SPDesktop * /*desktop*/, SPItem* item, Geom:
 
 static gint sp_measure_context_root_handler(SPEventContext *event_context, GdkEvent *event)
 {
+	return event_context->ceventcontext->root_handler(event);
+}
+
+gint CMeasureContext::root_handler(GdkEvent* event) {
+	SPEventContext* event_context = this->speventcontext;
+
     SPDesktop *desktop = event_context->desktop;
     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
     tolerance = prefs->getIntLimited("/options/dragtolerance/value", 0, 0, 100);
@@ -764,9 +806,10 @@ static gint sp_measure_context_root_handler(SPEventContext *event_context, GdkEv
     }
 
     if (!ret) {
-        if (SP_EVENT_CONTEXT_CLASS(sp_measure_context_parent_class)->root_handler) {
-            ret = SP_EVENT_CONTEXT_CLASS(sp_measure_context_parent_class)->root_handler(event_context, event);
-        }
+//        if (SP_EVENT_CONTEXT_CLASS(sp_measure_context_parent_class)->root_handler) {
+//            ret = SP_EVENT_CONTEXT_CLASS(sp_measure_context_parent_class)->root_handler(event_context, event);
+//        }
+    	ret = CEventContext::root_handler(event);
     }
 
     return ret;
-- 
cgit v1.2.3


From fbb85064cfaaf03cc09bacedb16a8561f61f2b3d Mon Sep 17 00:00:00 2001
From: Markus Engel <markus.engel@tum.de>
Date: Sat, 13 Apr 2013 00:37:18 +0200
Subject: Added prefPaths to contexts; modified SPFactory

(bzr r11608.1.94)
---
 src/measure-context.cpp | 2 ++
 1 file changed, 2 insertions(+)

(limited to 'src/measure-context.cpp')

diff --git a/src/measure-context.cpp b/src/measure-context.cpp
index 8b0a3608f..f56239690 100644
--- a/src/measure-context.cpp
+++ b/src/measure-context.cpp
@@ -64,6 +64,8 @@ boost::optional<Geom::Point> lastEnd;
 
 std::vector<Inkscape::Display::TemporaryItem*> measure_tmp_items;
 
+const std::string SPMeasureContext::prefsPath = "/tools/measure";
+
 G_DEFINE_TYPE(SPMeasureContext, sp_measure_context, SP_TYPE_EVENT_CONTEXT);
 
 namespace
-- 
cgit v1.2.3


From fbdc8b84ff670c684dafc7d7d403ed01e7077e70 Mon Sep 17 00:00:00 2001
From: Markus Engel <markus.engel@tum.de>
Date: Sat, 13 Apr 2013 18:13:17 +0200
Subject: Replaced casting macros for EventContext tree; added contructors.

(bzr r11608.1.96)
---
 src/measure-context.cpp | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)

(limited to 'src/measure-context.cpp')

diff --git a/src/measure-context.cpp b/src/measure-context.cpp
index f56239690..8012efc8b 100644
--- a/src/measure-context.cpp
+++ b/src/measure-context.cpp
@@ -64,6 +64,21 @@ boost::optional<Geom::Point> lastEnd;
 
 std::vector<Inkscape::Display::TemporaryItem*> measure_tmp_items;
 
+
+#include "sp-factory.h"
+
+namespace {
+	SPEventContext* createMeasureContext() {
+		return new SPMeasureContext();
+	}
+
+	bool measureContextRegistered = ToolFactory::instance().registerObject("/tools/measure", createMeasureContext);
+}
+
+const std::string& CMeasureContext::getPrefsPath() {
+	return SPMeasureContext::prefsPath;
+}
+
 const std::string SPMeasureContext::prefsPath = "/tools/measure";
 
 G_DEFINE_TYPE(SPMeasureContext, sp_measure_context, SP_TYPE_EVENT_CONTEXT);
@@ -254,6 +269,7 @@ SPMeasureContext::SPMeasureContext() : SPEventContext() {
 	measure_context->cmeasurecontext = new CMeasureContext(measure_context);
 	delete measure_context->ceventcontext;
 	measure_context->ceventcontext = measure_context->cmeasurecontext;
+	types.insert(typeid(SPMeasureContext));
 
 	measure_context->grabbed = 0;
 
-- 
cgit v1.2.3


From 65ba6ad9a82f8f47974eb10665478fd783692bb5 Mon Sep 17 00:00:00 2001
From: Markus Engel <markus.engel@tum.de>
Date: Sat, 20 Apr 2013 23:19:46 +0200
Subject: Merging of EventContext classes complete.

(bzr r11608.1.98)
---
 src/measure-context.cpp | 75 +++++++++----------------------------------------
 1 file changed, 13 insertions(+), 62 deletions(-)

(limited to 'src/measure-context.cpp')

diff --git a/src/measure-context.cpp b/src/measure-context.cpp
index 8012efc8b..1b4d4afe3 100644
--- a/src/measure-context.cpp
+++ b/src/measure-context.cpp
@@ -47,12 +47,6 @@
 using Inkscape::ControlManager;
 using Inkscape::CTLINE_SECONDARY;
 
-static void sp_measure_context_setup(SPEventContext *ec);
-static void sp_measure_context_finish(SPEventContext *ec);
-
-static gint sp_measure_context_root_handler(SPEventContext *event_context, GdkEvent *event);
-static gint sp_measure_context_item_handler(SPEventContext *event_context, SPItem *item, GdkEvent *event);
-
 static gint xp = 0; // where drag started
 static gint yp = 0;
 static gint tolerance = 0;
@@ -75,14 +69,12 @@ namespace {
 	bool measureContextRegistered = ToolFactory::instance().registerObject("/tools/measure", createMeasureContext);
 }
 
-const std::string& CMeasureContext::getPrefsPath() {
+const std::string& SPMeasureContext::getPrefsPath() {
 	return SPMeasureContext::prefsPath;
 }
 
 const std::string SPMeasureContext::prefsPath = "/tools/measure";
 
-G_DEFINE_TYPE(SPMeasureContext, sp_measure_context, SP_TYPE_EVENT_CONTEXT);
-
 namespace
 {
 
@@ -248,29 +240,10 @@ void createAngleDisplayCurve(SPDesktop *desktop, Geom::Point const &center, Geom
 
 } // namespace
 
-static void sp_measure_context_class_init(SPMeasureContextClass *klass)
-{
-    SPEventContextClass *event_context_class = reinterpret_cast<SPEventContextClass *>(klass);
-
-//    event_context_class->setup = sp_measure_context_setup;
-//    event_context_class->finish = sp_measure_context_finish;
-//
-//    event_context_class->root_handler = sp_measure_context_root_handler;
-//    event_context_class->item_handler = sp_measure_context_item_handler;
-}
-
-CMeasureContext::CMeasureContext(SPMeasureContext* measurecontext) : CEventContext(measurecontext) {
-	this->spmeasurecontext = measurecontext;
-}
 
 SPMeasureContext::SPMeasureContext() : SPEventContext() {
 	SPMeasureContext* measure_context = this;
 
-	measure_context->cmeasurecontext = new CMeasureContext(measure_context);
-	delete measure_context->ceventcontext;
-	measure_context->ceventcontext = measure_context->cmeasurecontext;
-	types.insert(typeid(SPMeasureContext));
-
 	measure_context->grabbed = 0;
 
     SPEventContext *event_context = SP_EVENT_CONTEXT(measure_context);
@@ -280,18 +253,11 @@ SPMeasureContext::SPMeasureContext() : SPEventContext() {
     event_context->hot_y = 4;
 }
 
-static void sp_measure_context_init(SPMeasureContext *measure_context)
-{
-	new (measure_context) SPMeasureContext();
-}
-
-static void sp_measure_context_finish(SPEventContext *ec)
-{
-	ec->ceventcontext->finish();
+SPMeasureContext::~SPMeasureContext() {
 }
 
-void CMeasureContext::finish() {
-	SPEventContext* ec = this->speventcontext;
+void SPMeasureContext::finish() {
+	SPEventContext* ec = this;
 
     SPMeasureContext *mc = SP_MEASURE_CONTEXT(ec);
 
@@ -303,34 +269,24 @@ void CMeasureContext::finish() {
     }
 }
 
-static void sp_measure_context_setup(SPEventContext *ec)
-{
-	ec->ceventcontext->setup();
-}
-
-void CMeasureContext::setup() {
-	SPEventContext* ec = this->speventcontext;
+void SPMeasureContext::setup() {
+	SPEventContext* ec = this;
 
 //    if (SP_EVENT_CONTEXT_CLASS(sp_measure_context_parent_class)->setup) {
 //        SP_EVENT_CONTEXT_CLASS(sp_measure_context_parent_class)->setup(ec);
 //    }
-	CEventContext::setup();
+	SPEventContext::setup();
 }
 
-static gint sp_measure_context_item_handler(SPEventContext *event_context, SPItem *item, GdkEvent *event)
-{
-	return event_context->ceventcontext->item_handler(item, event);
-}
-
-gint CMeasureContext::item_handler(SPItem* item, GdkEvent* event) {
-	SPEventContext* event_context = this->speventcontext;
+gint SPMeasureContext::item_handler(SPItem* item, GdkEvent* event) {
+	SPEventContext* event_context = this;
 
     gint ret = FALSE;
 
 //    if (SP_EVENT_CONTEXT_CLASS(sp_measure_context_parent_class)->item_handler) {
 //        ret = SP_EVENT_CONTEXT_CLASS(sp_measure_context_parent_class)->item_handler(event_context, item, event);
 //    }
-    ret = CEventContext::item_handler(item, event);
+    ret = SPEventContext::item_handler(item, event);
 
     return ret;
 }
@@ -370,13 +326,8 @@ static void calculate_intersections(SPDesktop * /*desktop*/, SPItem* item, Geom:
     }
 }
 
-static gint sp_measure_context_root_handler(SPEventContext *event_context, GdkEvent *event)
-{
-	return event_context->ceventcontext->root_handler(event);
-}
-
-gint CMeasureContext::root_handler(GdkEvent* event) {
-	SPEventContext* event_context = this->speventcontext;
+gint SPMeasureContext::root_handler(GdkEvent* event) {
+	SPEventContext* event_context = this;
 
     SPDesktop *desktop = event_context->desktop;
     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
@@ -827,7 +778,7 @@ gint CMeasureContext::root_handler(GdkEvent* event) {
 //        if (SP_EVENT_CONTEXT_CLASS(sp_measure_context_parent_class)->root_handler) {
 //            ret = SP_EVENT_CONTEXT_CLASS(sp_measure_context_parent_class)->root_handler(event_context, event);
 //        }
-    	ret = CEventContext::root_handler(event);
+    	ret = SPEventContext::root_handler(event);
     }
 
     return ret;
-- 
cgit v1.2.3


From 5512f857e2f33f1aa40124dc82b353e5f2e5a0b0 Mon Sep 17 00:00:00 2001
From: Markus Engel <markus.engel@tum.de>
Date: Sat, 20 Apr 2013 23:58:53 +0200
Subject: Moved factories to different files.

(bzr r11608.1.100)
---
 src/measure-context.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'src/measure-context.cpp')

diff --git a/src/measure-context.cpp b/src/measure-context.cpp
index 1b4d4afe3..2e8a1cd99 100644
--- a/src/measure-context.cpp
+++ b/src/measure-context.cpp
@@ -59,7 +59,7 @@ boost::optional<Geom::Point> lastEnd;
 std::vector<Inkscape::Display::TemporaryItem*> measure_tmp_items;
 
 
-#include "sp-factory.h"
+#include "tool-factory.h"
 
 namespace {
 	SPEventContext* createMeasureContext() {
-- 
cgit v1.2.3


From 389b871cdea29ace85567863c439eb0537a36f54 Mon Sep 17 00:00:00 2001
From: Markus Engel <markus.engel@tum.de>
Date: Sun, 21 Apr 2013 20:45:27 +0200
Subject: Cleaned up a bit.

(bzr r11608.1.102)
---
 src/measure-context.cpp | 114 +++++++++++++++++++-----------------------------
 1 file changed, 45 insertions(+), 69 deletions(-)

(limited to 'src/measure-context.cpp')

diff --git a/src/measure-context.cpp b/src/measure-context.cpp
index 2e8a1cd99..99f1d8d06 100644
--- a/src/measure-context.cpp
+++ b/src/measure-context.cpp
@@ -47,11 +47,6 @@
 using Inkscape::ControlManager;
 using Inkscape::CTLINE_SECONDARY;
 
-static gint xp = 0; // where drag started
-static gint yp = 0;
-static gint tolerance = 0;
-static bool within_tolerance = false;
-
 Geom::Point start_point;
 boost::optional<Geom::Point> explicitBase;
 boost::optional<Geom::Point> lastEnd;
@@ -242,54 +237,44 @@ void createAngleDisplayCurve(SPDesktop *desktop, Geom::Point const &center, Geom
 
 
 SPMeasureContext::SPMeasureContext() : SPEventContext() {
-	SPMeasureContext* measure_context = this;
-
-	measure_context->grabbed = 0;
+	this->grabbed = 0;
 
-    SPEventContext *event_context = SP_EVENT_CONTEXT(measure_context);
-
-    event_context->cursor_shape = cursor_measure_xpm;
-    event_context->hot_x = 4;
-    event_context->hot_y = 4;
+    this->cursor_shape = cursor_measure_xpm;
+    this->hot_x = 4;
+    this->hot_y = 4;
 }
 
 SPMeasureContext::~SPMeasureContext() {
 }
 
 void SPMeasureContext::finish() {
-	SPEventContext* ec = this;
-
-    SPMeasureContext *mc = SP_MEASURE_CONTEXT(ec);
+    this->enableGrDrag(false);
 
-    ec->enableGrDrag(false);
-
-    if (mc->grabbed) {
-        sp_canvas_item_ungrab(mc->grabbed, GDK_CURRENT_TIME);
-        mc->grabbed = NULL;
+    if (this->grabbed) {
+        sp_canvas_item_ungrab(this->grabbed, GDK_CURRENT_TIME);
+        this->grabbed = NULL;
     }
 }
 
-void SPMeasureContext::setup() {
-	SPEventContext* ec = this;
-
-//    if (SP_EVENT_CONTEXT_CLASS(sp_measure_context_parent_class)->setup) {
-//        SP_EVENT_CONTEXT_CLASS(sp_measure_context_parent_class)->setup(ec);
-//    }
-	SPEventContext::setup();
-}
-
-gint SPMeasureContext::item_handler(SPItem* item, GdkEvent* event) {
-	SPEventContext* event_context = this;
-
-    gint ret = FALSE;
-
-//    if (SP_EVENT_CONTEXT_CLASS(sp_measure_context_parent_class)->item_handler) {
-//        ret = SP_EVENT_CONTEXT_CLASS(sp_measure_context_parent_class)->item_handler(event_context, item, event);
-//    }
-    ret = SPEventContext::item_handler(item, event);
-
-    return ret;
-}
+//void SPMeasureContext::setup() {
+//	SPEventContext* ec = this;
+//
+////    if (SP_EVENT_CONTEXT_CLASS(sp_measure_context_parent_class)->setup) {
+////        SP_EVENT_CONTEXT_CLASS(sp_measure_context_parent_class)->setup(ec);
+////    }
+//	SPEventContext::setup();
+//}
+
+//gint SPMeasureContext::item_handler(SPItem* item, GdkEvent* event) {
+//    gint ret = FALSE;
+//
+////    if (SP_EVENT_CONTEXT_CLASS(sp_measure_context_parent_class)->item_handler) {
+////        ret = SP_EVENT_CONTEXT_CLASS(sp_measure_context_parent_class)->item_handler(event_context, item, event);
+////    }
+//    ret = SPEventContext::item_handler(item, event);
+//
+//    return ret;
+//}
 
 static bool GeomPointSortPredicate(const Geom::Point& p1, const Geom::Point& p2)
 {
@@ -327,23 +312,19 @@ static void calculate_intersections(SPDesktop * /*desktop*/, SPItem* item, Geom:
 }
 
 gint SPMeasureContext::root_handler(GdkEvent* event) {
-	SPEventContext* event_context = this;
-
-    SPDesktop *desktop = event_context->desktop;
     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
     tolerance = prefs->getIntLimited("/options/dragtolerance/value", 0, 0, 100);
 
-    SPMeasureContext *mc = SP_MEASURE_CONTEXT(event_context);
     gint ret = FALSE;
 
     switch (event->type) {
-        case GDK_BUTTON_PRESS:
-        {
+        case GDK_BUTTON_PRESS: {
             Geom::Point const button_w(event->button.x, event->button.y);
             explicitBase = boost::none;
             lastEnd = boost::none;
             start_point = desktop->w2d(button_w);
-            if (event->button.button == 1 && !event_context->space_panning) {
+
+            if (event->button.button == 1 && !this->space_panning) {
                 // save drag origin
                 xp = static_cast<gint>(event->button.x);
                 yp = static_cast<gint>(event->button.y);
@@ -360,12 +341,10 @@ gint SPMeasureContext::root_handler(GdkEvent* event) {
             sp_canvas_item_grab(SP_CANVAS_ITEM(desktop->acetate),
                                 GDK_KEY_PRESS_MASK | GDK_KEY_RELEASE_MASK | GDK_BUTTON_RELEASE_MASK | GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK | GDK_BUTTON_PRESS_MASK,
                                 NULL, event->button.time);
-            mc->grabbed = SP_CANVAS_ITEM(desktop->acetate);
+            this->grabbed = SP_CANVAS_ITEM(desktop->acetate);
             break;
         }
-
-        case GDK_KEY_PRESS:
-        {
+        case GDK_KEY_PRESS: {
             if ((event->key.keyval == GDK_KEY_Shift_L) || (event->key.keyval == GDK_KEY_Shift_R)) {
                 if (lastEnd) {
                     explicitBase = lastEnd;
@@ -373,10 +352,8 @@ gint SPMeasureContext::root_handler(GdkEvent* event) {
             }
             break;
         }
-
-        case GDK_MOTION_NOTIFY:
-        {
-            if (!((event->motion.state & GDK_BUTTON1_MASK) && !event_context->space_panning)) {
+        case GDK_MOTION_NOTIFY: {
+            if (!((event->motion.state & GDK_BUTTON1_MASK) && !this->space_panning)) {
                 if (!(event->motion.state & GDK_SHIFT_MASK)) {
                     Geom::Point const motion_w(event->motion.x, event->motion.y);
                     Geom::Point const motion_dt(desktop->w2d(motion_w));
@@ -407,6 +384,7 @@ gint SPMeasureContext::root_handler(GdkEvent* event) {
                 for (size_t idx = 0; idx < measure_tmp_items.size(); ++idx) {
                     desktop->remove_temporary_canvasitem(measure_tmp_items[idx]);
                 }
+
                 measure_tmp_items.clear();
 
                 Geom::Point const motion_w(event->motion.x, event->motion.y);
@@ -414,7 +392,7 @@ gint SPMeasureContext::root_handler(GdkEvent* event) {
                 Geom::Point end_point = motion_dt;
 
                 if (event->motion.state & GDK_CONTROL_MASK) {
-                    spdc_endpoint_snap_rotation(event_context, end_point, start_point, event->motion.state);
+                    spdc_endpoint_snap_rotation(this, end_point, start_point, event->motion.state);
                 } else {
                     if (!(event->motion.state & GDK_SHIFT_MASK)) {
                         SnapManager &m = desktop->namedview->snap_manager;
@@ -427,7 +405,6 @@ gint SPMeasureContext::root_handler(GdkEvent* event) {
                     }
                 }
 
-
                 Geom::PathVector lineseg;
                 Geom::Path p;
                 p.start(desktop->dt2doc(start_point));
@@ -445,6 +422,7 @@ gint SPMeasureContext::root_handler(GdkEvent* event) {
 
                     baseAngle = atan2(deltay2, deltax2);
                     angle -= baseAngle;
+
                     if (angle < -M_PI) {
                         angle += 2 * M_PI;
                     } else if (angle > M_PI) {
@@ -457,6 +435,7 @@ gint SPMeasureContext::root_handler(GdkEvent* event) {
 #define NPOINTS 800
 
                 std::vector<Geom::Point> points;
+
                 for (double i = 0; i < NPOINTS; i++) {
                     points.push_back(desktop->d2w(start_point + (i / NPOINTS) * (end_point - start_point)));
                 }
@@ -749,10 +728,8 @@ gint SPMeasureContext::root_handler(GdkEvent* event) {
             }
             break;
         }
-
-        case GDK_BUTTON_RELEASE:
-        {
-            sp_event_context_discard_delayed_snap_event(event_context);
+        case GDK_BUTTON_RELEASE: {
+            sp_event_context_discard_delayed_snap_event(this);
             explicitBase = boost::none;
             lastEnd = boost::none;
 
@@ -760,12 +737,14 @@ gint SPMeasureContext::root_handler(GdkEvent* event) {
             for (size_t idx = 0; idx < measure_tmp_items.size(); ++idx) {
                 desktop->remove_temporary_canvasitem(measure_tmp_items[idx]);
             }
+
             measure_tmp_items.clear();
 
-            if (mc->grabbed) {
-                sp_canvas_item_ungrab(mc->grabbed, event->button.time);
-                mc->grabbed = NULL;
+            if (this->grabbed) {
+                sp_canvas_item_ungrab(this->grabbed, event->button.time);
+                this->grabbed = NULL;
             }
+
             xp = 0;
             yp = 0;
             break;
@@ -775,9 +754,6 @@ gint SPMeasureContext::root_handler(GdkEvent* event) {
     }
 
     if (!ret) {
-//        if (SP_EVENT_CONTEXT_CLASS(sp_measure_context_parent_class)->root_handler) {
-//            ret = SP_EVENT_CONTEXT_CLASS(sp_measure_context_parent_class)->root_handler(event_context, event);
-//        }
     	ret = SPEventContext::root_handler(event);
     }
 
-- 
cgit v1.2.3


From bd77ef25e9161acb007323f851ba77e106036939 Mon Sep 17 00:00:00 2001
From: Matthew Petroff <matthew@mpetroff.net>
Date: Mon, 1 Jul 2013 23:40:52 -0400
Subject: Ported "ui/widget/page-sizer.cpp" and "document.cpp" to "Util::Unit"
 class.

(bzr r12380.1.4)
---
 src/measure-context.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'src/measure-context.cpp')

diff --git a/src/measure-context.cpp b/src/measure-context.cpp
index dc23cf5c6..9d60d38e8 100644
--- a/src/measure-context.cpp
+++ b/src/measure-context.cpp
@@ -13,7 +13,7 @@
 
 #include <gdk/gdkkeysyms.h>
 #include <boost/none_t.hpp>
-#include "helper/units.h"
+#include "util/units.h"
 #include "macros.h"
 #include "display/curve.h"
 #include "sp-shape.h"
-- 
cgit v1.2.3


From dd961a4de274306767c27756e80630d57f75ee0c Mon Sep 17 00:00:00 2001
From: Matthew Petroff <matthew@mpetroff.net>
Date: Sat, 6 Jul 2013 10:03:42 -0400
Subject: Ported measure-context.cpp (to do: port widgets/measure-toolbar.cpp
 so unit selector works again).

(bzr r12380.1.6)
---
 src/measure-context.cpp | 21 +++++++++++++--------
 1 file changed, 13 insertions(+), 8 deletions(-)

(limited to 'src/measure-context.cpp')

diff --git a/src/measure-context.cpp b/src/measure-context.cpp
index 9d60d38e8..6e7709d56 100644
--- a/src/measure-context.cpp
+++ b/src/measure-context.cpp
@@ -515,8 +515,13 @@ static gint sp_measure_context_root_handler(SPEventContext *event_context, GdkEv
                     std::sort(intersections.begin(), intersections.end(), GeomPointSortPredicate);
                 }
 
-                SPUnitId unitid = static_cast<SPUnitId>(prefs->getInt("/tools/measure/unitid", SP_UNIT_PX));
-                SPUnit unit = sp_unit_get_by_id(unitid);
+                Inkscape::Util::UnitTable unit_table;
+                Glib::ustring unit_name = prefs->getString("/tools/measure/unit");
+                if (!unit_name.compare("")) {
+                    unit_name = "px";
+                }
+                Inkscape::Util::Unit unit = unit_table.getUnit(unit_name);
+                Inkscape::Util::Unit px = unit_table.getUnit("px");
 
                 double fontsize = prefs->getInt("/tools/measure/fontsize");
 
@@ -527,7 +532,7 @@ static gint sp_measure_context_root_handler(SPEventContext *event_context, GdkEv
                 for (size_t idx = 1; idx < intersections.size(); ++idx) {
                     LabelPlacement placement;
                     placement.lengthVal = (intersections[idx] - intersections[idx - 1]).length();
-                    sp_convert_distance(&placement.lengthVal, &sp_unit_get_by_id(SP_UNIT_PX), &unit);
+                    placement.lengthVal = Inkscape::Util::Quantity::convert(placement.lengthVal, &px, &unit);
                     placement.offset = DIMENSION_OFFSET;
                     placement.start = desktop->doc2dt( (intersections[idx - 1] + intersections[idx]) / 2 );
                     placement.end = placement.start - (normal * placement.offset);
@@ -543,7 +548,7 @@ static gint sp_measure_context_root_handler(SPEventContext *event_context, GdkEv
                     LabelPlacement &place = *it;
 
                     // TODO cleanup memory, Glib::ustring, etc.:
-                    gchar *measure_str = g_strdup_printf("%.2f %s", place.lengthVal, unit.abbr);
+                    gchar *measure_str = g_strdup_printf("%.2f %s", place.lengthVal, unit.abbr.c_str());
                     SPCanvasText *canvas_tooltip = sp_canvastext_new(sp_desktop_tempgroup(desktop),
                                                                      desktop,
                                                                      place.end,
@@ -584,10 +589,10 @@ static gint sp_measure_context_root_handler(SPEventContext *event_context, GdkEv
 
                 {
                     double totallengthval = (end_point - start_point).length();
-                    sp_convert_distance(&totallengthval, &sp_unit_get_by_id(SP_UNIT_PX), &unit);
+                    totallengthval = Inkscape::Util::Quantity::convert(totallengthval, &px, &unit);
 
                     // TODO cleanup memory, Glib::ustring, etc.:
-                    gchar *totallength_str = g_strdup_printf("%.2f %s", totallengthval, unit.abbr);
+                    gchar *totallength_str = g_strdup_printf("%.2f %s", totallengthval, unit.abbr.c_str());
                     SPCanvasText *canvas_tooltip = sp_canvastext_new(sp_desktop_tempgroup(desktop),
                                                                      desktop,
                                                                      end_point + desktop->w2d(Geom::Point(3*fontsize, -fontsize)),
@@ -605,10 +610,10 @@ static gint sp_measure_context_root_handler(SPEventContext *event_context, GdkEv
 
                 if (intersections.size() > 2) {
                     double totallengthval = (intersections[intersections.size()-1] - intersections[0]).length();
-                    sp_convert_distance(&totallengthval, &sp_unit_get_by_id(SP_UNIT_PX), &unit);
+                    totallengthval = Inkscape::Util::Quantity::convert(totallengthval, &px, &unit);
 
                     // TODO cleanup memory, Glib::ustring, etc.:
-                    gchar *total_str = g_strdup_printf("%.2f %s", totallengthval, unit.abbr);
+                    gchar *total_str = g_strdup_printf("%.2f %s", totallengthval, unit.abbr.c_str());
                     SPCanvasText *canvas_tooltip = sp_canvastext_new(sp_desktop_tempgroup(desktop),
                                                                      desktop,
                                                                      desktop->doc2dt((intersections[0] + intersections[intersections.size()-1])/2) + normal * 60,
-- 
cgit v1.2.3


From 3772fc428950b2b946a1bd7c7c97e06219c3165f Mon Sep 17 00:00:00 2001
From: Matthew Petroff <matthew@mpetroff.net>
Date: Thu, 18 Jul 2013 17:21:24 -0400
Subject: Switch unit functions from using pointer arguements to reference
 arguements.

(bzr r12380.1.28)
---
 src/measure-context.cpp | 14 ++++++--------
 1 file changed, 6 insertions(+), 8 deletions(-)

(limited to 'src/measure-context.cpp')

diff --git a/src/measure-context.cpp b/src/measure-context.cpp
index 6e7709d56..465b1da80 100644
--- a/src/measure-context.cpp
+++ b/src/measure-context.cpp
@@ -520,8 +520,6 @@ static gint sp_measure_context_root_handler(SPEventContext *event_context, GdkEv
                 if (!unit_name.compare("")) {
                     unit_name = "px";
                 }
-                Inkscape::Util::Unit unit = unit_table.getUnit(unit_name);
-                Inkscape::Util::Unit px = unit_table.getUnit("px");
 
                 double fontsize = prefs->getInt("/tools/measure/fontsize");
 
@@ -532,7 +530,7 @@ static gint sp_measure_context_root_handler(SPEventContext *event_context, GdkEv
                 for (size_t idx = 1; idx < intersections.size(); ++idx) {
                     LabelPlacement placement;
                     placement.lengthVal = (intersections[idx] - intersections[idx - 1]).length();
-                    placement.lengthVal = Inkscape::Util::Quantity::convert(placement.lengthVal, &px, &unit);
+                    placement.lengthVal = Inkscape::Util::Quantity::convert(placement.lengthVal, "px", unit_name);
                     placement.offset = DIMENSION_OFFSET;
                     placement.start = desktop->doc2dt( (intersections[idx - 1] + intersections[idx]) / 2 );
                     placement.end = placement.start - (normal * placement.offset);
@@ -548,7 +546,7 @@ static gint sp_measure_context_root_handler(SPEventContext *event_context, GdkEv
                     LabelPlacement &place = *it;
 
                     // TODO cleanup memory, Glib::ustring, etc.:
-                    gchar *measure_str = g_strdup_printf("%.2f %s", place.lengthVal, unit.abbr.c_str());
+                    gchar *measure_str = g_strdup_printf("%.2f %s", place.lengthVal, unit_name.c_str());
                     SPCanvasText *canvas_tooltip = sp_canvastext_new(sp_desktop_tempgroup(desktop),
                                                                      desktop,
                                                                      place.end,
@@ -589,10 +587,10 @@ static gint sp_measure_context_root_handler(SPEventContext *event_context, GdkEv
 
                 {
                     double totallengthval = (end_point - start_point).length();
-                    totallengthval = Inkscape::Util::Quantity::convert(totallengthval, &px, &unit);
+                    totallengthval = Inkscape::Util::Quantity::convert(totallengthval, "px", unit_name);
 
                     // TODO cleanup memory, Glib::ustring, etc.:
-                    gchar *totallength_str = g_strdup_printf("%.2f %s", totallengthval, unit.abbr.c_str());
+                    gchar *totallength_str = g_strdup_printf("%.2f %s", totallengthval, unit_name.c_str());
                     SPCanvasText *canvas_tooltip = sp_canvastext_new(sp_desktop_tempgroup(desktop),
                                                                      desktop,
                                                                      end_point + desktop->w2d(Geom::Point(3*fontsize, -fontsize)),
@@ -610,10 +608,10 @@ static gint sp_measure_context_root_handler(SPEventContext *event_context, GdkEv
 
                 if (intersections.size() > 2) {
                     double totallengthval = (intersections[intersections.size()-1] - intersections[0]).length();
-                    totallengthval = Inkscape::Util::Quantity::convert(totallengthval, &px, &unit);
+                    totallengthval = Inkscape::Util::Quantity::convert(totallengthval, "px", unit_name);
 
                     // TODO cleanup memory, Glib::ustring, etc.:
-                    gchar *total_str = g_strdup_printf("%.2f %s", totallengthval, unit.abbr.c_str());
+                    gchar *total_str = g_strdup_printf("%.2f %s", totallengthval, unit_name.c_str());
                     SPCanvasText *canvas_tooltip = sp_canvastext_new(sp_desktop_tempgroup(desktop),
                                                                      desktop,
                                                                      desktop->doc2dt((intersections[0] + intersections[intersections.size()-1])/2) + normal * 60,
-- 
cgit v1.2.3


From b2dd3583e7372d23d18bbc6e861f4f645ec3dc37 Mon Sep 17 00:00:00 2001
From: Markus Engel <markus.engel@tum.de>
Date: Tue, 30 Jul 2013 23:17:21 +0200
Subject: Further refactoring of EventContexts.

(bzr r11608.1.109)
---
 src/measure-context.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'src/measure-context.cpp')

diff --git a/src/measure-context.cpp b/src/measure-context.cpp
index 99f1d8d06..9ee728bc8 100644
--- a/src/measure-context.cpp
+++ b/src/measure-context.cpp
@@ -311,7 +311,7 @@ static void calculate_intersections(SPDesktop * /*desktop*/, SPItem* item, Geom:
     }
 }
 
-gint SPMeasureContext::root_handler(GdkEvent* event) {
+bool SPMeasureContext::root_handler(GdkEvent* event) {
     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
     tolerance = prefs->getIntLimited("/options/dragtolerance/value", 0, 0, 100);
 
-- 
cgit v1.2.3


From 013e92537296f6ba2434e29a96d18eeb353d9560 Mon Sep 17 00:00:00 2001
From: "Johan B. C. Engelen" <jbc.engelen@swissonline.ch>
Date: Sat, 3 Aug 2013 23:30:12 +0200
Subject: reduce scope of variables

(bzr r12463)
---
 src/measure-context.cpp | 1 -
 1 file changed, 1 deletion(-)

(limited to 'src/measure-context.cpp')

diff --git a/src/measure-context.cpp b/src/measure-context.cpp
index dc23cf5c6..771125b7f 100644
--- a/src/measure-context.cpp
+++ b/src/measure-context.cpp
@@ -494,7 +494,6 @@ static gint sp_measure_context_root_handler(SPEventContext *event_context, GdkEv
                                 }
 
                                 curve->transform(item->i2doc_affine());
-                                Geom::PathVector pathv = curve->get_pathvector();
 
                                 calculate_intersections(desktop, item, lineseg, curve, intersections);
 
-- 
cgit v1.2.3


From 6ae6c0bea96eef09907091279e0678aa5f83102d Mon Sep 17 00:00:00 2001
From: Matthew Petroff <matthew@mpetroff.net>
Date: Sun, 4 Aug 2013 18:01:18 -0400
Subject: Switched to global UnitTable.

(bzr r12380.1.62)
---
 src/measure-context.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'src/measure-context.cpp')

diff --git a/src/measure-context.cpp b/src/measure-context.cpp
index 465b1da80..3c02c6f15 100644
--- a/src/measure-context.cpp
+++ b/src/measure-context.cpp
@@ -46,6 +46,7 @@
 
 using Inkscape::ControlManager;
 using Inkscape::CTLINE_SECONDARY;
+using Inkscape::Util::unit_table;
 
 static void sp_measure_context_setup(SPEventContext *ec);
 static void sp_measure_context_finish(SPEventContext *ec);
@@ -515,7 +516,6 @@ static gint sp_measure_context_root_handler(SPEventContext *event_context, GdkEv
                     std::sort(intersections.begin(), intersections.end(), GeomPointSortPredicate);
                 }
 
-                Inkscape::Util::UnitTable unit_table;
                 Glib::ustring unit_name = prefs->getString("/tools/measure/unit");
                 if (!unit_name.compare("")) {
                     unit_name = "px";
-- 
cgit v1.2.3


From fc710269ffba364187eb44df32d868addbbf30d9 Mon Sep 17 00:00:00 2001
From: Markus Engel <markus.engel@tum.de>
Date: Fri, 27 Sep 2013 02:30:21 +0200
Subject: Adjusted code style of SPEllipse.

(bzr r12602)
---
 src/measure-context.cpp | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

(limited to 'src/measure-context.cpp')

diff --git a/src/measure-context.cpp b/src/measure-context.cpp
index 8db703205..9d8dc2b2f 100644
--- a/src/measure-context.cpp
+++ b/src/measure-context.cpp
@@ -48,10 +48,6 @@ using Inkscape::ControlManager;
 using Inkscape::CTLINE_SECONDARY;
 using Inkscape::Util::unit_table;
 
-Geom::Point start_point;
-boost::optional<Geom::Point> explicitBase;
-boost::optional<Geom::Point> lastEnd;
-
 std::vector<Inkscape::Display::TemporaryItem*> measure_tmp_items;
 
 
@@ -313,6 +309,10 @@ static void calculate_intersections(SPDesktop * /*desktop*/, SPItem* item, Geom:
 }
 
 bool SPMeasureContext::root_handler(GdkEvent* event) {
+    Geom::Point start_point;
+    boost::optional<Geom::Point> explicitBase;
+    boost::optional<Geom::Point> lastEnd;
+
     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
     tolerance = prefs->getIntLimited("/options/dragtolerance/value", 0, 0, 100);
 
-- 
cgit v1.2.3


From 6ee13490aaa9781b765589e22fb9206c6cb7e9e9 Mon Sep 17 00:00:00 2001
From: Markus Engel <markus.engel@tum.de>
Date: Sat, 28 Sep 2013 20:47:16 +0200
Subject: Fixed MeasureContext.

Fixed bugs:
  - https://launchpad.net/bugs/1232494

(bzr r12613)
---
 src/measure-context.cpp | 4 ----
 1 file changed, 4 deletions(-)

(limited to 'src/measure-context.cpp')

diff --git a/src/measure-context.cpp b/src/measure-context.cpp
index 9d8dc2b2f..7570e36e7 100644
--- a/src/measure-context.cpp
+++ b/src/measure-context.cpp
@@ -309,10 +309,6 @@ static void calculate_intersections(SPDesktop * /*desktop*/, SPItem* item, Geom:
 }
 
 bool SPMeasureContext::root_handler(GdkEvent* event) {
-    Geom::Point start_point;
-    boost::optional<Geom::Point> explicitBase;
-    boost::optional<Geom::Point> lastEnd;
-
     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
     tolerance = prefs->getIntLimited("/options/dragtolerance/value", 0, 0, 100);
 
-- 
cgit v1.2.3


From 55b451bf382e0c3d5ed8728e42fbb535acfa8a33 Mon Sep 17 00:00:00 2001
From: Markus Engel <markus.engel@tum.de>
Date: Thu, 7 Nov 2013 21:44:00 +0100
Subject: First step of moving tools into appropriate namespaces.

(bzr r12782)
---
 src/measure-context.cpp | 41 ++++++++++++++++++++++++-----------------
 1 file changed, 24 insertions(+), 17 deletions(-)

(limited to 'src/measure-context.cpp')

diff --git a/src/measure-context.cpp b/src/measure-context.cpp
index 7570e36e7..11161dc8f 100644
--- a/src/measure-context.cpp
+++ b/src/measure-context.cpp
@@ -48,24 +48,27 @@ using Inkscape::ControlManager;
 using Inkscape::CTLINE_SECONDARY;
 using Inkscape::Util::unit_table;
 
-std::vector<Inkscape::Display::TemporaryItem*> measure_tmp_items;
+#include "tool-factory.h"
 
+namespace Inkscape {
+namespace UI {
+namespace Tools {
 
-#include "tool-factory.h"
+std::vector<Inkscape::Display::TemporaryItem*> measure_tmp_items;
 
 namespace {
-	SPEventContext* createMeasureContext() {
-		return new SPMeasureContext();
+	ToolBase* createMeasureContext() {
+		return new MeasureTool();
 	}
 
 	bool measureContextRegistered = ToolFactory::instance().registerObject("/tools/measure", createMeasureContext);
 }
 
-const std::string& SPMeasureContext::getPrefsPath() {
-	return SPMeasureContext::prefsPath;
+const std::string& MeasureTool::getPrefsPath() {
+	return MeasureTool::prefsPath;
 }
 
-const std::string SPMeasureContext::prefsPath = "/tools/measure";
+const std::string MeasureTool::prefsPath = "/tools/measure";
 
 namespace
 {
@@ -233,7 +236,7 @@ void createAngleDisplayCurve(SPDesktop *desktop, Geom::Point const &center, Geom
 } // namespace
 
 
-SPMeasureContext::SPMeasureContext() : SPEventContext() {
+MeasureTool::MeasureTool() : ToolBase() {
 	this->grabbed = 0;
 
     this->cursor_shape = cursor_measure_xpm;
@@ -241,10 +244,10 @@ SPMeasureContext::SPMeasureContext() : SPEventContext() {
     this->hot_y = 4;
 }
 
-SPMeasureContext::~SPMeasureContext() {
+MeasureTool::~MeasureTool() {
 }
 
-void SPMeasureContext::finish() {
+void MeasureTool::finish() {
     this->enableGrDrag(false);
 
     if (this->grabbed) {
@@ -253,22 +256,22 @@ void SPMeasureContext::finish() {
     }
 }
 
-//void SPMeasureContext::setup() {
-//	SPEventContext* ec = this;
+//void MeasureTool::setup() {
+//	ToolBase* ec = this;
 //
 ////    if (SP_EVENT_CONTEXT_CLASS(sp_measure_context_parent_class)->setup) {
 ////        SP_EVENT_CONTEXT_CLASS(sp_measure_context_parent_class)->setup(ec);
 ////    }
-//	SPEventContext::setup();
+//	ToolBase::setup();
 //}
 
-//gint SPMeasureContext::item_handler(SPItem* item, GdkEvent* event) {
+//gint MeasureTool::item_handler(SPItem* item, GdkEvent* event) {
 //    gint ret = FALSE;
 //
 ////    if (SP_EVENT_CONTEXT_CLASS(sp_measure_context_parent_class)->item_handler) {
 ////        ret = SP_EVENT_CONTEXT_CLASS(sp_measure_context_parent_class)->item_handler(event_context, item, event);
 ////    }
-//    ret = SPEventContext::item_handler(item, event);
+//    ret = ToolBase::item_handler(item, event);
 //
 //    return ret;
 //}
@@ -308,7 +311,7 @@ static void calculate_intersections(SPDesktop * /*desktop*/, SPItem* item, Geom:
     }
 }
 
-bool SPMeasureContext::root_handler(GdkEvent* event) {
+bool MeasureTool::root_handler(GdkEvent* event) {
     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
     tolerance = prefs->getIntLimited("/options/dragtolerance/value", 0, 0, 100);
 
@@ -752,12 +755,16 @@ bool SPMeasureContext::root_handler(GdkEvent* event) {
     }
 
     if (!ret) {
-    	ret = SPEventContext::root_handler(event);
+    	ret = ToolBase::root_handler(event);
     }
 
     return ret;
 }
 
+}
+}
+}
+
 /*
   Local Variables:
   mode:c++
-- 
cgit v1.2.3


From c04e30df241a3ee039077425bab9b9c37abe2854 Mon Sep 17 00:00:00 2001
From: Markus Engel <markus.engel@tum.de>
Date: Sat, 9 Nov 2013 23:36:13 +0100
Subject: Moved and renamed some tool-related files.

(bzr r12785)
---
 src/measure-context.cpp | 777 ------------------------------------------------
 1 file changed, 777 deletions(-)
 delete mode 100644 src/measure-context.cpp

(limited to 'src/measure-context.cpp')

diff --git a/src/measure-context.cpp b/src/measure-context.cpp
deleted file mode 100644
index 11161dc8f..000000000
--- a/src/measure-context.cpp
+++ /dev/null
@@ -1,777 +0,0 @@
-/*
- * Our nice measuring tool
- *
- * Authors:
- *   Felipe Correa da Silva Sanches <juca@members.fsf.org>
- *   Jon A. Cruz <jon@joncruz.org>
- *
- * Copyright (C) 2011 Authors
- *
- * Released under GNU GPL, read the file 'COPYING' for more information
- */
-
-
-#include <gdk/gdkkeysyms.h>
-#include <boost/none_t.hpp>
-#include "util/units.h"
-#include "macros.h"
-#include "display/curve.h"
-#include "sp-shape.h"
-#include "sp-text.h"
-#include "sp-flowtext.h"
-#include "text-editing.h"
-#include "display/sp-ctrlline.h"
-#include "display/sodipodi-ctrl.h"
-#include "display/sp-canvas-item.h"
-#include "display/sp-canvas-util.h"
-#include "desktop.h"
-#include "document.h"
-#include "pixmaps/cursor-measure.xpm"
-#include "preferences.h"
-#include "inkscape.h"
-#include "desktop-handles.h"
-#include "measure-context.h"
-#include "draw-context.h"
-#include "display/canvas-text.h"
-#include "path-chemistry.h"
-#include "2geom/line.h"
-#include <2geom/path-intersection.h>
-#include <2geom/pathvector.h>
-#include <2geom/crossing.h>
-#include <2geom/angle.h>
-#include "snap.h"
-#include "sp-namedview.h"
-#include "enums.h"
-#include "ui/control-manager.h"
-
-using Inkscape::ControlManager;
-using Inkscape::CTLINE_SECONDARY;
-using Inkscape::Util::unit_table;
-
-#include "tool-factory.h"
-
-namespace Inkscape {
-namespace UI {
-namespace Tools {
-
-std::vector<Inkscape::Display::TemporaryItem*> measure_tmp_items;
-
-namespace {
-	ToolBase* createMeasureContext() {
-		return new MeasureTool();
-	}
-
-	bool measureContextRegistered = ToolFactory::instance().registerObject("/tools/measure", createMeasureContext);
-}
-
-const std::string& MeasureTool::getPrefsPath() {
-	return MeasureTool::prefsPath;
-}
-
-const std::string MeasureTool::prefsPath = "/tools/measure";
-
-namespace
-{
-
-gint const DIMENSION_OFFSET = 35;
-
-/**
- * Simple class to use for removing label overlap.
- */
-class LabelPlacement {
-public:
-
-    double lengthVal;
-    double offset;
-    Geom::Point start;
-    Geom::Point end;
-};
-
-bool SortLabelPlacement(LabelPlacement const &first, LabelPlacement const &second)
-{
-    if (first.end[Geom::Y] == second.end[Geom::Y]) {
-        return first.end[Geom::X] < second.end[Geom::X];
-    } else {
-        return first.end[Geom::Y] < second.end[Geom::Y];
-    }
-}
-
-void repositionOverlappingLabels(std::vector<LabelPlacement> &placements, SPDesktop *desktop, Geom::Point const &normal, double fontsize)
-{
-    std::sort(placements.begin(), placements.end(), SortLabelPlacement);
-
-    double border = 3;
-    Geom::Rect box;
-    {
-        Geom::Point tmp(fontsize * 8 + (border * 2), fontsize + (border * 2));
-        tmp = desktop->w2d(tmp);
-        box = Geom::Rect(-tmp[Geom::X] / 2, -tmp[Geom::Y] / 2, tmp[Geom::X] / 2, tmp[Geom::Y] / 2);
-    }
-
-    // Using index since vector may be re-ordered as we go.
-    // Starting at one, since the first item can't overlap itself
-    for (size_t i = 1; i < placements.size(); i++) {
-        LabelPlacement &place = placements[i];
-
-        bool changed = false;
-        do {
-            Geom::Rect current(box + place.end);
-
-            changed = false;
-            bool overlaps = false;
-            for (size_t j = i; (j > 0) && !overlaps; --j) {
-                LabelPlacement &otherPlace = placements[j - 1];
-                Geom::Rect target(box + otherPlace.end);
-                if (current.intersects(target)) {
-                    overlaps = true;
-                }
-            }
-            if (overlaps) {
-                place.offset += (fontsize + border);
-                place.end = place.start - desktop->w2d(normal * place.offset);
-                changed = true;
-            }
-        } while (changed);
-
-        std::sort(placements.begin(), placements.begin() + i + 1, SortLabelPlacement);
-    }
-}
-
-/**
- * Calculates where to place the anchor for the display text and arc.
- *
- * @param desktop the desktop that is being used.
- * @param angle the angle to be displaying.
- * @param baseAngle the angle of the initial baseline.
- * @param startPoint the point that is the vertex of the selected angle.
- * @param endPoint the point that is the end the user is manipulating for measurement.
- * @param fontsize the size to display the text label at.
- */
-Geom::Point calcAngleDisplayAnchor(SPDesktop *desktop, double angle, double baseAngle,
-                                   Geom::Point const &startPoint, Geom::Point const &endPoint,
-                                   double fontsize)
-{
-    // Time for the trick work of figuring out where things should go, and how.
-    double lengthVal = (endPoint - startPoint).length();
-    double effective = baseAngle + (angle / 2);
-    Geom::Point where(lengthVal, 0);
-    where *= Geom::Affine(Geom::Rotate(effective)) * Geom::Affine(Geom::Translate(startPoint));
-
-    // When the angle is tight, the label would end up under the cursor and/or lines. Bump it
-    double scaledFontsize = std::abs(fontsize * desktop->w2d(Geom::Point(0, 1.0))[Geom::Y]);
-    if (std::abs((where - endPoint).length()) < scaledFontsize) {
-        where[Geom::Y] += scaledFontsize * 2;
-    }
-
-    // We now have the ideal position, but need to see if it will fit/work.
-
-    Geom::Rect visibleArea = desktop->get_display_area();
-    // Bring it in to "title safe" for the anchor point
-    Geom::Point textBox = desktop->w2d(Geom::Point(fontsize * 3, fontsize / 2));
-    textBox[Geom::Y] = std::abs(textBox[Geom::Y]);
-
-    visibleArea = Geom::Rect(visibleArea.min()[Geom::X] + textBox[Geom::X],
-                             visibleArea.min()[Geom::Y] + textBox[Geom::Y],
-                             visibleArea.max()[Geom::X] - textBox[Geom::X],
-                             visibleArea.max()[Geom::Y] - textBox[Geom::Y]);
-
-    where[Geom::X] = std::min(where[Geom::X], visibleArea.max()[Geom::X]);
-    where[Geom::X] = std::max(where[Geom::X], visibleArea.min()[Geom::X]);
-    where[Geom::Y] = std::min(where[Geom::Y], visibleArea.max()[Geom::Y]);
-    where[Geom::Y] = std::max(where[Geom::Y], visibleArea.min()[Geom::Y]);
-
-    return where;
-}
-
-/**
- * Given an angle, the arc center and edge point, draw an arc segment centered around that edge point.
- *
- * @param desktop the desktop that is being used.
- * @param center the center point for the arc.
- * @param end the point that ends at the edge of the arc segment.
- * @param anchor the anchor point for displaying the text label.
- * @param angle the angle of the arc segment to draw.
- */
-void createAngleDisplayCurve(SPDesktop *desktop, Geom::Point const &center, Geom::Point const &end, Geom::Point const &anchor, double angle)
-{
-    // Given that we have a point on the arc's edge and the angle of the arc, we need to get the two endpoints.
-
-    double textLen = std::abs((anchor - center).length());
-    double sideLen = std::abs((end - center).length());
-    if (sideLen > 0.0) {
-        double factor = std::min(1.0, textLen / sideLen);
-    
-        // arc start
-        Geom::Point p1 = end * (Geom::Affine(Geom::Translate(-center))
-                                * Geom::Affine(Geom::Scale(factor))
-                                * Geom::Affine(Geom::Translate(center)));
-
-        // arc end
-        Geom::Point p4 = p1 * (Geom::Affine(Geom::Translate(-center))
-                               * Geom::Affine(Geom::Rotate(-angle))
-                               * Geom::Affine(Geom::Translate(center)));
-
-        // from Riskus
-        double xc = center[Geom::X];
-        double yc = center[Geom::Y];
-        double ax = p1[Geom::X] - xc;
-        double ay = p1[Geom::Y] - yc;
-        double bx = p4[Geom::X] - xc;
-        double by = p4[Geom::Y] - yc;
-        double q1 = (ax * ax) + (ay * ay);
-        double q2 = q1 + (ax * bx) + (ay * by);
-
-        double k2 = (4.0 / 3.0) * (std::sqrt(2 * q1 * q2) - q2) / ((ax * by) - (ay * bx));
-
-        Geom::Point p2(xc + ax - (k2 * ay),
-                       yc + ay  + (k2 * ax));
-        Geom::Point p3(xc + bx + (k2 * by),
-                       yc + by - (k2 * bx));
-        SPCtrlCurve *curve = ControlManager::getManager().createControlCurve(sp_desktop_tempgroup(desktop), p1, p2, p3, p4, CTLINE_SECONDARY);
-
-        measure_tmp_items.push_back(desktop->add_temporary_canvasitem(SP_CANVAS_ITEM(curve), 0, true));
-    }
-}
-
-} // namespace
-
-
-MeasureTool::MeasureTool() : ToolBase() {
-	this->grabbed = 0;
-
-    this->cursor_shape = cursor_measure_xpm;
-    this->hot_x = 4;
-    this->hot_y = 4;
-}
-
-MeasureTool::~MeasureTool() {
-}
-
-void MeasureTool::finish() {
-    this->enableGrDrag(false);
-
-    if (this->grabbed) {
-        sp_canvas_item_ungrab(this->grabbed, GDK_CURRENT_TIME);
-        this->grabbed = NULL;
-    }
-}
-
-//void MeasureTool::setup() {
-//	ToolBase* ec = this;
-//
-////    if (SP_EVENT_CONTEXT_CLASS(sp_measure_context_parent_class)->setup) {
-////        SP_EVENT_CONTEXT_CLASS(sp_measure_context_parent_class)->setup(ec);
-////    }
-//	ToolBase::setup();
-//}
-
-//gint MeasureTool::item_handler(SPItem* item, GdkEvent* event) {
-//    gint ret = FALSE;
-//
-////    if (SP_EVENT_CONTEXT_CLASS(sp_measure_context_parent_class)->item_handler) {
-////        ret = SP_EVENT_CONTEXT_CLASS(sp_measure_context_parent_class)->item_handler(event_context, item, event);
-////    }
-//    ret = ToolBase::item_handler(item, event);
-//
-//    return ret;
-//}
-
-static bool GeomPointSortPredicate(const Geom::Point& p1, const Geom::Point& p2)
-{
-    if (p1[Geom::Y] == p2[Geom::Y]) {
-        return p1[Geom::X] < p2[Geom::X];
-    } else {
-        return p1[Geom::Y] < p2[Geom::Y];
-    }
-}
-
-static void calculate_intersections(SPDesktop * /*desktop*/, SPItem* item, Geom::PathVector const &lineseg, SPCurve *curve, std::vector<Geom::Point> &intersections)
-{
-    curve->transform(item->i2doc_affine());
-
-    // Find all intersections of the control-line with this shape
-    Geom::CrossingSet cs = Geom::crossings(lineseg, curve->get_pathvector());
-
-    // Reconstruct and store the points of intersection
-    for (Geom::Crossings::const_iterator m = cs[0].begin(); m != cs[0].end(); ++m) {
-#if 0
-//TODO: consider only visible intersections
-        Geom::Point intersection = lineseg[0].pointAt((*m).ta);
-        double eps = 0.0001;
-        SPDocument* doc = sp_desktop_document(desktop);
-        if (((*m).ta > eps &&
-             item == doc->getItemAtPoint(desktop->dkey, lineseg[0].pointAt((*m).ta - eps), false, NULL)) ||
-            ((*m).ta + eps < 1 &&
-             item == doc->getItemAtPoint(desktop->dkey, lineseg[0].pointAt((*m).ta + eps), false, NULL)) ) {
-            intersections.push_back(intersection);
-        }
-#else
-        intersections.push_back(lineseg[0].pointAt((*m).ta));
-#endif
-    }
-}
-
-bool MeasureTool::root_handler(GdkEvent* event) {
-    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
-    tolerance = prefs->getIntLimited("/options/dragtolerance/value", 0, 0, 100);
-
-    gint ret = FALSE;
-
-    switch (event->type) {
-        case GDK_BUTTON_PRESS: {
-            Geom::Point const button_w(event->button.x, event->button.y);
-            explicitBase = boost::none;
-            lastEnd = boost::none;
-            start_point = desktop->w2d(button_w);
-
-            if (event->button.button == 1 && !this->space_panning) {
-                // save drag origin
-                xp = static_cast<gint>(event->button.x);
-                yp = static_cast<gint>(event->button.y);
-                within_tolerance = true;
-
-                ret = TRUE;
-            }
-
-            SnapManager &m = desktop->namedview->snap_manager;
-            m.setup(desktop);
-            m.freeSnapReturnByRef(start_point, Inkscape::SNAPSOURCE_OTHER_HANDLE);
-            m.unSetup();
-
-            sp_canvas_item_grab(SP_CANVAS_ITEM(desktop->acetate),
-                                GDK_KEY_PRESS_MASK | GDK_KEY_RELEASE_MASK | GDK_BUTTON_RELEASE_MASK | GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK | GDK_BUTTON_PRESS_MASK,
-                                NULL, event->button.time);
-            this->grabbed = SP_CANVAS_ITEM(desktop->acetate);
-            break;
-        }
-        case GDK_KEY_PRESS: {
-            if ((event->key.keyval == GDK_KEY_Shift_L) || (event->key.keyval == GDK_KEY_Shift_R)) {
-                if (lastEnd) {
-                    explicitBase = lastEnd;
-                }
-            }
-            break;
-        }
-        case GDK_MOTION_NOTIFY: {
-            if (!((event->motion.state & GDK_BUTTON1_MASK) && !this->space_panning)) {
-                if (!(event->motion.state & GDK_SHIFT_MASK)) {
-                    Geom::Point const motion_w(event->motion.x, event->motion.y);
-                    Geom::Point const motion_dt(desktop->w2d(motion_w));
-
-                    SnapManager &m = desktop->namedview->snap_manager;
-                    m.setup(desktop);
-
-                    Inkscape::SnapCandidatePoint scp(motion_dt, Inkscape::SNAPSOURCE_OTHER_HANDLE);
-                    scp.addOrigin(start_point);
-
-                    m.preSnap(scp);
-                    m.unSetup();
-                }
-            } else {
-                ret = TRUE;
-
-                if ( within_tolerance
-                     && ( abs( static_cast<gint>(event->motion.x) - xp ) < tolerance )
-                     && ( abs( static_cast<gint>(event->motion.y) - yp ) < tolerance ) ) {
-                    break; // do not drag if we're within tolerance from origin
-                }
-                // Once the user has moved farther than tolerance from the original location
-                // (indicating they intend to move the object, not click), then always process the
-                // motion notify coordinates as given (no snapping back to origin)
-                within_tolerance = false;
-
-                //clear previous temporary canvas items, we'll draw new ones
-                for (size_t idx = 0; idx < measure_tmp_items.size(); ++idx) {
-                    desktop->remove_temporary_canvasitem(measure_tmp_items[idx]);
-                }
-
-                measure_tmp_items.clear();
-
-                Geom::Point const motion_w(event->motion.x, event->motion.y);
-                Geom::Point const motion_dt(desktop->w2d(motion_w));
-                Geom::Point end_point = motion_dt;
-
-                if (event->motion.state & GDK_CONTROL_MASK) {
-                    spdc_endpoint_snap_rotation(this, end_point, start_point, event->motion.state);
-                } else {
-                    if (!(event->motion.state & GDK_SHIFT_MASK)) {
-                        SnapManager &m = desktop->namedview->snap_manager;
-                        m.setup(desktop);
-                        Inkscape::SnapCandidatePoint scp(end_point, Inkscape::SNAPSOURCE_OTHER_HANDLE);
-                        scp.addOrigin(start_point);
-                        Inkscape::SnappedPoint sp = m.freeSnap(scp);
-                        end_point = sp.getPoint();
-                        m.unSetup();
-                    }
-                }
-
-                Geom::PathVector lineseg;
-                Geom::Path p;
-                p.start(desktop->dt2doc(start_point));
-                p.appendNew<Geom::LineSegment>(desktop->dt2doc(end_point));
-                lineseg.push_back(p);
-
-                double deltax = end_point[Geom::X] - start_point[Geom::X];
-                double deltay = end_point[Geom::Y] - start_point[Geom::Y];
-                double angle = atan2(deltay, deltax);
-                double baseAngle = 0;
-
-                if (explicitBase) {
-                    double deltax2 = explicitBase.get()[Geom::X] - start_point[Geom::X];
-                    double deltay2 = explicitBase.get()[Geom::Y] - start_point[Geom::Y];
-
-                    baseAngle = atan2(deltay2, deltax2);
-                    angle -= baseAngle;
-
-                    if (angle < -M_PI) {
-                        angle += 2 * M_PI;
-                    } else if (angle > M_PI) {
-                        angle -= 2 * M_PI;
-                    }
-                }
-
-//TODO: calculate NPOINTS
-//800 seems to be a good value for 800x600 resolution
-#define NPOINTS 800
-
-                std::vector<Geom::Point> points;
-
-                for (double i = 0; i < NPOINTS; i++) {
-                    points.push_back(desktop->d2w(start_point + (i / NPOINTS) * (end_point - start_point)));
-                }
-
-// TODO: Felipe, why don't you simply iterate over all items, and test whether their bounding boxes intersect
-// with the measurement line, instead of interpolating? E.g. bbox_of_measurement_line.intersects(*bbox_of_item).
-// That's also how the object-snapper works, see _findCandidates() in object-snapper.cpp.
-
-                //select elements crossed by line segment:
-                GSList *items = sp_desktop_document(desktop)->getItemsAtPoints(desktop->dkey, points);
-                std::vector<Geom::Point> intersections;
-                Inkscape::Preferences *prefs = Inkscape::Preferences::get();
-                bool ignore_1st_and_last = prefs->getBool("/tools/measure/ignore_1st_and_last", true);
-
-                if (!ignore_1st_and_last) {
-                    intersections.push_back(desktop->dt2doc(start_point));
-                }
-
-                std::vector<LabelPlacement> placements;
-
-                // TODO switch to a different variable name. The single letter 'l' is easy to misread.
-                for (GSList *l = items; l != NULL; l = l->next) {
-                    SPItem *item = static_cast<SPItem*>(l->data);
-
-                    if (SP_IS_SHAPE(item)) {
-                       calculate_intersections(desktop, item, lineseg, SP_SHAPE(item)->getCurve(), intersections);
-                    } else {
-                        if (SP_IS_TEXT(item) || SP_IS_FLOWTEXT(item)) {
-                            Inkscape::Text::Layout::iterator iter = te_get_layout(item)->begin();
-                            do {
-                                Inkscape::Text::Layout::iterator iter_next = iter;
-                                iter_next.nextGlyph(); // iter_next is one glyph ahead from iter
-                                if (iter == iter_next) {
-                                    break;
-                                }
-
-                                // get path from iter to iter_next:
-                                SPCurve *curve = te_get_layout(item)->convertToCurves(iter, iter_next);
-                                iter = iter_next; // shift to next glyph
-                                if (!curve) {
-                                    continue; // error converting this glyph
-                                }
-                                if (curve->is_empty()) { // whitespace glyph?
-                                    curve->unref();
-                                    continue;
-                                }
-
-                                curve->transform(item->i2doc_affine());
-
-                                calculate_intersections(desktop, item, lineseg, curve, intersections);
-
-                                if (iter == te_get_layout(item)->end()) {
-                                    break;
-                                }
-                            } while (true);
-                        }
-                    }
-                }
-
-                if (!ignore_1st_and_last) {
-                    intersections.push_back(desktop->dt2doc(end_point));
-                }
-
-                //sort intersections
-                if (intersections.size() > 2) {
-                    std::sort(intersections.begin(), intersections.end(), GeomPointSortPredicate);
-                }
-
-                Glib::ustring unit_name = prefs->getString("/tools/measure/unit");
-                if (!unit_name.compare("")) {
-                    unit_name = "px";
-                }
-
-                double fontsize = prefs->getInt("/tools/measure/fontsize");
-
-                // Normal will be used for lines and text
-                Geom::Point windowNormal = Geom::unit_vector(Geom::rot90(desktop->d2w(end_point - start_point)));
-                Geom::Point normal = desktop->w2d(windowNormal);
-
-                for (size_t idx = 1; idx < intersections.size(); ++idx) {
-                    LabelPlacement placement;
-                    placement.lengthVal = (intersections[idx] - intersections[idx - 1]).length();
-                    placement.lengthVal = Inkscape::Util::Quantity::convert(placement.lengthVal, "px", unit_name);
-                    placement.offset = DIMENSION_OFFSET;
-                    placement.start = desktop->doc2dt( (intersections[idx - 1] + intersections[idx]) / 2 );
-                    placement.end = placement.start - (normal * placement.offset);
-
-                    placements.push_back(placement);
-                }
-
-                // Adjust positions
-                repositionOverlappingLabels(placements, desktop, windowNormal, fontsize);
-
-                for (std::vector<LabelPlacement>::iterator it = placements.begin(); it != placements.end(); ++it)
-                {
-                    LabelPlacement &place = *it;
-
-                    // TODO cleanup memory, Glib::ustring, etc.:
-                    gchar *measure_str = g_strdup_printf("%.2f %s", place.lengthVal, unit_name.c_str());
-                    SPCanvasText *canvas_tooltip = sp_canvastext_new(sp_desktop_tempgroup(desktop),
-                                                                     desktop,
-                                                                     place.end,
-                                                                     measure_str);
-                    sp_canvastext_set_fontsize(canvas_tooltip, fontsize);
-                    canvas_tooltip->rgba = 0xffffffff;
-                    canvas_tooltip->rgba_background = 0x0000007f;
-                    canvas_tooltip->outline = false;
-                    canvas_tooltip->background = true;
-                    canvas_tooltip->anchor_position = TEXT_ANCHOR_CENTER;
-
-                    measure_tmp_items.push_back(desktop->add_temporary_canvasitem(canvas_tooltip, 0));
-                    g_free(measure_str);
-                }
-
-                Geom::Point angleDisplayPt = calcAngleDisplayAnchor(desktop, angle, baseAngle,
-                                                                    start_point, end_point,
-                                                                    fontsize);
-
-                {
-                    // TODO cleanup memory, Glib::ustring, etc.:
-                    gchar *angle_str = g_strdup_printf("%.2f °", angle * 180/M_PI);
-
-                    SPCanvasText *canvas_tooltip = sp_canvastext_new(sp_desktop_tempgroup(desktop),
-                                                                     desktop,
-                                                                     angleDisplayPt,
-                                                                     angle_str);
-                    sp_canvastext_set_fontsize(canvas_tooltip, fontsize);
-                    canvas_tooltip->rgba = 0xffffffff;
-                    canvas_tooltip->rgba_background = 0x337f337f;
-                    canvas_tooltip->outline = false;
-                    canvas_tooltip->background = true;
-                    canvas_tooltip->anchor_position = TEXT_ANCHOR_CENTER;
-
-                    measure_tmp_items.push_back(desktop->add_temporary_canvasitem(canvas_tooltip, 0));
-                    g_free(angle_str);
-                }
-
-                {
-                    double totallengthval = (end_point - start_point).length();
-                    totallengthval = Inkscape::Util::Quantity::convert(totallengthval, "px", unit_name);
-
-                    // TODO cleanup memory, Glib::ustring, etc.:
-                    gchar *totallength_str = g_strdup_printf("%.2f %s", totallengthval, unit_name.c_str());
-                    SPCanvasText *canvas_tooltip = sp_canvastext_new(sp_desktop_tempgroup(desktop),
-                                                                     desktop,
-                                                                     end_point + desktop->w2d(Geom::Point(3*fontsize, -fontsize)),
-                                                                     totallength_str);
-                    sp_canvastext_set_fontsize(canvas_tooltip, fontsize);
-                    canvas_tooltip->rgba = 0xffffffff;
-                    canvas_tooltip->rgba_background = 0x3333337f;
-                    canvas_tooltip->outline = false;
-                    canvas_tooltip->background = true;
-                    canvas_tooltip->anchor_position = TEXT_ANCHOR_LEFT;
-
-                    measure_tmp_items.push_back(desktop->add_temporary_canvasitem(canvas_tooltip, 0));
-                    g_free(totallength_str);
-                }
-
-                if (intersections.size() > 2) {
-                    double totallengthval = (intersections[intersections.size()-1] - intersections[0]).length();
-                    totallengthval = Inkscape::Util::Quantity::convert(totallengthval, "px", unit_name);
-
-                    // TODO cleanup memory, Glib::ustring, etc.:
-                    gchar *total_str = g_strdup_printf("%.2f %s", totallengthval, unit_name.c_str());
-                    SPCanvasText *canvas_tooltip = sp_canvastext_new(sp_desktop_tempgroup(desktop),
-                                                                     desktop,
-                                                                     desktop->doc2dt((intersections[0] + intersections[intersections.size()-1])/2) + normal * 60,
-                                                                     total_str);
-                    sp_canvastext_set_fontsize(canvas_tooltip, fontsize);
-                    canvas_tooltip->rgba = 0xffffffff;
-                    canvas_tooltip->rgba_background = 0x33337f7f;
-                    canvas_tooltip->outline = false;
-                    canvas_tooltip->background = true;
-                    canvas_tooltip->anchor_position = TEXT_ANCHOR_CENTER;
-
-                    measure_tmp_items.push_back(desktop->add_temporary_canvasitem(canvas_tooltip, 0));
-                    g_free(total_str);
-                }
-
-                // Now that text has been added, we can add lines and controls so that they go underneath
-
-                for (size_t idx = 0; idx < intersections.size(); ++idx) {
-                    // Display the intersection indicator (i.e. the cross)
-                    SPCanvasItem * canvasitem = sp_canvas_item_new(sp_desktop_tempgroup(desktop),
-                                                                   SP_TYPE_CTRL,
-                                                                   "anchor", SP_ANCHOR_CENTER,
-                                                                   "size", 8.0,
-                                                                   "stroked", TRUE,
-                                                                   "stroke_color", 0xff0000ff,
-                                                                   "mode", SP_KNOT_MODE_XOR,
-                                                                   "shape", SP_KNOT_SHAPE_CROSS,
-                                                                   NULL );
-
-                    SP_CTRL(canvasitem)->moveto(desktop->doc2dt(intersections[idx]));
-                    measure_tmp_items.push_back(desktop->add_temporary_canvasitem(canvasitem, 0));
-                }
-
-                // Since adding goes to the bottom, do all lines last.
-
-                // draw main control line
-                {
-                    SPCtrlLine *control_line = ControlManager::getManager().createControlLine(sp_desktop_tempgroup(desktop),
-                                                                                              start_point,
-                                                                                              end_point);
-                    measure_tmp_items.push_back(desktop->add_temporary_canvasitem(control_line, 0));
-
-                    if ((end_point[Geom::X] != start_point[Geom::X]) && (end_point[Geom::Y] != start_point[Geom::Y])) {
-                        double length = std::abs((end_point - start_point).length());
-                        Geom::Point anchorEnd = start_point;
-                        anchorEnd[Geom::X] += length;
-                        if (explicitBase) {
-                            anchorEnd *= (Geom::Affine(Geom::Translate(-start_point))
-                                          * Geom::Affine(Geom::Rotate(baseAngle))
-                                          * Geom::Affine(Geom::Translate(start_point)));
-                        }
-
-                        SPCtrlLine *control_line = ControlManager::getManager().createControlLine(sp_desktop_tempgroup(desktop),
-                                                                                                  start_point,
-                                                                                                  anchorEnd,
-                                                                                                  CTLINE_SECONDARY);
-                        measure_tmp_items.push_back(desktop->add_temporary_canvasitem(control_line, 0));
-
-                        createAngleDisplayCurve(desktop, start_point, end_point, angleDisplayPt, angle);
-                    }
-                }
-
-                if (intersections.size() > 2) {
-                    ControlManager &mgr = ControlManager::getManager();
-                    SPCtrlLine *control_line = 0;
-                    control_line = mgr.createControlLine(sp_desktop_tempgroup(desktop),
-                                                         desktop->doc2dt(intersections[0]) + normal * 60,
-                                                         desktop->doc2dt(intersections[intersections.size() - 1]) + normal * 60);
-                    measure_tmp_items.push_back(desktop->add_temporary_canvasitem(control_line, 0));
-
-                    control_line = mgr.createControlLine(sp_desktop_tempgroup(desktop),
-                                                         desktop->doc2dt(intersections[0]),
-                                                         desktop->doc2dt(intersections[0]) + normal * 65);
-                    measure_tmp_items.push_back(desktop->add_temporary_canvasitem(control_line, 0));
-
-                    control_line = mgr.createControlLine(sp_desktop_tempgroup(desktop),
-                                                         desktop->doc2dt(intersections[intersections.size() - 1]),
-                                                         desktop->doc2dt(intersections[intersections.size() - 1]) + normal * 65);
-                    measure_tmp_items.push_back(desktop->add_temporary_canvasitem(control_line, 0));
-                }
-
-                // call-out lines
-                for (std::vector<LabelPlacement>::iterator it = placements.begin(); it != placements.end(); ++it)
-                {
-                    LabelPlacement &place = *it;
-
-                    ControlManager &mgr = ControlManager::getManager();
-                    SPCtrlLine *control_line = mgr.createControlLine(sp_desktop_tempgroup(desktop),
-                                                                     place.start,
-                                                                     place.end,
-                                                                     CTLINE_SECONDARY);
-                    measure_tmp_items.push_back(desktop->add_temporary_canvasitem(control_line, 0));
-                }
-
-                {
-                    for (size_t idx = 1; idx < intersections.size(); ++idx) {
-                        Geom::Point measure_text_pos = (intersections[idx - 1] + intersections[idx]) / 2;
-
-                        ControlManager &mgr = ControlManager::getManager();
-                        SPCtrlLine *control_line = mgr.createControlLine(sp_desktop_tempgroup(desktop),
-                                                                         desktop->doc2dt(measure_text_pos),
-                                                                         desktop->doc2dt(measure_text_pos) - (normal * DIMENSION_OFFSET),
-                                                                         CTLINE_SECONDARY);
-                        measure_tmp_items.push_back(desktop->add_temporary_canvasitem(control_line, 0));
-                    }
-                }
-
-                // Initial point
-                {
-                    SPCanvasItem * canvasitem = sp_canvas_item_new(sp_desktop_tempgroup(desktop),
-                                                                   SP_TYPE_CTRL,
-                                                                   "anchor", SP_ANCHOR_CENTER,
-                                                                   "size", 8.0,
-                                                                   "stroked", TRUE,
-                                                                   "stroke_color", 0xff0000ff,
-                                                                   "mode", SP_KNOT_MODE_XOR,
-                                                                   "shape", SP_KNOT_SHAPE_CROSS,
-                                                                   NULL );
-
-                    SP_CTRL(canvasitem)->moveto(start_point);
-                    measure_tmp_items.push_back(desktop->add_temporary_canvasitem(canvasitem, 0));
-                }
-
-                lastEnd = end_point; // track in case we get a anchoring key-press later
-
-                gobble_motion_events(GDK_BUTTON1_MASK);
-            }
-            break;
-        }
-        case GDK_BUTTON_RELEASE: {
-            sp_event_context_discard_delayed_snap_event(this);
-            explicitBase = boost::none;
-            lastEnd = boost::none;
-
-            //clear all temporary canvas items related to the measurement tool.
-            for (size_t idx = 0; idx < measure_tmp_items.size(); ++idx) {
-                desktop->remove_temporary_canvasitem(measure_tmp_items[idx]);
-            }
-
-            measure_tmp_items.clear();
-
-            if (this->grabbed) {
-                sp_canvas_item_ungrab(this->grabbed, event->button.time);
-                this->grabbed = NULL;
-            }
-
-            xp = 0;
-            yp = 0;
-            break;
-        }
-        default:
-            break;
-    }
-
-    if (!ret) {
-    	ret = ToolBase::root_handler(event);
-    }
-
-    return ret;
-}
-
-}
-}
-}
-
-/*
-  Local Variables:
-  mode:c++
-  c-file-style:"stroustrup"
-  c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
-  indent-tabs-mode:nil
-  fill-column:99
-  End:
-*/
-// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4 :
-- 
cgit v1.2.3