diff --git a/src/Reveal.cpp b/src/Reveal.cpp
index 6ce5dddb9a021af57180764d6e1a86291e4eb693..478110c230aedd6edfcdc254ef292c8b7978fef8 100644
--- a/src/Reveal.cpp
+++ b/src/Reveal.cpp
@@ -65,243 +65,243 @@
 using namespace std;
 
 Reveal* Reveal::getInstance() {
-	static Reveal rev;
-	return &rev;
+    static Reveal rev;
+    return &rev;
 }
 
 Reveal::~Reveal(){}
 
 Reveal::Reveal() : GroupModule() {
-	m_type="Rivill";
-	m_name="rivill";
-	addAttribute(new Attribute("open", 
-				Attribute::FILE_OPEN_ATTRIBUTE, 
-				openCallback, this, Attribute::LOCAL, 
-				false));
-	addAttribute(new Attribute("save", 
-				Attribute::FILE_SAVE_ATTRIBUTE, 
-				saveCallback, this, Attribute::LOCAL, 
-				false));
-	addAttribute(new Attribute("quit", 
-				Attribute::ACTION_ATTRIBUTE, 
-				quitCallback, this, Attribute::LOCAL, 
-				false));
-
-	addAttribute(new Attribute("audio_output", 
-				Attribute::BOOL_ATTRIBUTE, 
-				audioOutputCallback,this,1,Attribute::GLOBAL));
-	m_audioOut=false;
-
-	/*
-	addAttribute(new Attribute("ressources_folder", 
-				Attribute::FOLDER_OPEN_ATTRIBUTE, 
-				ressourcesCallback, this, Attribute::LOCAL, 
-				false));
-	addAttribute(new Attribute("ressource_upload", 
-				Attribute::ACTION_STRING_ATTRIBUTE, 
-				uploadCallback,this,2,Attribute::GLOBAL,false));
-				*/
-	addAttribute(new Attribute("debug_osc_input", 
-				Attribute::BOOL_ATTRIBUTE, 
-				debugOscCallback,this,1,Attribute::GLOBAL));
-	m_debugOSC=false;
+    m_type="Rivill";
+    m_name="rivill";
+    addAttribute(new Attribute("open", 
+                Attribute::FILE_OPEN_ATTRIBUTE, 
+                openCallback, this, Attribute::LOCAL, 
+                false));
+    addAttribute(new Attribute("save", 
+                Attribute::FILE_SAVE_ATTRIBUTE, 
+                saveCallback, this, Attribute::LOCAL, 
+                false));
+    addAttribute(new Attribute("quit", 
+                Attribute::ACTION_ATTRIBUTE, 
+                quitCallback, this, Attribute::LOCAL, 
+                false));
+
+    addAttribute(new Attribute("audio_output", 
+                Attribute::BOOL_ATTRIBUTE, 
+                audioOutputCallback,this,1,Attribute::GLOBAL));
+    m_audioOut=false;
+
+    /*
+       addAttribute(new Attribute("ressources_folder", 
+       Attribute::FOLDER_OPEN_ATTRIBUTE, 
+       ressourcesCallback, this, Attribute::LOCAL, 
+       false));
+       addAttribute(new Attribute("ressource_upload", 
+       Attribute::ACTION_STRING_ATTRIBUTE, 
+       uploadCallback,this,2,Attribute::GLOBAL,false));
+       */
+    addAttribute(new Attribute("debug_osc_input", 
+                Attribute::BOOL_ATTRIBUTE, 
+                debugOscCallback,this,1,Attribute::GLOBAL));
+    m_debugOSC=false;
 }
 
 void idleFunc(void* data) {
-	Reveal::getInstance()->update();
-	usleep(1000);
+    Reveal::getInstance()->update();
+    usleep(1000);
 }
 
 void Reveal::init() {
-	m_openPlanned=0;
-
-	//initialize osc input 
-	OscManager::getInstance()->init();
-
-	//initialize depth cameras
-	openni::OpenNI::initialize();
-	openni::OpenNI::setLogConsoleOutput(false);
-	cout<<"Initialized OpenNI "<<openni::OpenNI::getExtendedError()<<endl;
-
-	//initialize observers counter
-	m_upObsIdCounter=0;
-
-	//create all scene geometries 
-	m_geomsMap[GEOM_BOX] = new BoxGeometry();
-	m_geomsMap[GEOM_QUAD] = new QuadGeometry();
-	m_geomsMap[GEOM_SPHERE] = new SphereGeometry();
-	m_geomsMap[GEOM_TUBE] = new TubeGeometry();
-	m_geomsMap[GEOM_CONE] = new ConeGeometry();
-	m_geomsMap[GEOM_FRAME] = new FrameGeometry();
-	map<GEOM_ID, Geometry*>::iterator itGeom = m_geomsMap.begin();
-	for(; itGeom!=m_geomsMap.end(); ++itGeom) {
-		itGeom->second->setGeomID(itGeom->first);
-		m_geoms.push_back(itGeom->second);
-	}
-
-	m_contextHandlersCounter=0;
-
-	m_maxNbRevealed=502;
-	m_maxNbDepthCams=10;
-
-	//add the outputs module
-	m_output = new OutputManagerModule();
-	addChild(m_output);
-
-	//add spaces module 
-	m_spaces = new SpacesModule();
-	addChild(m_spaces);
-
-	//create scene module
-	m_scene = new RootSceneGroupModule();
-	m_scene->addGroupAttributes();
-	addChild(m_scene);
-
-	//Initialize main window
-	fl_register_images();
-	MainWindow::getInstance()->init();
-	Fl::add_idle(idleFunc, MainWindow::getInstance());
-
-	//Initialize glfw for preview and projector windows
-	glewExperimental = GL_TRUE;
-	if(!glfwInit()) {
-		exit(EXIT_FAILURE);
-	}
-	glfwWindowHint(GLFW_TRANSPARENT_FRAMEBUFFER, GLFW_TRUE); //FIXME GLFW 3.3
-	glfwWindowHint(GLFW_RESIZABLE, GL_TRUE);
-	glfwWindowHint(GLFW_AUTO_ICONIFY, GL_FALSE);
+    m_openPlanned=0;
+
+    //initialize osc input 
+    OscManager::getInstance()->init();
+
+    //initialize depth cameras
+    openni::OpenNI::initialize();
+    openni::OpenNI::setLogConsoleOutput(false);
+    cout<<"Initialized OpenNI "<<openni::OpenNI::getExtendedError()<<endl;
+
+    //initialize observers counter
+    m_upObsIdCounter=0;
+
+    //create all scene geometries 
+    m_geomsMap[GEOM_BOX] = new BoxGeometry();
+    m_geomsMap[GEOM_QUAD] = new QuadGeometry();
+    m_geomsMap[GEOM_SPHERE] = new SphereGeometry();
+    m_geomsMap[GEOM_TUBE] = new TubeGeometry();
+    m_geomsMap[GEOM_CONE] = new ConeGeometry();
+    m_geomsMap[GEOM_FRAME] = new FrameGeometry();
+    map<GEOM_ID, Geometry*>::iterator itGeom = m_geomsMap.begin();
+    for(; itGeom!=m_geomsMap.end(); ++itGeom) {
+        itGeom->second->setGeomID(itGeom->first);
+        m_geoms.push_back(itGeom->second);
+    }
+
+    m_contextHandlersCounter=0;
+
+    m_maxNbRevealed=502;
+    m_maxNbDepthCams=10;
+
+    //add the outputs module
+    m_output = new OutputManagerModule();
+    addChild(m_output);
+
+    //add spaces module 
+    m_spaces = new SpacesModule();
+    addChild(m_spaces);
+
+    //create scene module
+    m_scene = new RootSceneGroupModule();
+    m_scene->addGroupAttributes();
+    addChild(m_scene);
+
+    //Initialize main window
+    fl_register_images();
+    MainWindow::getInstance()->init();
+    Fl::add_idle(idleFunc, MainWindow::getInstance());
+
+    //Initialize glfw for preview and projector windows
+    glewExperimental = GL_TRUE;
+    if(!glfwInit()) {
+        exit(EXIT_FAILURE);
+    }
+    glfwWindowHint(GLFW_TRANSPARENT_FRAMEBUFFER, GLFW_TRUE); //FIXME GLFW 3.3
+    glfwWindowHint(GLFW_RESIZABLE, GL_TRUE);
+    glfwWindowHint(GLFW_AUTO_ICONIFY, GL_FALSE);
 #ifdef GL42
-	glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 4);
-	glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
+    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 4);
+    glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
 #else 
