X-Git-Url: http://git.tdb.fi/?a=blobdiff_plain;f=source%2Fdesigner%2Fdesigner.cpp;h=5f125fd11c64a0ed44e90321568364a948b30994;hb=7e27b311e33beda1746eb63e0945633f262427f6;hp=99655683c1a3bc772d3fe6737d336d2a6d2e7802;hpb=02c9a9779954d993cb73fe5f7a72b0847e87f633;p=r2c2.git

diff --git a/source/designer/designer.cpp b/source/designer/designer.cpp
index 9965568..5f125fd 100644
--- a/source/designer/designer.cpp
+++ b/source/designer/designer.cpp
@@ -1,13 +1,14 @@
 /* $Id$
 
-This file is part of the MSP Märklin suite
+This file is part of R²C²
 Copyright © 2006-2010 Mikkosoft Productions, Mikko Rasa
 Distributed under the GPL
 */
 
 #include <signal.h>
+#include <algorithm>
 #include <cmath>
-#include <GL/gl.h>
+#include <msp/fs/utils.h>
 #include <msp/gl/blend.h>
 #include <msp/gl/framebuffer.h>
 #include <msp/gl/matrix.h>
@@ -25,38 +26,46 @@ Distributed under the GPL
 #include <msp/strings/utils.h>
 #include <msp/time/units.h>
 #include <msp/time/utils.h>
-#include "libmarklin/tracktype.h"
+#include "libr2c2/route.h"
+#include "libr2c2/tracktype.h"
+#include "libr2c2/zone.h"
+#include "3d/path.h"
 #include "designer.h"
 #include "input.h"
+#include "layoutbar.h"
 #include "manipulator.h"
 #include "measure.h"
+#include "routebar.h"
 #include "selection.h"
-#include "toolbar.h"
+#include "svgexporter.h"
+#include "trackbar.h"
+#include "trackproperties.h"
+#include "zonebar.h"
+#include "zoneproperties.h"
 
 using namespace std;
-using namespace Marklin;
+using namespace R2C2;
 using namespace Msp;
 
 Application::RegApp<Designer> Designer::reg;
 
 Designer::Designer(int argc, char **argv):
 	window(1280, 960),
+	ui_res("r2c2.res"),
+	root(ui_res, window),
 	base_object(0),
 	cur_route(0),
+	cur_zone(0),
 	mode(SELECT),
-	manipulator(*this, selection),
+	manipulator(*this, root, selection),
 	measure(*this),
