src/knot-holder-entity.cpp

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