Major code refactoring:

[r2c2.git] / source / designer / manipulator.cpp

diff --git a/source/designer/manipulator.cpp b/source/designer/manipulator.cpp
index cbeb982198a81687f28b432a2a2a40e63640ea91..e7cceadcc1b286d63fdc8f2467ae11d25e395b65 100644 (file)
--- a/source/designer/manipulator.cpp
+++ b/source/designer/manipulator.cpp
@@ -2,6 +2,7 @@
 #include <cmath>
 #include <GL/gl.h>
 #include "3d/layout.h"
+#include "libmarklin/tracktype.h"
 #include "designer.h"
 #include "manipulator.h"
 #include "selection.h"
@@ -66,19 +67,19 @@ void Manipulator::duplicate()
        if(mode)
                cancel();
 
-       TrackSeq new_tracks;
-       for(MTrackSeq::iterator i=tracks.begin(); i!=tracks.end(); ++i)
+       list<Track *> new_tracks;
+       for(vector<MTrack>::iterator i=tracks.begin(); i!=tracks.end(); ++i)
        {
                Track *track=i->track->copy();
-               designer.get_layout()->add_track(track);
+               designer.get_layout()->add_track(*track);
                new_tracks.push_back(track);
        }
 
        selection->clear();
-       for(TrackSeq::iterator i=new_tracks.begin(); i!=new_tracks.end(); ++i)
+       for(list<Track *>::iterator i=new_tracks.begin(); i!=new_tracks.end(); ++i)
        {
                selection->add_track(*i);
-               for(TrackSeq::iterator j=i; j!=new_tracks.end(); ++j)
+               for(list<Track *>::iterator j=i; j!=new_tracks.end(); ++j)
                        if(j!=i)
                                (*i)->snap_to(**j, true);
        }
@@ -92,18 +93,18 @@ void Manipulator::flatten()
        if(tracks.empty()) return;
 
        float z=0;
-       for(MTrackSeq::iterator i=tracks.begin(); i!=tracks.end(); ++i)
+       for(vector<MTrack>::iterator i=tracks.begin(); i!=tracks.end(); ++i)
                z+=i->track->get_position().z+i->track->get_slope()/2;
        z/=tracks.size();
 
-       for(MTrackSeq::iterator i=tracks.begin(); i!=tracks.end(); ++i)
+       for(vector<MTrack>::iterator i=tracks.begin(); i!=tracks.end(); ++i)
        {
                Point p=i->track->get_position();
                i->track->set_position(Point(p.x, p.y, z));
                i->track->set_slope(0);
        }
 
-       for(TrackSeq::iterator i=neighbors.begin(); i!=neighbors.end(); ++i)
+       for(set<Track *>::iterator i=neighbors.begin(); i!=neighbors.end(); ++i)
                (*i)->check_slope();
 
        update_wrap();
@@ -117,31 +118,31 @@ void Manipulator::even_slope(bool smooth)
        if(neighbors.size()!=2)
                return;
 
-       for(MTrackSeq::iterator i=tracks.begin(); i!=tracks.end(); ++i)
-               if(i->track->get_endpoints().size()!=2)
+       for(vector<MTrack>::iterator i=tracks.begin(); i!=tracks.end(); ++i)
+               if(i->track->get_type().get_endpoints().size()!=2)
                        return;
 
-       TrackSeq tracks2;
-       for(MTrackSeq::iterator i=tracks.begin(); i!=tracks.end(); ++i)
+       list<Track *> tracks2;
+       for(vector<MTrack>::iterator i=tracks.begin(); i!=tracks.end(); ++i)
                tracks2.push_back(i->track);
 
        float total_len=0;
 