-	input(0),
-	camera_ctl(window, camera),
-	shift(false)
+	camera_ctl(*this, root, camera),
+	track_wrap(*this, selection)
 {
 	window.set_title("Railway Designer");
 	window.signal_close.connect(sigc::bind(sigc::mem_fun(this, &Designer::exit), 0));
-	window.signal_key_press.connect(sigc::mem_fun(this, &Designer::key_press));
-	window.signal_key_release.connect(sigc::mem_fun(this, &Designer::key_release));
-	window.signal_button_press.connect(sigc::mem_fun(this, &Designer::button_press));
-	window.signal_pointer_motion.connect(sigc::mem_fun(this, &Designer::pointer_motion));
 
+	selection.signal_changed.connect(sigc::mem_fun(this, &Designer::selection_changed));
 	manipulator.signal_status.connect(sigc::mem_fun(this, &Designer::manipulation_status));
 	manipulator.signal_done.connect(sigc::mem_fun(this, &Designer::manipulation_done));
 	measure.signal_changed.connect(sigc::mem_fun(this, &Designer::measure_changed));
@@ -70,6 +79,9 @@ Designer::Designer(int argc, char **argv):
 	layout = new Layout(catalogue);
 	layout_3d = new Layout3D(*layout);
 
+	layout->signal_track_added.connect(sigc::mem_fun(this, &Designer::track_added));
+	layout->signal_track_removed.connect(sigc::mem_fun(this, &Designer::track_removed));
+
 	if(argc>1)
 	{
 		filename = argv[1];
@@ -83,51 +95,76 @@ Designer::Designer(int argc, char **argv):
 	}
 
 	// Setup OpenGL
-	GL::enable(GL::DEPTH_TEST);
-	GL::enable(GL::BLEND);
-	GL::blend_func(GL::SRC_ALPHA, GL::ONE_MINUS_SRC_ALPHA);
 	GL::enable(GL_CULL_FACE);
 
 	pipeline = new GL::Pipeline(window.get_width(), window.get_height(), false);
 	pipeline->set_camera(&camera);
-	pipeline->add_renderable(layout_3d->get_scene());
+	pipeline->add_renderable_for_pass(layout_3d->get_scene(), 0);
 	if(base_object)
 		pipeline->add_renderable(*base_object);
+	pipeline->add_renderable_for_pass(track_wrap, "unlit");
+	pipeline->add_renderable_for_pass(layout_3d->get_path_scene(), "unlit");
+	pipeline->add_renderable_for_pass(layout_3d->get_endpoint_scene(), "unlit");
 
 	light.set_position(0, -0.259, 0.966, 0);
 	lighting.attach(0, light);
 
-	GL::PipelinePass *pass = &pipeline->add_pass(GL::Tag());
+	GL::PipelinePass *pass = &pipeline->add_pass(0);
+	pass->lighting = &lighting;
+	pass->depth_test = &GL::DepthTest::lequal();
+
+	pass = &pipeline->add_pass("unlit");
+	pass->depth_test = &GL::DepthTest::lequal();
+	pass->blend = &GL::Blend::alpha();
+
+	pass = &pipeline->add_pass("blended");
 	pass->lighting = &lighting;
+	pass->depth_test = &GL::DepthTest::lequal();
+	pass->blend = &GL::Blend::alpha();
 
 	camera.set_up_direction(GL::Vector3(0, 0, 1));
-	view_all();
+	camera.set_look_direction(GL::Vector3(0, 0.5, -0.866));
 
 	// Setup UI
-	DataFile::load(ui_res, "marklin.res");
-	root = new GLtk::Root(ui_res, window);
+	root.signal_key_press.connect(sigc::mem_fun(this, &Designer::key_press));
+	root.signal_button_press.connect(sigc::mem_fun(this, &Designer::button_press));
+	root.signal_pointer_motion.connect(sigc::mem_fun(this, &Designer::pointer_motion));
+	root.signal_tooltip.connect(sigc::mem_fun(this, &Designer::tooltip));
+
+	toolbars.push_back(new Layoutbar(*this));
+	toolbars.push_back(new Trackbar(*this));
+	toolbars.push_back(new Routebar(*this));
+	toolbars.push_back(new Zonebar(*this));
+	for(vector<Toolbar *>::iterator i=toolbars.begin(); i!=toolbars.end(); ++i)
+	{
+		root.add(**i);
+		if(i!=toolbars.begin())
+			(*i)->expand(false);
+		(*i)->signal_expanded.connect(sigc::hide(sigc::mem_fun(this, &Designer::arrange_toolbars)));
+	}
+	arrange_toolbars();
 
-	lbl_tooltip = new GLtk::Label(ui_res);
-	lbl_tooltip->set_style("tooltip");
-	root->add(*lbl_tooltip);
-	lbl_tooltip->set_visible(false);
+	GLtk::Panel *statusbar = new GLtk::Panel;
+	root.add(*statusbar);
+	statusbar->set_size(window.get_width(), 20);
+	statusbar->set_focusable(false);
 
-	toolbar = new Toolbar(*this);
-	root->add(*toolbar);
-	toolbar->set_position(0, window.get_height()-toolbar->get_geometry().h);
-	toolbar->set_visible(true);
+	lbl_status = new GLtk::Label;
+	statusbar->add(*lbl_status);
+	lbl_status->set_geometry(GLtk::Geometry(20, 2, 300, 16));
 
 	overlay = new Overlay3D(window, camera, ui_res.get_default_font());
 
-	const list<Track3D *> &tracks = layout_3d->get_tracks();
-	for(list<Track3D *>::const_iterator i=tracks.begin(); i!=tracks.end(); ++i)
-		update_track_icon(**i);
+	camera_ctl.view_all();
+
+	const Layout3D::TrackMap &tracks = layout_3d->get_tracks();
+	for(Layout3D::TrackMap::const_iterator i=tracks.begin(); i!=tracks.end(); ++i)
+		update_track_icon(*i->second);
 }
 
 Designer::~Designer()
 {
 	delete overlay;
-	delete root;
 	delete pipeline;
 	delete base_object;
 	delete layout_3d;
@@ -146,10 +183,8 @@ int Designer::main()
 
 void Designer::save()
 {
-	input = new ::Input(*this, "Save layout", filename);
-	input->signal_cancel.connect(sigc::mem_fun(this, &Designer::input_dismiss));
-	input->signal_accept.connect(sigc::mem_fun(this, &Designer::save_accept));
-	mode = INPUT;
+	InputDialog *input = new InputDialog(*this, "Save layout", filename);
+	input->signal_accept.connect(sigc::mem_fun(layout, &Layout::save));
 }
 
 void Designer::quit()
@@ -157,9 +192,91 @@ void Designer::quit()
 	exit(0);
 }
 
