src/ui/tool/transform-handle-set.cpp

   1 /** @file
   2  * Affine transform handles component
   3  */
   4 /* Authors:
   5  *   Krzysztof Kosiński <tweenk.pl@gmail.com>
   6  *
   7  * Copyright (C) 2009 Authors
   8  * Released under GNU GPL, read the file 'COPYING' for more information
   9  */
  10
  11 #include <math.h>
  12 #include <algorithm>
  13 #include <glib.h>
  14 #include <glib/gi18n.h>
  15 #include <gdk/gdk.h>
  16 #include <2geom/transforms.h>
  17 #include "desktop.h"
  18 #include "desktop-handles.h"
  19 #include "display/sodipodi-ctrlrect.h"
  20 #include "preferences.h"
  21 #include "ui/tool/commit-events.h"
  22 #include "ui/tool/control-point.h"
  23 #include "ui/tool/event-utils.h"
  24 #include "ui/tool/transform-handle-set.h"
  25
  26 // FIXME BRAIN DAMAGE WARNING: this is a global variable in select-context.cpp
  27 // It should be moved to a header
  28 extern GdkPixbuf *handles[];
  29 GType sp_select_context_get_type();
  30
  31 namespace Inkscape {
  32 namespace UI {
  33
  34 namespace {
  35 Gtk::AnchorType corner_to_anchor(unsigned c) {
  36     switch (c % 4) {
  37     case 0: return Gtk::ANCHOR_NE;
  38     case 1: return Gtk::ANCHOR_NW;
  39     case 2: return Gtk::ANCHOR_SW;
  40     default: return Gtk::ANCHOR_SE;
  41     }
  42 }
  43 Gtk::AnchorType side_to_anchor(unsigned s) {
  44     switch (s % 4) {
  45     case 0: return Gtk::ANCHOR_N;
  46     case 1: return Gtk::ANCHOR_W;
  47     case 2: return Gtk::ANCHOR_S;
  48     default: return Gtk::ANCHOR_E;
  49     }
  50 }
  51
  52 // TODO move those two functions into a common place
  53 double snap_angle(double a) {
  54     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
  55     int snaps = prefs->getIntLimited("/options/rotationsnapsperpi/value", 12, 1, 1000);
  56     double unit_angle = M_PI / snaps;
  57     return CLAMP(unit_angle * round(a / unit_angle), -M_PI, M_PI);
  58 }
  59 double snap_increment_degrees() {
  60     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
  61     int snaps = prefs->getIntLimited("/options/rotationsnapsperpi/value", 12, 1, 1000);
  62     return 180.0 / snaps;
  63 }
  64
  65 ControlPoint::ColorSet thandle_cset = {
  66     {0x000000ff, 0x000000ff},
  67     {0x00ff6600, 0x000000ff},
  68     {0x00ff6600, 0x000000ff}
  69 };
  70
  71 ControlPoint::ColorSet center_cset = {
  72     {0x00000000, 0x000000ff},
  73     {0x00000000, 0xff0000b0},
  74     {0x00000000, 0xff0000b0}
  75 };
  76 } // anonymous namespace
  77
  78 /** Base class for node transform handles to simplify implementation */
  79 class TransformHandle : public ControlPoint {
  80 public:
  81     TransformHandle(TransformHandleSet &th, Gtk::AnchorType anchor, Glib::RefPtr<Gdk::Pixbuf> pb)
  82         : ControlPoint(th._desktop, Geom::Point(), anchor, pb, &thandle_cset,
  83             th._transform_handle_group)
  84         , _th(th)
  85     {
  86         setVisible(false);
  87         signal_grabbed.connect(
  88             sigc::bind_return(
  89                 sigc::hide(
  90                     sigc::mem_fun(*this, &TransformHandle::_grabbedHandler)),
  91                 false));
  92         signal_dragged.connect(
  93             sigc::hide<0>(
  94                 sigc::mem_fun(*this, &TransformHandle::_draggedHandler)));
  95         signal_ungrabbed.connect(
  96             sigc::hide(
  97                 sigc::mem_fun(*this, &TransformHandle::_ungrabbedHandler)));
  98     }
  99 protected:
 100     virtual void startTransform() {}
 101     virtual void endTransform() {}
 102     virtual Geom::Matrix computeTransform(Geom::Point const &pos, GdkEventMotion *event) = 0;
 103     virtual CommitEvent getCommitEvent() = 0;
 104
 105     Geom::Matrix _last_transform;
 106     Geom::Point _origin;
 107     TransformHandleSet &_th;
 108 private:
 109     void _grabbedHandler() {
 110         _origin = position();
 111         _last_transform.setIdentity();
 112         startTransform();
 113
 114         _th._setActiveHandle(this);
 115         _cset = &invisible_cset;
 116         _setState(_state);
 117     }
 118     void _draggedHandler(Geom::Point &new_pos, GdkEventMotion *event)
 119     {
 120         Geom::Matrix t = computeTransform(new_pos, event);
 121         // protect against degeneracies
 122         if (t.isSingular()) return;
 123         Geom::Matrix incr = _last_transform.inverse() * t;
 124         if (incr.isSingular()) return;
 125         _th.signal_transform.emit(incr);
 126         _last_transform = t;
 127     }
 128     void _ungrabbedHandler() {
 129         _th._clearActiveHandle();
 130         _cset = &thandle_cset;
 131         _setState(_state);
 132         endTransform();
 133         _th.signal_commit.emit(getCommitEvent());
 134     }
 135 };
 136
 137 class ScaleHandle : public TransformHandle {
 138 public:
 139     ScaleHandle(TransformHandleSet &th, Gtk::AnchorType anchor, Glib::RefPtr<Gdk::Pixbuf> pb)
 140         : TransformHandle(th, anchor, pb)
 141     {}
 142 protected:
 143     virtual Glib::ustring _getTip(unsigned state) {
 144         if (state_held_control(state)) {
 145             if (state_held_shift(state)) {
 146                 return C_("Transform handle tip",
 147                     "<b>Shift+Ctrl:</b> scale uniformly about the rotation center");
 148             }
 149             return C_("Transform handle tip", "<b>Ctrl:</b> scale uniformly");
 150         }
 151         if (state_held_shift(state)) {
 152             if (state_held_alt(state)) {
 153                 return C_("Transform handle tip",
 154                     "<b>Shift+Alt:</b> scale using an integer ratio about the rotation center");
 155             }
 156             return C_("Transform handle tip", "<b>Shift:</b> scale from the rotation center");
 157         }
 158         if (state_held_alt(state)) {
 159             return C_("Transform handle tip", "<b>Alt:</b> scale using an integer ratio");
 160         }
 161         return C_("Transform handle tip", "<b>Scale handle:</b> drag to scale the selection");
 162     }
 163
 164     virtual Glib::ustring _getDragTip(GdkEventMotion */*event*/) {
 165         return format_tip(C_("Transform handle tip",
 166             "Scale by %.2f%% x %.2f%%"), _last_scale_x * 100, _last_scale_y * 100);
 167     }
 168
 169     virtual bool _hasDragTips() { return true; }
 170
 171     static double _last_scale_x, _last_scale_y;
 172 };
 173 double ScaleHandle::_last_scale_x = 1.0;
 174 double ScaleHandle::_last_scale_y = 1.0;
 175
 176 /// Corner scaling handle for node transforms
 177 class ScaleCornerHandle : public ScaleHandle {
 178 public:
 179     ScaleCornerHandle(TransformHandleSet &th, unsigned corner)
 180         : ScaleHandle(th, corner_to_anchor(corner), _corner_to_pixbuf(corner))
 181         , _corner(corner)
 182     {}
 183 protected:
 184     virtual void startTransform() {
 185         _sc_center = _th.rotationCenter();
 186         _sc_opposite = _th.bounds().corner(_corner + 2);
 187         _last_scale_x = _last_scale_y = 1.0;
 188     }
 189     virtual Geom::Matrix computeTransform(Geom::Point const &new_pos, GdkEventMotion *event) {
 190         Geom::Point scc = held_shift(*event) ? _sc_center : _sc_opposite;
 191         Geom::Point vold = _origin - scc, vnew = new_pos - scc;
 192         // avoid exploding the selection
 193         if (Geom::are_near(vold[Geom::X], 0) || Geom::are_near(vold[Geom::Y], 0))
 194             return Geom::identity();
 195
 196         double scale[2] = { vnew[Geom::X] / vold[Geom::X], vnew[Geom::Y] / vold[Geom::Y] };
 197         if (held_alt(*event)) {
 198             for (unsigned i = 0; i < 2; ++i) {
 199                 if (scale[i] >= 1.0) scale[i] = round(scale[i]);
 200                 else scale[i] = 1.0 / round(1.0 / scale[i]);
 201             }
 202         } else if (held_control(*event)) {
 203             scale[0] = scale[1] = std::min(scale[0], scale[1]);
 204         }
 205         _last_scale_x = scale[0];
 206         _last_scale_y = scale[1];
 207         Geom::Matrix t = Geom::Translate(-scc)
 208             * Geom::Scale(scale[0], scale[1])
 209             * Geom::Translate(scc);
 210         return t;
 211     }
 212     virtual CommitEvent getCommitEvent() {
 213         return _last_transform.isUniformScale()
 214             ? COMMIT_MOUSE_SCALE_UNIFORM
 215             : COMMIT_MOUSE_SCALE;
 216     }
 217 private:
 218     static Glib::RefPtr<Gdk::Pixbuf> _corner_to_pixbuf(unsigned c) {
 219         sp_select_context_get_type();
 220         switch (c % 2) {
 221         case 0: return Glib::wrap(handles[1], true);
 222         default: return Glib::wrap(handles[0], true);
 223         }
 224     }
 225     Geom::Point _sc_center;
 226     Geom::Point _sc_opposite;
 227     unsigned _corner;
 228 };
 229
 230 /// Side scaling handle for node transforms
 231 class ScaleSideHandle : public ScaleHandle {
 232 public:
 233     ScaleSideHandle(TransformHandleSet &th, unsigned side)
 234         : ScaleHandle(th, side_to_anchor(side), _side_to_pixbuf(side))
 235         , _side(side)
 236     {}
 237 protected:
 238     virtual void startTransform() {
 239         _sc_center = _th.rotationCenter();
 240         Geom::Rect b = _th.bounds();
 241         _sc_opposite = Geom::middle_point(b.corner(_side + 2), b.corner(_side + 3));
 242         _last_scale_x = _last_scale_y = 1.0;
 243     }
 244     virtual Geom::Matrix computeTransform(Geom::Point const &new_pos, GdkEventMotion *event) {
 245         Geom::Point scc = held_shift(*event) ? _sc_center : _sc_opposite;
 246         Geom::Point vs;
 247         Geom::Dim2 d1 = static_cast<Geom::Dim2>((_side + 1) % 2);
 248         Geom::Dim2 d2 = static_cast<Geom::Dim2>(_side % 2);
 249
 250         // avoid exploding the selection
 251         if (Geom::are_near(scc[d1], _origin[d1]))
 252             return Geom::identity();
 253
 254         vs[d1] = (new_pos - scc)[d1] / (_origin - scc)[d1];
 255         if (held_alt(*event)) {
 256             if (vs[d1] >= 1.0) vs[d1] = round(vs[d1]);
 257             else vs[d1] = 1.0 / round(1.0 / vs[d1]);
 258         }
 259         vs[d2] = held_control(*event) ? vs[d1] : 1.0;
 260
 261         _last_scale_x = vs[Geom::X];
 262         _last_scale_y = vs[Geom::Y];
 263         Geom::Matrix t = Geom::Translate(-scc)
 264             * Geom::Scale(vs)
 265             * Geom::Translate(scc);
 266         return t;
 267     }
 268     virtual CommitEvent getCommitEvent() {
 269         return _last_transform.isUniformScale()
 270             ? COMMIT_MOUSE_SCALE_UNIFORM
 271             : COMMIT_MOUSE_SCALE;
 272     }
 273 private:
 274     static Glib::RefPtr<Gdk::Pixbuf> _side_to_pixbuf(unsigned c) {
 275         sp_select_context_get_type();
 276         switch (c % 2) {
 277         case 0: return Glib::wrap(handles[3], true);
 278         default: return Glib::wrap(handles[2], true);
 279         }
 280     }
 281     Geom::Point _sc_center;
 282     Geom::Point _sc_opposite;
 283     unsigned _side;
 284 };
 285
 286 /// Rotation handle for node transforms
 287 class RotateHandle : public TransformHandle {
 288 public:
 289     RotateHandle(TransformHandleSet &th, unsigned corner)
 290         : TransformHandle(th, corner_to_anchor(corner), _corner_to_pixbuf(corner))
 291         , _corner(corner)
 292     {}
 293 protected:
 294
 295     virtual void startTransform() {
 296         _rot_center = _th.rotationCenter();
 297         _rot_opposite = _th.bounds().corner(_corner + 2);
 298         _last_angle = 0;
 299     }
 300
 301     virtual Geom::Matrix computeTransform(Geom::Point const &new_pos, GdkEventMotion *event)
 302     {
 303         Geom::Point rotc = held_shift(*event) ? _rot_opposite : _rot_center;
 304         double angle = Geom::angle_between(_origin - rotc, new_pos - rotc);
 305         if (held_control(*event)) {
 306             angle = snap_angle(angle);
 307         }
 308         _last_angle = angle;
 309         Geom::Matrix t = Geom::Translate(-rotc)
 310             * Geom::Rotate(angle)
 311             * Geom::Translate(rotc);
 312         return t;
 313     }
 314
 315     virtual CommitEvent getCommitEvent() { return COMMIT_MOUSE_ROTATE; }
 316
 317     virtual Glib::ustring _getTip(unsigned state) {
 318         if (state_held_shift(state)) {
 319             if (state_held_control(state)) {
 320                 return format_tip(C_("Transform handle tip",
 321                     "<b>Shift+Ctrl:</b> rotate around the opposite corner and snap "
 322                     "angle to %f° increments"), snap_increment_degrees());
 323             }
 324             return C_("Transform handle tip", "<b>Shift:</b> rotate around the opposite corner");
 325         }
 326         if (state_held_control(state)) {
 327             return format_tip(C_("Transform handle tip",
 328                 "<b>Ctrl:</b> snap angle to %f° increments"), snap_increment_degrees());
 329         }
 330         return C_("Transform handle tip", "<b>Rotation handle:</b> drag to rotate "
 331             "the selection around the rotation center");
 332     }
 333
 334     virtual Glib::ustring _getDragTip(GdkEventMotion */*event*/) {
 335         return format_tip(C_("Transform handle tip", "Rotate by %.2f°"),
 336             _last_angle * 360.0);
 337     }
 338
 339     virtual bool _hasDragTips() { return true; }
 340
 341 private:
 342     static Glib::RefPtr<Gdk::Pixbuf> _corner_to_pixbuf(unsigned c) {
 343         sp_select_context_get_type();
 344         switch (c % 4) {
 345         case 0: return Glib::wrap(handles[10], true);
 346         case 1: return Glib::wrap(handles[8], true);
 347         case 2: return Glib::wrap(handles[6], true);
 348         default: return Glib::wrap(handles[4], true);
 349         }
 350     }
 351     Geom::Point _rot_center;
 352     Geom::Point _rot_opposite;
 353     unsigned _corner;
 354     static double _last_angle;
 355 };
 356 double RotateHandle::_last_angle = 0;
 357
 358 class SkewHandle : public TransformHandle {
 359 public:
 360     SkewHandle(TransformHandleSet &th, unsigned side)
 361         : TransformHandle(th, side_to_anchor(side), _side_to_pixbuf(side))
 362         , _side(side)
 363     {}
 364
 365 protected:
 366
 367     virtual void startTransform() {
 368         _skew_center = _th.rotationCenter();
 369         Geom::Rect b = _th.bounds();
 370         _skew_opposite = Geom::middle_point(b.corner(_side + 2), b.corner(_side + 3));
 371         _last_angle = 0;
 372         _last_horizontal = _side % 2;
 373     }
 374
 375     virtual Geom::Matrix computeTransform(Geom::Point const &new_pos, GdkEventMotion *event)
 376     {
 377         Geom::Point scc = held_shift(*event) ? _skew_center : _skew_opposite;
 378         // d1 and d2 are reversed with respect to ScaleSideHandle
 379         Geom::Dim2 d1 = static_cast<Geom::Dim2>(_side % 2);
 380         Geom::Dim2 d2 = static_cast<Geom::Dim2>((_side + 1) % 2);
 381         Geom::Point proj, scale(1.0, 1.0);
 382
 383         // Skew handles allow scaling up to integer multiples of the original size
 384         // in the second direction; prevent explosions
 385         // TODO should the scaling part be only active with Alt?
 386         if (!Geom::are_near(_origin[d2], scc[d2])) {
 387             scale[d2] = (new_pos - scc)[d2] / (_origin - scc)[d2];
 388         }
 389
 390         if (scale[d2] < 1.0) {
 391             scale[d2] = copysign(1.0, scale[d2]);
 392         } else {
 393             scale[d2] = floor(scale[d2]);
 394         }
 395
 396         // Calculate skew angle. The angle is calculated with regards to the point obtained
 397         // by projecting the handle position on the relevant side of the bounding box.
 398         // This avoids degeneracies when moving the skew angle over the rotation center
 399         proj[d1] = new_pos[d1];
 400         proj[d2] = scc[d2] + (_origin[d2] - scc[d2]) * scale[d2];
 401         double angle = 0;
 402         if (!Geom::are_near(proj[d2], scc[d2]))
 403             angle = Geom::angle_between(_origin - scc, proj - scc);
 404         if (held_control(*event)) angle = snap_angle(angle);
 405
 406         // skew matrix has the from [[1, k],[0, 1]] for horizontal skew
 407         // and [[1,0],[k,1]] for vertical skew.
 408         Geom::Matrix skew = Geom::identity();
 409         // correct the sign of the tangent
 410         skew[d2 + 1] = (d1 == Geom::X ? -1.0 : 1.0) * tan(angle);
 411
 412         _last_angle = angle;
 413         Geom::Matrix t = Geom::Translate(-scc)
 414             * Geom::Scale(scale) * skew
 415             * Geom::Translate(scc);
 416         return t;
 417     }
 418
 419     virtual CommitEvent getCommitEvent() {
 420         return _side % 2
 421             ? COMMIT_MOUSE_SKEW_Y
 422             : COMMIT_MOUSE_SKEW_X;
 423     }
 424
 425     virtual Glib::ustring _getTip(unsigned state) {
 426         if (state_held_shift(state)) {
 427             if (state_held_control(state)) {
 428                 return format_tip(C_("Transform handle tip",
 429                     "<b>Shift+Ctrl:</b> skew about the rotation center with snapping "
 430                     "to %f° increments"), snap_increment_degrees());
 431             }
 432             return C_("Transform handle tip", "<b>Shift:</b> skew about the rotation center");
 433         }
 434         if (state_held_control(state)) {
 435             return format_tip(C_("Transform handle tip",
 436                 "<b>Ctrl:</b> snap skew angle to %f° increments"), snap_increment_degrees());
 437         }
 438         return C_("Transform handle tip",
 439             "<b>Skew handle:</b> drag to skew (shear) selection about "
 440             "the opposite handle");
 441     }
 442
 443     virtual Glib::ustring _getDragTip(GdkEventMotion */*event*/) {
 444         if (_last_horizontal) {
 445             return format_tip(C_("Transform handle tip", "Skew horizontally by %.2f°"),
 446                 _last_angle * 360.0);
 447         } else {
 448             return format_tip(C_("Transform handle tip", "Skew vertically by %.2f°"),
 449                 _last_angle * 360.0);
 450         }
 451     }
 452
 453     virtual bool _hasDragTips() { return true; }
 454
 455 private:
 456
 457     static Glib::RefPtr<Gdk::Pixbuf> _side_to_pixbuf(unsigned s) {
 458         sp_select_context_get_type();
 459         switch (s % 4) {
 460         case 0: return Glib::wrap(handles[9], true);
 461         case 1: return Glib::wrap(handles[7], true);
 462         case 2: return Glib::wrap(handles[5], true);
 463         default: return Glib::wrap(handles[11], true);
 464         }
 465     }
 466     Geom::Point _skew_center;
 467     Geom::Point _skew_opposite;
 468     unsigned _side;
 469     static bool _last_horizontal;
 470     static double _last_angle;
 471 };
 472 bool SkewHandle::_last_horizontal = false;
 473 double SkewHandle::_last_angle = 0;
 474
 475 class RotationCenter : public ControlPoint {
 476 public:
 477     RotationCenter(TransformHandleSet &th)
 478         : ControlPoint(th._desktop, Geom::Point(), Gtk::ANCHOR_CENTER, _get_pixbuf(),
 479             &center_cset, th._transform_handle_group)
 480         , _th(th)
 481     {
 482         setVisible(false);
 483     }
 484
 485 protected:
 486
 487     virtual Glib::ustring _getTip(unsigned /*state*/) {
 488         return C_("Transform handle tip",
 489             "<b>Rotation center:</b> drag to change the origin of transforms");
 490     }
 491
 492 private:
 493
 494     static Glib::RefPtr<Gdk::Pixbuf> _get_pixbuf() {
 495         sp_select_context_get_type();
 496         return Glib::wrap(handles[12], true);
 497     }
 498
 499     TransformHandleSet &_th;
 500 };
 501
 502 TransformHandleSet::TransformHandleSet(SPDesktop *d, SPCanvasGroup *th_group)
 503     : Manipulator(d)
 504     , _active(0)
 505     , _transform_handle_group(th_group)
 506     , _mode(MODE_SCALE)
 507     , _in_transform(false)
 508     , _visible(true)
 509 {
 510     _trans_outline = static_cast<CtrlRect*>(sp_canvas_item_new(sp_desktop_controls(_desktop),
 511         SP_TYPE_CTRLRECT, NULL));
 512     sp_canvas_item_hide(_trans_outline);
 513     _trans_outline->setDashed(true);
 514
 515     for (unsigned i = 0; i < 4; ++i) {
 516         _scale_corners[i] = new ScaleCornerHandle(*this, i);
 517         _scale_sides[i] = new ScaleSideHandle(*this, i);
 518         _rot_corners[i] = new RotateHandle(*this, i);
 519         _skew_sides[i] = new SkewHandle(*this, i);
 520     }
 521     _center = new RotationCenter(*this);
 522     // when transforming, update rotation center position
 523     signal_transform.connect(sigc::mem_fun(*_center, &RotationCenter::transform));
 524 }
 525
 526 TransformHandleSet::~TransformHandleSet()
 527 {
 528     for (unsigned i = 0; i < 17; ++i) {
 529         delete _handles[i];
 530     }
 531 }
 532
 533 /** Sets the mode of transform handles (scale or rotate). */
 534 void TransformHandleSet::setMode(Mode m)
 535 {
 536     _mode = m;
 537     _updateVisibility(_visible);
 538 }
 539
 540 Geom::Rect TransformHandleSet::bounds()
 541 {
 542     return Geom::Rect(*_scale_corners[0], *_scale_corners[2]);
 543 }
 544
 545 ControlPoint &TransformHandleSet::rotationCenter()
 546 {
 547     return *_center;
 548 }
 549
 550 void TransformHandleSet::setVisible(bool v)
 551 {
 552     if (_visible != v) {
 553         _visible = v;
 554         _updateVisibility(_visible);
 555     }
 556 }
 557
 558 void TransformHandleSet::setBounds(Geom::Rect const &r, bool preserve_center)
 559 {
 560     if (_in_transform) {
 561         _trans_outline->setRectangle(r);
 562     } else {
 563         for (unsigned i = 0; i < 4; ++i) {
 564             _scale_corners[i]->move(r.corner(i));
 565             _scale_sides[i]->move(Geom::middle_point(r.corner(i), r.corner(i+1)));
 566             _rot_corners[i]->move(r.corner(i));
 567             _skew_sides[i]->move(Geom::middle_point(r.corner(i), r.corner(i+1)));
 568         }
 569         if (!preserve_center) _center->move(r.midpoint());
 570         if (_visible) _updateVisibility(true);
 571     }
 572 }
 573
 574 bool TransformHandleSet::event(GdkEvent*)
 575 {
 576     return false;
 577 }
 578
 579 void TransformHandleSet::_emitTransform(Geom::Matrix const &t)
 580 {
 581     signal_transform.emit(t);
 582     _center->transform(t);
 583 }
 584
 585 void TransformHandleSet::_setActiveHandle(ControlPoint *th)
 586 {
 587     _active = th;
 588     if (_in_transform)
 589         throw std::logic_error("Transform initiated when another transform in progress");
 590     _in_transform = true;
 591     // hide all handles except the active one
 592     _updateVisibility(false);
 593     sp_canvas_item_show(_trans_outline);
 594 }
 595
 596 void TransformHandleSet::_clearActiveHandle()
 597 {
 598     // This can only be called from handles, so they had to be visible before _setActiveHandle
 599     sp_canvas_item_hide(_trans_outline);
 600     _active = 0;
 601     _in_transform = false;
 602     _updateVisibility(_visible);
 603 }
 604
 605 /** Update the visibility of transformation handles according to settings and the dimensions
 606  * of the bounding box. It hides the handles that would have no effect or lead to
 607  * discontinuities. Additionally, side handles for which there is no space are not shown. */
 608 void TransformHandleSet::_updateVisibility(bool v)
 609 {
 610     if (v) {
 611         Geom::Rect b = bounds();
 612         Geom::Point handle_size(
 613             gdk_pixbuf_get_width(handles[0]) / _desktop->current_zoom(),
 614             gdk_pixbuf_get_height(handles[0]) / _desktop->current_zoom());
 615         Geom::Point bp = b.dimensions();
 616
 617         // do not scale when the bounding rectangle has zero width or height
 618         bool show_scale = (_mode == MODE_SCALE) && !Geom::are_near(b.minExtent(), 0);
 619         // do not rotate if the bounding rectangle is degenerate
 620         bool show_rotate = (_mode == MODE_ROTATE_SKEW) && !Geom::are_near(b.maxExtent(), 0);
 621         bool show_scale_side[2], show_skew[2];
 622
 623         // show sides if:
 624         // a) there is enough space between corner handles, or
 625         // b) corner handles are not shown, but side handles make sense
 626         // this affects horizontal and vertical scale handles; skew handles never
 627         // make sense if rotate handles are not shown
 628         for (unsigned i = 0; i < 2; ++i) {
 629             Geom::Dim2 d = static_cast<Geom::Dim2>(i);
 630             Geom::Dim2 otherd = static_cast<Geom::Dim2>((i+1)%2);
 631             show_scale_side[i] = (_mode == MODE_SCALE);
 632             show_scale_side[i] &= (show_scale ? bp[d] >= handle_size[d]
 633                 : !Geom::are_near(bp[otherd], 0));
 634             show_skew[i] = (show_rotate && bp[d] >= handle_size[d]
 635                 && !Geom::are_near(bp[otherd], 0));
 636         }
 637         for (unsigned i = 0; i < 4; ++i) {
 638             _scale_corners[i]->setVisible(show_scale);
 639             _rot_corners[i]->setVisible(show_rotate);
 640             _scale_sides[i]->setVisible(show_scale_side[i%2]);
 641             _skew_sides[i]->setVisible(show_skew[i%2]);
 642         }
 643         // show rotation center if there is enough space (?)
 644         _center->setVisible(show_rotate /*&& bp[Geom::X] > handle_size[Geom::X]
 645             && bp[Geom::Y] > handle_size[Geom::Y]*/);
 646     } else {
 647         for (unsigned i = 0; i < 17; ++i) {
 648             if (_handles[i] != _active)
 649                 _handles[i]->setVisible(false);
 650         }
 651     }
 652
 653 }
 654
 655 } // namespace UI
 656 } // namespace Inkscape
 657
 658 /*
 659   Local Variables:
 660   mode:c++
 661   c-file-style:"stroustrup"
 662   c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
 663   indent-tabs-mode:nil
 664   fill-column:99
 665   End:
 666 */
 667 // vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:encoding=utf-8:textwidth=99 :