source/designer/manipulator.cpp

   1 /* $Id$
   2
   3 This file is part of the MSP Märklin suite
   4 Copyright © 2006-2010  Mikkosoft Productions, Mikko Rasa
   5 Distributed under the GPL
   6 */
   7
   8 #include <algorithm>
   9 #include <cmath>
  10 #include <msp/strings/formatter.h>
  11 #include "libmarklin/tracktype.h"
  12 #include "designer.h"
  13 #include "manipulator.h"
  14 #include "selection.h"
  15
  16 using namespace std;
  17 using namespace Marklin;
  18 using namespace Msp;
  19
  20 Manipulator::Manipulator(Designer &d, Selection &s):
  21         designer(d),
  22         selection(s),
  23         mode(NONE),
  24         angle(0)
  25 {
  26         selection.signal_changed.connect(sigc::mem_fun(this, &Manipulator::selection_changed));
  27 }
  28
  29 void Manipulator::start_move()
  30 {
  31         if(mode)
  32                 cancel();
  33
  34         move_origin = gpointer;
  35
  36         mode = MOVE;
  37 }
  38
  39 void Manipulator::start_rotate()
  40 {
  41         if(mode)
  42                 cancel();
  43
  44         rot_origin = atan2(gpointer.y-center.y, gpointer.x-center.x);
  45
  46         mode = ROTATE;
  47 }
  48
  49 void Manipulator::start_elevate()
  50 {
  51         if(mode)
  52                 cancel();
  53
  54         elev_origin = pointer_y;
  55
  56         mode = ELEVATE;
  57 }
  58
  59 void Manipulator::duplicate()
  60 {
  61         if(mode)
  62                 cancel();
  63
  64         list<Track *> new_tracks;
  65         for(vector<MTrack>::iterator i=tracks.begin(); i!=tracks.end(); ++i)
  66         {
  67                 Track *track = new Track(*designer.get_layout(), i->track->get_type());
  68                 track->set_position(i->track->get_position());
  69                 track->set_rotation(i->track->get_rotation());
  70                 new_tracks.push_back(track);
  71         }
  72
  73         selection.clear();
  74         for(list<Track *>::iterator i=new_tracks.begin(); i!=new_tracks.end(); ++i)
  75         {
  76                 selection.add_track(*i);
  77                 for(list<Track *>::iterator j=i; j!=new_tracks.end(); ++j)
  78                         if(j!=i)
  79                                 (*i)->snap_to(**j, true);
  80         }
  81 }
  82
  83 void Manipulator::flatten()
  84 {
  85         if(mode)
  86                 cancel();
  87
  88         if(tracks.empty()) return;
  89
  90         float z = 0;
  91         for(vector<MTrack>::iterator i=tracks.begin(); i!=tracks.end(); ++i)
  92                 z += i->track->get_position().z+i->track->get_slope()/2;
  93         z /= tracks.size();
  94
  95         for(vector<MTrack>::iterator i=tracks.begin(); i!=tracks.end(); ++i)
  96         {
  97                 Point p = i->track->get_position();
  98                 i->track->set_position(Point(p.x, p.y, z));
  99                 i->track->set_slope(0);
 100         }
 101
 102         for(set<Track *>::iterator i=neighbors.begin(); i!=neighbors.end(); ++i)
 103                 (*i)->check_slope();
 104
 105         update_tracks();
 106 }
 107
 108 void Manipulator::even_slope(bool smooth)
 109 {
 110         if(mode)
 111                 cancel();
 112
 113         if(neighbors.size()!=2)
 114                 return;
 115
 116         for(vector<MTrack>::iterator i=tracks.begin(); i!=tracks.end(); ++i)
 117                 if(i->track->get_type().get_endpoints().size()!=2)
 118                         return;
 119
 120         list<Track *> tracks2;
 121         for(vector<MTrack>::iterator i=tracks.begin(); i!=tracks.end(); ++i)
 122                 tracks2.push_back(i->track);
 123
 124         float total_len = 0;
 125
 126         list<TrackOrder> order;
 127         Track *cur = *neighbors.begin();
 128         while(tracks2.size())
 129         {
 130                 bool rev = false;
 131                 for(list<Track *>::iterator i=tracks2.begin(); i!=tracks2.end(); ++i)
 132                 {
 133                         const vector<Track *> &links = (*i)->get_links();
 134                         if(links[0]==cur)
 135                         {
 136                                 cur = *i;
 137                                 tracks2.erase(i);
 138                                 break;
 139                         }
 140                         else if(links[1]==cur)
 141                         {
 142                                 cur = *i;
 143                                 rev = true;
 144                                 tracks2.erase(i);
 145                                 break;
 146                         }
 147                 }
 148                 order.push_back(TrackOrder(cur, rev));
 149                 total_len += cur->get_type().get_total_length();
 150         }
 151
 152         set<Track *>::iterator nb = neighbors.begin();
 153         int epi = (*nb)->get_endpoint_by_link(*order.front().track);
 154         float start_z = (*nb)->get_endpoint_position(epi).z;
 155         ++nb;
 156         epi = (*nb)->get_endpoint_by_link(*order.back().track);
 157         float end_z = (*nb)->get_endpoint_position(epi).z;
 158
 159         if(smooth)
 160         {
 161                 float dir = (end_z>start_z)?1:-1;
 162                 float cur_slope = 0;
 163                 while((end_z-start_z)*dir/total_len>cur_slope+0.025 && order.size()>2)
 164                 {
 165                         cur_slope += 0.025;
 166
 167                         float dz = order.front().track->get_type().get_total_length()*dir*cur_slope;
 168                         set_slope(order.front(), start_z, dz);
 169                         start_z += dz;
 170                         total_len -= order.front().track->get_type().get_total_length();
 171                         order.erase(order.begin());
 172
 173                         dz = order.back().track->get_type().get_total_length()*dir*cur_slope;
 174                         set_slope(order.back(), end_z-dz, dz);
 175                         end_z -= dz;
 176                         total_len -= order.back().track->get_type().get_total_length();
 177                         order.erase(--order.end());
 178                 }
 179         }
 180
 181         float cur_z = start_z;
 182         for(list<TrackOrder>::iterator i=order.begin(); i!=order.end(); ++i)
 183         {
 184                 float dz = i->track->get_type().get_total_length()*(end_z-start_z)/total_len;
 185                 set_slope(*i, cur_z, dz);
 186                 cur_z += dz;
 187         }
 188
 189         for(set<Track *>::iterator i=neighbors.begin(); i!=neighbors.end(); ++i)
 190                 (*i)->check_slope();
 191
 192         update_tracks();
 193 }
 194
 195 void Manipulator::cancel()
 196 {
 197         if(!mode)
 198                 return;
 199         mode = NONE;
 200
 201         for(vector<MTrack>::iterator i=tracks.begin(); i!=tracks.end(); ++i)
 202         {
 203                 i->track->set_position(Point(center.x+i->pos.x, center.y+i->pos.y, center.z+i->pos.z));
 204                 i->track->set_rotation(i->rot);
 205         }
 206
 207         for(set<Track *>::iterator i=neighbors.begin(); i!=neighbors.end(); ++i)
 208                 (*i)->check_slope();
 209
 210         angle = 0;
 211
 212         signal_done.emit(false);
 213 }
 214
 215 void Manipulator::button_press(int, int, float, float, unsigned btn)
 216 {
 217         if(btn==3)
 218                 cancel();
 219         else if(mode)
 220         {
 221                 mode = NONE;
 222                 angle = 0;
 223
 224                 for(set<Track *>::iterator i=neighbors.begin(); i!=neighbors.end(); ++i)
 225                         for(vector<MTrack>::iterator j=tracks.begin(); j!=tracks.end(); ++j)
 226                                 j->track->break_link(**i);
 227
 228                 const set<Track *> &ltracks = designer.get_layout()->get_tracks();
 229                 for(set<Track *>::const_iterator i=ltracks.begin(); i!=ltracks.end(); ++i)
 230                 {
 231                         bool ok = true;
 232                         for(vector<MTrack>::iterator j=tracks.begin(); (j!=tracks.end() && ok); ++j)
 233                                 ok = (j->track!=*i);
 234                         if(!ok) continue;
 235
 236                         for(vector<MTrack>::iterator j=tracks.begin(); j!=tracks.end(); ++j)
 237                                 j->track->snap_to(**i, true);
 238                 }
 239
 240                 update_tracks();
 241                 update_neighbors();
 242
 243                 signal_done.emit(true);
 244         }
 245 }
 246
 247 void Manipulator::pointer_motion(int, int y, float gx, float gy)
 248 {
 249         pointer_y = y;
 250         gpointer = Point(gx, gy, 0);
 251
 252         if(mode==MOVE)
 253         {
 254                 Point delta(gpointer.x-move_origin.x, gpointer.y-move_origin.y, 0);
 255                 Point offset(center.x+delta.x, center.y+delta.y, center.z);
 256                 for(vector<MTrack>::iterator i=tracks.begin(); i!=tracks.end(); ++i)
 257                 {
 258                         i->track->set_position(Point(offset.x+i->pos.x, offset.y+i->pos.y, offset.z+i->pos.z));
 259                         i->track->set_rotation(i->rot);
 260                 }
 261
 262                 const set<Track *> &ltracks = designer.get_layout()->get_tracks();
 263                 MTrack *snapped = 0;
 264                 for(set<Track *>::const_iterator i=ltracks.begin(); (i!=ltracks.end() && !snapped); ++i)
 265                 {
 266                         bool ok = true;
 267                         for(vector<MTrack>::iterator j=tracks.begin(); (j!=tracks.end() && ok); ++j)
 268                                 ok = (j->track!=*i);
 269                         if(!ok) continue;
 270
 271                         for(vector<MTrack>::iterator j=tracks.begin(); (j!=tracks.end() && !snapped); ++j)
 272                                 if(j->track->snap_to(**i, false))
 273                                         snapped = &*j;
 274                 }
 275
 276                 if(snapped)
 277                 {
 278                         float da = snapped->track->get_rotation()-snapped->rot;
 279                         float c = cos(da);
 280                         float s = sin(da);
 281                         const Point &sp = snapped->track->get_position();
 282                         for(vector<MTrack>::iterator i=tracks.begin(); i!=tracks.end(); ++i)
 283                         {
 284                                 if(&*i==snapped)
 285                                         continue;
 286
 287                                 Point dp(i->pos.x-snapped->pos.x, i->pos.y-snapped->pos.y, 0);
 288                                 i->track->set_position(Point(sp.x+c*dp.x-s*dp.y, sp.y+s*dp.x+c*dp.y, sp.z+i->pos.z-snapped->pos.z));
 289                                 i->track->set_rotation(i->rot+da);
 290                         }
 291                 }
 292         }
 293         else if(mode==ROTATE)
 294         {
 295                 float a = atan2(gpointer.y-center.y, gpointer.x-center.x);
 296                 angle += a-rot_origin;
 297                 rot_origin = a;
 298
 299                 for(vector<MTrack>::iterator i=tracks.begin(); i!=tracks.end(); ++i)
 300                 {
 301                         float c = cos(angle);
 302                         float s = sin(angle);
 303                         i->track->set_position(Point(center.x+c*i->pos.x-s*i->pos.y, center.y+s*i->pos.x+c*i->pos.y, center.z+i->pos.z));
 304                         i->track->set_rotation(angle+i->rot);
 305                 }
 306         }
 307         else if(mode==ELEVATE)
 308         {
 309                 float dz = (y-elev_origin)/1000.;
 310
 311                 signal_status.emit(format("Elevation: %+.0fmm (%.0fmm)", dz*1000, (center.z+dz)*1000));
 312
 313                 for(vector<MTrack>::iterator i=tracks.begin(); i!=tracks.end(); ++i)
 314                         i->track->set_position(Point(center.x+i->pos.x, center.y+i->pos.y, center.z+i->pos.z+dz));
 315
 316                 for(set<Track *>::iterator i=neighbors.begin(); i!=neighbors.end(); ++i)
 317                         (*i)->check_slope();
 318         }
 319 }
 320
 321 void Manipulator::selection_changed()
 322 {
 323         if(mode)
 324                 cancel();
 325
 326         tracks.clear();
 327         const set<Track *> &stracks = selection.get_tracks();
 328         tracks.insert(tracks.end(), stracks.begin(), stracks.end());
 329
 330         update_neighbors();
 331         update_tracks();
 332 }
 333
 334 void Manipulator::update_tracks()
 335 {
 336         Point minp, maxp;
 337         for(vector<MTrack>::iterator i=tracks.begin(); i!=tracks.end(); ++i)
 338         {
 339                 unsigned n_endpoints = i->track->get_type().get_endpoints().size();
 340                 for(unsigned j=0; j<n_endpoints; ++j)
 341                 {
 342                         Point p = i->track->get_endpoint_position(j);
 343                         if(i==tracks.begin() && j==0)
 344                                 minp = maxp = p;
 345                         else
 346                         {
 347                                 minp.x = min(minp.x, p.x);
 348                                 maxp.x = max(maxp.x, p.x);
 349                                 minp.y = min(minp.y, p.y);
 350                                 maxp.y = max(maxp.y, p.y);
 351                                 minp.z = min(minp.z, p.z);
 352                         }
 353                 }
 354         }
 355
 356         center = Point((minp.x+maxp.x)/2, (minp.y+maxp.y)/2, minp.z);
 357         for(vector<MTrack>::iterator i=tracks.begin(); i!=tracks.end(); ++i)
 358         {
 359                 const Point &tp = i->track->get_position();
 360                 i->pos = Point(tp.x-center.x, tp.y-center.y, tp.z-center.z);
 361                 i->rot = i->track->get_rotation();
 362         }
 363 }
 364
 365 void Manipulator::update_neighbors()
 366 {
 367         neighbors.clear();
 368         for(vector<MTrack>::iterator i=tracks.begin(); i!=tracks.end(); ++i)
 369         {
 370                 const vector<Track *> &links = i->track->get_links();
 371                 for(vector<Track *>::const_iterator j=links.begin(); j!=links.end(); ++j)
 372                 {
 373                         if(!*j)
 374                                 continue;
 375                         if(neighbors.count(*j))
 376                                 continue;
 377
 378                         bool ok = true;
 379                         for(vector<MTrack>::iterator k=tracks.begin(); (k!=tracks.end() && ok); ++k)
 380                                 ok = (k->track!=*j);
 381
 382                         if(ok)
 383                                 neighbors.insert(*j);
 384                 }
 385         }
 386 }
 387
 388 void Manipulator::set_slope(TrackOrder &track, float z, float dz)
 389 {
 390         const Point &p = track.track->get_position();
 391         if(track.rev)
 392         {
 393                 track.track->set_position(Point(p.x, p.y, z+dz));
 394                 track.track->set_slope(-dz);
 395         }
 396         else
 397         {
 398                 track.track->set_position(Point(p.x, p.y, z));
 399                 track.track->set_slope(dz);
 400         }
 401 }
 402
 403 Manipulator::MTrack::MTrack(Track *t):
 404         track(t),
 405         pos(track->get_position()),
 406         rot(track->get_rotation())
 407 { }