-void Designer::edit_route(Route &r)
+void Designer::new_track()
+{
+	if(mode!=SELECT)
+		return;
+
+	mode = CATALOGUE;
+	lbl_status->set_text("Select new track or press Esc to cancel");
+}
+
+void Designer::erase_tracks()
+{
+	if(mode!=SELECT)
+		return;
+
+	set<Track *> tracks = selection.get_tracks();
+	selection.clear();
+	for(set<Track *>::iterator i=tracks.begin(); i!=tracks.end(); ++i)
+	{
+		overlay->clear(layout_3d->get_track(**i));
+		delete *i;
+	}
+}
+
+void Designer::track_properties()
+{
+	if(mode!=SELECT || selection.empty())
+		return;
+
+	TrackProperties *track_prop = new TrackProperties(selection);
+	root.add(*track_prop);
+	const GLtk::Geometry &root_geom = root.get_geometry();
+	const GLtk::Geometry &dlg_geom = track_prop->get_geometry();
+	track_prop->set_position((root_geom.w-dlg_geom.w)/2, (root_geom.h-dlg_geom.h)/2);
+
+	track_prop->signal_response.connect(sigc::mem_fun(this, &Designer::track_properties_response));
+}
+
+void Designer::extend_track()
+{
+	if(mode!=SELECT)
+		return;
+
+	if(manipulator.start_extend())
+		mode = MANIPULATE;
+}
+
+void Designer::connect_tracks()
+{
+	if(mode!=SELECT)
+		return;
+
+	manipulator.connect();
+}
+
+void Designer::flatten_tracks()
+{
+	if(mode!=SELECT)
+		return;
+
+	manipulator.flatten();
+}
+
+void Designer::svg_export()
+{
+	InputDialog *input = new InputDialog(*this, "SVG export", FS::basepart(filename)+".svg");
+	input->signal_accept.connect(sigc::mem_fun(this, &Designer::svg_export_accept));
+}
+
+void Designer::edit_route(Route *r)
 {
-	cur_route = &r;
+	cur_route = r;
+	cur_zone = 0;
+	if(cur_route)
+		show_route(*cur_route);
+	else
+		clear_paths();
+}
+
+void Designer::rename_route()
+{
+	if(mode!=SELECT || !cur_route)
+		return;
+
+	InputDialog *input = new InputDialog(*this, "Route name", cur_route->get_name());
+	input->signal_accept.connect(sigc::mem_fun(this, &Designer::route_name_accept));
 }
 
 void Designer::add_selection_to_route()
@@ -169,17 +286,56 @@ void Designer::add_selection_to_route()
 
 	try
 	{
-		const set<Track *> &stracks = selection.get_tracks();
-		set<const Track *> tracks(stracks.begin(), stracks.end());
-		cur_route->add_tracks(tracks);
+		cur_route->add_tracks(selection.get_tracks());
 	}
 	catch(const Exception &e)
 	{
-		IO::print("%s\n", e.what());
+		lbl_status->set_text(e.what());
 	}
+
+	show_route(*cur_route);
 }
 
