X-Git-Url: http://git.tdb.fi/?a=blobdiff_plain;f=source%2Fdesigner%2Fdesigner.cpp;h=f79ef7a9ae8daa4bfdb94a901ba3b6d170412b9c;hb=e07c0d862a4d43b2585c93e79d25380d00675309;hp=3ca630f2431cfccbc12b475b91e357fd0b9edc65;hpb=1d735b80482317fd930eb47ca255ab9f1f120a7d;p=r2c2.git

diff --git a/source/designer/designer.cpp b/source/designer/designer.cpp
index 3ca630f..f79ef7a 100644
--- a/source/designer/designer.cpp
+++ b/source/designer/designer.cpp
@@ -1,11 +1,24 @@
+/* $Id$
+
+This file is part of the MSP Märklin suite
+Copyright © 2006-2009 Mikkosoft Productions, Mikko Rasa
+Distributed under the GPL
+*/
+
 #include <signal.h>
 #include <cmath>
-#include <iostream>
 #include <GL/gl.h>
-#include <SDL.h>
+#include <msp/gl/blend.h>
+#include <msp/gl/framebuffer.h>
+#include <msp/gl/matrix.h>
+#include <msp/gl/misc.h>
+#include <msp/gl/projection.h>
 #include <msp/gl/rendermode.h>
 #include <msp/gl/select.h>
+#include <msp/gl/tests.h>
 #include <msp/gl/texture2d.h>
+#include <msp/input/keys.h>
+#include <msp/io/print.h>
 #include <msp/strings/codec.h>
 #include <msp/strings/lexicalcast.h>
 #include <msp/strings/utf8.h>
@@ -18,338 +31,276 @@
 #include "manipulator.h"
 #include "measure.h"
 #include "selection.h"
+#include "toolbar.h"
 
 using namespace std;
 using namespace Marklin;
 using namespace Msp;
 
+Application::RegApp<Designer> Designer::reg;
+
 Designer::Designer(int argc, char **argv):
-	screen_w(1280),
-	screen_h(960),
-	input(0),
+	window(1280, 960),
+	base_object(0),
+	cur_route(0),
 	mode(SELECT),
-	cam_yaw(M_PI/2),
-	cam_pitch(-M_PI/4),
-	cam_pos(0, -0.5, 0.5),
-	shift(false),
-	move_x(0),
-	move_y(0),
-	zoom(0),
-	rotate(0),
-	pitch(0)
+	manipulator(*this, selection),
+	measure(*this),
+	input(0),
+	camera_ctl(window, camera),
+	shift(false)
 {
-	catalogue.load("tracks.dat");
+	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));
 
-	cat_layout=new Layout(catalogue);
-	cat_layout_3d=new Layout3D(*cat_layout);
+	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));
+	measure.signal_done.connect(sigc::mem_fun(this, &Designer::measure_done));
 
-	const map<unsigned, TrackType *> &ctracks=catalogue.get_tracks();
-	unsigned n=0;
-	for(map<unsigned, TrackType *>::const_iterator i=ctracks.begin(); i!=ctracks.end(); ++i, ++n)
-	{
-		Track *track=new Track(*i->second);
-		track->set_position(Point((n%11)*0.1-0.5, 0.2-n/11*0.3, 0));
-		track->set_rotation(M_PI/2);
-		cat_layout->add_track(*track);
-	}
+	// Setup catalogue and layout
+	DataFile::load(catalogue, "tracks.dat");
 
-	manipulator=new Manipulator(*this);
-	manipulator->signal_status.connect(sigc::mem_fun(this, &Designer::manipulation_status));
-	manipulator->signal_done.connect(sigc::mem_fun(this, &Designer::manipulation_done));
+	cat_layout_3d = new Layout3D(catalogue.get_layout());
 