-       TrackOrderSeq order;
-       Track *cur=neighbors.front();
+       list<TrackOrder> order;
+       Track *cur=*neighbors.begin();
        while(tracks2.size())
        {
                bool rev=false;
-               for(TrackSeq::iterator i=tracks2.begin(); i!=tracks2.end(); ++i)
+               for(list<Track *>::iterator i=tracks2.begin(); i!=tracks2.end(); ++i)
                {
-                       const Track::EndpointSeq &epl=(*i)->get_endpoints();
-                       if(epl.front().link==cur)
+                       const vector<Track *> &links=(*i)->get_links();
+                       if(links[0]==cur)
                        {
                                cur=*i;
                                tracks2.erase(i);
                                break;
                        }
-                       else if(epl.back().link==cur)
+                       else if(links[1]==cur)
                        {
                                cur=*i;
                                rev=true;
@@ -150,13 +151,15 @@ void Manipulator::even_slope(bool smooth)
                        }
                }
                order.push_back(TrackOrder(cur, rev));
-               total_len+=cur->get_length();
+               total_len+=cur->get_type().get_total_length();
        }
 
-       const Track::Endpoint *ep=neighbors.front()->get_endpoint_by_link(order.front().track);
-       float start_z=neighbors.front()->get_position().z+ep->pos.z;
-       ep=neighbors.back()->get_endpoint_by_link(order.back().track);
-       float end_z=neighbors.back()->get_position().z+ep->pos.z;
+       set<Track *>::iterator nb=neighbors.begin();
+       int epi=(*nb)->get_endpoint_by_link(*order.front().track);
+       float start_z=(*nb)->get_endpoint_position(epi).z;
+       ++nb;
+       epi=(*nb)->get_endpoint_by_link(*order.back().track);
+       float end_z=(*nb)->get_endpoint_position(epi).z;
 
        if(smooth)
        {
@@ -166,29 +169,29 @@ void Manipulator::even_slope(bool smooth)
                {
                        cur_slope+=0.025;
 
-                       float dz=order.front().track->get_length()*dir*cur_slope;
+                       float dz=order.front().track->get_type().get_total_length()*dir*cur_slope;
                        set_slope(order.front(), start_z, dz);
                        start_z+=dz;
-                       total_len-=order.front().track->get_length();
+                       total_len-=order.front().track->get_type().get_total_length();
                        order.erase(order.begin());
 
-                       dz=order.back().track->get_length()*dir*cur_slope;
+                       dz=order.back().track->get_type().get_total_length()*dir*cur_slope;
                        set_slope(order.back(), end_z-dz, dz);
                        end_z-=dz;
-                       total_len-=order.back().track->get_length();
+                       total_len-=order.back().track->get_type().get_total_length();
                        order.erase(--order.end());
                }
        }
 
        float cur_z=start_z;
-       for(TrackOrderSeq::iterator i=order.begin(); i!=order.end(); ++i)
+       for(list<TrackOrder>::iterator i=order.begin(); i!=order.end(); ++i)
        {
-               float dz=i->track->get_length()*(end_z-start_z)/total_len;
+               float dz=i->track->get_type().get_total_length()*(end_z-start_z)/total_len;
                set_slope(*i, cur_z, dz);
                cur_z+=dz;
        }
 
-       for(TrackSeq::iterator i=neighbors.begin(); i!=neighbors.end(); ++i)
+       for(set<Track *>::iterator i=neighbors.begin(); i!=neighbors.end(); ++i)
                (*i)->check_slope();
 
        update_wrap();
@@ -201,13 +204,13 @@ void Manipulator::cancel()
        mode=NONE;
 
        wrap_pos=center;
-       for(MTrackSeq::iterator i=tracks.begin(); i!=tracks.end(); ++i)
+       for(vector<MTrack>::iterator i=tracks.begin(); i!=tracks.end(); ++i)
        {
                i->track->set_position(Point(center.x+i->pos.x, center.y+i->pos.y, center.z+i->pos.z));
                i->track->set_rotation(i->rot);
        }
 
-       for(TrackSeq::iterator i=neighbors.begin(); i!=neighbors.end(); ++i)
+       for(set<Track *>::iterator i=neighbors.begin(); i!=neighbors.end(); ++i)
                (*i)->check_slope();
 
        angle=0;