-Point Designer::map_pointer_coords(int x, int y)
+void Designer::edit_zone(Zone *z)
+{
+	cur_zone = z;
+	cur_route = 0;
+	if(cur_zone)
+		show_zone(*cur_zone);
+	else
+		clear_paths();
+}
+
+void Designer::zone_properties()
+{
+	if(!cur_zone)
+		return;
+
+	ZoneProperties *zone_prop = new ZoneProperties(*cur_zone);
+	root.add(*zone_prop);
+	const GLtk::Geometry &root_geom = root.get_geometry();
+	const GLtk::Geometry &dlg_geom = zone_prop->get_geometry();
+	zone_prop->set_position((root_geom.w-dlg_geom.w)/2, (root_geom.h-dlg_geom.h)/2);
+}
+
+void Designer::add_selection_to_zone()
+{
+	if(!cur_zone)
+		return;
+
+	try
+	{
+		cur_zone->add_tracks(selection.get_tracks());
+	}
+	catch(const Exception &e)
+	{
+		lbl_status->set_text(e.what());
+	}
+
+	show_zone(*cur_zone);
+}
+
+Point Designer::map_pointer_to_ground(int x, int y)
 {
 	float xf = x*2.0/window.get_width()-1.0;
 	float yf = y*2.0/window.get_height()-1.0;
@@ -195,55 +351,31 @@ void Designer::tick()
 	float dt = (t-last_tick)/Msp::Time::sec;
 	last_tick = t;
 
-	window.get_display().tick();
-	camera_ctl.tick(dt);
-
-	if(tooltip_timeout && t>tooltip_timeout)
-	{
-		Track3D *t3d = 0;
-
-		if(mode==CATALOGUE)
-			t3d = pick_track(pointer_x, pointer_y);
-		else
-			t3d = pick_track(pointer_x, pointer_y);
+	if(mode==MANIPULATE_DONE)
+		mode = SELECT;
 
-		if(t3d)
-		{
-			const Track &track = t3d->get_track();
-			const TrackType &ttype = track.get_type();
-			string info = format("%d %s", ttype.get_article_number(), ttype.get_description());
-			if(mode!=CATALOGUE && abs(track.get_slope())>1e-4)
-				info += format(" (slope %.1f%%)", abs(track.get_slope()/ttype.get_total_length()*100));
-			if(track.get_turnout_id())
-				info += format(" (turnout %d)", track.get_turnout_id());
-			else if(track.get_sensor_id())
-				info += format(" (sensor %d)", track.get_sensor_id());
-
-			set_tooltip(pointer_x, pointer_y, info);
-		}
-		else
-			clear_tooltip();
+	window.tick();
+	root.tick();
+	camera_ctl.tick(dt);
 
-		tooltip_timeout = Msp::Time::TimeStamp();
-	}
+	for(list<Track *>::iterator i=new_tracks.begin(); i!=new_tracks.end(); ++i)
+		layout_3d->get_track(**i).get_path().set_mask(0);
+	new_tracks.clear();
 
 	render();
 
 	window.swap_buffers();
 }
 