-	layout=new Layout(catalogue);
-	layout_3d=new Layout3D(*layout);
+	layout = new Layout(catalogue);
+	layout_3d = new Layout3D(*layout);
 
 	if(argc>1)
 	{
-		layout->load(argv[1]);
-		const list<Track3D *> &ltracks=layout_3d->get_tracks();
+		filename = argv[1];
+		DataFile::load(*layout, argv[1]);
+		const list<Track3D *> &ltracks = layout_3d->get_tracks();
 		for(list<Track3D *>::const_iterator i=ltracks.begin(); i!=ltracks.end(); ++i)
+			update_track_color(**i);
+
+		if(!layout->get_base().empty())
 		{
-			if((*i)->get_track().get_sensor_id())
-				(*i)->set_color(GL::Color(1, 1, 0.5));
-			else if((*i)->get_track().get_turnout_id())
-				(*i)->set_color(GL::Color(0.5, 1, 1));
-			else if((*i)->get_track().get_flex())
-				(*i)->set_color(GL::Color(1, 0.5, 1));
+			base_object = new GL::Object;
+			DataFile::load(*base_object, layout->get_base());
 		}
 	}
 
-	selection=new Selection;
-	manipulator->set_selection(selection);
+	// 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());
+	if(base_object)
+		pipeline->add_renderable(*base_object);
+
+	light.set_position(0, -0.259, 0.966, 0);
+	lighting.attach(0, light);
+
+	GL::PipelinePass *pass = &pipeline->add_pass(GL::Tag());
+	pass->lighting = &lighting;
+
+	camera.set_up_direction(GL::Vector3(0, 0, 1));
+	view_all();
 
-	measure=new Measure(*this);
-	measure->signal_changed.connect(sigc::mem_fun(this, &Designer::measure_changed));
-	measure->signal_done.connect(sigc::mem_fun(this, &Designer::measure_done));
+	// Setup UI
+	DataFile::load(ui_res, "marklin.res");
+	root = new GLtk::Root(ui_res, window);
+
+	lbl_tooltip = new GLtk::Label(ui_res);
+	lbl_tooltip->set_style("tooltip");
+	root->add(*lbl_tooltip);
+	lbl_tooltip->set_visible(false);
+
+	toolbar = new Toolbar(*this);
+	root->add(*toolbar);
+	toolbar->set_position(0, window.get_height()-toolbar->get_geometry().h);
+	toolbar->set_visible(true);
 }
 
 Designer::~Designer()
 {
-	delete manipulator;
-	delete selection;
+	delete root;
 	delete layout;
 	delete layout_3d;
-	delete cat_layout;
 	delete cat_layout_3d;
-	delete measure;
 }
 
 int Designer::main()
 {
-	setenv("__GL_SYNC_TO_VBLANK", "1", 0);
-	SDL_Init(SDL_INIT_VIDEO);
-	SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
-	SDL_GL_SetAttribute(SDL_GL_MULTISAMPLESAMPLES, 4);
-	SDL_SetVideoMode(screen_w, screen_h, 32, SDL_OPENGL);
-	SDL_EnableUNICODE(1);
-
-	glEnableClientState(GL_VERTEX_ARRAY);
-	glEnable(GL_DEPTH_TEST);
-	glEnable(GL_BLEND);
-	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
-	glEnable(GL_CULL_FACE);
-
-	GL::Texture2D *font_tex=new GL::Texture2D;
-	font_tex->set_min_filter(GL::LINEAR);
-	font_tex->load_image("dejavu-20.png");
-	font=new GL::Font();
-	font->set_texture(*font_tex);
-	DataFile::load(*font, "dejavu-20.font");
-
-	mode=SELECT;
-
-	Application::main();
-
-	delete font;
-	delete font_tex;
-	delete input;
+	window.show();
 
-	SDL_Quit();
+	mode = SELECT;
 
-	return exit_code;
+	return Application::main();
 }
 
-void Designer::map_pointer_coords(int x, int y, float &gx, float &gy)
+void Designer::save()
 {
-	float cos_pitch=cos(cam_pitch);
-	float sin_pitch=sin(cam_pitch);
-	float cos_yaw=cos(cam_yaw);
-	float sin_yaw=sin(cam_yaw);
-
-	float rx=sin_yaw*0.55228;
-	float ry=-cos_yaw*0.55228;
-
-	float ux=cos_yaw*-sin_pitch*0.41421;
-	float uy=sin_yaw*-sin_pitch*0.41421;
-	float uz=cos_pitch*0.41421;
-
-	float xf=static_cast<float>(x)*2/screen_w-1;
-	float yf=1-static_cast<float>(y)*2/screen_h;
-
-	float vx=cos_yaw*cos_pitch + xf*rx + yf*ux;
-	float vy=sin_yaw*cos_pitch + xf*ry + yf*uy;
-	float vz=sin_pitch + yf*uz;
+	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;
+}
 