@@ -226,19 +229,19 @@ void Manipulator::button_press(int, int, float, float, unsigned btn)
                update_wrap();
                //snapped=0;
 
-               for(TrackSeq::iterator i=neighbors.begin(); i!=neighbors.end(); ++i)
-                       for(MTrackSeq::iterator j=tracks.begin(); j!=tracks.end(); ++j)
+               for(set<Track *>::iterator i=neighbors.begin(); i!=neighbors.end(); ++i)
+                       for(vector<MTrack>::iterator j=tracks.begin(); j!=tracks.end(); ++j)
                                j->track->break_link(**i);
 
-               const TrackSeq &ltracks=designer.get_layout()->get_tracks();
-               for(TrackSeq::const_iterator i=ltracks.begin(); i!=ltracks.end(); ++i)
+               const set<Track *> &ltracks=designer.get_layout()->get_tracks();
+               for(set<Track *>::const_iterator i=ltracks.begin(); i!=ltracks.end(); ++i)
                {
                        bool ok=true;
-                       for(MTrackSeq::iterator j=tracks.begin(); (j!=tracks.end() && ok); ++j)
+                       for(vector<MTrack>::iterator j=tracks.begin(); (j!=tracks.end() && ok); ++j)
                                ok=(j->track!=*i);
                        if(!ok) continue;
 
-                       for(MTrackSeq::iterator j=tracks.begin(); j!=tracks.end(); ++j)
+                       for(vector<MTrack>::iterator j=tracks.begin(); j!=tracks.end(); ++j)
                                j->track->snap_to(**i, true);
                }
 
@@ -258,22 +261,22 @@ void Manipulator::pointer_motion(int, int y, float gx, float gy)
                Point delta(gpointer.x-move_origin.x, gpointer.y-move_origin.y, 0);
 
                wrap_pos=Point(center.x+delta.x, center.y+delta.y, center.z);
-               for(MTrackSeq::iterator i=tracks.begin(); i!=tracks.end(); ++i)
+               for(vector<MTrack>::iterator i=tracks.begin(); i!=tracks.end(); ++i)
                {
                        i->track->set_position(Point(wrap_pos.x+i->pos.x, wrap_pos.y+i->pos.y, wrap_pos.z+i->pos.z));
                        i->track->set_rotation(i->rot);
                }
 
-               const TrackSeq &ltracks=designer.get_layout()->get_tracks();
+               const set<Track *> &ltracks=designer.get_layout()->get_tracks();
                MTrack *snapped=0;
-               for(TrackSeq::const_iterator i=ltracks.begin(); (i!=ltracks.end() && !snapped); ++i)
+               for(set<Track *>::const_iterator i=ltracks.begin(); (i!=ltracks.end() && !snapped); ++i)
                {
                        bool ok=true;
-                       for(MTrackSeq::iterator j=tracks.begin(); (j!=tracks.end() && ok); ++j)
+                       for(vector<MTrack>::iterator j=tracks.begin(); (j!=tracks.end() && ok); ++j)
                                ok=(j->track!=*i);
                        if(!ok) continue;
 
-                       for(MTrackSeq::iterator j=tracks.begin(); (j!=tracks.end() && !snapped); ++j)
+                       for(vector<MTrack>::iterator j=tracks.begin(); (j!=tracks.end() && !snapped); ++j)
                                if(j->track->snap_to(**i, false))
                                        snapped=&*j;
                }
@@ -284,7 +287,7 @@ void Manipulator::pointer_motion(int, int y, float gx, float gy)
                        float c=cos(da);
                        float s=sin(da);
                        const Point &sp=snapped->track->get_position();