-void Designer::key_press(unsigned code, unsigned mod, wchar_t)
+void Designer::key_press(unsigned key, unsigned mod, wchar_t)
 {
-	unsigned key = Msp::Input::key_from_sys(code);
-
-	if(mode==INPUT)
-		return;
+	key = Input::key_from_sys(key);
+	mod = Input::mod_from_sys(mod);
 
-	if(key==Msp::Input::KEY_SHIFT_L || key==Msp::Input::KEY_SHIFT_R)
-		shift = true;
-
-	if(key==Msp::Input::KEY_N)
-		mode = CATALOGUE;
+	if(key==Msp::Input::KEY_N && (mod&Input::MOD_SHIFT))
+		extend_track();
+	else if(key==Msp::Input::KEY_N)
+		new_track();
 	else if(key==Msp::Input::KEY_G)
 	{
 		manipulator.start_move();
@@ -264,14 +396,8 @@ void Designer::key_press(unsigned code, unsigned mod, wchar_t)
 		save();
 	else if(key==Msp::Input::KEY_PLUS)
 		selection.select_more();
-	else if(key==Msp::Input::KEY_L && (mod&1))
-	{
-		const set<Track *> &tracks = layout->get_tracks();
-		float len = 0;
-		for(set<Track *>::const_iterator i=tracks.begin(); i!=tracks.end(); ++i)
-			len += (*i)->get_type().get_total_length();
-		IO::print("Total length: %.1fm\n", len);
-	}
+	else if(key==Msp::Input::KEY_L && (mod&Input::MOD_SHIFT))
+		selection.select_blocks();
 	else if(key==Msp::Input::KEY_L)
 		selection.select_linked();
 	else if(key==Msp::Input::KEY_M)
@@ -294,17 +420,8 @@ void Designer::key_press(unsigned code, unsigned mod, wchar_t)
 			selection.clear();
 	}
 	else if(key==Msp::Input::KEY_X)
-	{
-		set<Track *> tracks = selection.get_tracks();
-		selection.clear();
-		for(set<Track *>::iterator i=tracks.begin(); i!=tracks.end(); ++i)
-		{
-			overlay->clear(layout_3d->get_track(**i));
-			layout->remove_track(**i);
-			delete *i;
-		}
-	}
-	else if(key==Msp::Input::KEY_F && (mod&1))
+		erase_tracks();
+	else if(key==Msp::Input::KEY_F && (mod&Input::MOD_SHIFT))
 	{
 		const set<Track *> &tracks = selection.get_tracks();
 		const set<Track *> &ltracks = layout->get_tracks();
@@ -320,67 +437,32 @@ void Designer::key_press(unsigned code, unsigned mod, wchar_t)
 		}
 	}
 	else if(key==Msp::Input::KEY_F)
-		manipulator.flatten();
-	else if(key==Msp::Input::KEY_E && (mod&1))
+		flatten_tracks();
+	else if(key==Msp::Input::KEY_E && (mod&Input::MOD_SHIFT))
 		manipulator.even_slope(true);
 	else if(key==Msp::Input::KEY_E)
 		manipulator.even_slope();
-	else if(key==Msp::Input::KEY_T)
+	else if(key==Msp::Input::KEY_A)
 	{
-		Track *track = selection.get_track();
-		if(selection.size()==1 && track->get_type().get_n_paths()>1)
-		{
-			input = new ::Input(*this, "Turnout ID", lexical_cast(track->get_turnout_id()));
-			input->signal_cancel.connect(sigc::mem_fun(this, &Designer::input_dismiss));
-			input->signal_accept.connect(sigc::mem_fun(this, &Designer::turnout_id_accept));
-			mode = INPUT;
-		}
+		if(cur_route)
+			add_selection_to_route();
+		else if(cur_zone)
+			add_selection_to_zone();
 	}
-	else if(key==Msp::Input::KEY_S)
-	{
-		const set<Track *> &tracks = selection.get_tracks();
-		bool ok = false;
-		int id = -1;
-		for(set<Track *>::const_iterator i=tracks.begin(); i!=tracks.end(); ++i)
-		{
-			if((*i)->get_type().get_n_paths()==1)
-				ok = true;
-			if(static_cast<int>((*i)->get_sensor_id())!=id)
-			{
-				if(id==-1)
-					id = (*i)->get_sensor_id();
-				else
-					id = -2;
-			}
-		}
-		if(ok)
-		{
-			input = new ::Input(*this, "Sensor ID", (id>=0 ? lexical_cast(id) : string()));
-			input->signal_cancel.connect(sigc::mem_fun(this, &Designer::input_dismiss));
-			input->signal_accept.connect(sigc::mem_fun(this, &Designer::sensor_id_accept));
-			mode = INPUT;
-		}
-	}
-	else if(key==Msp::Input::KEY_A)
-		add_selection_to_route();
-}
-
-void Designer::key_release(unsigned code, unsigned)
-{
-	unsigned key = Msp::Input::key_from_sys(code);
-
-	if(mode==INPUT)
-		return;
-
-	if(key==Msp::Input::KEY_SHIFT_L || key==Msp::Input::KEY_SHIFT_R)
-		shift = false;
+	else if(key==Msp::Input::KEY_C)
+		connect_tracks();
+	else if(key==Msp::Input::KEY_V)
+		svg_export();
+	else if(key==Msp::Input::KEY_P)
+		track_properties();
 }
 