-	gx=cam_pos.x-vx*cam_pos.z/vz;
-	gy=cam_pos.y-vy*cam_pos.z/vz;
+void Designer::quit()
+{
+	exit(0);
 }
 
-void Designer::tick()
+void Designer::edit_route(Route &r)
 {
-	SDL_Event event;
-	while(SDL_PollEvent(&event))
-	{
-		float gx, gy;
-		switch(event.type)
-		{
-		case SDL_MOUSEBUTTONDOWN:
-			map_pointer_coords(event.button.x, event.button.y, gx, gy);
-			button_press(event.button.x, screen_h-1-event.button.y, gx, gy, event.button.button);
-			break;
-		case SDL_MOUSEMOTION:
-			map_pointer_coords(event.motion.x, event.motion.y, gx, gy);
-			pointer_motion(event.motion.x, screen_h-1-event.motion.y, gx, gy);
-			break;
-		case SDL_KEYDOWN:
-			key_press(event.key.keysym.sym, event.key.keysym.mod, event.key.keysym.unicode);
-			break;
-		case SDL_KEYUP:
-			key_release(event.key.keysym.sym, event.key.keysym.mod);
-			break;
-		case SDL_QUIT:
-			exit(0);
-			break;
-		}
-	}
+	cur_route = &r;
+}
 
-	const Time::TimeStamp t=Time::now();
-	float dt=(t-last_tick)/Time::sec;
-	last_tick=t;
+void Designer::add_selection_to_route()
+{
+	if(!cur_route)
+		return;
 
-	if(move_y)
+	try
 	{
-		cam_pos.x+=cos(cam_yaw)*dt*move_y;
-		cam_pos.y+=sin(cam_yaw)*dt*move_y;
+		const set<Track *> &stracks = selection.get_tracks();
+		set<const Track *> tracks(stracks.begin(), stracks.end());
+		cur_route->add_tracks(tracks);
 	}
-	if(move_x)
+	catch(const Exception &e)
 	{
-		cam_pos.x+=sin(cam_yaw)*dt*move_x;
-		cam_pos.y+=-cos(cam_yaw)*dt*move_x;
-	}
-	if(zoom)
-	{
-		cam_pos.x+=cos(cam_yaw)*cos(cam_pitch)*dt*zoom;
-		cam_pos.y+=sin(cam_yaw)*cos(cam_pitch)*dt*zoom;
-		cam_pos.z+=sin(cam_pitch)*dt*zoom;
-	}
-	if(rotate)
-	{
-		float vx=cos(cam_yaw)*cos(cam_pitch);
-		float vy=sin(cam_yaw)*cos(cam_pitch);
-		float vz=sin(cam_pitch);
-
-		float gx=cam_pos.x-vx*cam_pos.z/vz;
-		float gy=cam_pos.y-vy*cam_pos.z/vz;
-		float d=sqrt(vx*vx+vy*vy)*cam_pos.z/vz;
-
-		cam_yaw+=M_PI*dt*rotate;
-		if(cam_yaw>M_PI*2)
-			cam_yaw-=M_PI*2;
-		else if(cam_yaw<0)
-			cam_yaw+=M_PI*2;
-
-		cam_pos.x=gx+cos(cam_yaw)*d;
-		cam_pos.y=gy+sin(cam_yaw)*d;
-	}
-	if(pitch)
-	{
-		cam_pitch+=M_PI/2*dt*pitch;
-		if(cam_pitch>M_PI/12)
-			cam_pitch=M_PI/12;
-		else if(cam_pitch<-M_PI/2)
-			cam_pitch=-M_PI/2;
+		IO::print("%s\n", e.what());
 	}
+}
+
+Point Designer::map_pointer_coords(int x, int y)
+{
+	float xf = x*2.0/window.get_width()-1.0;
+	float yf = y*2.0/window.get_height()-1.0;
+	GL::Vector4 vec = camera.unproject(GL::Vector4(xf, yf, 0, 0));
+	const GL::Vector3 &pos = camera.get_position();
+
+	return Point(pos.x-vec.x*pos.z/vec.z, pos.y-vec.y*pos.z/vec.z);
+}
+
+void Designer::tick()
+{
+	const Msp::Time::TimeStamp t = Msp::Time::now();
+	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;
+		Track3D *t3d = 0;
 
 		if(mode==CATALOGUE)
-			t3d=pick_track(pointer_x, pointer_y);
+			t3d = pick_track(pointer_x, pointer_y);
 		else
-			t3d=pick_track(pointer_x, pointer_y);
+			t3d = pick_track(pointer_x, pointer_y);
 
 		if(t3d)
 		{
-			const Track &track=t3d->get_track();
-			const TrackType &ttype=track.get_type();
-			ostringstream ss;
-			ss.precision(2);
-			ss<<ttype.get_article_number()<<' '<<ttype.get_description();
-			if(mode!=CATALOGUE)
-				ss<<" (slope "<<track.get_slope()/ttype.get_total_length()*100<<"%)";
+			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())
-				ss<<" (turnout "<<track.get_turnout_id()<<')';
+				info += format(" (turnout %d)", track.get_turnout_id());
 			else if(track.get_sensor_id())
-				ss<<" (sensor "<<track.get_sensor_id()<<')';
-			tooltip=ss.str();
+				info += format(" (sensor %d)", track.get_sensor_id());
 
-			move_tooltip(pointer_x, pointer_y);
+			set_tooltip(pointer_x, pointer_y, info);
 		}
 		else
