src/knot-holder-entity.cpp

   1 /** \file
   2  * KnotHolderEntity definition.
   3  *
   4  * Authors:
   5  *   Mitsuru Oka <oka326@parkcity.ne.jp>
   6  *   Maximilian Albert <maximilian.albert@gmail.com>
   7  *   Abhishek Sharma
   8  *
   9  * Copyright (C) 1999-2001 Lauris Kaplinski
  10  * Copyright (C) 2000-2001 Ximian, Inc.
  11  * Copyright (C) 2001 Mitsuru Oka
  12  * Copyright (C) 2004 Monash University
  13  * Copyright (C) 2008 Maximilian Albert
  14  *
  15  * Released under GNU GPL
  16  */
  17
  18 #include "knotholder.h"
  19 #include "sp-item.h"
  20 #include "style.h"
  21 #include "preferences.h"
  22 #include "macros.h"
  23 #include <libnr/nr-matrix-ops.h>
  24 #include "sp-pattern.h"
  25 #include "snap.h"
  26 #include "desktop.h"
  27 #include "sp-namedview.h"
  28 #include <2geom/matrix.h>
  29 #include <2geom/transforms.h>
  30
  31 int KnotHolderEntity::counter = 0;
  32
  33 void
  34 KnotHolderEntity::create(SPDesktop *desktop, SPItem *item, KnotHolder *parent, const gchar *tip,
  35                          SPKnotShapeType shape, SPKnotModeType mode, guint32 color)
  36 {
  37     knot = sp_knot_new(desktop, tip);
  38
  39     this->parent_holder = parent;
  40     this->item = item; // TODO: remove the item either from here or from knotholder.cpp
  41     this->desktop = desktop;
  42
  43     my_counter = KnotHolderEntity::counter++;
  44
  45     g_object_set(G_OBJECT (knot->item), "shape", shape, NULL);
  46     g_object_set(G_OBJECT (knot->item), "mode", mode, NULL);
  47
  48     knot->fill [SP_KNOT_STATE_NORMAL] = color;
  49     g_object_set (G_OBJECT (knot->item), "fill_color", color, NULL);
  50
  51     update_knot();
  52     sp_knot_show(knot);
  53
  54     _moved_connection = knot->_moved_signal.connect(sigc::mem_fun(*parent_holder, &KnotHolder::knot_moved_handler));
  55     _click_connection = knot->_click_signal.connect(sigc::mem_fun(*parent_holder, &KnotHolder::knot_clicked_handler));
  56     _ungrabbed_connection = knot->_ungrabbed_signal.connect(sigc::mem_fun(*parent_holder, &KnotHolder::knot_ungrabbed_handler));
  57 }
  58
  59
  60 KnotHolderEntity::~KnotHolderEntity()
  61 {
  62     _moved_connection.disconnect();
  63     _click_connection.disconnect();
  64     _ungrabbed_connection.disconnect();
  65
  66     /* unref should call destroy */
  67     if (knot) {
  68         g_object_unref(knot);
  69     } else {
  70         // FIXME: This shouldn't occur. Perhaps it is caused by LPE PointParams being knotholder entities, too
  71         //        If so, it will likely be fixed with upcoming refactoring efforts.
  72         g_return_if_fail(knot);
  73     }
  74 }
  75
  76 void
  77 KnotHolderEntity::update_knot()
  78 {
  79     Geom::Matrix const i2d(item->i2d_affine());
  80
  81     Geom::Point dp(knot_get() * i2d);
  82
  83     _moved_connection.block();
  84     sp_knot_set_position(knot, dp, SP_KNOT_STATE_NORMAL);
  85     _moved_connection.unblock();
  86 }
  87
  88 Geom::Point
  89 KnotHolderEntity::snap_knot_position(Geom::Point const &p)
  90 {
  91     Geom::Matrix const i2d (item->i2d_affine());
  92     Geom::Point s = p * i2d;
  93
  94     SnapManager &m = desktop->namedview->snap_manager;
  95     m.setup(desktop, true, item);
  96     m.freeSnapReturnByRef(s, Inkscape::SNAPSOURCE_NODE_HANDLE);
  97     m.unSetup();
  98
  99     return s * i2d.inverse();
 100 }
 101
 102 Geom::Point
 103 KnotHolderEntity::snap_knot_position_constrained(Geom::Point const &p, Inkscape::Snapper::SnapConstraint const &constraint)
 104 {
 105     Geom::Matrix const i2d (item->i2d_affine());
 106     Geom::Point s = p * i2d;
 107
 108     SnapManager &m = desktop->namedview->snap_manager;
 109     m.setup(desktop, true, item);
 110
 111     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
 112     // constrainedSnap() will first project the point p onto the constraint line and then try to snap along that line.
 113     // This way the constraint is already enforced, no need to worry about that later on
 114     Inkscape::Snapper::SnapConstraint transformed_constraint = Inkscape::Snapper::SnapConstraint(constraint.getPoint() * i2d, (constraint.getPoint() + constraint.getDirection()) * i2d - constraint.getPoint() * i2d);
 115     m.constrainedSnapReturnByRef(s, Inkscape::SNAPSOURCE_NODE_HANDLE, transformed_constraint);
 116     m.unSetup();
 117
 118     return s * i2d.inverse();
 119 }
 120
 121
 122 /* Pattern manipulation */
 123
 124 /*  TODO: this pattern manipulation is not able to handle general transformation matrices. Only matrices that are the result of a pure scale times a pure rotation. */
 125
 126 static gdouble sp_pattern_extract_theta(SPPattern *pat)
 127 {
 128     Geom::Matrix transf = pat->patternTransform;
 129     return Geom::atan2(transf.xAxis());
 130 }
 131
 132 static Geom::Point sp_pattern_extract_scale(SPPattern *pat)
 133 {
 134     Geom::Matrix transf = pat->patternTransform;
 135     return Geom::Point( transf.expansionX(), transf.expansionY() );
 136 }
 137
 138 static Geom::Point sp_pattern_extract_trans(SPPattern const *pat)
 139 {
 140     return Geom::Point(pat->patternTransform[4], pat->patternTransform[5]);
 141 }
 142
 143 void
 144 PatternKnotHolderEntityXY::knot_set(Geom::Point const &p, Geom::Point const &origin, guint state)
 145 {
 146     SPPattern *pat = SP_PATTERN(SP_STYLE_FILL_SERVER(SP_OBJECT(item)->style));
 147
 148     // FIXME: this snapping should be done together with knowing whether control was pressed. If GDK_CONTROL_MASK, then constrained snapping should be used.
 149     Geom::Point p_snapped = snap_knot_position(p);
 150
 151     if ( state & GDK_CONTROL_MASK ) {
 152         if (fabs((p - origin)[Geom::X]) > fabs((p - origin)[Geom::Y])) {
 153             p_snapped[Geom::Y] = origin[Geom::Y];
 154         } else {
 155             p_snapped[Geom::X] = origin[Geom::X];
 156         }
 157     }
 158
 159     if (state)  {
 160         Geom::Point const q = p_snapped - sp_pattern_extract_trans(pat);
 161         item->adjust_pattern(Geom::Matrix(Geom::Translate(q)));
 162     }
 163
 164     item->requestDisplayUpdate(SP_OBJECT_MODIFIED_FLAG);
 165 }
 166
 167 Geom::Point
 168 PatternKnotHolderEntityXY::knot_get()
 169 {
 170     SPPattern const *pat = SP_PATTERN(SP_STYLE_FILL_SERVER(SP_OBJECT(item)->style));
 171     return sp_pattern_extract_trans(pat);
 172 }
 173
 174 Geom::Point
 175 PatternKnotHolderEntityAngle::knot_get()
 176 {
 177     SPPattern *pat = SP_PATTERN(SP_STYLE_FILL_SERVER(SP_OBJECT(item)->style));
 178
 179     gdouble x = (pattern_width(pat));
 180     gdouble y = 0;
 181     Geom::Point delta = Geom::Point(x,y);
 182     Geom::Point scale = sp_pattern_extract_scale(pat);
 183     gdouble theta = sp_pattern_extract_theta(pat);
 184     delta = delta * Geom::Matrix(Geom::Scale(scale))*Geom::Matrix(Geom::Rotate(theta));
 185     delta = delta + sp_pattern_extract_trans(pat);
 186     return delta;
 187 }
 188
 189 void
 190 PatternKnotHolderEntityAngle::knot_set(Geom::Point const &p, Geom::Point const &/*origin*/, guint state)
 191 {
 192     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
 193     int const snaps = prefs->getInt("/options/rotationsnapsperpi/value", 12);
 194
 195     SPPattern *pat = SP_PATTERN(SP_STYLE_FILL_SERVER(SP_OBJECT(item)->style));
 196
 197     // get the angle from pattern 0,0 to the cursor pos
 198     Geom::Point delta = p - sp_pattern_extract_trans(pat);
 199     gdouble theta = atan2(delta);
 200
 201     if ( state & GDK_CONTROL_MASK ) {
 202         theta = sp_round(theta, M_PI/snaps);
 203     }
 204
 205     // get the scale from the current transform so we can keep it.
 206     Geom::Point scl = sp_pattern_extract_scale(pat);
 207     Geom::Matrix rot = Geom::Matrix(Geom::Scale(scl)) * Geom::Matrix(Geom::Rotate(theta));
 208     Geom::Point const t = sp_pattern_extract_trans(pat);
 209     rot[4] = t[Geom::X];
 210     rot[5] = t[Geom::Y];
 211     item->adjust_pattern(rot, true);
 212     item->requestDisplayUpdate(SP_OBJECT_MODIFIED_FLAG);
 213 }
 214
 215 void
 216 PatternKnotHolderEntityScale::knot_set(Geom::Point const &p, Geom::Point const &/*origin*/, guint state)
 217 {
 218     SPPattern *pat = SP_PATTERN(SP_STYLE_FILL_SERVER(SP_OBJECT(item)->style));
 219
 220     // FIXME: this snapping should be done together with knowing whether control was pressed. If GDK_CONTROL_MASK, then constrained snapping should be used.
 221     Geom::Point p_snapped = snap_knot_position(p);
 222
 223     // get angle from current transform
 224     gdouble theta = sp_pattern_extract_theta(pat);
 225
 226     // Get the new scale from the position of the knotholder
 227     Geom::Point d = p_snapped - sp_pattern_extract_trans(pat);
 228     gdouble pat_x = pattern_width(pat);
 229     gdouble pat_y = pattern_height(pat);
 230     Geom::Scale scl(1);
 231     if ( state & GDK_CONTROL_MASK ) {
 232         // if ctrl is pressed: use 1:1 scaling
 233         gdouble pat_h = hypot(pat_x, pat_y);
 234         scl = Geom::Scale(d.length() / pat_h);
 235     } else {
 236         d *= Geom::Rotate(-theta);
 237         scl = Geom::Scale(d[Geom::X] / pat_x, d[Geom::Y] / pat_y);
 238     }
 239
 240     Geom::Matrix rot = (Geom::Matrix)scl * Geom::Rotate(theta);
 241
 242     Geom::Point const t = sp_pattern_extract_trans(pat);
 243     rot[4] = t[Geom::X];
 244     rot[5] = t[Geom::Y];
 245     item->adjust_pattern(rot, true);
 246     item->requestDisplayUpdate(SP_OBJECT_MODIFIED_FLAG);
 247 }
 248
 249
 250 Geom::Point
 251 PatternKnotHolderEntityScale::knot_get()
 252 {
 253     SPPattern *pat = SP_PATTERN(SP_STYLE_FILL_SERVER(SP_OBJECT(item)->style));
 254
 255     gdouble x = pattern_width(pat);
 256     gdouble y = pattern_height(pat);
 257     Geom::Point delta = Geom::Point(x,y);
 258     Geom::Matrix a = pat->patternTransform;
 259     a[4] = 0;
 260     a[5] = 0;
 261     delta = delta * a;
 262     delta = delta + sp_pattern_extract_trans(pat);
 263     return delta;
 264 }
 265
 266 /*
 267   Local Variables:
 268   mode:c++
 269   c-file-style:"stroustrup"
 270   c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
 271   indent-tabs-mode:nil
 272   fill-column:99
 273   End:
 274 */
 275 // vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:fileencoding=utf-8:textwidth=99 :