-void Designer::button_press(int x, int y, unsigned btn, unsigned)
+void Designer::button_press(int x, int y, unsigned btn, unsigned mod)
 {
 	y = window.get_height()-y-1;
+	mod = Input::mod_from_sys(mod);
 
-	Point ground = map_pointer_coords(x, y);
+	Point ground = map_pointer_to_ground(x, y);
 
 	if(mode==CATALOGUE)
 	{
@@ -389,9 +471,8 @@ void Designer::button_press(int x, int y, unsigned btn, unsigned)
 			Track3D *ctrack = pick_track(x, y);
 			if(ctrack)
 			{
-				Track *track = ctrack->get_track().copy();
+				Track *track = new Track(*layout, ctrack->get_track().get_type());
 				track->set_position(ground);
-				layout->add_track(*track);
 
 				selection.clear();
 				selection.add_track(track);
@@ -409,14 +490,12 @@ void Designer::button_press(int x, int y, unsigned btn, unsigned)
 			Track3D *track = pick_track(x, y);
 			if(track)
 			{
-				if(!shift)
+				if(!(mod&Input::MOD_SHIFT))
 					selection.clear();
 				selection.toggle_track(&track->get_track());
 			}
 		}
 	}
-	else if(mode==MANIPULATE)
-		manipulator.button_press(x, y, ground.x, ground.y, btn);
 	else if(mode==MEASURE)
 		measure.button_press(x, y, ground.x, ground.y, btn);
 }
@@ -425,18 +504,9 @@ void Designer::pointer_motion(int x, int y)
 {
 	y = window.get_height()-y-1;
 
-	pointer_x = x;
-	pointer_y = y;
-
-	if(mode==SELECT || mode==CATALOGUE)
-		tooltip_timeout = Msp::Time::now()+100*Msp::Time::msec;
-
-	clear_tooltip();
-
-	if(mode!=INPUT)
+	if(!root.get_child_at(x, y))
 	{
-		Point ground = map_pointer_coords(x, y);
-		manipulator.pointer_motion(x, y, ground.x, ground.y);
+		Point ground = map_pointer_to_ground(x, y);
 		measure.pointer_motion(x, y, ground.x, ground.y);
 	}
 }
@@ -458,9 +528,7 @@ void Designer::apply_camera()
 
 void Designer::render()
 {
-	GL::clear(GL::COLOR_BUFFER_BIT|GL::DEPTH_BUFFER_BIT);
-	GL::enable(GL::DEPTH_TEST);
-	GL::Texture::unbind();
+	GL::Framebuffer::system().clear(GL::COLOR_BUFFER_BIT|GL::DEPTH_BUFFER_BIT);
 
 	if(mode==CATALOGUE)
 	{
@@ -470,30 +538,13 @@ void Designer::render()
 	else
 	{
 		pipeline->render_all();
-		layout_3d->get_endpoint_scene().render();
 		GL::enable(GL_CULL_FACE);
-		GL::disable(GL::DEPTH_TEST);
-		overlay->render(0);
-		GL::enable(GL::DEPTH_TEST);
-		/*if(cur_route)
 		{
-			glColor4f(0.5, 0.8, 1.0, 1.0);
-			const set<const Track *> &rtracks = cur_route->get_tracks();
-			const map<unsigned, int> &turnouts = cur_route->get_turnouts();
-			for(set<const Track *>::const_iterator i=rtracks.begin(); i!=rtracks.end(); ++i)
-			{
-				unsigned path = 0;
-				if(unsigned tid=(*i)->get_turnout_id())
-				{
-					map<unsigned, int>::const_iterator j = turnouts.find(tid);
-					if(j!=turnouts.end())
-						path = j->second;
-				}
-				layout_3d->get_track(**i).render_path(path);
-			}
-		}*/
+			GL::Bind bind_blend(GL::Blend::alpha());
+			overlay->render(0);
+		}
 
-		manipulator.render();
+		GL::Bind bind_depth(GL::DepthTest::lequal());
 		if(mode==MEASURE)
 			measure.render();
 	}
@@ -506,7 +557,21 @@ void Designer::render()
 
 	GL::disable(GL::DEPTH_TEST);
 
-	root->render();
+	GL::Bind bind_blend(GL::Blend::alpha());
+	root.render();
+	GL::Texture::unbind();
+}
+
+void Designer::track_added(Track &trk)
+{
+	new_tracks.push_back(&trk);
+}
+
+void Designer::track_removed(Track &trk)
+{
+	list<Track *>::iterator i = find(new_tracks.begin(), new_tracks.end(), &trk);
+	if(i!=new_tracks.end())
+		new_tracks.erase(i);
 }
 
 Track3D *Designer::pick_track(int x, int y)