-	glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 4);
-	glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 1);
+    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 4);
+    glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 1);
 #endif
 #ifdef OSX
-	glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
-	glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);
-	glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 4);
-	glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 1);
+    glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
+    glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);
+    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 4);
+    glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 1);
 #endif
 
-	//add preview module
-	m_preview = new PreviewModule();
-	m_spaces->addChild(m_preview);
+    //add preview module
+    m_preview = new PreviewModule();
+    m_spaces->addChild(m_preview);
 
-	refreshModules();
+    refreshModules();
 
-	//Show main window
-	MainWindow::getInstance()->show();
+    //Show main window
+    MainWindow::getInstance()->show();
 
-	//start timer
-	gettimeofday(&m_prevTime, NULL);
+    //start timer
+    gettimeofday(&m_prevTime, NULL);
 }
 
 GLFWwindow* Reveal::getPreviewWindow() {
-	return m_preview->getWindow();
+    return m_preview->getWindow();
 }
 
 void Reveal::setAudioOutput(const bool& aud) {
-	if(aud) {
-		AudioManager::getInstance()->init();
-	}
+    if(aud) {
+        AudioManager::getInstance()->init();
+    }
 }
 
 void Reveal::planOpen(std::string opSt) {
-	//FIXME find better strategy for delaying text
-	m_openPlanned=10;
-	m_openPlannedName=opSt;
+    //FIXME find better strategy for delaying text
+    m_openPlanned=10;
+    m_openPlannedName=opSt;
 }
 
 void Reveal::update() {
-	//delete listeners, attributes and modules
-	testDelete();
-
-	//update osc manager
-	OscManager::getInstance()->update();
-
-	//FIXME distinguish between anim and update (cam)
-	//update observers every 50ms 
-	timeval curTime, timeDiff;
-	gettimeofday(&curTime,NULL);
-	timersub(&curTime, &m_prevTime, &timeDiff);
-	int timeDiffMs = timeDiff.tv_sec*1000.0+timeDiff.tv_usec/1000.0;
-	m_prevTime=curTime;
-	vector<Module*>::iterator itUp = m_updateObservers.begin();
-	for(; itUp!=m_updateObservers.end(); ++itUp) {
-		(*itUp)->update(timeDiffMs);
-	}
-
-	//draw all spaces
-	m_spaces->draw();
-
-	//delayed open to fix text rendering issues ...
-	if(m_openPlanned>0) {
-		m_openPlanned--;
-		if(m_openPlanned==0) {
-			open(m_openPlannedName);
-		}
-	}
-
-	glfwPollEvents();
+    //delete listeners, attributes and modules
+    testDelete();
+
+    //update osc manager
+    OscManager::getInstance()->update();
+
+    //FIXME distinguish between anim and update (cam)
+    //update observers every 50ms 
+    timeval curTime, timeDiff;
+    gettimeofday(&curTime,NULL);
+    timersub(&curTime, &m_prevTime, &timeDiff);
+    int timeDiffMs = timeDiff.tv_sec*1000.0+timeDiff.tv_usec/1000.0;
+    m_prevTime=curTime;
+    vector<Module*>::iterator itUp = m_updateObservers.begin();
+    for(; itUp!=m_updateObservers.end(); ++itUp) {
+        (*itUp)->update(timeDiffMs);
+    }
+
+    //draw all spaces
+    m_spaces->draw();
+
+    //delayed open to fix text rendering issues ...
+    if(m_openPlanned>0) {
+        m_openPlanned--;
+        if(m_openPlanned==0) {
+            open(m_openPlannedName);
+        }
+    }
+
+    glfwPollEvents();
 }
 
 int Reveal::run() {
-	return Fl::run();
+    return Fl::run();
 }
 
 void Reveal::askQuit() {
-	MainWindow::getInstance()->cbQuit();
+    MainWindow::getInstance()->cbQuit();
 }
 
 void Reveal::quit() {
-	glfwTerminate();
-	exit(0);
+    glfwTerminate();
+    exit(0);
 }
 
 void Reveal::open(const std::string& fileName) {
-	cout<<"Opening "<<fileName<<endl;
-	bool open=true;
-	xmlDocPtr doc = xmlReadFile(fileName.c_str(), NULL, 0);
-	xmlNodePtr rootNode = xmlDocGetRootElement(doc);
-	if(doc==NULL || rootNode==NULL) {
-		DEBUG("Could not open file "<<fileName);
-		open=false;
-	}
-	else if(xmlStrcmp(rootNode->name, (const xmlChar*)"Rivill")) {
-		xmlFreeDoc(doc);
-		DEBUG("Could not open file "<<fileName);
-		open=false;
-	}
-	if(open) { //if the file is valid
-		m_currentFile=fileName;
-		//clear the scene and spaces
-		m_scene->deleteChildren();
-		m_spaces->removeChild(m_preview);
-		m_spaces->deleteChildren();
-		m_spaces->addChild(m_preview);
-		m_revealedMap.clear();
-		m_registeredOutputRevealed.clear();
-		m_registeredOutputDepthCams.clear();
-		m_upObsIdCounter=0;
-		m_updateObservers.clear();
-		//and load
-		load(rootNode);
-		m_attributesMap["save"]->initFile(m_currentFile);
-		MainWindow::getInstance()->refreshModules();
-		DEBUG("Opened file "<<fileName);
-	}
+    cout<<"Opening "<<fileName<<endl;
+    bool open=true;
+    xmlDocPtr doc = xmlReadFile(fileName.c_str(), NULL, 0);
+    xmlNodePtr rootNode = xmlDocGetRootElement(doc);
+    if(doc==NULL || rootNode==NULL) {
+        DEBUG("Could not open file "<<fileName);
+        open=false;
+    }
+    else if(xmlStrcmp(rootNode->name, (const xmlChar*)"Rivill")) {
+        xmlFreeDoc(doc);
+        DEBUG("Could not open file "<<fileName);
+        open=false;
+    }
+    if(open) { //if the file is valid
+        m_currentFile=fileName;
+        //clear the scene and spaces
+        m_scene->deleteChildren();
+        m_spaces->removeChild(m_preview);
+        m_spaces->deleteChildren();
+        m_spaces->addChild(m_preview);
+        m_revealedMap.clear();
+        m_registeredOutputRevealed.clear();
+        m_registeredOutputDepthCams.clear();
+        m_upObsIdCounter=0;
+        m_updateObservers.clear();
+        //and load
+        load(rootNode);
+        m_attributesMap["save"]->initFile(m_currentFile);
+        MainWindow::getInstance()->refreshModules();
+        DEBUG("Opened file "<<fileName);
+    }
 }
 
 void Reveal::save(const std::string& fileName) {
-	cout<<"Saving to "<<fileName<<endl;
-	m_currentFile=fileName;
-	xmlDocPtr doc = xmlNewDoc(BAD_CAST "1.0");
-	xmlNodePtr rootNode = GroupModule::save(NULL);
-	xmlDocSetRootElement(doc, rootNode);
-	xmlSaveFormatFileEnc(fileName.c_str(), doc, "UTF-8", 1);
-	xmlFreeDoc(doc);
-	xmlCleanupParser();
+    cout<<"Saving to "<<fileName<<endl;
+    m_currentFile=fileName;
+    xmlDocPtr doc = xmlNewDoc(BAD_CAST "1.0");
+    xmlNodePtr rootNode = GroupModule::save(NULL);
+    xmlDocSetRootElement(doc, rootNode);
+    xmlSaveFormatFileEnc(fileName.c_str(), doc, "UTF-8", 1);
+    xmlFreeDoc(doc);
+    xmlCleanupParser();
 }
 
 void Reveal::setRessourcesFolder(const std::string& f) {
@@ -313,422 +313,422 @@ void Reveal::uploadRessource(const std::vector<std::string>& vf) {
 }
 
 void Reveal::load(xmlNodePtr node) {
-	Module::load(node);
-	xmlNodePtr modsNode;
-	for(modsNode=node->children; modsNode; modsNode=modsNode->next){
-		if(modsNode->type == XML_ELEMENT_NODE &&
-				!xmlStrcmp(modsNode->name, (const xmlChar *) "Modules")) {
-			xmlNodePtr modNode;
-			for(modNode=modsNode->children; modNode; modNode=modNode->next){
-				if(modNode->type == XML_ELEMENT_NODE) {
-					if(!xmlStrcmp(modNode->name,(const xmlChar *)"Scene")) {
-						m_scene->load(modNode);
-					}
-					else if(!xmlStrcmp(modNode->name,(const xmlChar*)"Spaces")){
-						m_spaces->load(modNode);
-					}
-				}
-			}
-		}
-	}
+    Module::load(node);
+    xmlNodePtr modsNode;
+    for(modsNode=node->children; modsNode; modsNode=modsNode->next){
+        if(modsNode->type == XML_ELEMENT_NODE &&
+                !xmlStrcmp(modsNode->name, (const xmlChar *) "Modules")) {
+            xmlNodePtr modNode;
+            for(modNode=modsNode->children; modNode; modNode=modNode->next){
+                if(modNode->type == XML_ELEMENT_NODE) {
+                    if(!xmlStrcmp(modNode->name,(const xmlChar *)"Scene")) {
+                        m_scene->load(modNode);
+                    }
+                    else if(!xmlStrcmp(modNode->name,(const xmlChar*)"Spaces")){
+                        m_spaces->load(modNode);
+                    }
+                }
+            }
+        }
+    }
 }
 
 Module* Reveal::createModule(const std::string& typeStr) {
-	Module* mod=NULL;
-	if(typeStr.compare("Projector")==0) {
-		mod=new ProjectorModule();
-	}
-	else if(typeStr.compare("Space")==0) {
-		mod=new SpaceModule();
-	}
-	else if(typeStr.compare("DepthGroup")==0) {
-		mod=new DepthGroupModule();
-	}
-	else if(typeStr.compare("DepthCam")==0) {
-		mod=new DepthCamModule();
-	}
-	else if(typeStr.compare("DepthShape")==0) {
-		mod=new DepthShapeModule();
-	}
-	else if(typeStr.compare("DepthMesh")==0) {
-		mod=new DepthMeshModule();
-	}
-	else if(typeStr.compare("SceneGroup")==0) {
-		mod=new SceneGroupModule();
-	}
-	else if(typeStr.compare("Shape")==0) {
-		mod=new RevealedShapeModule();
-	}
-	else if(typeStr.compare("Model")==0) {
-		mod=new RevealedModelModule();
-	}
-	else if(typeStr.compare("Path")==0) {
-		mod=new RevealedPathModule();
-	}
-	else if(typeStr.compare("Text")==0) {
-		mod=new RevealedTextModule();
-	}
-	else if(typeStr.compare("Cut")==0) {
-		mod=new RevealedCutModule();
-	}
-	else if(typeStr.compare("Arrow")==0) {
-		mod=new RevealedArrowModule();
-	}
-	else if(typeStr.compare("Grid")==0) {
-		mod=new RevealedGridModule();
-	}
-	return mod;
+    Module* mod=NULL;
+    if(typeStr.compare("Projector")==0) {
+        mod=new ProjectorModule();
+    }
+    else if(typeStr.compare("Space")==0) {
+        mod=new SpaceModule();
+    }
+    else if(typeStr.compare("DepthGroup")==0) {
+        mod=new DepthGroupModule();
+    }
+    else if(typeStr.compare("DepthCam")==0) {
+        mod=new DepthCamModule();
+    }
+    else if(typeStr.compare("DepthShape")==0) {
+        mod=new DepthShapeModule();
+    }
+    else if(typeStr.compare("DepthMesh")==0) {
+        mod=new DepthMeshModule();
+    }
+    else if(typeStr.compare("SceneGroup")==0) {
+        mod=new SceneGroupModule();
+    }
+    else if(typeStr.compare("Shape")==0) {
+        mod=new RevealedShapeModule();
+    }
+    else if(typeStr.compare("Model")==0) {
+        mod=new RevealedModelModule();
+    }
+    else if(typeStr.compare("Path")==0) {
+        mod=new RevealedPathModule();
+    }
+    else if(typeStr.compare("Text")==0) {
+        mod=new RevealedTextModule();
+    }
+    else if(typeStr.compare("Cut")==0) {
+        mod=new RevealedCutModule();
+    }
+    else if(typeStr.compare("Arrow")==0) {
+        mod=new RevealedArrowModule();
+    }
+    else if(typeStr.compare("Grid")==0) {
+        mod=new RevealedGridModule();
+    }
+    return mod;
 }
 
 Listener* Reveal::createListener(const std::string& typeStr) {
-	Listener* lis=NULL;
-	if(typeStr.compare("OscListener")==0) {
-		lis=new OscListener();
-	}
-	return lis;
+    Listener* lis=NULL;
+    if(typeStr.compare("OscListener")==0) {
+        lis=new OscListener();
+    }
+    return lis;
 }
 
 int Reveal::getVisibilityMask(const std::string& visibleFrom) {
-	int res=0;
-	map<string, int>::iterator itVis = m_visibleFromMap.find(visibleFrom);
-	if(itVis!=m_visibleFromMap.end()) {
-		res=itVis->second;
-	}
-	return res;
+    int res=0;
+    map<string, int>::iterator itVis = m_visibleFromMap.find(visibleFrom);
+    if(itVis!=m_visibleFromMap.end()) {
+        res=itVis->second;
+    }
+    return res;
 }
 
 void Reveal::addUpdateObserver(Module* upObs) {
-	m_updateObservers.push_back(upObs);
-	upObs->setUpID(m_upObsIdCounter);
-	m_upObsIdCounter++;
+    m_updateObservers.push_back(upObs);
+    upObs->setUpID(m_upObsIdCounter);
+    m_upObsIdCounter++;
 }
 
 void Reveal::removeUpdateObserver(Module* upObs) {
-	vector<Module*>::iterator itObs = m_updateObservers.begin();
-	for(; itObs!=m_updateObservers.end(); ) {
-		if((*itObs)->getUpID()==upObs->getUpID()) {
-			itObs = m_updateObservers.erase(itObs);
-		}
-		else {
-			itObs++;
-		}
-	}
+    vector<Module*>::iterator itObs = m_updateObservers.begin();
+    for(; itObs!=m_updateObservers.end(); ) {
+        if((*itObs)->getUpID()==upObs->getUpID()) {
+            itObs = m_updateObservers.erase(itObs);
+        }
+        else {
+            itObs++;
+        }
+    }
 }
 
 void Reveal::addModuleListObserver(ModuleListObserver* obs) {
-	unsigned int obsID=0;
-	while(m_moduleListObservers.find(obsID)!=m_moduleListObservers.end()) {
-		obsID++;
-	}
-	m_moduleListObservers[obsID]=obs;
-	obs->setModuleListObsID(obsID);
+    unsigned int obsID=0;
+    while(m_moduleListObservers.find(obsID)!=m_moduleListObservers.end()) {
+        obsID++;
+    }
+    m_moduleListObservers[obsID]=obs;
+    obs->setModuleListObsID(obsID);
 }
 
 void Reveal::removeModuleListObserver(ModuleListObserver* obs) {
-	m_moduleListObservers.erase(obs->getModuleListObsID());
+    m_moduleListObservers.erase(obs->getModuleListObsID());
 }
 
 void Reveal::addContextHandler(ContextHandler* cont) {
-	m_contextHandlers[m_contextHandlersCounter]=cont;
-	cont->setContextHandlerID(m_contextHandlersCounter);
-	m_contextHandlersCounter++;
+    m_contextHandlers[m_contextHandlersCounter]=cont;
+    cont->setContextHandlerID(m_contextHandlersCounter);
+    m_contextHandlersCounter++;
 }
 
 void Reveal::removeContextHandler(ContextHandler* cont) {
-	m_contextHandlers.erase(cont->getContextHandlerID());
+    m_contextHandlers.erase(cont->getContextHandlerID());
 }
 
 void Reveal::registerGeom(Geometry* geom) {
-	GEOM_ID newID = GEOM_MODEL;
-	while(m_geomsMap.find(newID)!=m_geomsMap.end()) {
-		newID = GEOM_ID(int(newID)+1);
-	}
-	geom->setGeomID(newID);
-	m_geomsMap[newID]=geom;
-	m_geoms.push_back(geom);
+    GEOM_ID newID = GEOM_MODEL;
+    while(m_geomsMap.find(newID)!=m_geomsMap.end()) {
+        newID = GEOM_ID(int(newID)+1);
+    }
+    geom->setGeomID(newID);
+    m_geomsMap[newID]=geom;
+    m_geoms.push_back(geom);
 }
 
 void Reveal::unregisterGeom(Geometry* geom) {
-	m_geomsMap.erase(geom->getGeomID());
-	vector<Geometry*>::iterator itGeom = m_geoms.begin();
-	for(; itGeom!=m_geoms.end(); ) {
-		if((*itGeom)->getGeomID()==geom->getGeomID()) {
-			itGeom = m_geoms.erase(itGeom);
-		}
-		else {
-			++itGeom;
-		}
-	}
+    m_geomsMap.erase(geom->getGeomID());
+    vector<Geometry*>::iterator itGeom = m_geoms.begin();
+    for(; itGeom!=m_geoms.end(); ) {
+        if((*itGeom)->getGeomID()==geom->getGeomID()) {
+            itGeom = m_geoms.erase(itGeom);
+        }
+        else {
+            ++itGeom;
+        }
+    }
 }
 
 void Reveal::registerRevealed(RevealedModule* rev) {
-	m_revealedVec.push_back(rev);
-	updateRevealed();
+    m_revealedVec.push_back(rev);
+    updateRevealed();
 }
 
 void Reveal::unregisterRevealed(RevealedModule* rev) {
-	vector<RevealedModule*>::iterator itRev=m_revealedVec.begin();
-	for(; itRev!=m_revealedVec.end();) {
-		if((*itRev)->getRevID()==rev->getRevID()) {
-			itRev=m_revealedVec.erase(itRev);
-		}
-		else {
-			++itRev;
-		}
-	}
-	updateRevealed();
-	unregisterOutputRevealed(rev);
+    vector<RevealedModule*>::iterator itRev=m_revealedVec.begin();
+    for(; itRev!=m_revealedVec.end();) {
+        if((*itRev)->getRevID()==rev->getRevID()) {
+            itRev=m_revealedVec.erase(itRev);
+        }
+        else {
+            ++itRev;
+        }
+    }
+    updateRevealed();
+    unregisterOutputRevealed(rev);
 }
 
 void Reveal::updateRevealed() {
-	m_revealedMap.clear();
-	vector<RevealedModule*>::iterator itRev=m_revealedVec.begin();
-	unsigned int id=1;
-	for(; itRev!=m_revealedVec.end(); ++itRev, ++id) {
-		(*itRev)->setRevID(id);
-		m_revealedMap[id]=*itRev;
-	}
+    m_revealedMap.clear();
+    vector<RevealedModule*>::iterator itRev=m_revealedVec.begin();
+    unsigned int id=1;
+    for(; itRev!=m_revealedVec.end(); ++itRev, ++id) {
+        (*itRev)->setRevID(id);
+        m_revealedMap[id]=*itRev;
+    }
 }
 
 void Reveal::refreshModules() {
-	//recreate map of modules and attributes
-	m_modulesMap.clear();
-	m_fullAttributesMap.clear();
-	GroupModule::listModulesAndAttributes("", m_modulesMap, 
-			m_fullAttributesMap);
-
-	//inform observers of the new module list
-	map<unsigned int, ModuleListObserver*>::iterator itObs 
-		= m_moduleListObservers.begin(); 
-	for(; itObs!=m_moduleListObservers.end(); ++itObs) {
-		itObs->second->updateModulesList(m_modulesMap);
-	}
-
-	//refresh space/projectors list
-	m_visibleFromVec.clear();
-	m_visibleFromMap.clear();
-	m_visibleFromVec.push_back("none");
-	m_visibleFromMap[m_visibleFromVec.back()]=VISIBLE_FROM_NONE;
-	m_visibleFromVec.push_back("all");
-	m_visibleFromMap[m_visibleFromVec.back()]=VISIBLE_FROM_ALL;
-	m_spaces->getVisibleFromList(m_visibleFromVec, m_visibleFromMap);
-
-	map<unsigned int, RevealedModule*>::iterator itMod
-		= m_revealedMap.begin(); 
-	for(; itMod!=m_revealedMap.end(); ++itMod) {
-		itMod->second->setVisibleFromList(m_visibleFromVec);
-	}
-
-	//refresh display
-	MainWindow::getInstance()->refreshModules();
-
-	/*
-	//TEMP list all attributes of all modules 
-	map<string, Attribute*>::iterator itAtt = m_attributesMap.begin();
-	for(;itAtt!=m_attributesMap.end(); ++itAtt) {
-	cout<<itAtt->first<<endl;
-	}
-	*/
+    //recreate map of modules and attributes
+    m_modulesMap.clear();
+    m_fullAttributesMap.clear();
+    GroupModule::listModulesAndAttributes("", m_modulesMap, 
+            m_fullAttributesMap);
+
+    //inform observers of the new module list
+    map<unsigned int, ModuleListObserver*>::iterator itObs 
+        = m_moduleListObservers.begin(); 
+    for(; itObs!=m_moduleListObservers.end(); ++itObs) {
+        itObs->second->updateModulesList(m_modulesMap);
+    }
+
+    //refresh space/projectors list
+    m_visibleFromVec.clear();
+    m_visibleFromMap.clear();
+    m_visibleFromVec.push_back("none");
+    m_visibleFromMap[m_visibleFromVec.back()]=VISIBLE_FROM_NONE;
+    m_visibleFromVec.push_back("all");
+    m_visibleFromMap[m_visibleFromVec.back()]=VISIBLE_FROM_ALL;
+    m_spaces->getVisibleFromList(m_visibleFromVec, m_visibleFromMap);
+
+    map<unsigned int, RevealedModule*>::iterator itMod
+        = m_revealedMap.begin(); 
+    for(; itMod!=m_revealedMap.end(); ++itMod) {
+        itMod->second->setVisibleFromList(m_visibleFromVec);
+    }
+
+    //refresh display
+    MainWindow::getInstance()->refreshModules();
+
+    /*
+    //TEMP list all attributes of all modules 
+    map<string, Attribute*>::iterator itAtt = m_attributesMap.begin();
+    for(;itAtt!=m_attributesMap.end(); ++itAtt) {
+    cout<<itAtt->first<<endl;
+    }
+    */
 }
 
 Attribute* Reveal::findAttribute(const std::string& fullName) {
-	map<string,Attribute*>::iterator itAtt = m_fullAttributesMap.find(fullName);
-	if(itAtt!=m_fullAttributesMap.end()) {
-		return itAtt->second;
-	}
-	return NULL;
+    map<string,Attribute*>::iterator itAtt = m_fullAttributesMap.find(fullName);
+    if(itAtt!=m_fullAttributesMap.end()) {
+        return itAtt->second;
+    }
+    return NULL;
 }
 
 Module* Reveal::findModule(const std::string& fullName) {
-	map<string, Module*>::iterator itMod = m_modulesMap.find(fullName);
-	if(itMod!=m_modulesMap.end()) {
-		return itMod->second;
-	}
-	return NULL;
+    map<string, Module*>::iterator itMod = m_modulesMap.find(fullName);
+    if(itMod!=m_modulesMap.end()) {
+        return itMod->second;
+    }
+    return NULL;
 }
 
 void Reveal::registerOutputRevealed(RevealedModule* rev) {
-	bool found=false;
-	vector<RevealedModule*>::iterator itSh=m_registeredOutputRevealed.begin();
-	for(; itSh!=m_registeredOutputRevealed.end(); ++itSh) {
-		if((*itSh)->getRevID()==rev->getRevID()) {
-			found=true;
-		}
-	}
-	if(!found) {
-		m_registeredOutputRevealed.push_back(rev);
-	}
-	updateOutputRevealed();
+    bool found=false;
+    vector<RevealedModule*>::iterator itSh=m_registeredOutputRevealed.begin();
+    for(; itSh!=m_registeredOutputRevealed.end(); ++itSh) {
+        if((*itSh)->getRevID()==rev->getRevID()) {
+            found=true;
+        }
+    }
+    if(!found) {
+        m_registeredOutputRevealed.push_back(rev);
+    }
+    updateOutputRevealed();
 }
 
 void Reveal::unregisterOutputRevealed(RevealedModule* rev) {
 
-	//remove it from list
-	vector<RevealedModule*>::iterator itSh=m_registeredOutputRevealed.begin();
-	for(; itSh!=m_registeredOutputRevealed.end(); ) {
-		if((*itSh)->getRevID()==rev->getRevID()) {
-			itSh=m_registeredOutputRevealed.erase(itSh);
-		}
-		else {
-			++itSh;
-		}
-	}
+    //remove it from list
+    vector<RevealedModule*>::iterator itSh=m_registeredOutputRevealed.begin();
+    for(; itSh!=m_registeredOutputRevealed.end(); ) {
+        if((*itSh)->getRevID()==rev->getRevID()) {
+            itSh=m_registeredOutputRevealed.erase(itSh);
+        }
+        else {
+            ++itSh;
+        }
+    }
 
-	//reset offsets 
-	updateOutputRevealed();
+    //reset offsets 
+    updateOutputRevealed();
 }
 
 void Reveal::updateOutputRevealed() {
-	vector<RevealedModule*>::iterator itSh=m_registeredOutputRevealed.begin();
-	unsigned int offset=0;
-	for(; itSh!=m_registeredOutputRevealed.end(); ++itSh) {
-		(*itSh)->updateRevOffset(offset);
-	}
+    vector<RevealedModule*>::iterator itSh=m_registeredOutputRevealed.begin();
+    unsigned int offset=0;
+    for(; itSh!=m_registeredOutputRevealed.end(); ++itSh) {
+        (*itSh)->updateRevOffset(offset);
+    }
 }
 
 void Reveal::registerOutputDepthCam(DepthCamModule* cam) {
-	bool found=false;
-	vector<DepthCamModule*>::iterator itCa=m_registeredOutputDepthCams.begin();
-	for(; itCa!=m_registeredOutputDepthCams.end(); ++itCa) {
-		if((*itCa)->getDepthID()==cam->getDepthID()) {
-			found=true;
-		}
-	}
-	if(!found) {
-		m_registeredOutputDepthCams.push_back(cam);
-	}
+    bool found=false;
+    vector<DepthCamModule*>::iterator itCa=m_registeredOutputDepthCams.begin();
+    for(; itCa!=m_registeredOutputDepthCams.end(); ++itCa) {
+        if((*itCa)->getDepthID()==cam->getDepthID()) {
+            found=true;
+        }
+    }
+    if(!found) {
+        m_registeredOutputDepthCams.push_back(cam);
+    }
 }
 
 void Reveal::unregisterOutputDepthCam(DepthCamModule* cam) {
-	vector<DepthCamModule*>::iterator itCa=m_registeredOutputDepthCams.begin();
-	for(; itCa!=m_registeredOutputDepthCams.end(); ) {
-		if((*itCa)->getDepthID()==cam->getDepthID()) {
-			itCa=m_registeredOutputDepthCams.erase(itCa);
-		}
-		else {
-			++itCa;
-		}
-	}
+    vector<DepthCamModule*>::iterator itCa=m_registeredOutputDepthCams.begin();
+    for(; itCa!=m_registeredOutputDepthCams.end(); ) {
+        if((*itCa)->getDepthID()==cam->getDepthID()) {
+            itCa=m_registeredOutputDepthCams.erase(itCa);
+        }
+        else {
+            ++itCa;
+        }
+    }
 }
 
 void Reveal::deleteListener(Listener* lis) {
-	m_listenersDeleteVec.push_back(lis);
+    m_listenersDeleteVec.push_back(lis);
 }
 
 void Reveal::deleteModule(Module* mod) {
-	m_modulesDeleteVec.push_back(mod);
-	refreshModules();
+    m_modulesDeleteVec.push_back(mod);
+    refreshModules();
 }
 
 void Reveal::testDelete() {
-	bool erasedListeners=false;
-	vector<Listener*>::iterator itLis = m_listenersDeleteVec.begin();
-	for(; itLis!=m_listenersDeleteVec.end(); ++itLis) {
-		delete (*itLis);
-		erasedListeners=true;
-	}
-	m_listenersDeleteVec.clear();
-
-	if(m_modulesDeleteVec.size()>0) {
-		MainWindow::getInstance()->refreshModules(true, erasedListeners);
-	}
-	vector<Module*>::iterator itMod = m_modulesDeleteVec.begin();
-	for(; itMod!=m_modulesDeleteVec.end(); ++itMod) {
-		delete (*itMod);
-	}
-	m_modulesDeleteVec.clear();
+    bool erasedListeners=false;
+    vector<Listener*>::iterator itLis = m_listenersDeleteVec.begin();
+    for(; itLis!=m_listenersDeleteVec.end(); ++itLis) {
+        delete (*itLis);
+        erasedListeners=true;
+    }
+    m_listenersDeleteVec.clear();
+
+    if(m_modulesDeleteVec.size()>0) {
+        MainWindow::getInstance()->refreshModules(true, erasedListeners);
+    }
+    vector<Module*>::iterator itMod = m_modulesDeleteVec.begin();
+    for(; itMod!=m_modulesDeleteVec.end(); ++itMod) {
+        delete (*itMod);
+    }
+    m_modulesDeleteVec.clear();
 }
 
 GLuint Reveal::createProgram(const char* vertSource, const char* fragSource) {
-	GLint compile_ok = GL_FALSE, link_ok = GL_FALSE;
-	GLuint vertexShader, fragmentShader;
-	vertexShader = glCreateShader(GL_VERTEX_SHADER);
-	glShaderSource(vertexShader, 1, &vertSource, NULL);
-	glCompileShader(vertexShader);
-	glGetShaderiv(vertexShader, GL_COMPILE_STATUS, &compile_ok);
-	if(!compile_ok) {
-		cout << "Error in vertex shader" << endl;
-		GLint maxLength = 0;
-		glGetShaderiv(vertexShader, GL_INFO_LOG_LENGTH, &maxLength);
-		std::vector<GLchar> errorLog(maxLength);
-		glGetShaderInfoLog(vertexShader,maxLength,&maxLength, &errorLog[0]);
-		vector<GLchar>::iterator itC=errorLog.begin();
-		for(; itC!=errorLog.end(); ++itC) {
-			cout<<*itC;
-		}
-		cout<<endl;
-	} 
-	fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
-	glShaderSource(fragmentShader, 1, &fragSource, NULL);
-	glCompileShader(fragmentShader);
-	glGetShaderiv(fragmentShader, GL_COMPILE_STATUS, &compile_ok);
-	if(!compile_ok) {
-		cout << "Error in fragment shader" << endl;
-		GLint maxLength = 0;
-		glGetShaderiv(fragmentShader, GL_INFO_LOG_LENGTH, &maxLength);
-		std::vector<GLchar> errorLog(maxLength);
-		glGetShaderInfoLog(fragmentShader,maxLength,&maxLength, &errorLog[0]);
-		vector<GLchar>::iterator itC=errorLog.begin();
-		for(; itC!=errorLog.end(); ++itC) {
-			cout<<*itC;
-		}
-		cout<<endl;
-	}
-	GLuint program = glCreateProgram();
-	glAttachShader(program, vertexShader);
-	glAttachShader(program, fragmentShader);
-	glLinkProgram(program);
-	glGetProgramiv(program, GL_LINK_STATUS, &link_ok);
-	if(!link_ok) {
-		cout<<"Error linking glsl program "<<program<<" "<<endl;
-		GLint maxLength = 0;
-		glGetProgramiv(program, GL_INFO_LOG_LENGTH, &maxLength);
-		std::vector<GLchar> errorLog(maxLength);
-		glGetProgramInfoLog(program,maxLength,&maxLength, &errorLog[0]);
-		vector<GLchar>::iterator itC=errorLog.begin();
-		for(; itC!=errorLog.end(); ++itC) {
-			cout<<*itC;
-		}
-		cout<<endl;
-	}
-	return program;
+    GLint compile_ok = GL_FALSE, link_ok = GL_FALSE;
+    GLuint vertexShader, fragmentShader;
+    vertexShader = glCreateShader(GL_VERTEX_SHADER);
+    glShaderSource(vertexShader, 1, &vertSource, NULL);
+    glCompileShader(vertexShader);
+    glGetShaderiv(vertexShader, GL_COMPILE_STATUS, &compile_ok);
+    if(!compile_ok) {
+        cout << "Error in vertex shader" << endl;
+        GLint maxLength = 0;
+        glGetShaderiv(vertexShader, GL_INFO_LOG_LENGTH, &maxLength);
+        std::vector<GLchar> errorLog(maxLength);
+        glGetShaderInfoLog(vertexShader,maxLength,&maxLength, &errorLog[0]);
+        vector<GLchar>::iterator itC=errorLog.begin();
+        for(; itC!=errorLog.end(); ++itC) {
+            cout<<*itC;
+        }
+        cout<<endl;
+    } 
+    fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
+    glShaderSource(fragmentShader, 1, &fragSource, NULL);
+    glCompileShader(fragmentShader);
+    glGetShaderiv(fragmentShader, GL_COMPILE_STATUS, &compile_ok);
+    if(!compile_ok) {
+        cout << "Error in fragment shader" << endl;
+        GLint maxLength = 0;
+        glGetShaderiv(fragmentShader, GL_INFO_LOG_LENGTH, &maxLength);
+        std::vector<GLchar> errorLog(maxLength);
+        glGetShaderInfoLog(fragmentShader,maxLength,&maxLength, &errorLog[0]);
+        vector<GLchar>::iterator itC=errorLog.begin();
+        for(; itC!=errorLog.end(); ++itC) {
+            cout<<*itC;
+        }
+        cout<<endl;
+    }
+    GLuint program = glCreateProgram();
+    glAttachShader(program, vertexShader);
+    glAttachShader(program, fragmentShader);
+    glLinkProgram(program);
+    glGetProgramiv(program, GL_LINK_STATUS, &link_ok);
+    if(!link_ok) {
+        cout<<"Error linking glsl program "<<program<<" "<<endl;
+        GLint maxLength = 0;
+        glGetProgramiv(program, GL_INFO_LOG_LENGTH, &maxLength);
+        std::vector<GLchar> errorLog(maxLength);
+        glGetProgramInfoLog(program,maxLength,&maxLength, &errorLog[0]);
+        vector<GLchar>::iterator itC=errorLog.begin();
+        for(; itC!=errorLog.end(); ++itC) {
+            cout<<*itC;
+        }
+        cout<<endl;
+    }
+    return program;
 }
 
 void Reveal::measureStart() {
-	gettimeofday(&m_measureTime, NULL);
-	m_measuring=true;
+    gettimeofday(&m_measureTime, NULL);
+    m_measuring=true;
 }
 
 void Reveal::measureStore(const int& nbPixels) {
-	if(m_measuring) {
-		timeval curTime, timeDiff;
-		gettimeofday(&curTime, NULL);
-		timersub(&curTime, &m_measureTime, &timeDiff);
-		int timeDiffMs=int(timeDiff.tv_sec)*1000000 
-			+ int(timeDiff.tv_usec);
-		if(m_measurePixelNb.find(nbPixels)==m_measurePixelNb.end()) {
-			m_measurePixelTimes[nbPixels]=0;
-			m_measurePixelNb[nbPixels]=0;
-		}
-		m_measurePixelNb[nbPixels]++;
-		m_measurePixelTimes[nbPixels]+=timeDiffMs;
-		cout<<nbPixels<<" "
-			<<float(m_measurePixelTimes[nbPixels])
-			/ float(m_measurePixelNb[nbPixels])<<endl;
-
-		m_measuring=false;
-	}
+    if(m_measuring) {
+        timeval curTime, timeDiff;
+        gettimeofday(&curTime, NULL);
+        timersub(&curTime, &m_measureTime, &timeDiff);
+        int timeDiffMs=int(timeDiff.tv_sec)*1000000 
+            + int(timeDiff.tv_usec);
+        if(m_measurePixelNb.find(nbPixels)==m_measurePixelNb.end()) {
+            m_measurePixelTimes[nbPixels]=0;
+            m_measurePixelNb[nbPixels]=0;
+        }
+        m_measurePixelNb[nbPixels]++;
+        m_measurePixelTimes[nbPixels]+=timeDiffMs;
+        cout<<nbPixels<<" "
+            <<float(m_measurePixelTimes[nbPixels])
+            / float(m_measurePixelNb[nbPixels])<<endl;
+
+        m_measuring=false;
+    }
 }
 
 //MAIN 
 int main( int argc, char **argv ) {
-	Reveal::getInstance()->init();
-	if(argc>1) {
-		char* abs = new char[200];
-		fl_filename_absolute(abs, 200, argv[1]);
-		Reveal::getInstance()->planOpen(string(abs));	 
-	}
-	return Reveal::getInstance()->run();
+    Reveal::getInstance()->init();
+    if(argc>1) {
+        char* abs = new char[200];
+        fl_filename_absolute(abs, 200, argv[1]);
+        Reveal::getInstance()->planOpen(string(abs));	 
+    }
+    return Reveal::getInstance()->run();
 }