-			tooltip="";
+			clear_tooltip();
 
-		tooltip_timeout=Time::TimeStamp();
+		tooltip_timeout = Msp::Time::TimeStamp();
 	}
 
 	render();
 
-	SDL_GL_SwapBuffers();
+	window.swap_buffers();
 }
 
-/*** private ***/
-
-void Designer::key_press(unsigned key, unsigned mod, wchar_t ch)
+void Designer::key_press(unsigned code, unsigned mod, wchar_t)
 {
+	unsigned key = Msp::Input::key_from_sys(code);
+
 	if(mode==INPUT)
-	{
-		input->key_press(key, mod, ch);
 		return;
-	}
 
-	if(key==SDLK_RSHIFT || key==SDLK_LSHIFT)
-		shift=true;
+	if(key==Msp::Input::KEY_SHIFT_L || key==Msp::Input::KEY_SHIFT_R)
+		shift = true;
 
-	if(key==SDLK_n)
-		mode=CATALOGUE;
-	else if(key==SDLK_g)
-	{
-		manipulator->start_move();
-		mode=MANIPULATE;
-	}
-	else if(key==SDLK_r)
+	if(key==Msp::Input::KEY_N)
+		mode = CATALOGUE;
+	else if(key==Msp::Input::KEY_G)
 	{
-		manipulator->start_rotate();
-		mode=MANIPULATE;
+		manipulator.start_move();
+		mode = MANIPULATE;
 	}
-	else if(key==SDLK_d)
+	else if(key==Msp::Input::KEY_R)
 	{
-		manipulator->duplicate();
-		manipulator->start_move();
-		mode=MANIPULATE;
+		manipulator.start_rotate();
+		mode = MANIPULATE;
 	}
-	else if(key==SDLK_w)
+	else if(key==Msp::Input::KEY_D)
 	{
-		input=new Input(*this, "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;
+		manipulator.duplicate();
+		manipulator.start_move();
+		mode = MANIPULATE;
 	}
-	else if(key==SDLK_PLUS)
-		selection->select_more();
-	else if(key==SDLK_l && (mod&KMOD_SHIFT))
+	else if(key==Msp::Input::KEY_W)
+		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;
+		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();
-		cout<<"Total length: "<<len<<"m\n";
+			len += (*i)->get_type().get_total_length();
+		IO::print("Total length: %.1fm\n", len);
 	}
-	else if(key==SDLK_l)
-		selection->select_linked();
-	else if(key==SDLK_m)
+	else if(key==Msp::Input::KEY_L)
+		selection.select_linked();
+	else if(key==Msp::Input::KEY_M)
 	{
-		measure->start();
-		mode=MEASURE;
+		measure.start();
+		mode = MEASURE;
 	}
-	else if(key==SDLK_z)
+	else if(key==Msp::Input::KEY_Z)
 	{
-		manipulator->start_elevate();
-		mode=MANIPULATE;
+		manipulator.start_elevate();
+		mode = MANIPULATE;
 	}
-	else if(key==SDLK_ESCAPE)
+	else if(key==Msp::Input::KEY_ESC)
 	{
 		if(mode==MANIPULATE)
-			manipulator->cancel();
+			manipulator.cancel();
 		else if(mode==CATALOGUE)
-			mode=SELECT;
+			mode = SELECT;
 		else
-			selection->clear();
+			selection.clear();
 	}
-	else if(key==SDLK_x)
+	else if(key==Msp::Input::KEY_X)
 	{
-		set<Track *> tracks=selection->get_tracks();
-		selection->clear();
+		set<Track *> tracks = selection.get_tracks();
+		selection.clear();
 		for(set<Track *>::iterator i=tracks.begin(); i!=tracks.end(); ++i)
 		{
 			layout->remove_track(**i);
 			delete *i;
 		}
 	}
-	else if(key==SDLK_f && (mod&KMOD_SHIFT))
+	else if(key==Msp::Input::KEY_F && (mod&1))
 	{
-		const set<Track *> &tracks=selection->get_tracks();
-		const set<Track *> &ltracks=layout->get_tracks();
+		const set<Track *> &tracks = selection.get_tracks();
+		const set<Track *> &ltracks = layout->get_tracks();
 		for(set<Track *>::const_iterator i=tracks.begin(); i!=tracks.end(); ++i)
 		{
 			(*i)->set_flex(!(*i)->get_flex());
@@ -358,260 +309,268 @@ void Designer::key_press(unsigned key, unsigned mod, wchar_t ch)
 				if(*j!=*i)
 					(*i)->snap_to(**j, true);
 
-			Track3D &t3d=layout_3d->get_track(**i);
-			if((*i)->get_flex())
-				t3d.set_color(GL::Color(1, 0.5, 1));
-			else
-				t3d.set_color(GL::Color(1, 1, 1));
+			update_track_color(layout_3d->get_track(**i));
 		}
 	}
-	else if(key==SDLK_f)
-		manipulator->flatten();
-	else if(key==SDLK_e && (mod&KMOD_SHIFT))
-		manipulator->even_slope(true);
-	else if(key==SDLK_e)
-		manipulator->even_slope();
-	else if(key==SDLK_t)
+	else if(key==Msp::Input::KEY_F)
+		manipulator.flatten();
+	else if(key==Msp::Input::KEY_E && (mod&1))
+		manipulator.even_slope(true);
+	else if(key==Msp::Input::KEY_E)
+		manipulator.even_slope();
+	else if(key==Msp::Input::KEY_T)
 	{
-		Track *track=selection->get_track();
-		if(selection->size()==1 && track->get_type().get_n_routes()>1)
+		Track *track = selection.get_track();
+		if(selection.size()==1 && track->get_type().get_n_paths()>1)
 		{
-			ostringstream ss;
-			ss<<track->get_turnout_id();
-			input=new Input(*this, "Turnout ID", ss.str());
+			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;
+			mode = INPUT;
 		}
 	}
-	else if(key==SDLK_s)
+	else if(key==Msp::Input::KEY_S)
 	{
-		Track *track=selection->get_track();
-		if(selection->size()==1 && track->get_type().get_n_routes()==1)
+		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)
 		{
-			ostringstream ss;
-			ss<<track->get_sensor_id();
-			input=new Input(*this, "Sensor ID", ss.str());
+			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;
+			mode = INPUT;
 		}
 	}