@@ -538,19 +603,37 @@ void Designer::update_track_icon(Track3D &track)
 	}
 	else if(unsigned tid = track.get_track().get_turnout_id())
 	{
-		overlay->add_graphic(track, "turnout");
-		overlay->set_label(track, lexical_cast(tid));
+		if(tid<0x800)
+		{
+			overlay->add_graphic(track, "turnout");
+			overlay->set_label(track, lexical_cast(tid));
+		}
+	}
+}
+
+void Designer::selection_changed()
+{
+	const set<Track *> &tracks = selection.get_tracks();
+	if(tracks.empty())
+		lbl_status->set_text(string());
+	else
+	{
+		float len = 0;
+		for(set<Track *>::const_iterator i=tracks.begin(); i!=tracks.end(); ++i)
+			len += (*i)->get_type().get_total_length();
+		lbl_status->set_text(format("%.2fm of track selected\n", len));
 	}
 }
 
 void Designer::manipulation_status(const string &status)
 {
-	set_tooltip(pointer_x, pointer_y, status);
+	lbl_status->set_text(status);
 }
 
 void Designer::manipulation_done(bool)
 {
-	mode = SELECT;
+	mode = MANIPULATE_DONE;
+	selection_changed();
 }
 
 void Designer::measure_changed()
@@ -560,91 +643,103 @@ void Designer::measure_changed()
 	float d = sqrt(pard*pard+perpd*perpd);
 	float adiff = measure.get_angle_difference()*180/M_PI;
 	string info = format("Par %.1fmm - Perp %.1fmm - Total %.1fmm - Angle %.1f°", pard, perpd, d, adiff);
-	set_tooltip(pointer_x, pointer_y, info);
+	lbl_status->set_text(info);
 }
 
 void Designer::measure_done()
 {
 	mode = SELECT;
+	selection_changed();
 }
 
-void Designer::set_tooltip(int x, int y, const std::string &text)
+void Designer::arrange_toolbars()
 {
-	int fontsize = ui_res.get_default_font().get_default_size();
-	int h = fontsize+6;
-	int w = static_cast<int>(ui_res.get_default_font().get_string_width(text)*fontsize)+6;
-	x = max(min(static_cast<int>(window.get_width())-w, x), 0);
-	y = max(min(static_cast<int>(window.get_height())-h, y), 0);
-	lbl_tooltip->set_text(text);
-	lbl_tooltip->set_geometry(GLtk::Geometry(x, y, w, h));
-	lbl_tooltip->set_visible(true);
+	unsigned x = 0;
+	for(vector<Toolbar *>::iterator i=toolbars.begin(); i!=toolbars.end(); ++i)
+	{
+		const GLtk::Geometry &geom = (*i)->get_geometry();
+		(*i)->set_position(x, window.get_height()-geom.h);
+		x += geom.w;
+	}
 }
 
-void Designer::clear_tooltip()
+void Designer::track_properties_response(int)
 {
-	lbl_tooltip->set_visible(false);
+	const set<Track *> &tracks = selection.get_tracks();
+	for(set<Track *>::const_iterator i=tracks.begin(); i!=tracks.end(); ++i)
+		update_track_icon(layout_3d->get_track(**i));
 }
 
-void Designer::save_accept()
+void Designer::route_name_accept(const string &text)
 {
-	layout->save(input->get_text());
-
-	input_dismiss();
+	if(cur_route)
+		cur_route->set_name(text);
 }
 