-                       for(MTrackSeq::iterator i=tracks.begin(); i!=tracks.end(); ++i)
+                       for(vector<MTrack>::iterator i=tracks.begin(); i!=tracks.end(); ++i)
                        {
                                if(&*i==snapped)
                                        continue;
@@ -302,7 +305,7 @@ void Manipulator::pointer_motion(int, int y, float gx, float gy)
                rot_origin=a;
 
                wrap_rot=angle;
-               for(MTrackSeq::iterator i=tracks.begin(); i!=tracks.end(); ++i)
+               for(vector<MTrack>::iterator i=tracks.begin(); i!=tracks.end(); ++i)
                {
                        float c=cos(angle);
                        float s=sin(angle);
@@ -320,10 +323,10 @@ void Manipulator::pointer_motion(int, int y, float gx, float gy)
                signal_status.emit(ss.str());
 
                wrap_pos.z=center.z+dz;
-               for(MTrackSeq::iterator i=tracks.begin(); i!=tracks.end(); ++i)
+               for(vector<MTrack>::iterator i=tracks.begin(); i!=tracks.end(); ++i)
                        i->track->set_position(Point(center.x+i->pos.x, center.y+i->pos.y, center.z+i->pos.z+dz));
 
-               for(TrackSeq::iterator i=neighbors.begin(); i!=neighbors.end(); ++i)
+               for(set<Track *>::iterator i=neighbors.begin(); i!=neighbors.end(); ++i)
                        (*i)->check_slope();
        }
 }
@@ -365,7 +368,7 @@ void Manipulator::selection_changed()
        tracks.clear();
        if(selection)
        {
-               const Selection::TrackSet &stracks=selection->get_tracks();
+               const set<Track *> &stracks=selection->get_tracks();
                tracks.insert(tracks.end(), stracks.begin(), stracks.end());
        }
 
@@ -378,7 +381,7 @@ void Manipulator::update_wrap()
        wrap.clear();
        float min_x=0,max_x=0;
        float min_y=0,max_y=0;
-       for(MTrackSeq::iterator i=tracks.begin(); i!=tracks.end(); ++i)
+       for(vector<MTrack>::iterator i=tracks.begin(); i!=tracks.end(); ++i)
        {
                Track3D *t3d=designer.get_layout_3d()->get_track(i->track);
 
@@ -422,7 +425,7 @@ void Manipulator::update_wrap()
        center=Point((min_x+max_x)/2, (min_y+max_y)/2, 0);
        wrap_pos=center;
        wrap_rot=0;
-       for(MTrackSeq::iterator i=tracks.begin(); i!=tracks.end(); ++i)
+       for(vector<MTrack>::iterator i=tracks.begin(); i!=tracks.end(); ++i)
        {
                const Point &tp=i->track->get_position();
                i->pos=Point(tp.x-center.x, tp.y-center.y, tp.z);
@@ -437,22 +440,22 @@ void Manipulator::update_wrap()
 void Manipulator::update_neighbors()
 {
        neighbors.clear();
-       for(MTrackSeq::iterator i=tracks.begin(); i!=tracks.end(); ++i)
+       for(vector<MTrack>::iterator i=tracks.begin(); i!=tracks.end(); ++i)
        {
-               const Track::EndpointSeq &epl=i->track->get_endpoints();
-               for(Track::EndpointSeq::const_iterator j=epl.begin(); j!=epl.end(); ++j)
+               const vector<Track *> &links=i->track->get_links();
+               for(vector<Track *>::const_iterator j=links.begin(); j!=links.end(); ++j)
                {
-                       if(!j->link)
+                       if(!*j)
                                continue;
-                       if(find(neighbors.begin(), neighbors.end(), j->link)!=neighbors.end())
+                       if(neighbors.count(*j))
                                continue;
 
                        bool ok=true;
-                       for(MTrackSeq::iterator k=tracks.begin(); (k!=tracks.end() && ok); ++k)
-                               ok=(k->track!=j->link);
+                       for(vector<MTrack>::iterator k=tracks.begin(); (k!=tracks.end() && ok); ++k)
+                               ok=(k->track!=*j);
 
                        if(ok)
-                               neighbors.push_back(j->link);
+                               neighbors.insert(*j);
                }
        }
 }