-	else if(key==SDLK_RIGHT)
-		rotate=-1;
-	else if(key==SDLK_LEFT)
-		rotate=1;
-	else if(key==SDLK_UP)
-		move_y=1;
-	else if(key==SDLK_DOWN)
-		move_y=-1;
-	else if(key==SDLK_INSERT)
-		zoom=-1;
-	else if(key==SDLK_PAGEUP)
-		zoom=1;
-	else if(key==SDLK_HOME)
-		pitch=1;
-	else if(key==SDLK_END)
-		pitch=-1;
-	else if(key==SDLK_DELETE)
-		move_x=-1;
-	else if(key==SDLK_PAGEDOWN)
-		move_x=1;
+	else if(key==Msp::Input::KEY_A)
+		add_selection_to_route();
 }
 
-void Designer::key_release(unsigned key, unsigned)
+void Designer::key_release(unsigned code, unsigned)
 {
+	unsigned key = Msp::Input::key_from_sys(code);
+
 	if(mode==INPUT)
 		return;
 
-	if(key==SDLK_RSHIFT || key==SDLK_LSHIFT)
-		shift=false;
-	else if(key==SDLK_RIGHT || key==SDLK_LEFT)
-		rotate=0;
-	else if(key==SDLK_UP || key==SDLK_DOWN)
-		move_y=0;
-	else if(key==SDLK_INSERT || key==SDLK_PAGEUP)
-		zoom=0;
-	else if(key==SDLK_HOME || key==SDLK_END)
-		pitch=0;
-	else if(key==SDLK_DELETE || key==SDLK_PAGEDOWN)
-		move_x=0;
+	if(key==Msp::Input::KEY_SHIFT_L || key==Msp::Input::KEY_SHIFT_R)
+		shift = false;
 }
 