-void Designer::turnout_id_accept()
+void Designer::svg_export_accept(const string &text)
 {
-	Track *track = selection.get_track();
-	unsigned id = lexical_cast<unsigned>(input->get_text());
-	track->set_turnout_id(id);
-
-	update_track_icon(layout_3d->get_track(*track));
-
-	input_dismiss();
+	SvgExporter svg_exp(*layout);
+	svg_exp.save(text);
 }
 
-void Designer::sensor_id_accept()
+string Designer::tooltip(int x, int y)
 {
-	const set<Track *> &tracks = selection.get_tracks();
-	unsigned id = lexical_cast<unsigned>(input->get_text());
-	for(set<Track *>::const_iterator i=tracks.begin(); i!=tracks.end(); ++i)
+	if(Track3D *t3d = pick_track(x, y))
 	{
-		(*i)->set_sensor_id(id);
-
-		update_track_icon(layout_3d->get_track(**i));
+		const Track &track = t3d->get_track();
+		const TrackType &ttype = track.get_type();
+		string info = format("%d %s", ttype.get_article_number(), ttype.get_description());
+		if(mode!=CATALOGUE && abs(track.get_slope())>1e-4)
+			info += format(" (slope %.1f%%)", abs(track.get_slope()/ttype.get_total_length()*100));
+		if(track.get_turnout_id())
+			info += format(" (turnout %d)", track.get_turnout_id());
+		else if(track.get_sensor_id())
+			info += format(" (sensor %d)", track.get_sensor_id());
+
+		return info;
 	}
 
-	input_dismiss();
+	return string();
 }
 
-void Designer::input_dismiss()
+void Designer::clear_paths()
 {
-	delete input;
-	input = 0;
-	mode = SELECT;
+	const set<Track *> &ltracks = layout->get_tracks();
+	for(set<Track *>::iterator i=ltracks.begin(); i!=ltracks.end(); ++i)
+	{
+		Track3D &t3d = layout_3d->get_track(**i);
+		t3d.get_path().set_mask(0);
+	}
 }
 
-void Designer::view_all()
+void Designer::show_route(const Route &route)
 {
-	Point minp;
-	Point maxp;
+	clear_paths();
 
-	const list<Track3D *> &tracks = layout_3d->get_tracks();
-	for(list<Track3D *>::const_iterator i=tracks.begin(); i!=tracks.end(); ++i)
+	const set<Track *> &rtracks = route.get_tracks();
+	for(set<Track *>::iterator i=rtracks.begin(); i!=rtracks.end(); ++i)
 	{
-		Point tmin;
-		Point tmax;
-		(*i)->get_bounds(0, tmin, tmax);
-		minp.x = min(minp.x, tmin.x);
-		minp.y = min(minp.y, tmin.y);
-		maxp.x = max(maxp.x, tmax.x);
-		maxp.y = max(maxp.y, tmax.y);
+		Track3D &t3d = layout_3d->get_track(**i);
+		t3d.get_path().set_color(GL::Color(0.5, 0.8, 1.0));
+		int path = -1;
+		if(unsigned tid = (*i)->get_turnout_id())
+			path = route.get_turnout(tid);
+		if(path>=0)
+			t3d.get_path().set_path(path);
+		else
+			t3d.get_path().set_mask((*i)->get_type().get_paths());
 	}
+}
 
-	float t = tan(camera.get_field_of_view()/2)*2;
-	float size = max((maxp.y-minp.y+0.1), (maxp.x-minp.x+0.1)/camera.get_aspect());
-	float cam_dist = size/t+size*0.25;
-	Point center((minp.x+maxp.x)/2, (minp.y+maxp.y)/2);
-	camera.set_position(GL::Vector3(center.x, center.y-cam_dist*0.5, cam_dist*0.866));
-	camera.set_look_direction(GL::Vector3(0, 0.5, -0.866));
+void Designer::show_zone(const Zone &zone)
+{
+	clear_paths();
+
+	const Zone::TrackSet &ztracks = zone.get_tracks();
+	for(Zone::TrackSet::const_iterator i=ztracks.begin(); i!=ztracks.end(); ++i)
+	{
+		Track3D &t3d = layout_3d->get_track(**i);
+		t3d.get_path().set_color(GL::Color(0.8, 1.0, 0.5));
+		t3d.get_path().set_mask((*i)->get_type().get_paths());
+	}
 }