-void Designer::button_press(int x, int y, float gx, float gy, unsigned btn)
+void Designer::button_press(int x, int y, unsigned btn, unsigned)
 {
+	y = window.get_height()-y-1;
+
+	Point ground = map_pointer_coords(x, y);
+
 	if(mode==CATALOGUE)
 	{
 		if(btn==1)
 		{
-			Track3D *ctrack=pick_track(x, y);
+			Track3D *ctrack = pick_track(x, y);
 			if(ctrack)
 			{
-				Track *track=ctrack->get_track().copy();
-				track->set_position(Point(gx, gy, 0));
+				Track *track = ctrack->get_track().copy();
+				track->set_position(ground);
 				layout->add_track(*track);
 
-				selection->clear();
-				selection->add_track(track);
+				selection.clear();
+				selection.add_track(track);
 
-				mode=SELECT;
+				mode = SELECT;
 			}
 		}
 		else
-			mode=SELECT;
+			mode = SELECT;
 	}
 	else if(mode==SELECT)
 	{
 		if(btn==1)
 		{
-			Track3D *track=pick_track(x, y);
+			Track3D *track = pick_track(x, y);
 			if(track)
 			{
 				if(!shift)
-					selection->clear();
-				selection->toggle_track(&track->get_track());
+					selection.clear();
+				selection.toggle_track(&track->get_track());
 			}
 		}
 	}
 	else if(mode==MANIPULATE)
-		manipulator->button_press(x, y, gx, gy, btn);
+		manipulator.button_press(x, y, ground.x, ground.y, btn);
 	else if(mode==MEASURE)
-		measure->button_press(x, y, gx, gy, btn);
+		measure.button_press(x, y, ground.x, ground.y, btn);
 }
 
-void Designer::pointer_motion(int x, int y, float gx, float gy)
+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)
-	{
-		pointer_x=x;
-		pointer_y=y;
-		tooltip_timeout=Time::now()+100*Time::msec;
-	}
+		tooltip_timeout = Msp::Time::now()+100*Msp::Time::msec;
+
+	clear_tooltip();
 
 	if(mode!=INPUT)
 	{
-		manipulator->pointer_motion(x, y, gx, gy);
-		measure->pointer_motion(x, y, gx, gy);
+		Point ground = map_pointer_coords(x, y);
+		manipulator.pointer_motion(x, y, ground.x, ground.y);
+		measure.pointer_motion(x, y, ground.x, ground.y);
 	}
-
-	if(mode==MEASURE || mode==MANIPULATE)
-		move_tooltip(x, y);
-}
-
-void Designer::project_3d()
-{
-	glMatrixMode(GL_PROJECTION);
-	glLoadIdentity();
-	glFrustum(-0.055228, 0.055228, -0.041421, 0.041421, 0.1, 10);
-	glMatrixMode(GL_MODELVIEW);
 }
 
 void Designer::apply_camera()
 {
-	glLoadIdentity();
 	if(mode==CATALOGUE)
-		glTranslatef(0, 0, -1);
-	else
 	{
-		glRotatef(-cam_pitch*180/M_PI-90, 1, 0, 0);
-		glRotatef(90-cam_yaw*180/M_PI, 0, 0, 1);
-		glTranslatef(-cam_pos.x, -cam_pos.y, -cam_pos.z);
+		GL::matrix_mode(GL::PROJECTION);
+		GL::load_identity();
+		GL::frustum_centered(0.11046, 0.082843, 0.1, 10);
+		GL::matrix_mode(GL::MODELVIEW);
+		GL::load_identity();
+		GL::translate(0, 0, -1);
 	}
+	else
+		camera.apply();
 }
 
 void Designer::render()
 {
-	glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
-	glEnable(GL_DEPTH_TEST);
+	GL::clear(GL::COLOR_BUFFER_BIT|GL::DEPTH_BUFFER_BIT);
+	GL::enable(GL::DEPTH_TEST);
+	GL::Texture::unbind();
 
-	project_3d();
-	apply_camera();
 	if(mode==CATALOGUE)
-		cat_layout_3d->render();
+	{
+		apply_camera();
+		cat_layout_3d->get_scene().render();
+	}
 	else
 	{
-		layout_3d->render(true);
-		manipulator->render();
+		pipeline->render_all();
+		layout_3d->get_endpoint_scene().render();
+		GL::enable(GL_CULL_FACE);
+		/*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);
+			}
+		}*/
+
+		manipulator.render();
 		if(mode==MEASURE)
-			measure->render();
+			measure.render();
 	}
 
-	glMatrixMode(GL_PROJECTION);
-	glLoadIdentity();
-	glOrtho(0, screen_w, 0, screen_h, 0, 1);
-	glMatrixMode(GL_MODELVIEW);
-	glLoadIdentity();
+	GL::matrix_mode(GL::PROJECTION);
+	GL::load_identity();
+	GL::ortho_bottomleft(window.get_width(), window.get_height());
+	GL::matrix_mode(GL::MODELVIEW);
+	GL::load_identity();
 
-	glDisable(GL_DEPTH_TEST);
+	GL::disable(GL::DEPTH_TEST);
 
-	if(!tooltip.empty())
-	{
-		glTranslatef(tooltip_x, tooltip_y, 0);
-		glScalef(20, 20, 20);
-		float width=font->get_string_width(tooltip);
-		glColor4f(0, 0, 0, 0.5);
-		glBegin(GL_QUADS);
-		glVertex2f(0, 0);
-		glVertex2f(width, 0);
-		glVertex2f(width, 1);
-		glVertex2f(0, 1);
-		glEnd();
-		glColor4f(1, 1, 1, 1);
-		font->draw_string(tooltip);
-	}
-
-	if(mode==INPUT)
-		input->render();
+	root->render();
 }
 
 Track3D *Designer::pick_track(int x, int y)
 {
-	Layout3D *l=layout_3d;
+	Layout3D *l = layout_3d;
 	if(mode==CATALOGUE)
-		l=cat_layout_3d;
+		l = cat_layout_3d;
 
-	float xx=(static_cast<float>(x-static_cast<int>(screen_w)/2)/screen_h)*0.82843;
-	float yy=(static_cast<float>(y)/screen_h-0.5)*0.82843;
-	float size=4.0/screen_h*0.82843;
+	float xx = ((float(x)-window.get_width()/2)/window.get_height())*0.82843;
+	float yy = (float(y)/window.get_height()-0.5)*0.82843;
+	float size = 4.0/window.get_height()*0.82843;
 
-	project_3d();
 	apply_camera();
 
 	return l->pick_track(xx, yy, size);
 }
 
+void Designer::update_track_color(Track3D &track)
+{
+	if(track.get_track().get_sensor_id())
+	{
+		if(track.get_track().get_flex())
+			track.set_color(GL::Color(1, 0.6, 1));
+		else
+			track.set_color(GL::Color(0.7, 0.7, 1));
+	}
+	else if(track.get_track().get_turnout_id())
+		track.set_color(GL::Color(0.8, 1, 0.8));
+	else if(track.get_track().get_flex())
+		track.set_color(GL::Color(1, 0.8, 0.8));
+	else
+		track.set_color(GL::Color(1, 1, 1));
+}
+
 void Designer::manipulation_status(const string &status)
 {
-	tooltip=status;
+	set_tooltip(pointer_x, pointer_y, status);
 }
 
 void Designer::manipulation_done(bool)
 {
-	mode=SELECT;
+	mode = SELECT;
 }
 
 void Designer::measure_changed()
 {
-	float pard=measure->get_parallel_distance()*1000;
-	float perpd=measure->get_perpendicular_distance()*1000;
-	float d=sqrt(pard*pard+perpd*perpd);
-	float adiff=measure->get_angle_difference()*180/M_PI;
-	ostringstream ss;
-	ss.precision(3);
-	ss<<"Par "<<pard<<"mm - Perp "<<perpd<<"mm - Total "<<d<<"mm - Angle "<<adiff<<"°";
-	tooltip=ss.str();
+	float pard = measure.get_parallel_distance()*1000;
+	float perpd = measure.get_perpendicular_distance()*1000;
+	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);
 }
 
 void Designer::measure_done()
 {
-	mode=SELECT;
+	mode = SELECT;
 }
 
-void Designer::move_tooltip(int x, int y)
+void Designer::set_tooltip(int x, int y, const std::string &text)
 {
-	int w=static_cast<int>(font->get_string_width(tooltip)*20);
-	tooltip_x=max(min(static_cast<int>(screen_w)-w, x), 0);
-	tooltip_y=max(min(static_cast<int>(screen_h)-20, y), 0);
+	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);
+}
+
+void Designer::clear_tooltip()
+{
+	lbl_tooltip->set_visible(false);
 }
 
 void Designer::save_accept()
@@ -623,30 +582,25 @@ void Designer::save_accept()
 
 void Designer::turnout_id_accept()
 {
-	Track *track=selection->get_track();
-	unsigned id=lexical_cast<unsigned>(input->get_text());
+	Track *track = selection.get_track();
+	unsigned id = lexical_cast<unsigned>(input->get_text());
 	track->set_turnout_id(id);
 
-	Track3D &t3d=layout_3d->get_track(*track);
-	if(id)
-		t3d.set_color(GL::Color(0.5, 1, 1));
-	else
-		t3d.set_color(GL::Color(1, 1, 1));
+	update_track_color(layout_3d->get_track(*track));
 
 	input_dismiss();
 }
 
 void Designer::sensor_id_accept()
 {
-	Track *track=selection->get_track();
-	unsigned id=lexical_cast<unsigned>(input->get_text());
-	track->set_sensor_id(id);
+	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)
+	{
+		(*i)->set_sensor_id(id);
 
-	Track3D &t3d=layout_3d->get_track(*track);
-	if(id)
-		t3d.set_color(GL::Color(1, 1, 0.5));
-	else
-		t3d.set_color(GL::Color(1, 1, 1));
+		update_track_color(layout_3d->get_track(**i));
+	}
 
 	input_dismiss();
 }
@@ -654,8 +608,31 @@ void Designer::sensor_id_accept()
 void Designer::input_dismiss()
 {
 	delete input;
-	input=0;
-	mode=SELECT;
+	input = 0;
+	mode = SELECT;
 }
 
-Application::RegApp<Designer> Designer::reg;
+void Designer::view_all()
+{
+	Point minp;
+	Point maxp;
+
+	const list<Track3D *> &tracks = layout_3d->get_tracks();
+	for(list<Track3D *>::const_iterator i=tracks.begin(); i!=tracks.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);
+	}
+
+	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));
+}