diff --git a/plugins/processing/simple-visualization/src/algorithms/ovpCAlgorithmLevelMeasure.cpp b/plugins/processing/simple-visualization/src/algorithms/ovpCAlgorithmLevelMeasure.cpp
index cf3807cf918e4a514932ffa452253fd7d76a2f33..3b5a1572f4b478df18caa6c4bb7c0d0925cf2b72 100644
--- a/plugins/processing/simple-visualization/src/algorithms/ovpCAlgorithmLevelMeasure.cpp
+++ b/plugins/processing/simple-visualization/src/algorithms/ovpCAlgorithmLevelMeasure.cpp
@@ -1,8 +1,8 @@
 #include "ovpCAlgorithmLevelMeasure.h"
-
-#include <string>
-#include <sstream>
 #include <iomanip>
+#include <sstream>
+#include <string>
+
 
 using namespace OpenViBE;
 using namespace Kernel;
@@ -34,10 +34,10 @@ namespace
 
 bool CAlgorithmLevelMeasure::initialize()
 {
-	ip_matrix.initialize(getInputParameter(OVP_Algorithm_LevelMeasure_InputParameterId_Matrix));
+	m_ipMatrix.initialize(getInputParameter(OVP_Algorithm_LevelMeasure_InputParameterId_Matrix));
 
-	op_mainWidget.initialize(getOutputParameter(OVP_Algorithm_LevelMeasure_OutputParameterId_MainWidget));
-	op_toolbarWidget.initialize(getOutputParameter(OVP_Algorithm_LevelMeasure_OutputParameterId_ToolbarWidget));
+	m_opMainWidget.initialize(getOutputParameter(OVP_Algorithm_LevelMeasure_OutputParameterId_MainWidget));
+	m_opToolbarWidget.initialize(getOutputParameter(OVP_Algorithm_LevelMeasure_OutputParameterId_ToolbarWidget));
 
 	m_mainWidgetInterface = gtk_builder_new(); // glade_xml_new(OpenViBE::Directories::getDataDir() + "/plugins/simple-visualization/openvibe-simple-visualization-LevelMeasure.ui", "level-measure-table", NULL);
 	gtk_builder_add_from_file(m_mainWidgetInterface, Directories::getDataDir() + "/plugins/simple-visualization/openvibe-simple-visualization-LevelMeasure.ui", nullptr);
@@ -70,10 +70,10 @@ bool CAlgorithmLevelMeasure::uninitialize()
 	g_object_unref(m_mainWidgetInterface);
 	m_mainWidgetInterface = nullptr;
 
-	op_toolbarWidget.uninitialize();
-	op_mainWidget.uninitialize();
+	m_opToolbarWidget.uninitialize();
+	m_opMainWidget.uninitialize();
 
-	ip_matrix.uninitialize();
+	m_ipMatrix.uninitialize();
 
 	return true;
 }
@@ -82,14 +82,14 @@ bool CAlgorithmLevelMeasure::process()
 {
 	if (this->isInputTriggerActive(OVP_Algorithm_LevelMeasure_InputTriggerId_Reset))
 	{
-		if (ip_matrix->getDimensionCount() != 1 && ip_matrix->getDimensionCount() != 2)
+		if (m_ipMatrix->getDimensionCount() != 1 && m_ipMatrix->getDimensionCount() != 2)
 		{
-			getLogManager() << LogLevel_ImportantWarning << "Input matrix does not have 1 or 2 dimensions (" << ip_matrix->getDimensionCount() << ")\n";
+			getLogManager() << LogLevel_ImportantWarning << "Input matrix does not have 1 or 2 dimensions (" << m_ipMatrix->getDimensionCount() << ")\n";
 			return false;
 		}
 
-		const uint32_t rowCount = (ip_matrix->getDimensionCount() == 2 ? ip_matrix->getDimensionSize(0) : 1);
-		const uint32_t columnCount = (ip_matrix->getDimensionCount() == 2 ? ip_matrix->getDimensionSize(1) : ip_matrix->getDimensionSize(0));
+		const uint32_t rowCount = (m_ipMatrix->getDimensionCount() == 2 ? m_ipMatrix->getDimensionSize(0) : 1);
+		const uint32_t columnCount = (m_ipMatrix->getDimensionCount() == 2 ? m_ipMatrix->getDimensionSize(1) : m_ipMatrix->getDimensionSize(0));
 
 		GtkTable* table = GTK_TABLE(gtk_builder_get_object(m_mainWidgetInterface, "level-measure-table"));
 		gtk_table_resize(table, rowCount, columnCount);
@@ -114,16 +114,16 @@ bool CAlgorithmLevelMeasure::process()
 			}
 		}
 
-		op_mainWidget = m_mainWindow;
-		op_toolbarWidget = m_toolbarWidget;
+		m_opMainWidget = m_mainWindow;
+		m_opToolbarWidget = m_toolbarWidget;
 	}
 
 	if (this->isInputTriggerActive(OVP_Algorithm_LevelMeasure_InputTriggerId_Refresh))
 	{
 		auto it = m_ProgressBar.begin();
-		double* inBuffer = ip_matrix->getBuffer();
+		double* inBuffer = m_ipMatrix->getBuffer();
 
-		uint32_t elementCount = ip_matrix->getBufferElementCount();
+		uint32_t elementCount = m_ipMatrix->getBufferElementCount();
 		while (elementCount--)
 		{
 			double percent = *inBuffer;
diff --git a/plugins/processing/simple-visualization/src/algorithms/ovpCAlgorithmLevelMeasure.h b/plugins/processing/simple-visualization/src/algorithms/ovpCAlgorithmLevelMeasure.h
index a8a41eef05197a9c9bfcaf295ef4d4f8f3fad7a3..e2a83143c51821871b761fe65321f8a15e178553 100644
--- a/plugins/processing/simple-visualization/src/algorithms/ovpCAlgorithmLevelMeasure.h
+++ b/plugins/processing/simple-visualization/src/algorithms/ovpCAlgorithmLevelMeasure.h
@@ -5,8 +5,9 @@
 #include <toolkit/ovtk_all.h>
 
 #include <gtk/gtk.h>
-#include <vector>
 #include <map>
+#include <vector>
+
 
 namespace OpenViBEPlugins
 {
@@ -26,9 +27,9 @@ namespace OpenViBEPlugins
 
 		protected:
 
-			OpenViBE::Kernel::TParameterHandler<OpenViBE::IMatrix*> ip_matrix;
-			OpenViBE::Kernel::TParameterHandler<GtkWidget*> op_mainWidget;
-			OpenViBE::Kernel::TParameterHandler<GtkWidget*> op_toolbarWidget;
+			OpenViBE::Kernel::TParameterHandler<OpenViBE::IMatrix*> m_ipMatrix;
+			OpenViBE::Kernel::TParameterHandler<GtkWidget*> m_opMainWidget;
+			OpenViBE::Kernel::TParameterHandler<GtkWidget*> m_opToolbarWidget;
 
 			GtkBuilder* m_mainWidgetInterface = nullptr;
 			GtkBuilder* m_toolbarWidgetInterface = nullptr;
diff --git a/plugins/processing/simple-visualization/src/box-algorithms/ovpCBoxAlgorithmErpPlot.cpp b/plugins/processing/simple-visualization/src/box-algorithms/ovpCBoxAlgorithmErpPlot.cpp
index 2c3b0b40c2f7d194660d08fa93929b8a6475f8ec..c9e39d6d3abe96d0c5409854184dadfb37ec80fa 100644
--- a/plugins/processing/simple-visualization/src/box-algorithms/ovpCBoxAlgorithmErpPlot.cpp
+++ b/plugins/processing/simple-visualization/src/box-algorithms/ovpCBoxAlgorithmErpPlot.cpp
@@ -1,5 +1,6 @@
 #include "ovpCBoxAlgorithmErpPlot.h"
 #include <boost/lexical_cast.hpp>
+#include "../utils.h"
 
 using namespace OpenViBE;
 using namespace Kernel;
@@ -8,39 +9,7 @@ using namespace OpenViBEToolkit;
 using namespace OpenViBEPlugins;
 using namespace SimpleVisualization;
 
-
-namespace
-{
-	class _AutoCast_
-	{
-	public:
-		_AutoCast_(const IBox& rBox, IConfigurationManager& rConfigurationManager, const uint32_t index)
-			: m_rConfigurationManager(rConfigurationManager)
-		{
-			rBox.getSettingValue(index, m_sSettingValue);
-			m_sSettingValue = m_rConfigurationManager.expand(m_sSettingValue);
-		}
-
-		operator GdkColor() const
-		{
-			GdkColor color;
-			int r = 0, g = 0, b = 0;
-			sscanf(m_sSettingValue.toASCIIString(), "%i,%i,%i", &r, &g, &b);
-			color.pixel = 0;
-			color.red = (r * 65535) / 100;
-			color.green = (g * 65535) / 100;
-			color.blue = (b * 65535) / 100;
-			// std::cout << r << " " << g << " " << b << "\n";
-			return color;
-		}
-
-	protected:
-		IConfigurationManager& m_rConfigurationManager;
-		CString m_sSettingValue;
-	};
-}  // namespace
-
-static void event_handler(GtkWidget* widget, const gint width, const gint height, gpointer data)
+static void EventHandler(GtkWidget* widget, const gint width, const gint height, gpointer data)
 {
 	auto* graphs = reinterpret_cast<std::list<Graph*>*>(data);
 	for (auto it = graphs->begin(); it != graphs->end(); ++it)
@@ -50,32 +19,32 @@ static void event_handler(GtkWidget* widget, const gint width, const gint height
 	}
 }
 
-static void on_configure_event(GtkWidget* widget, GdkEventConfigure* event, gpointer data)
+static void OnConfigureEvent(GtkWidget* widget, GdkEventConfigure* event, gpointer data)
 {
-	//std::cout << "on_configure_event"<<event->width<<" "<< event->height<<"on widget "<<widget->allocation.width<<" "<<widget->allocation.height << "\n";
+	//std::cout << "OnConfigureEvent"<<event->width<<" "<< event->height<<"on widget "<<widget->allocation.width<<" "<<widget->allocation.height << "\n";
 	gtk_widget_queue_draw_area(widget, 0, 0, event->width, event->height);
-	event_handler(widget, event->width, event->height, data);
+	EventHandler(widget, event->width, event->height, data);
 }
 
 /*
 static gboolean on_resize_event(GtkWidget *widget,  GdkRectangle * event, gpointer data)
 {
 		//std::cout << "on_resize_event" << "\n";
-	event_handler(widget, event->width, event->height, data);
+	EventHandler(widget, event->width, event->height, data);
 	return TRUE;
 }
 //*/
 
-static gboolean on_expose_event(GtkWidget* widget, GdkEventExpose* event, gpointer data)
+static gboolean OnExposeEvent(GtkWidget* widget, GdkEventExpose* event, gpointer data)
 {
-	//std::cout << "on_expose_event" <<event->area.width<<" "<< event->area.height<<"on widget "<<widget->allocation.width<<" "<<widget->allocation.height<< "\n";
+	//std::cout << "OnExposeEvent" <<event->area.width<<" "<< event->area.height<<"on widget "<<widget->allocation.width<<" "<<widget->allocation.height<< "\n";
 	//gtk_widget_queue_draw_area(widget,0, 0,event->area.width, event->area.height );
-	event_handler(widget, event->area.width, event->area.height, data);
+	EventHandler(widget, event->area.width, event->area.height, data);
 
 	return FALSE;
 }
 
-static void rendertext(cairo_t* cr, const char* text, const double x, const double y)
+static void RenderText(cairo_t* cr, const char* text, const double x, const double y)
 {
 	cairo_identity_matrix(cr);
 	cairo_translate(cr, x, y);						// set the origin of cairo instance 'cr' to (10,20) (i.e. this is where
@@ -165,17 +134,17 @@ void Graph::drawAxis(cairo_t* cairoContext)
 	drawLine(cairoContext, &dXo, &dYo, &dXe, &dYe);
 }
 
-void Graph::drawLine(cairo_t* cairoContext, double* Xo, double* Yo, double* Xe, double* Ye) const
+void Graph::drawLine(cairo_t* cairoContext, double* xo, double* yo, double* xe, double* ye) const
 {
 	cairo_save(cairoContext);
 
-	snapCoords(cairoContext, Xo, Yo);
-	snapCoords(cairoContext, Xe, Ye);
+	snapCoords(cairoContext, xo, yo);
+	snapCoords(cairoContext, xe, ye);
 
 	cairo_identity_matrix(cairoContext);
 	cairo_set_line_width(cairoContext, 1.0);
-	cairo_move_to(cairoContext, *Xo, *Yo);
-	cairo_line_to(cairoContext, *Xe, *Ye);
+	cairo_move_to(cairoContext, *xo, *yo);
+	cairo_line_to(cairoContext, *xe, *ye);
 	cairo_stroke(cairoContext);
 	cairo_restore(cairoContext);
 }
@@ -201,7 +170,7 @@ void Graph::drawAxisLabels(cairo_t* cairoContext)
 		cairo_user_to_device(cairoContext, &cx, &cy);
 
 		cairo_save(cairoContext);
-		rendertext(cairoContext, "No data", cx, cy);
+		RenderText(cairoContext, "No data", cx, cy);
 		cairo_restore(cairoContext);
 		return;
 	}
@@ -225,9 +194,9 @@ void Graph::drawAxisLabels(cairo_t* cairoContext)
 	for (uint32_t i = 0; i <= numSteps; ++i)
 	{
 		const double valueAtTick = startY + i * stepSize,
-					 Y = adjustValueToScale(valueAtTick);
+					 y = adjustValueToScale(valueAtTick);
 
-		cairo_move_to(cairoContext, 0, Y);
+		cairo_move_to(cairoContext, 0, y);
 
 		double cx, cy;
 		cairo_get_current_point(cairoContext, &cx, &cy);
@@ -240,16 +209,16 @@ void Graph::drawAxisLabels(cairo_t* cairoContext)
 		ss << valueAtTick;
 
 		cairo_save(cairoContext);
-		rendertext(cairoContext, ss.str().c_str(), cx, cy);
+		RenderText(cairoContext, ss.str().c_str(), cx, cy);
 		cairo_restore(cairoContext);
 	}
 
 	const uint64_t xBegin = this->m_StartTime, xEnd = this->m_EndTime;
 
 
-	for (double X = 0; X <= 1; X += 0.2)
+	for (double x = 0; x <= 1; x += 0.2)
 	{
-		cairo_move_to(cairoContext, X, 1);
+		cairo_move_to(cairoContext, x, 1);
 
 		double cx, cy;
 		cairo_get_current_point(cairoContext, &cx, &cy);
@@ -263,10 +232,10 @@ void Graph::drawAxisLabels(cairo_t* cairoContext)
 
 		std::stringstream ss;
 		ss.precision(2);
-		ss << (dataLengthSecs * X + dataStart);
+		ss << (dataLengthSecs * x + dataStart);
 
 		cairo_save(cairoContext);
-		rendertext(cairoContext, ss.str().c_str(), cx, cy);
+		RenderText(cairoContext, ss.str().c_str(), cx, cy);
 		cairo_restore(cairoContext);
 	}
 }
@@ -443,7 +412,7 @@ bool CBoxAlgorithmErpPlot::initialize()
 		if ((i % 2) == 1)
 		{
 			const uint32_t c = i / 2;
-			m_legendColors.push_back(_AutoCast_(boxContext, this->getConfigurationManager(), inputParamsStartAt + 2 * c + 0));
+			m_legendColors.push_back(CGdkcolorAutoCast(boxContext, this->getConfigurationManager(), inputParamsStartAt + 2 * c + 0));
 			m_legend.push_back(FSettingValueAutoCast(*this->getBoxAlgorithmContext(), inputParamsStartAt + 2 * c + 1));
 			m_decoders.push_back(new TStreamedMatrixDecoder<CBoxAlgorithmErpPlot>(*this, i));
 		}
@@ -467,8 +436,8 @@ bool CBoxAlgorithmErpPlot::initialize()
 	m_visualizationContext = dynamic_cast<OpenViBEVisualizationToolkit::IVisualizationContext*>(this->createPluginObject(OVP_ClassId_Plugin_VisualizationContext));
 	m_visualizationContext->setWidget(*this, m_drawWindow);
 
-	g_signal_connect(m_drawWindow, "expose-event", G_CALLBACK (on_expose_event), m_graphList);
-	g_signal_connect(m_drawWindow, "configure-event", G_CALLBACK (on_configure_event), m_graphList);
+	g_signal_connect(m_drawWindow, "expose-event", G_CALLBACK (OnExposeEvent), m_graphList);
+	g_signal_connect(m_drawWindow, "configure-event", G_CALLBACK (OnConfigureEvent), m_graphList);
 
 
 	gtk_widget_show_all(m_drawWindow);
diff --git a/plugins/processing/simple-visualization/src/box-algorithms/ovpCBoxAlgorithmErpPlot.h b/plugins/processing/simple-visualization/src/box-algorithms/ovpCBoxAlgorithmErpPlot.h
index c49407bef13fe065b659ec9800201b61bcc7250a..de3cbeed3627b34c18b4590f0fb2b5c8376c7b02 100644
--- a/plugins/processing/simple-visualization/src/box-algorithms/ovpCBoxAlgorithmErpPlot.h
+++ b/plugins/processing/simple-visualization/src/box-algorithms/ovpCBoxAlgorithmErpPlot.h
@@ -7,18 +7,26 @@
 #include <toolkit/ovtk_all.h>
 #include <visualization-toolkit/ovviz_all.h>
 
-#include <gtk/gtk.h>
-#include <gdk/gdk.h>
 #include <cairo.h>
-#include <list>
-#include <vector>
-#include <iostream>
+
+#include <cfloat>
+
 #include <cmath>
-#include <system/ovCMemory.h>
-#include <utility>
+
 #include <cstdio>
+
 #include <cstring>
-#include <cfloat>
+
+#include <gdk/gdk.h>
+
+#include <gtk/gtk.h>
+
+#include <system/ovCMemory.h>
+#include <iostream>
+#include <list>
+#include <utility>
+#include <vector>
+
 
 namespace OpenViBEPlugins
 {
@@ -60,7 +68,7 @@ namespace OpenViBEPlugins
 			void resizeAxis(gint width, gint height, size_t nrOfGraphs);
 			void draw(GtkWidget* widget);
 			void drawAxis(cairo_t* cairoContext);
-			void drawLine(cairo_t* cairoContext, double* Xo, double* Yo, double* Xe, double* Ye) const;
+			void drawLine(cairo_t* cairoContext, double* xo, double* yo, double* xe, double* ye) const;
 			void drawAxisLabels(cairo_t* cairoContext);
 			void drawCurves(cairo_t* cairoContext);
 			void drawLegend(cairo_t* cairoContext) const;
diff --git a/plugins/processing/simple-visualization/src/box-algorithms/ovpCBoxAlgorithmP300IdentifierCardVisualization.cpp b/plugins/processing/simple-visualization/src/box-algorithms/ovpCBoxAlgorithmP300IdentifierCardVisualization.cpp
index 68ff781ce85386460956e7ddbf620d71a1cf2132..22f560b286b875be3cc4ad126820244dba868c8c 100755
--- a/plugins/processing/simple-visualization/src/box-algorithms/ovpCBoxAlgorithmP300IdentifierCardVisualization.cpp
+++ b/plugins/processing/simple-visualization/src/box-algorithms/ovpCBoxAlgorithmP300IdentifierCardVisualization.cpp
@@ -1,13 +1,12 @@
 #include "ovpCBoxAlgorithmP300IdentifierCardVisualization.h"
-
-#include <system/ovCMemory.h>
-
-#include <list>
-#include <vector>
-#include <string>
 #include <algorithm>
-#include <iostream>
 #include <iomanip>
+#include <iostream>
+#include <list>
+#include <string>
+#include <vector>
+#include <system/ovCMemory.h>
+#include "../utils.h"
 
 using namespace OpenViBE;
 using namespace Kernel;
@@ -16,37 +15,6 @@ using namespace Plugins;
 using namespace OpenViBEPlugins;
 using namespace SimpleVisualization;
 
-namespace
-{
-	class _AutoCast_
-	{
-	public:
-		_AutoCast_(const IBox& rBox, IConfigurationManager& rConfigurationManager, const uint32_t index)
-			: m_rConfigurationManager(rConfigurationManager)
-		{
-			rBox.getSettingValue(index, m_sSettingValue);
-			m_sSettingValue = m_rConfigurationManager.expand(m_sSettingValue);
-		}
-
-		operator GdkColor() const
-		{
-			GdkColor color;
-			int r = 0, g = 0, b = 0;
-			sscanf(m_sSettingValue.toASCIIString(), "%i,%i,%i", &r, &g, &b);
-			color.pixel = 0;
-			color.red = (r * 65535) / 100;
-			color.green = (g * 65535) / 100;
-			color.blue = (b * 65535) / 100;
-			// std::cout << r << " " << g << " " << b << "\n";
-			return color;
-		}
-
-	protected:
-		IConfigurationManager& m_rConfigurationManager;
-		CString m_sSettingValue;
-	};
-}  // namespace
-
 bool CBoxAlgorithmP300IdentifierCardVisualization::initialize()
 {
 	const IBox& boxContext = this->getStaticBoxContext();
@@ -55,9 +23,9 @@ bool CBoxAlgorithmP300IdentifierCardVisualization::initialize()
 
 	//get value of settings given in the configuration box
 	m_interfaceFilename = FSettingValueAutoCast(*this->getBoxAlgorithmContext(), 0);
-	m_backgroundColor = _AutoCast_(getStaticBoxContext(), getConfigurationManager(), 1);
-	m_targetBackgroundColor = _AutoCast_(getStaticBoxContext(), getConfigurationManager(), 2);
-	m_selectedBackgroundColor = _AutoCast_(getStaticBoxContext(), getConfigurationManager(), 3);
+	m_backgroundColor = CGdkcolorAutoCast(getStaticBoxContext(), getConfigurationManager(), 1);
+	m_targetBackgroundColor = CGdkcolorAutoCast(getStaticBoxContext(), getConfigurationManager(), 2);
+	m_selectedBackgroundColor = CGdkcolorAutoCast(getStaticBoxContext(), getConfigurationManager(), 3);
 	m_cardStimulationBase = FSettingValueAutoCast(*this->getBoxAlgorithmContext(), 4);
 
 	// ----------------------------------------------------------------------------------------------------------------------------------------------------------
@@ -388,7 +356,7 @@ bool CBoxAlgorithmP300IdentifierCardVisualization::process()
 	// --- Selection stimulations
 
 	//TParameterHandler<const IMemoryBuffer*> ip_pSelectionMemoryBuffer(m_cardSelectionStimulationDecoder->getInputParameter(OVP_GD_Algorithm_StimulationStreamDecoder_InputParameterId_MemoryBufferToDecode));
-	const TParameterHandler<IStimulationSet*> op_pSelectionStimulationSet(m_cardSelectionStimulationDecoder->getOutputParameter(OVP_GD_Algorithm_StimulationStreamDecoder_OutputParameterId_StimulationSet));
+	const TParameterHandler<IStimulationSet*> selectionStimulationSet(m_cardSelectionStimulationDecoder->getOutputParameter(OVP_GD_Algorithm_StimulationStreamDecoder_OutputParameterId_StimulationSet));
 
 	for (uint32_t i = 0; i < boxContext.getInputChunkCount(2); ++i)
 	{
@@ -401,7 +369,7 @@ bool CBoxAlgorithmP300IdentifierCardVisualization::process()
 
 			if (m_cardSelectionStimulationDecoder->isOutputTriggerActive(OVP_GD_Algorithm_StimulationStreamDecoder_OutputTriggerId_ReceivedBuffer))
 			{
-				IStimulationSet* stimulationSet = op_pSelectionStimulationSet;
+				IStimulationSet* stimulationSet = selectionStimulationSet;
 				for (uint64_t j = 0; j < stimulationSet->getStimulationCount(); ++j)
 				{
 					uint64_t stimulationIdentifier = stimulationSet->getStimulationIdentifier(j);
@@ -450,9 +418,9 @@ void CBoxAlgorithmP300IdentifierCardVisualization::cacheBuildFromTable(GtkTable*
 			if (tableChild->top_attach != 0)
 			{
 				int idx = 0;
-				for (unsigned long i = tableChild->top_attach; i < tableChild->bottom_attach; ++i)
+				for (size_t i = tableChild->top_attach; i < tableChild->bottom_attach; ++i)
 				{
-					for (unsigned long j = tableChild->left_attach; j < tableChild->right_attach; ++j)
+					for (size_t j = tableChild->left_attach; j < tableChild->right_attach; ++j)
 					{
 						idx++;
 						SWidgetStyle widgetStyle;
@@ -468,15 +436,12 @@ void CBoxAlgorithmP300IdentifierCardVisualization::cacheBuildFromTable(GtkTable*
 	}
 }
 
-void CBoxAlgorithmP300IdentifierCardVisualization::cacheForEach(_cache_callback_ fpCallback, void* data)
+void CBoxAlgorithmP300IdentifierCardVisualization::cacheForEach(cache_callback fpCallback, void* data)
 {
-	for (auto& cache : m_caches)
-	{
-		(this->*fpCallback)(cache, data);
-	}
+	for (auto& cache : m_caches) { (this->*fpCallback)(cache, data); }
 }
 
-void CBoxAlgorithmP300IdentifierCardVisualization::cacheForEachIf(const int iCard, _cache_callback_ fpIfCallback, _cache_callback_ fpElseCallback, void* pIfUserData, void* pElseUserData)
+void CBoxAlgorithmP300IdentifierCardVisualization::cacheForEachIf(const int iCard, cache_callback fpIfCallback, cache_callback fpElseCallback, void* pIfUserData, void* pElseUserData)
 {
 	for (auto& cache : m_caches)
 	{
@@ -485,32 +450,32 @@ void CBoxAlgorithmP300IdentifierCardVisualization::cacheForEachIf(const int iCar
 	}
 }
 
-void CBoxAlgorithmP300IdentifierCardVisualization::cacheChangeNullCB(SWidgetStyle& /*rWidgetStyle*/, void* /*data*/) {}
+void CBoxAlgorithmP300IdentifierCardVisualization::cacheChangeNullCB(SWidgetStyle& /*widgetStyle*/, void* /*data*/) {}
 
-void CBoxAlgorithmP300IdentifierCardVisualization::cacheChangeImageCB(SWidgetStyle& rWidgetStyle, void* data)
+void CBoxAlgorithmP300IdentifierCardVisualization::cacheChangeImageCB(SWidgetStyle& widgetStyle, void* data)
 {
-	GtkContainer* m_pContainer = GTK_CONTAINER(rWidgetStyle.pWidget);
+	GtkContainer* container = GTK_CONTAINER(widgetStyle.pWidget);
 	auto* image = static_cast<GtkWidget*>(data);
 
-	if (rWidgetStyle.pImage != image)
+	if (widgetStyle.pImage != image)
 	{
-		if (rWidgetStyle.pImage)
+		if (widgetStyle.pImage)
 		{
-			gtk_container_remove(m_pContainer, rWidgetStyle.pImage);
+			gtk_container_remove(container, widgetStyle.pImage);
 		}
-		gtk_container_add(m_pContainer, image);
-		rWidgetStyle.pImage = image;
+		gtk_container_add(container, image);
+		widgetStyle.pImage = image;
 	}
 }
 
-void CBoxAlgorithmP300IdentifierCardVisualization::cacheChangeBackgroundCB(SWidgetStyle& rWidgetStyle, void* data)
+void CBoxAlgorithmP300IdentifierCardVisualization::cacheChangeBackgroundCB(SWidgetStyle& widgetStyle, void* data)
 {
 	GdkColor oColor = *static_cast<GdkColor*>(data);
-	if (!System::Memory::compare(&rWidgetStyle.oBackgroundColor, &oColor, sizeof(GdkColor)))
+	if (!System::Memory::compare(&widgetStyle.oBackgroundColor, &oColor, sizeof(GdkColor)))
 	{
-		gtk_widget_modify_bg(rWidgetStyle.pParent, GTK_STATE_NORMAL, &oColor);
-		gtk_widget_modify_bg(rWidgetStyle.pWidget, GTK_STATE_NORMAL, &oColor);
-		gtk_widget_modify_bg(rWidgetStyle.pImage, GTK_STATE_NORMAL, &oColor);
-		rWidgetStyle.oBackgroundColor = oColor;
+		gtk_widget_modify_bg(widgetStyle.pParent, GTK_STATE_NORMAL, &oColor);
+		gtk_widget_modify_bg(widgetStyle.pWidget, GTK_STATE_NORMAL, &oColor);
+		gtk_widget_modify_bg(widgetStyle.pImage, GTK_STATE_NORMAL, &oColor);
+		widgetStyle.oBackgroundColor = oColor;
 	}
 }
diff --git a/plugins/processing/simple-visualization/src/box-algorithms/ovpCBoxAlgorithmP300IdentifierCardVisualization.h b/plugins/processing/simple-visualization/src/box-algorithms/ovpCBoxAlgorithmP300IdentifierCardVisualization.h
index 83cfd91bcaaca5685c0315f9e14e267fbec25e61..d6e3dc7f4006532a7c1e72b24ac10e3a9c4e4496 100755
--- a/plugins/processing/simple-visualization/src/box-algorithms/ovpCBoxAlgorithmP300IdentifierCardVisualization.h
+++ b/plugins/processing/simple-visualization/src/box-algorithms/ovpCBoxAlgorithmP300IdentifierCardVisualization.h
@@ -7,6 +7,7 @@
 
 #include <gtk/gtk.h>
 #include <map>
+#include "../utils.h"
 
 
 namespace OpenViBEPlugins
@@ -37,14 +38,14 @@ namespace OpenViBEPlugins
 				GtkWidget* pImage;
 			};
 
-			typedef void (CBoxAlgorithmP300IdentifierCardVisualization::*_cache_callback_)(SWidgetStyle& rWidgetStyle, void* data);
+			typedef void (CBoxAlgorithmP300IdentifierCardVisualization::*cache_callback)(SWidgetStyle& rWidgetStyle, void* data);
 
 			void cacheBuildFromTable(GtkTable* pTable);
-			void cacheForEach(_cache_callback_ fpCallback, void* data);
-			void cacheForEachIf(int iCard, _cache_callback_ fpIfCallback, _cache_callback_ fpElseCallback, void* pIfUserData, void* pElseUserData);
-			void cacheChangeNullCB(SWidgetStyle& rWidgetStyle, void* data);
-			void cacheChangeImageCB(SWidgetStyle& rWidgetStyle, void* data);
-			void cacheChangeBackgroundCB(SWidgetStyle& rWidgetStyle, void* data);
+			void cacheForEach(cache_callback fpCallback, void* data);
+			void cacheForEachIf(int iCard, cache_callback fpIfCallback, cache_callback fpElseCallback, void* pIfUserData, void* pElseUserData);
+			void cacheChangeNullCB(SWidgetStyle& widgetStyle, void* data);
+			void cacheChangeImageCB(SWidgetStyle& widgetStyle, void* data);
+			void cacheChangeBackgroundCB(SWidgetStyle& widgetStyle, void* data);
 
 		protected:
 
@@ -72,9 +73,9 @@ namespace OpenViBEPlugins
 			GtkTable* m_table = nullptr;
 			GtkLabel* m_result = nullptr;
 			//GtkLabel* m_target = nullptr;
-			GdkColor m_backgroundColor;
-			GdkColor m_targetBackgroundColor;
-			GdkColor m_selectedBackgroundColor;
+			GdkColor m_backgroundColor = InitGDKColor(0, 0, 0, 0);
+			GdkColor m_targetBackgroundColor = InitGDKColor(0, 6554, 26214, 6554);
+			GdkColor m_selectedBackgroundColor = InitGDKColor(0, 45875, 13107, 13107);
 			GtkLabel* m_targetLabel = nullptr;
 			GtkLabel* m_selectedLabel = nullptr;
 			uint64_t m_cardCount = 0;
diff --git a/plugins/processing/simple-visualization/src/box-algorithms/ovpCBoxAlgorithmP300MagicCardVisualization.cpp b/plugins/processing/simple-visualization/src/box-algorithms/ovpCBoxAlgorithmP300MagicCardVisualization.cpp
index 4fc70d6fdb1c4f7fe3a3940d29639fbf00fba1cf..b421c438ff82794f27a11a467bb6d02a44be5e48 100755
--- a/plugins/processing/simple-visualization/src/box-algorithms/ovpCBoxAlgorithmP300MagicCardVisualization.cpp
+++ b/plugins/processing/simple-visualization/src/box-algorithms/ovpCBoxAlgorithmP300MagicCardVisualization.cpp
@@ -1,12 +1,13 @@
 #include "ovpCBoxAlgorithmP300MagicCardVisualization.h"
 
-#include <system/ovCMemory.h>
-
+#include <algorithm>
 #include <list>
-#include <vector>
 #include <string>
-#include <algorithm>
+#include <vector>
+#include <system/ovCMemory.h>
 #include <tcptagging/IStimulusSender.h>
+#include "../utils.h"
+
 
 using namespace OpenViBE;
 using namespace Kernel;
@@ -15,37 +16,6 @@ using namespace Plugins;
 using namespace OpenViBEPlugins;
 using namespace SimpleVisualization;
 
-namespace
-{
-	class _AutoCast_
-	{
-	public:
-		_AutoCast_(const IBox& rBox, IConfigurationManager& rConfigurationManager, const uint32_t index)
-			: m_rConfigurationManager(rConfigurationManager)
-		{
-			rBox.getSettingValue(index, m_sSettingValue);
-			m_sSettingValue = m_rConfigurationManager.expand(m_sSettingValue);
-		}
-
-		operator GdkColor() const
-		{
-			GdkColor color;
-			int r = 0, g = 0, b = 0;
-			sscanf(m_sSettingValue.toASCIIString(), "%i,%i,%i", &r, &g, &b);
-			color.pixel = 0;
-			color.red = (r * 65535) / 100;
-			color.green = (g * 65535) / 100;
-			color.blue = (b * 65535) / 100;
-			// std::cout << r << " " << g << " " << b << "\n";
-			return color;
-		}
-
-	protected:
-		IConfigurationManager& m_rConfigurationManager;
-		CString m_sSettingValue;
-	};
-}  // namespace
-
 // This callback flushes all accumulated stimulations to the TCP Tagging 
 // after the rendering has completed.
 static gboolean FlushCB(gpointer data)
@@ -62,9 +32,9 @@ bool CBoxAlgorithmP300MagicCardVisualization::initialize()
 	m_toolbarWidgetInterface = nullptr;
 
 	m_interfaceFilename = FSettingValueAutoCast(*this->getBoxAlgorithmContext(), 0);
-	m_backgroundColor = _AutoCast_(getStaticBoxContext(), getConfigurationManager(), 1);
-	m_targetBackgroundColor = _AutoCast_(getStaticBoxContext(), getConfigurationManager(), 2);
-	m_selectedBackgroundColor = _AutoCast_(getStaticBoxContext(), getConfigurationManager(), 3);
+	m_backgroundColor = CGdkcolorAutoCast(getStaticBoxContext(), getConfigurationManager(), 1);
+	m_targetBackgroundColor = CGdkcolorAutoCast(getStaticBoxContext(), getConfigurationManager(), 2);
+	m_selectedBackgroundColor = CGdkcolorAutoCast(getStaticBoxContext(), getConfigurationManager(), 3);
 	m_cardStimulationBase = FSettingValueAutoCast(*this->getBoxAlgorithmContext(), 4);
 	CString tcpTaggingHostAddress = FSettingValueAutoCast(*this->getBoxAlgorithmContext(), 5);
 	CString tcpTaggingHostPort = FSettingValueAutoCast(*this->getBoxAlgorithmContext(), 6);
@@ -373,7 +343,7 @@ bool CBoxAlgorithmP300MagicCardVisualization::process()
 	// --- Selection stimulations
 
 	//TParameterHandler<const IMemoryBuffer*> ip_pSelectionMemoryBuffer(m_cardSelectionStimulationDecoder->getInputParameter(OVP_GD_Algorithm_StimulationStreamDecoder_InputParameterId_MemoryBufferToDecode));
-	const TParameterHandler<IStimulationSet*> op_pSelectionStimulationSet(m_cardSelectionStimulationDecoder->getOutputParameter(OVP_GD_Algorithm_StimulationStreamDecoder_OutputParameterId_StimulationSet));
+	const TParameterHandler<IStimulationSet*> selectionStimulationSet(m_cardSelectionStimulationDecoder->getOutputParameter(OVP_GD_Algorithm_StimulationStreamDecoder_OutputParameterId_StimulationSet));
 
 	for (uint32_t i = 0; i < boxContext.getInputChunkCount(2); ++i)
 	{
@@ -386,7 +356,7 @@ bool CBoxAlgorithmP300MagicCardVisualization::process()
 
 			if (m_cardSelectionStimulationDecoder->isOutputTriggerActive(OVP_GD_Algorithm_StimulationStreamDecoder_OutputTriggerId_ReceivedBuffer))
 			{
-				IStimulationSet* stimulationSet = op_pSelectionStimulationSet;
+				IStimulationSet* stimulationSet = selectionStimulationSet;
 				for (uint64_t j = 0; j < stimulationSet->getStimulationCount(); ++j)
 				{
 					uint64_t stimulationIdentifier = stimulationSet->getStimulationIdentifier(j);
@@ -436,9 +406,9 @@ void CBoxAlgorithmP300MagicCardVisualization::cacheBuildFromTable(GtkTable* pTab
 		{
 			tableChild = static_cast<GtkTableChild*>(list->data);
 
-			for (unsigned long i = tableChild->top_attach; i < tableChild->bottom_attach; ++i)
+			for (size_t i = tableChild->top_attach; i < tableChild->bottom_attach; ++i)
 			{
-				for (unsigned long j = tableChild->left_attach; j < tableChild->right_attach; ++j)
+				for (size_t j = tableChild->left_attach; j < tableChild->right_attach; ++j)
 				{
 					const int idx = int(i * m_tableColumnCount + j);
 					SWidgetStyle& widgetStyle = m_caches[idx];
@@ -452,12 +422,12 @@ void CBoxAlgorithmP300MagicCardVisualization::cacheBuildFromTable(GtkTable* pTab
 	}
 }
 
-void CBoxAlgorithmP300MagicCardVisualization::cacheForEach(_cache_callback_ fpCallback, void* data)
+void CBoxAlgorithmP300MagicCardVisualization::cacheForEach(cache_callback fpCallback, void* data)
 {
 	for (auto& cache : m_caches) { (this->*fpCallback)(cache.second, data); }
 }
 
-void CBoxAlgorithmP300MagicCardVisualization::cacheForEachIf(const int card, _cache_callback_ fpIfCallback, _cache_callback_ fpElseCallback, void* pIfUserData, void* pElseUserData)
+void CBoxAlgorithmP300MagicCardVisualization::cacheForEachIf(const int card, cache_callback fpIfCallback, cache_callback fpElseCallback, void* pIfUserData, void* pElseUserData)
 {
 	for (auto& cache : m_caches)
 	{
@@ -466,32 +436,32 @@ void CBoxAlgorithmP300MagicCardVisualization::cacheForEachIf(const int card, _ca
 	}
 }
 
-void CBoxAlgorithmP300MagicCardVisualization::cacheChangeNullCB(SWidgetStyle& /*rWidgetStyle*/, void* /*data*/) {}
+void CBoxAlgorithmP300MagicCardVisualization::cacheChangeNullCB(SWidgetStyle& /*widgetStyle*/, void* /*data*/) {}
 
-void CBoxAlgorithmP300MagicCardVisualization::cacheChangeImageCB(SWidgetStyle& rWidgetStyle, void* data)
+void CBoxAlgorithmP300MagicCardVisualization::cacheChangeImageCB(SWidgetStyle& widgetStyle, void* data)
 {
-	GtkContainer* container = GTK_CONTAINER(rWidgetStyle.pWidget);
+	GtkContainer* container = GTK_CONTAINER(widgetStyle.pWidget);
 	auto* pvImage = static_cast<std::vector<GtkWidget*> *>(data);
 
-	GtkWidget* image = (*pvImage)[rWidgetStyle.iIndex];
+	GtkWidget* image = (*pvImage)[widgetStyle.iIndex];
 
-	if (rWidgetStyle.pImage != image)
+	if (widgetStyle.pImage != image)
 	{
-		if (rWidgetStyle.pImage) { gtk_container_remove(container, rWidgetStyle.pImage); }
+		if (widgetStyle.pImage) { gtk_container_remove(container, widgetStyle.pImage); }
 		gtk_container_add(container, image);
-		rWidgetStyle.pImage = image;
+		widgetStyle.pImage = image;
 	}
 }
 
-void CBoxAlgorithmP300MagicCardVisualization::cacheChangeBackgroundCB(SWidgetStyle& rWidgetStyle, void* data)
+void CBoxAlgorithmP300MagicCardVisualization::cacheChangeBackgroundCB(SWidgetStyle& widgetStyle, void* data)
 {
 	GdkColor color = *static_cast<GdkColor*>(data);
-	if (!System::Memory::compare(&rWidgetStyle.oBackgroundColor, &color, sizeof(GdkColor)))
+	if (!System::Memory::compare(&widgetStyle.oBackgroundColor, &color, sizeof(GdkColor)))
 	{
-		gtk_widget_modify_bg(rWidgetStyle.pParent, GTK_STATE_NORMAL, &color);
-		gtk_widget_modify_bg(rWidgetStyle.pWidget, GTK_STATE_NORMAL, &color);
-		gtk_widget_modify_bg(rWidgetStyle.pImage, GTK_STATE_NORMAL, &color);
-		rWidgetStyle.oBackgroundColor = color;
+		gtk_widget_modify_bg(widgetStyle.pParent, GTK_STATE_NORMAL, &color);
+		gtk_widget_modify_bg(widgetStyle.pWidget, GTK_STATE_NORMAL, &color);
+		gtk_widget_modify_bg(widgetStyle.pImage, GTK_STATE_NORMAL, &color);
+		widgetStyle.oBackgroundColor = color;
 	}
 }
 
diff --git a/plugins/processing/simple-visualization/src/box-algorithms/ovpCBoxAlgorithmP300MagicCardVisualization.h b/plugins/processing/simple-visualization/src/box-algorithms/ovpCBoxAlgorithmP300MagicCardVisualization.h
index b112d197ef80c57ee4880035b2d2f6cc0d251724..109462f80bef0aee92f6c5484e2b5afcf55ecc89 100755
--- a/plugins/processing/simple-visualization/src/box-algorithms/ovpCBoxAlgorithmP300MagicCardVisualization.h
+++ b/plugins/processing/simple-visualization/src/box-algorithms/ovpCBoxAlgorithmP300MagicCardVisualization.h
@@ -7,11 +7,12 @@
 
 #include <gtk/gtk.h>
 #include <map>
+#include "../utils.h"
 
 namespace TCPTagging
 {
 	class IStimulusSender;	// fwd declare
-}
+}  // namespace TCPTagging
 
 namespace OpenViBEPlugins
 {
@@ -42,14 +43,14 @@ namespace OpenViBEPlugins
 				GtkWidget* pImage;
 			};
 
-			typedef void (CBoxAlgorithmP300MagicCardVisualization::*_cache_callback_)(SWidgetStyle& rWidgetStyle, void* data);
+			typedef void (CBoxAlgorithmP300MagicCardVisualization::*cache_callback)(SWidgetStyle& rWidgetStyle, void* data);
 
 			void cacheBuildFromTable(GtkTable* pTable);
-			void cacheForEach(_cache_callback_ fpCallback, void* data);
-			void cacheForEachIf(int card, _cache_callback_ fpIfCallback, _cache_callback_ fpElseCallback, void* pIfUserData, void* pElseUserData);
-			void cacheChangeNullCB(SWidgetStyle& rWidgetStyle, void* data);
-			void cacheChangeImageCB(SWidgetStyle& rWidgetStyle, void* data);
-			void cacheChangeBackgroundCB(SWidgetStyle& rWidgetStyle, void* data);
+			void cacheForEach(cache_callback fpCallback, void* data);
+			void cacheForEachIf(int card, cache_callback fpIfCallback, cache_callback fpElseCallback, void* pIfUserData, void* pElseUserData);
+			void cacheChangeNullCB(SWidgetStyle& widgetStyle, void* data);
+			void cacheChangeImageCB(SWidgetStyle& widgetStyle, void* data);
+			void cacheChangeBackgroundCB(SWidgetStyle& widgetStyle, void* data);
 
 		protected:
 
@@ -77,9 +78,9 @@ namespace OpenViBEPlugins
 			GtkTable* m_table = nullptr;
 			GtkLabel* m_result = nullptr;
 			//GtkLabel* m_target = nullptr;
-			GdkColor m_backgroundColor;
-			GdkColor m_targetBackgroundColor;
-			GdkColor m_selectedBackgroundColor;
+			GdkColor m_backgroundColor = InitGDKColor(0, 58982, 58982, 58982);
+			GdkColor m_targetBackgroundColor = InitGDKColor(0, 6554, 26214, 6554);
+			GdkColor m_selectedBackgroundColor = InitGDKColor(0, 45875, 13107, 13107);
 			uint64_t m_tableRowCount = 0;
 			uint64_t m_tableColumnCount = 0;
 			uint64_t m_cardCount = 0;
@@ -91,7 +92,7 @@ namespace OpenViBEPlugins
 
 			bool m_tableInitialized = false;
 
-			std::map<unsigned long, SWidgetStyle> m_caches;
+			std::map<size_t, SWidgetStyle> m_caches;
 
 			OpenViBEVisualizationToolkit::IVisualizationContext* m_visualizationContext = nullptr;
 
diff --git a/plugins/processing/simple-visualization/src/box-algorithms/ovpCBoxAlgorithmP300SpellerVisualization.cpp b/plugins/processing/simple-visualization/src/box-algorithms/ovpCBoxAlgorithmP300SpellerVisualization.cpp
index d31c38ac4c15b281073486e847ba584b08a6da03..30ffc4cada79cff5a1aa122ee473cd7ea96957f2 100755
--- a/plugins/processing/simple-visualization/src/box-algorithms/ovpCBoxAlgorithmP300SpellerVisualization.cpp
+++ b/plugins/processing/simple-visualization/src/box-algorithms/ovpCBoxAlgorithmP300SpellerVisualization.cpp
@@ -3,13 +3,13 @@
 #include "ovpCBoxAlgorithmP300SpellerVisualization.h"
 
 #include <system/ovCMemory.h>
+#include <tcptagging/IStimulusSender.h>
 
+#include <algorithm>
 #include <list>
-#include <vector>
 #include <string>
-#include <algorithm>
-
-#include <tcptagging/IStimulusSender.h>
+#include <vector>
+#include "../utils.h"
 
 using namespace OpenViBE;
 using namespace Kernel;
@@ -18,41 +18,11 @@ using namespace Plugins;
 using namespace OpenViBEPlugins;
 using namespace SimpleVisualization;
 
-namespace
+static void ToggleButtonShowHideCB(GtkToggleToolButton* pToggleButton, gpointer data)
 {
-	class _AutoCast_
-	{
-	public:
-		_AutoCast_(const IBox& rBox, IConfigurationManager& rConfigurationManager, const uint32_t index)
-			: m_rConfigurationManager(rConfigurationManager)
-		{
-			rBox.getSettingValue(index, m_sSettingValue);
-			m_sSettingValue = m_rConfigurationManager.expand(m_sSettingValue);
-		}
-
-		operator GdkColor() const
-		{
-			GdkColor color;
-			int r = 0, g = 0, b = 0;
-			sscanf(m_sSettingValue.toASCIIString(), "%i,%i,%i", &r, &g, &b);
-			color.pixel = 0;
-			color.red = (r * 65535) / 100;
-			color.green = (g * 65535) / 100;
-			color.blue = (b * 65535) / 100;
-			return color;
-		}
-
-	protected:
-		IConfigurationManager& m_rConfigurationManager;
-		CString m_sSettingValue;
-	};
-
-	void ToggleButtonShowHideCB(GtkToggleToolButton* pToggleButton, gpointer data)
-	{
-		if (gtk_toggle_tool_button_get_active(pToggleButton)) { gtk_widget_show(GTK_WIDGET(data)); }
-		else { gtk_widget_hide(GTK_WIDGET(data)); }
-	}
-}  // namespace
+	if (gtk_toggle_tool_button_get_active(pToggleButton)) { gtk_widget_show(GTK_WIDGET(data)); }
+	else { gtk_widget_hide(GTK_WIDGET(data)); }
+}
 
 // This callback flushes all accumulated stimulations to the TCP Tagging 
 // after the rendering has completed.
@@ -80,17 +50,17 @@ bool CBoxAlgorithmP300SpellerVisualization::initialize()
 	m_rowStimulationBase = FSettingValueAutoCast(*this->getBoxAlgorithmContext(), 1);
 	m_columnStimulationBase = FSettingValueAutoCast(*this->getBoxAlgorithmContext(), 2);
 
-	m_flashBackgroundColor = _AutoCast_(boxContext, this->getConfigurationManager(), 3);
-	m_flashForegroundColor = _AutoCast_(boxContext, this->getConfigurationManager(), 4);
+	m_flashBackgroundColor = CGdkcolorAutoCast(boxContext, this->getConfigurationManager(), 3);
+	m_flashForegroundColor = CGdkcolorAutoCast(boxContext, this->getConfigurationManager(), 4);
 	m_flashFontSize = FSettingValueAutoCast(*this->getBoxAlgorithmContext(), 5);
-	m_noFlashBackgroundColor = _AutoCast_(boxContext, this->getConfigurationManager(), 6);
-	m_noFlashForegroundColor = _AutoCast_(boxContext, this->getConfigurationManager(), 7);
+	m_noFlashBackgroundColor = CGdkcolorAutoCast(boxContext, this->getConfigurationManager(), 6);
+	m_noFlashForegroundColor = CGdkcolorAutoCast(boxContext, this->getConfigurationManager(), 7);
 	m_noFlashFontSize = FSettingValueAutoCast(*this->getBoxAlgorithmContext(), 8);
-	m_targetBackgroundColor = _AutoCast_(boxContext, this->getConfigurationManager(), 9);
-	m_targetForegroundColor = _AutoCast_(boxContext, this->getConfigurationManager(), 10);
+	m_targetBackgroundColor = CGdkcolorAutoCast(boxContext, this->getConfigurationManager(), 9);
+	m_targetForegroundColor = CGdkcolorAutoCast(boxContext, this->getConfigurationManager(), 10);
 	m_targetFontSize = FSettingValueAutoCast(*this->getBoxAlgorithmContext(), 11);
-	m_selectedBackgroundColor = _AutoCast_(boxContext, this->getConfigurationManager(), 12);
-	m_selectedForegroundColor = _AutoCast_(boxContext, this->getConfigurationManager(), 13);
+	m_selectedBackgroundColor = CGdkcolorAutoCast(boxContext, this->getConfigurationManager(), 12);
+	m_selectedForegroundColor = CGdkcolorAutoCast(boxContext, this->getConfigurationManager(), 13);
 	m_selectedFontSize = FSettingValueAutoCast(*this->getBoxAlgorithmContext(), 14);
 
 	// ----------------------------------------------------------------------------------------------------------------------------------------------------------
@@ -516,7 +486,7 @@ bool CBoxAlgorithmP300SpellerVisualization::process()
 	{
 		IAlgorithmProxy* selectionStimulationDecoder = (k == 2 ? m_rowSelectionStimulationDecoder : m_columnSelectionStimulationDecoder);
 		//TParameterHandler<const IMemoryBuffer*> ip_pSelectionMemoryBuffer(l_pSelectionStimulationDecoder->getInputParameter(OVP_GD_Algorithm_StimulationStreamDecoder_InputParameterId_MemoryBufferToDecode));
-		TParameterHandler<IStimulationSet*> op_pSelectionStimulationSet(selectionStimulationDecoder->getOutputParameter(OVP_GD_Algorithm_StimulationStreamDecoder_OutputParameterId_StimulationSet));
+		TParameterHandler<IStimulationSet*> selectionStimulationSet(selectionStimulationDecoder->getOutputParameter(OVP_GD_Algorithm_StimulationStreamDecoder_OutputParameterId_StimulationSet));
 
 		for (uint32_t i = 0; i < boxContext.getInputChunkCount(k); ++i)
 		{
@@ -529,7 +499,7 @@ bool CBoxAlgorithmP300SpellerVisualization::process()
 
 				if (selectionStimulationDecoder->isOutputTriggerActive(OVP_GD_Algorithm_StimulationStreamDecoder_OutputTriggerId_ReceivedBuffer))
 				{
-					IStimulationSet* stimulationSet = op_pSelectionStimulationSet;
+					IStimulationSet* stimulationSet = selectionStimulationSet;
 					for (uint64_t j = 0; j < stimulationSet->getStimulationCount(); ++j)
 					{
 						uint64_t stimulationIdentifier = stimulationSet->getStimulationIdentifier(j);
@@ -634,20 +604,16 @@ void CBoxAlgorithmP300SpellerVisualization::cacheBuildFromTable(GtkTable* pTable
 {
 	if (pTable)
 	{
-		GdkColor white;
-		white.red = 65535;
-		white.green = 65535;
-		white.blue = 65535;
-		white.pixel = 65535;
+		const GdkColor white = InitGDKColor(65535, 65535, 65535, 65535);
 
 		GtkTableChild* tableChild = nullptr;
 		for (GList* list = pTable->children; list; list = list->next)
 		{
 			tableChild = static_cast<GtkTableChild*>(list->data);
 
-			for (unsigned long i = tableChild->top_attach; i < tableChild->bottom_attach; ++i)
+			for (size_t i = tableChild->top_attach; i < tableChild->bottom_attach; ++i)
 			{
-				for (unsigned long j = tableChild->left_attach; j < tableChild->right_attach; ++j)
+				for (size_t j = tableChild->left_attach; j < tableChild->right_attach; ++j)
 				{
 					SWidgetStyle& widgetStyle = m_cache[i][j];
 					widgetStyle.pWidget = tableChild->widget;
@@ -661,7 +627,7 @@ void CBoxAlgorithmP300SpellerVisualization::cacheBuildFromTable(GtkTable* pTable
 	}
 }
 
-void CBoxAlgorithmP300SpellerVisualization::cacheForEach(_cache_callback_ fpCallback, void* data)
+void CBoxAlgorithmP300SpellerVisualization::cacheForEach(cache_callback fpCallback, void* data)
 {
 	for (auto i = m_cache.begin(); i != m_cache.end(); ++i)
 	{
@@ -672,7 +638,7 @@ void CBoxAlgorithmP300SpellerVisualization::cacheForEach(_cache_callback_ fpCall
 	}
 }
 
-void CBoxAlgorithmP300SpellerVisualization::cacheForEachIf(const int iLine, const int iColumn, _cache_callback_ fpIfCallback, _cache_callback_ fpElseCallback, 
+void CBoxAlgorithmP300SpellerVisualization::cacheForEachIf(const int iLine, const int iColumn, cache_callback fpIfCallback, cache_callback fpElseCallback, 
 														   void* pIfUserData, void* pElseUserData)
 {
 	for (auto i = m_cache.begin(); i != m_cache.end(); ++i)
@@ -685,8 +651,8 @@ void CBoxAlgorithmP300SpellerVisualization::cacheForEachIf(const int iLine, cons
 			bool inColumn = false;
 			bool first;
 
-			if (line && static_cast<unsigned long>(iLine) == i->first) { inLine = true; }
-			if (column && static_cast<unsigned long>(iColumn) == j->first) { inColumn = true; }
+			if (line && static_cast<size_t>(iLine) == i->first) { inLine = true; }
+			if (column && static_cast<size_t>(iColumn) == j->first) { inColumn = true; }
 
 			if (line && column) { first = inLine && inColumn; }
 			else { first = inLine || inColumn; }
diff --git a/plugins/processing/simple-visualization/src/box-algorithms/ovpCBoxAlgorithmP300SpellerVisualization.h b/plugins/processing/simple-visualization/src/box-algorithms/ovpCBoxAlgorithmP300SpellerVisualization.h
index 2e4011dc5d88f760fbd2ed9d0de55e908d18de68..82e6719bb8f88a4170fdb18a68884425539d0abf 100755
--- a/plugins/processing/simple-visualization/src/box-algorithms/ovpCBoxAlgorithmP300SpellerVisualization.h
+++ b/plugins/processing/simple-visualization/src/box-algorithms/ovpCBoxAlgorithmP300SpellerVisualization.h
@@ -5,13 +5,15 @@
 #include <visualization-toolkit/ovviz_all.h>
 
 #include <gtk/gtk.h>
-#include <map>
 #include <list>
+#include <map>
+#include "../utils.h"
+
 
 namespace TCPTagging
 {
 	class IStimulusSender; // fwd declare
-}
+}  // namespace TCPTagging
 
 namespace OpenViBEPlugins
 {
@@ -41,11 +43,11 @@ namespace OpenViBEPlugins
 				PangoFontDescription* pFontDescription;
 			};
 
-			typedef void (CBoxAlgorithmP300SpellerVisualization::*_cache_callback_)(SWidgetStyle& rWidgetStyle, void* data);
+			typedef void (CBoxAlgorithmP300SpellerVisualization::*cache_callback)(SWidgetStyle& rWidgetStyle, void* data);
 
 			void cacheBuildFromTable(GtkTable* pTable);
-			void cacheForEach(_cache_callback_ fpCallback, void* data);
-			void cacheForEachIf(int iLine, int iColumn, _cache_callback_ fpIfCallback, _cache_callback_ fpElseCallback, void* pIfUserData, void* pElseUserData);
+			void cacheForEach(cache_callback fpCallback, void* data);
+			void cacheForEachIf(int iLine, int iColumn, cache_callback fpIfCallback, cache_callback fpElseCallback, void* pIfUserData, void* pElseUserData);
 			void cacheChangeNullCB(SWidgetStyle& rWidgetStyle, void* data);
 			void cacheChangeBackgroundCB(SWidgetStyle& rWidgetStyle, void* data);
 			void cacheChangeForegroundCB(SWidgetStyle& rWidgetStyle, void* data);
@@ -63,21 +65,21 @@ namespace OpenViBEPlugins
 			uint64_t m_rowStimulationBase = 0;
 			uint64_t m_columnStimulationBase = 0;
 
-			GdkColor m_flashBackgroundColor;
-			GdkColor m_flashForegroundColor;
-			uint64_t m_flashFontSize = 0;
+			GdkColor m_flashBackgroundColor = InitGDKColor(0, 6554, 6554, 6554);
+			GdkColor m_flashForegroundColor = InitGDKColor(0, 65535, 65535, 65535);
+			uint64_t m_flashFontSize = 100;
 			PangoFontDescription* m_flashFontDescription = nullptr;
-			GdkColor m_noFlashBackgroundColor;
-			GdkColor m_noFlashForegroundColor;
-			uint64_t m_noFlashFontSize = 0;
+			GdkColor m_noFlashBackgroundColor = InitGDKColor(0, 0, 0, 0);
+			GdkColor m_noFlashForegroundColor = InitGDKColor(0, 32768, 32768, 32768);
+			uint64_t m_noFlashFontSize = 75;
 			PangoFontDescription* m_noFlashFontDescription = nullptr;
-			GdkColor m_targetBackgroundColor;
-			GdkColor m_targetForegroundColor;
-			uint64_t m_targetFontSize = 0;
+			GdkColor m_targetBackgroundColor = InitGDKColor(0, 6554, 26214, 6554);
+			GdkColor m_targetForegroundColor = InitGDKColor(0, 39321, 65535, 39321);
+			uint64_t m_targetFontSize = 100;
 			PangoFontDescription* m_targetFontDescription = nullptr;
-			GdkColor m_selectedBackgroundColor;
-			GdkColor m_selectedForegroundColor;
-			uint64_t m_selectedFontSize = 0;
+			GdkColor m_selectedBackgroundColor = InitGDKColor(0, 45875, 13107, 13107);
+			GdkColor m_selectedForegroundColor = InitGDKColor(0, 19661, 6554, 6554);
+			uint64_t m_selectedFontSize = 100;
 			PangoFontDescription* m_selectedFontDescription = nullptr;
 
 		private:
@@ -115,7 +117,7 @@ namespace OpenViBEPlugins
 			bool m_tableInitialized = false;
 
 			// @todo refactor to std::pair<long,long> ?
-			std::map<unsigned long, std::map<unsigned long, SWidgetStyle>> m_cache;
+			std::map<size_t, std::map<size_t, SWidgetStyle>> m_cache;
 			std::list<std::pair<int, int>> m_targetHistory;
 
 			// TCP Tagging
diff --git a/plugins/processing/simple-visualization/src/box-algorithms/ovpCDisplayCueImage.cpp b/plugins/processing/simple-visualization/src/box-algorithms/ovpCDisplayCueImage.cpp
index db72c20c5a0bcf0db3718383a7338c012fa5f07d..3f8d591c880e53a01e4150466d648628401d6f66 100755
--- a/plugins/processing/simple-visualization/src/box-algorithms/ovpCDisplayCueImage.cpp
+++ b/plugins/processing/simple-visualization/src/box-algorithms/ovpCDisplayCueImage.cpp
@@ -1,17 +1,18 @@
 #include "ovpCDisplayCueImage.h"
 
 #include <cmath>
-#include <iostream>
 #include <cstdlib>
+#include <iostream>
+#include <algorithm> // std::min
+
+#include <openvibe/ovITimeArithmetics.h>
+#include <tcptagging/IStimulusSender.h>
+
 
 #if defined TARGET_OS_Linux
   #include <unistd.h>
 #endif
 
-#include <tcptagging/IStimulusSender.h>
-#include <openvibe/ovITimeArithmetics.h>
-
-#include <algorithm> // std::min
 
 using namespace OpenViBE;
 using namespace Plugins;
@@ -31,37 +32,24 @@ namespace OpenViBEPlugins
 	{
 		// This callback flushes all accumulated stimulations to the TCP Tagging 
 		// after the rendering has completed.
-		gboolean DisplayCueImage_flush_callback(gpointer data)
+		gboolean DisplayCueImageFlushCB(gpointer data)
 		{
 			reinterpret_cast<CDisplayCueImage*>(data)->flushQueue();
 			return false;	// Only run once
 		}
 
-		gboolean DisplayCueImage_SizeAllocateCallback(GtkWidget* /*widget*/, GtkAllocation* allocation, gpointer data)
+		gboolean DisplayCueImageResizeCB(GtkWidget* /*widget*/, GtkAllocation* allocation, gpointer data)
 		{
 			reinterpret_cast<CDisplayCueImage*>(data)->resize(uint32_t(allocation->width), uint32_t(allocation->height));
 			return FALSE;
 		}
 
-		gboolean DisplayCueImage_RedrawCallback(GtkWidget* /*widget*/, GdkEventExpose* /*event*/, gpointer data)
+		gboolean DisplayCueImageRedrawCB(GtkWidget* /*widget*/, GdkEventExpose* /*event*/, gpointer data)
 		{
 			reinterpret_cast<CDisplayCueImage*>(data)->redraw();
 			return TRUE;
 		}
 
-		CDisplayCueImage::CDisplayCueImage() 
-		{
-			m_backgroundColor.pixel = 0;
-			m_backgroundColor.red = 0;
-			m_backgroundColor.green = 0;
-			m_backgroundColor.blue = 0;
-
-			m_foregroundColor.pixel = 0;
-			m_foregroundColor.red = 0xFFFF;
-			m_foregroundColor.green = 0xFFFF;
-			m_foregroundColor.blue = 0xFFFF;
-		}
-
 		bool CDisplayCueImage::initialize()
 		{
 			m_idleFuncTag = 0;
@@ -110,8 +98,8 @@ namespace OpenViBEPlugins
 			gtk_builder_connect_signals(m_builderInterface, nullptr);
 
 			m_drawingArea = GTK_WIDGET(gtk_builder_get_object(m_builderInterface, "DisplayCueImageDrawingArea"));
-			g_signal_connect(G_OBJECT(m_drawingArea), "expose_event", G_CALLBACK(DisplayCueImage_RedrawCallback), this);
-			g_signal_connect(G_OBJECT(m_drawingArea), "size-allocate", G_CALLBACK(DisplayCueImage_SizeAllocateCallback), this);
+			g_signal_connect(G_OBJECT(m_drawingArea), "expose_event", G_CALLBACK(DisplayCueImageRedrawCB), this);
+			g_signal_connect(G_OBJECT(m_drawingArea), "size-allocate", G_CALLBACK(DisplayCueImageResizeCB), this);
 
 			//set widget bg color
 			gtk_widget_modify_bg(m_drawingArea, GTK_STATE_NORMAL, &m_backgroundColor);
@@ -318,8 +306,7 @@ namespace OpenViBEPlugins
 							{
 								if (m_imageRequested)
 								{
-									getBoxAlgorithmContext()->getPlayerContext()->getLogManager() << LogLevel_ImportantWarning
-										<< "Previous request of slot " << m_requestedImageId + 1 << " image was replaced by request for slot " << i + 1 << " => Not enough time between two images!!\n";
+									getBoxAlgorithmContext()->getPlayerContext()->getLogManager() << LogLevel_ImportantWarning << "Previous request of slot " << m_requestedImageId + 1 << " image was replaced by request for slot " << i + 1 << " => Not enough time between two images!!\n";
 								}
 								m_imageRequested = true;
 								stimulusMatchedBefore = true;
@@ -453,7 +440,7 @@ namespace OpenViBEPlugins
 				m_drawnImageId = m_requestedImageId;
 
 				// Set the handler to push out the queued stims after the actual rendering
-				if (m_idleFuncTag == 0) { m_idleFuncTag = g_idle_add(DisplayCueImage_flush_callback, this); }
+				if (m_idleFuncTag == 0) { m_idleFuncTag = g_idle_add(DisplayCueImageFlushCB, this); }
 			}
 		}
 
@@ -474,10 +461,7 @@ namespace OpenViBEPlugins
 
 			if (!m_scaleImages)
 			{
-				for (uint32_t i = 0; i < m_scaledPictures.size(); ++i)
-				{
-					m_scaledPictures[i] = gdk_pixbuf_copy(m_originalPictures[i]);
-				}
+				for (uint32_t i = 0; i < m_scaledPictures.size(); ++i) { m_scaledPictures[i] = gdk_pixbuf_copy(m_originalPictures[i]); }
 				return;
 			}
 
@@ -487,39 +471,38 @@ namespace OpenViBEPlugins
 				for (uint32_t i = 0; i < m_scaledPictures.size(); ++i)
 				{
 					// Keep aspect ratio when scaling
-					const int picWidth = gdk_pixbuf_get_width(m_originalPictures[i]);
-					const int picHeight = gdk_pixbuf_get_height(m_originalPictures[i]);
-
-					const double widthScale = width / double(picWidth);
-					const double heightScale = height / double(picHeight);
+					const int picWidth = gdk_pixbuf_get_width(m_originalPictures[i]),
+							  picHeight = gdk_pixbuf_get_height(m_originalPictures[i]);
 
-					const double minScale = std::min<double>(widthScale, heightScale);
+					const double widthScale = width / double(picWidth),
+								 heightScale = height / double(picHeight),
+								 minScale = std::min<double>(widthScale, heightScale);
 
-					const int newWidth = int(minScale * picWidth);
-					const int newHeight = int(minScale * picHeight);
+					const int newWidth = int(minScale * picWidth),
+							  newHeight = int(minScale * picHeight);
 
 					m_scaledPictures[i] = gdk_pixbuf_scale_simple(m_originalPictures[i], newWidth, newHeight, GDK_INTERP_BILINEAR);
 				}
 			}
 			else
 			{
-				const auto X = float(width < 64 ? 64 : width);
-				const auto Y = float(height < 64 ? 64 : height);
+				const auto x = float(width < 64 ? 64 : width),
+						   y = float(height < 64 ? 64 : height);
 				for (uint32_t i = 0; i < m_scaledPictures.size(); ++i)
 				{
-					auto x = float(gdk_pixbuf_get_width(m_originalPictures[i]));
-					auto y = float(gdk_pixbuf_get_height(m_originalPictures[i]));
-					if ((X / x) < (Y / y))
+					auto picWidth = float(gdk_pixbuf_get_width(m_originalPictures[i])),
+						 picHeight = float(gdk_pixbuf_get_height(m_originalPictures[i]));
+					if ((x / picWidth) < (y / picHeight))
 					{
-						y = X * y / (3 * x);
-						x = X / 3;
+						picHeight = x * picHeight / (3 * picWidth);
+						picWidth = x / 3;
 					}
 					else
 					{
-						x = Y * x / (3 * y);
-						y = Y / 3;
+						picWidth = y * picWidth / (3 * picHeight);
+						picHeight = y / 3;
 					}
-					m_scaledPictures[i] = gdk_pixbuf_scale_simple(m_originalPictures[i], int(x), int(y), GDK_INTERP_BILINEAR);
+					m_scaledPictures[i] = gdk_pixbuf_scale_simple(m_originalPictures[i], int(picWidth), int(picHeight), GDK_INTERP_BILINEAR);
 				}
 			}
 		}
diff --git a/plugins/processing/simple-visualization/src/box-algorithms/ovpCDisplayCueImage.h b/plugins/processing/simple-visualization/src/box-algorithms/ovpCDisplayCueImage.h
index 941897debd1b564c74b8bfbd40bb2b3cc9d9718c..7af7b96233fd00059d7355159a59ae59b09d7d7f 100755
--- a/plugins/processing/simple-visualization/src/box-algorithms/ovpCDisplayCueImage.h
+++ b/plugins/processing/simple-visualization/src/box-algorithms/ovpCDisplayCueImage.h
@@ -6,12 +6,14 @@
 #include <visualization-toolkit/ovviz_all.h>
 
 #include <gtk/gtk.h>
-#include <vector>
-#include <string>
-#include <sstream>
+#include <deque>
 #include <iomanip>
 #include <map>
-#include <deque>
+#include <sstream>
+#include <string>
+#include <vector>
+#include "../utils.h"
+
 
 #define OVP_ClassId_DisplayCueImage                                            OpenViBE::CIdentifier(0x005789A4, 0x3AB78A36)
 #define OVP_ClassId_DisplayCueImageDesc                                        OpenViBE::CIdentifier(0x086185A4, 0x796A854C)
@@ -19,19 +21,16 @@
 namespace TCPTagging
 {
 	class IStimulusSender; // fwd declare
-}
+}  // namespace TCPTagging
 
 namespace OpenViBEPlugins
 {
 	namespace SimpleVisualization
 	{
-		class CDisplayCueImage :
-			public OpenViBEToolkit::TBoxAlgorithm<OpenViBE::Plugins::IBoxAlgorithm>
+		class CDisplayCueImage : public OpenViBEToolkit::TBoxAlgorithm<OpenViBE::Plugins::IBoxAlgorithm>
 		{
 		public:
 
-			CDisplayCueImage();
-
 			void release() override { delete this; }
 
 			bool initialize() override;
@@ -74,8 +73,8 @@ namespace OpenViBEPlugins
 			std::vector<uint64_t> m_stimulationsIds;
 			std::vector<OpenViBE::CString> m_imageNames;
 
-			GdkColor m_backgroundColor;
-			GdkColor m_foregroundColor;
+			GdkColor m_backgroundColor = InitGDKColor(0, 0, 0, 0);
+			GdkColor m_foregroundColor = InitGDKColor(0, 65535, 65535, 65535);
 
 			//Settings
 			uint32_t m_numberOfCues = 0;
diff --git a/plugins/processing/simple-visualization/src/box-algorithms/ovpCGrazMultiVisualization.cpp b/plugins/processing/simple-visualization/src/box-algorithms/ovpCGrazMultiVisualization.cpp
index 3c2b6bc45698618c9d9d068c8b062d5b4d743787..eac6ff017bcbe1fd3b3f1a9ec2d05ea09706a75c 100644
--- a/plugins/processing/simple-visualization/src/box-algorithms/ovpCGrazMultiVisualization.cpp
+++ b/plugins/processing/simple-visualization/src/box-algorithms/ovpCGrazMultiVisualization.cpp
@@ -1,15 +1,16 @@
 #include "ovpCGrazMultiVisualization.h"
+#include "../utils.h"
 
-#include <cmath>
-#include <iostream>
-#include <vector>
 #include <algorithm> // std::min, max
+#include <array>
+#include <cmath>
 #include <cstdlib>
+#include <functional> // greater
+#include <iomanip>
+#include <iostream>
 #include <sys/timeb.h>
 #include <tcptagging/IStimulusSender.h>
-#include <iomanip>
-#include <array>
-#include <functional> // greater
+#include <vector>
 
 #if defined TARGET_OS_Linux
 #include <unistd.h>
@@ -30,7 +31,7 @@ using namespace std;
 static gboolean FlushCB(gpointer data)
 {
 	reinterpret_cast<CGrazMultiVisualization*>(data)->flushQueue();
-	return false;	// Only run once
+	return FALSE;	// Only run once
 }
 //---------------------------------------------------------------------------------------------------
 
@@ -51,25 +52,6 @@ static gboolean RedrawCB(GtkWidget* /*widget*/, GdkEventExpose* /*event*/, gpoin
 }
 //---------------------------------------------------------------------------------------------------
 
-
-//---------------------------------------------------------------------------------------------------
-/// <summary> Initializes the color of the GDK. with old compiler as vs2013 we can't initialize structure easily.....</summary>
-/// <param name="pixel"> For allocated colors, the pixel value used to draw this color on the screen.Not used anymore.</param>
-/// <param name="r"> The red component of the color. This is a value between 0 and 65535, with 65535 indicating full intensity.</param>
-/// <param name="g"> The green component of the color.</param>
-/// <param name="b"> The blue component of the color.</param>
-/// <returns> The initialized color (</returns>
-static GdkColor InitGDKColor(const guint32 pixel = 0, const guint16 r = 0, const guint16 g = 0, const guint16 b = 0)
-{
-	GdkColor c;
-	c.pixel = pixel;
-	c.red = r;
-	c.green = g;
-	c.blue = b;
-	return c;
-}
-//---------------------------------------------------------------------------------------------------
-
 //---------------------------------------------------------------------------------------------------
 /// <summary> Run scale command with the good size if you want to keep the proportion of the original pixbuf.</summary>
 /// <param name="in">	The pixbuf.</param>
@@ -294,9 +276,9 @@ void CGrazMultiVisualization::drawReference()
 	{
 		gdk_draw_line(m_widget->window, m_widget->style->fg_gc[gtk_widget_get_state(m_widget)], currX - m_modalityW, m_modalityY, currX + m_modalityW, m_modalityY);
 		gdk_draw_line(m_widget->window, m_widget->style->fg_gc[gtk_widget_get_state(m_widget)], currX, m_margin, currX, m_modalityY);
-		const gint X = currX - gdk_pixbuf_get_width(m_smallImgs[i]) / 2,
-				   Y = m_modalityY + (m_windowH - m_modalityY - gdk_pixbuf_get_height(m_smallImgs[i])) / 2;
-		gdk_draw_pixbuf(m_widget->window, nullptr, m_smallImgs[i], 0, 0, X, Y, -1, -1, GDK_RGB_DITHER_NONE, 0, 0);
+		const gint x = currX - gdk_pixbuf_get_width(m_smallImgs[i]) / 2,
+				   y = m_modalityY + (m_windowH - m_modalityY - gdk_pixbuf_get_height(m_smallImgs[i])) / 2;
+		gdk_draw_pixbuf(m_widget->window, nullptr, m_smallImgs[i], 0, 0, x, y, -1, -1, GDK_RGB_DITHER_NONE, 0, 0);
 	}
 }
 //---------------------------------------------------------------------------------------------------
@@ -344,7 +326,7 @@ void CGrazMultiVisualization::drawAccuracy()
 
 	const gint stepX = 40, stepY = 16;
 	const gint startX = 8, startY = 16;
-	gint X = startX, Y = startY;
+	gint x = startX, y = startY;
 
 	stringstream ss;
 	ss << std::setfill('0');
@@ -362,22 +344,22 @@ void CGrazMultiVisualization::drawAccuracy()
 			pango_layout_set_text(layout, ss.str().c_str(), -1);
 			if (i == j)
 			{
-				gdk_draw_layout(m_widget->window, m_widget->style->white_gc, X, Y, layout);
+				gdk_draw_layout(m_widget->window, m_widget->style->white_gc, x, y, layout);
 				good += val;
 			}
 			else
 			{
-				gdk_draw_layout(m_widget->window, m_widget->style->fg_gc[GTK_WIDGET_STATE(m_widget)], X, Y, layout);
+				gdk_draw_layout(m_widget->window, m_widget->style->fg_gc[GTK_WIDGET_STATE(m_widget)], x, y, layout);
 			}
-			X += stepX;
+			x += stepX;
 		}
-		X = startX;
-		Y += stepY;
+		x = startX;
+		y += stepY;
 	}
 	ss.str(string());
 	ss << "Acc = " << std::fixed << std::setprecision(1) << (predictions == 0 ? 0.0 : 100.0 * double(good) / double(predictions));
 	pango_layout_set_text(layout, ss.str().c_str(), -1);
-	gdk_draw_layout(m_widget->window, m_widget->style->white_gc, X + (m_nbModality * stepX), Y - stepY, layout);
+	gdk_draw_layout(m_widget->window, m_widget->style->white_gc, x + (m_nbModality * stepX), y - stepY, layout);
 
 	g_object_unref(layout);
 
@@ -454,10 +436,7 @@ void CGrazMultiVisualization::aggregatePredictions(const bool all)
 //---------------------------------------------------------------------------------------------------
 void CGrazMultiVisualization::updateConfusionMatrix()
 {
-	if (m_modality != -1 && m_vote != -1)
-	{
-		(m_confusion.getBuffer())[m_vote * m_nbModality + m_modality]++;		// Col = Expected modality, Row = Computed modality
-	}
+	if (m_modality != -1 && m_vote != -1) { (m_confusion.getBuffer())[m_vote * m_nbModality + m_modality]++; }		// Col = Expected modality, Row = Computed modality
 }
 //---------------------------------------------------------------------------------------------------
 
@@ -516,7 +495,6 @@ void CGrazMultiVisualization::setStimulation(const uint64_t stimulation)
 			m_state = 2;							// Draw Feedback State
 			break;
 
-
 		default:									// Modalities stimulations
 			m_modality = -1;						// Initialize modality number
 			m_vote = -1;							// Initialize vote
diff --git a/plugins/processing/simple-visualization/src/box-algorithms/ovpCGrazMultiVisualization.h b/plugins/processing/simple-visualization/src/box-algorithms/ovpCGrazMultiVisualization.h
index a72381125dac81e6030d2bf871137bd8cfa08825..55640951fcf770b168fa3b5c44d5982ac00c935b 100644
--- a/plugins/processing/simple-visualization/src/box-algorithms/ovpCGrazMultiVisualization.h
+++ b/plugins/processing/simple-visualization/src/box-algorithms/ovpCGrazMultiVisualization.h
@@ -20,13 +20,15 @@
 
 #include <gtk/gtk.h>
 
-#include <vector>
 #include <string>
 
+#include <vector>
+
+
 namespace TCPTagging
 {
 	class IStimulusSender; // fwd declare
-}
+}  // namespace TCPTagging
 
 namespace OpenViBEPlugins
 {
@@ -46,7 +48,6 @@ namespace OpenViBEPlugins
 
 			bool redraw();
 			void resize(uint32_t width, uint32_t height);
-			bool resize();
 			void flushQueue();					// Sends all accumulated stimuli to the TCP Tagging
 
 			static const size_t m_NonModalitySettingsCount = 7;
diff --git a/plugins/processing/simple-visualization/src/box-algorithms/ovpCGrazVisualization.cpp b/plugins/processing/simple-visualization/src/box-algorithms/ovpCGrazVisualization.cpp
index f4a9badc6b6c5e01670f4ddfd5904287a0e795eb..b914ae440fc45372559d8b37fa061d6063b8cd4d 100755
--- a/plugins/processing/simple-visualization/src/box-algorithms/ovpCGrazVisualization.cpp
+++ b/plugins/processing/simple-visualization/src/box-algorithms/ovpCGrazVisualization.cpp
@@ -1,9 +1,13 @@
 #include "ovpCGrazVisualization.h"
+#include <tcptagging/IStimulusSender.h>
 
-#include <cmath>
-#include <iostream>
 #include <algorithm> // std::min, max
+#include <cmath>
+#include <cstdlib>
 #include <iomanip>
+#include <iostream>
+#include <fstream>
+#include <sys/timeb.h>
 
 #if defined TARGET_OS_Linux
 #include <unistd.h>
@@ -17,16 +21,6 @@ using namespace SimpleVisualization;
 using namespace OpenViBEToolkit;
 using namespace std;
 
-////////////////////////
-
-#include <iostream>
-#include <fstream>
-#include <cstdlib>
-
-#include <sys/timeb.h>
-
-#include <tcptagging/IStimulusSender.h>
-
 //////////////////////////
 
 // This callback flushes all accumulated stimulations to the TCP Tagging 
@@ -34,7 +28,7 @@ using namespace std;
 static gboolean FlushCB(gpointer data)
 {
 	reinterpret_cast<CGrazVisualization*>(data)->flushQueue();
-	return false;	// Only run once
+	return FALSE;	// Only run once
 }
 
 static gboolean ResizeCB(GtkWidget* /*widget*/, GtkAllocation* allocation, gpointer data)
@@ -66,7 +60,7 @@ void CGrazVisualization::setStimulation(const uint32_t /*stimulationIndex*/, con
 	switch (stimulationIdentifier)
 	{
 		case OVTK_GDF_End_Of_Trial:
-			m_CurrentState = EGrazVisualizationState_Idle;
+			m_CurrentState = GrazVisualizationState_Idle;
 			stateUpdated = true;
 			if (m_ShowAccuracy || m_DelayFeedback)
 			{
@@ -77,7 +71,7 @@ void CGrazVisualization::setStimulation(const uint32_t /*stimulationIndex*/, con
 			break;
 
 		case OVTK_GDF_End_Of_Session:
-			m_CurrentState = EGrazVisualizationState_Idle;
+			m_CurrentState = GrazVisualizationState_Idle;
 			stateUpdated = true;
 			if (m_ShowFeedback)
 			{
@@ -87,7 +81,7 @@ void CGrazVisualization::setStimulation(const uint32_t /*stimulationIndex*/, con
 			break;
 
 		case OVTK_GDF_Cross_On_Screen:
-			m_CurrentState = EGrazVisualizationState_Reference;
+			m_CurrentState = GrazVisualizationState_Reference;
 			stateUpdated = true;
 			break;
 
@@ -102,33 +96,33 @@ void CGrazVisualization::setStimulation(const uint32_t /*stimulationIndex*/, con
 			break;
 
 		case OVTK_GDF_Left:
-			m_CurrentState = EGrazVisualizationState_Cue;
-			m_CurrentDirection = EArrowDirection_Left;
+			m_CurrentState = GrazVisualizationState_Cue;
+			m_CurrentDirection = ArrowDirection_Left;
 			stateUpdated = true;
 			break;
 
 		case OVTK_GDF_Right:
-			m_CurrentState = EGrazVisualizationState_Cue;
-			m_CurrentDirection = EArrowDirection_Right;
+			m_CurrentState = GrazVisualizationState_Cue;
+			m_CurrentDirection = ArrowDirection_Right;
 			stateUpdated = true;
 			break;
 
 		case OVTK_GDF_Up:
-			m_CurrentState = EGrazVisualizationState_Cue;
-			m_CurrentDirection = EArrowDirection_Up;
+			m_CurrentState = GrazVisualizationState_Cue;
+			m_CurrentDirection = ArrowDirection_Up;
 			stateUpdated = true;
 			break;
 
 		case OVTK_GDF_Down:
-			m_CurrentState = EGrazVisualizationState_Cue;
-			m_CurrentDirection = EArrowDirection_Down;
+			m_CurrentState = GrazVisualizationState_Cue;
+			m_CurrentDirection = ArrowDirection_Down;
 			stateUpdated = true;
 			break;
 
 		case OVTK_GDF_Feedback_Continuous:
 			// New trial starts
 
-			m_CurrentState = EGrazVisualizationState_ContinousFeedback;
+			m_CurrentState = GrazVisualizationState_ContinousFeedback;
 			m_Amplitudes.clear();
 
 			// as some trials may have artifacts and hence very high responses from e.g. LDA
@@ -154,10 +148,10 @@ void CGrazVisualization::processState()
 {
 	switch (m_CurrentState)
 	{
-		case EGrazVisualizationState_Reference:
-		case EGrazVisualizationState_Cue:
-		case EGrazVisualizationState_Idle:
-		case EGrazVisualizationState_ContinousFeedback:
+		case GrazVisualizationState_Reference:
+		case GrazVisualizationState_Cue:
+		case GrazVisualizationState_Idle:
+		case GrazVisualizationState_ContinousFeedback:
 			if (GTK_WIDGET(m_DrawingArea)->window) { gdk_window_invalidate_rect(GTK_WIDGET(m_DrawingArea)->window, nullptr, true); }
 			break;
 
@@ -171,16 +165,6 @@ void CGrazVisualization::processState()
 */
 CGrazVisualization::CGrazVisualization()
 {
-	m_BackgroundColor.pixel = 0;
-	m_BackgroundColor.red = 0;//0xFFFF;
-	m_BackgroundColor.green = 0;//0xFFFF;
-	m_BackgroundColor.blue = 0;//0xFFFF;
-
-	m_ForegroundColor.pixel = 0;
-	m_ForegroundColor.red = 0;
-	m_ForegroundColor.green = 0x8000;
-	m_ForegroundColor.blue = 0;
-
 	m_Confusion.setDimensionCount(2);
 	m_Confusion.setDimensionSize(0, 2);
 	m_Confusion.setDimensionSize(1, 2);
@@ -412,21 +396,21 @@ void CGrazVisualization::redraw()
 {
 	switch (m_CurrentState)
 	{
-		case EGrazVisualizationState_Reference:
+		case GrazVisualizationState_Reference:
 			drawReferenceCross();
 			break;
 
-		case EGrazVisualizationState_Cue:
+		case GrazVisualizationState_Cue:
 			drawReferenceCross();
-			drawArrow(m_ShowInstruction ? m_CurrentDirection : EArrowDirection_None);
+			drawArrow(m_ShowInstruction ? m_CurrentDirection : ArrowDirection_None);
 			break;
 
-		case EGrazVisualizationState_ContinousFeedback:
+		case GrazVisualizationState_ContinousFeedback:
 			drawReferenceCross();
 			if (m_ShowFeedback && !m_DelayFeedback) { drawBar(); }
 			break;
 
-		case EGrazVisualizationState_Idle:
+		case GrazVisualizationState_Idle:
 			if (m_ShowFeedback && m_DelayFeedback) { drawBar(); }
 			break;
 
@@ -457,43 +441,40 @@ void CGrazVisualization::drawArrow(const EArrowDirection eDirection)
 	const gint width = m_DrawingArea->allocation.width,
 			   height = m_DrawingArea->allocation.height;
 
-	gint x = 0, y = 0;
+	gint x = (width / 2), y = (height / 2);
 
 	switch (eDirection)
 	{
-		case EArrowDirection_None:
-			this->drawArrow(EArrowDirection_Left);
-			this->drawArrow(EArrowDirection_Right);
-			// this->drawArrow(EArrowDirection_Up);
-			// this->drawArrow(EArrowDirection_Down);
+		case ArrowDirection_None:
+			this->drawArrow(ArrowDirection_Left);
+			this->drawArrow(ArrowDirection_Right);
 			break;
 
-		case EArrowDirection_Left:
-			x = (width / 2) - gdk_pixbuf_get_width(m_LeftArrow) - 1;
-			y = (height / 2) - (gdk_pixbuf_get_height(m_LeftArrow) / 2);
+		case ArrowDirection_Left:
+			x -= gdk_pixbuf_get_width(m_LeftArrow) - 1;
+			y -= gdk_pixbuf_get_height(m_LeftArrow) / 2;
 			gdk_draw_pixbuf(m_DrawingArea->window, nullptr, m_LeftArrow, 0, 0, x, y, -1, -1, GDK_RGB_DITHER_NONE, 0, 0);
 			break;
 
-		case EArrowDirection_Right:
-			x = (width / 2) + 2;
-			y = (height / 2) - (gdk_pixbuf_get_height(m_RightArrow) / 2);
+		case ArrowDirection_Right:
+			x += 2;
+			y -= gdk_pixbuf_get_height(m_RightArrow) / 2;
 			gdk_draw_pixbuf(m_DrawingArea->window, nullptr, m_RightArrow, 0, 0, x, y, -1, -1, GDK_RGB_DITHER_NONE, 0, 0);
 			break;
 
-		case EArrowDirection_Up:
-			x = (width / 2) - (gdk_pixbuf_get_width(m_UpArrow) / 2);
-			y = (height / 2) - gdk_pixbuf_get_height(m_UpArrow) - 1;
+		case ArrowDirection_Up:
+			x -= gdk_pixbuf_get_width(m_UpArrow) / 2;
+			y -= gdk_pixbuf_get_height(m_UpArrow) - 1;
 			gdk_draw_pixbuf(m_DrawingArea->window, nullptr, m_UpArrow, 0, 0, x, y, -1, -1, GDK_RGB_DITHER_NONE, 0, 0);
 			break;
 
-		case EArrowDirection_Down:
-			x = (width / 2) - (gdk_pixbuf_get_width(m_DownArrow) / 2);
-			y = (height / 2) + 2;
+		case ArrowDirection_Down:
+			x -= gdk_pixbuf_get_width(m_DownArrow) / 2;
+			y += 2;
 			gdk_draw_pixbuf(m_DrawingArea->window, nullptr, m_DownArrow, 0, 0, x, y, -1, -1, GDK_RGB_DITHER_NONE, 0, 0);
 			break;
 
-		default:
-			break;
+		default: break;
 	}
 }
 
@@ -564,10 +545,7 @@ void CGrazVisualization::drawAccuracy()
 	gdk_draw_layout(m_DrawingArea->window, m_DrawingArea->style->white_gc, 8 + 56, 32, layout);
 
 	uint32_t predictions = 0;
-	for (uint32_t i = 0; i < 4; ++i)
-	{
-		predictions += int(buffer[i]);
-	}
+	for (uint32_t i = 0; i < 4; ++i) { predictions += int(buffer[i]); }
 
 	tmp.str(string());
 	tmp << "Acc = " << std::fixed << std::setprecision(1) << (predictions == 0 ? 0.0 : 100.0 * (buffer[0] + buffer[3]) / double(predictions)) << "%";
@@ -603,7 +581,7 @@ double CGrazVisualization::aggregatePredictions(const bool includeAll)
 // @fixme for >2 classes
 void CGrazVisualization::updateConfusionMatrix(const double prediction)
 {
-	if (m_CurrentDirection == EArrowDirection_Left || m_CurrentDirection == EArrowDirection_Right)
+	if (m_CurrentDirection == ArrowDirection_Left || m_CurrentDirection == ArrowDirection_Right)
 	{
 		const uint32_t trueDirection = m_CurrentDirection - 1;
 		const uint32_t thisVote = (prediction < 0 ? 0 : 1);
@@ -620,7 +598,7 @@ void CGrazVisualization::updateConfusionMatrix(const double prediction)
 
 void CGrazVisualization::setMatrixBuffer(const double* pBuffer)
 {
-	if (m_CurrentState != EGrazVisualizationState_ContinousFeedback)
+	if (m_CurrentState != GrazVisualizationState_ContinousFeedback)
 	{
 		// We're not inside a trial, discard the prediction
 		return;
diff --git a/plugins/processing/simple-visualization/src/box-algorithms/ovpCGrazVisualization.h b/plugins/processing/simple-visualization/src/box-algorithms/ovpCGrazVisualization.h
index b7b78ca7029c4750fc6c83d3c46a8ed1ce4ec190..3f18a4aee74c3182424797c79f5310ff887577f2 100755
--- a/plugins/processing/simple-visualization/src/box-algorithms/ovpCGrazVisualization.h
+++ b/plugins/processing/simple-visualization/src/box-algorithms/ovpCGrazVisualization.h
@@ -7,16 +7,17 @@
 #include <visualization-toolkit/ovviz_all.h>
 
 #include <gtk/gtk.h>
-
-#include <vector>
-#include <string>
-#include <map>
 #include <deque>
+#include <map>
+#include <string>
+#include <vector>
+#include "../utils.h"
+
 
 namespace TCPTagging
 {
 	class IStimulusSender; // fwd declare
-}
+}  // namespace TCPTagging
 
 namespace OpenViBEPlugins
 {
@@ -24,25 +25,24 @@ namespace OpenViBEPlugins
 	{
 		enum EArrowDirection
 		{
-			EArrowDirection_None = 0,
-			EArrowDirection_Left,
-			EArrowDirection_Right,
-			EArrowDirection_Up,
-			EArrowDirection_Down,
+			ArrowDirection_None = 0,
+			ArrowDirection_Left,
+			ArrowDirection_Right,
+			ArrowDirection_Up,
+			ArrowDirection_Down,
 		};
 
 		enum EGrazVisualizationState
 		{
-			EGrazVisualizationState_Idle,
-			EGrazVisualizationState_Reference,
-			EGrazVisualizationState_Cue,
-			EGrazVisualizationState_ContinousFeedback
+			GrazVisualizationState_Idle,
+			GrazVisualizationState_Reference,
+			GrazVisualizationState_Cue,
+			GrazVisualizationState_ContinousFeedback
 		};
 
 		/**
 		*/
-		class CGrazVisualization :
-			virtual public OpenViBEToolkit::TBoxAlgorithm<OpenViBE::Plugins::IBoxAlgorithm>
+		class CGrazVisualization : virtual public OpenViBEToolkit::TBoxAlgorithm<OpenViBE::Plugins::IBoxAlgorithm>
 		{
 		public:
 
@@ -88,8 +88,8 @@ namespace OpenViBEPlugins
 			OpenViBEToolkit::TStimulationDecoder<CGrazVisualization> m_StimulationDecoder;
 			OpenViBEToolkit::TStreamedMatrixDecoder<CGrazVisualization> m_MatrixDecoder;
 
-			EGrazVisualizationState m_CurrentState = EGrazVisualizationState_Idle;
-			EArrowDirection m_CurrentDirection = EArrowDirection_None;
+			EGrazVisualizationState m_CurrentState = GrazVisualizationState_Idle;
+			EArrowDirection m_CurrentDirection = ArrowDirection_None;
 
 			double m_MaxAmplitude = -DBL_MAX;
 			double m_BarScale = 0.0;
@@ -114,8 +114,8 @@ namespace OpenViBEPlugins
 			GdkPixbuf* m_UpArrow = nullptr;
 			GdkPixbuf* m_DownArrow = nullptr;
 
-			GdkColor m_BackgroundColor;
-			GdkColor m_ForegroundColor;
+			GdkColor m_BackgroundColor = InitGDKColor(0, 0, 0, 0);
+			GdkColor m_ForegroundColor = InitGDKColor(0, 0, 32768, 0);
 
 			std::deque<double> m_Amplitudes; // predictions for the current trial
 
diff --git a/plugins/processing/simple-visualization/src/box-algorithms/ovpCSignalDisplay.h b/plugins/processing/simple-visualization/src/box-algorithms/ovpCSignalDisplay.h
index 7d2f8980c1cdd8c0cc8af0e97bf485f98ba77122..55a4477fab7c70e3a7b59f2a2df7679af1b3541d 100755
--- a/plugins/processing/simple-visualization/src/box-algorithms/ovpCSignalDisplay.h
+++ b/plugins/processing/simple-visualization/src/box-algorithms/ovpCSignalDisplay.h
@@ -1,5 +1,4 @@
-#ifndef __OpenViBEPlugins_SimpleVisualization_CSignalDisplay_H__
-#define __OpenViBEPlugins_SimpleVisualization_CSignalDisplay_H__
+#pragma once
 
 #include "../ovp_defines.h"
 
@@ -141,5 +140,3 @@ namespace OpenViBEPlugins
 		};
 	}  // namespace SimpleVisualization
 }  // namespace OpenViBEPlugins
-
-#endif
diff --git a/plugins/processing/simple-visualization/src/box-algorithms/ovpCSignalDisplay/ovpCSignalChannelDisplay.cpp b/plugins/processing/simple-visualization/src/box-algorithms/ovpCSignalDisplay/ovpCSignalChannelDisplay.cpp
index 89e27c1a8e7badebcfdd7b0a94a8a2fe832d2077..70d78e58ece8c265199355eb0b9e6a017d855d04 100644
--- a/plugins/processing/simple-visualization/src/box-algorithms/ovpCSignalDisplay/ovpCSignalChannelDisplay.cpp
+++ b/plugins/processing/simple-visualization/src/box-algorithms/ovpCSignalDisplay/ovpCSignalChannelDisplay.cpp
@@ -19,14 +19,14 @@
  */
 
 #include "ovpCSignalChannelDisplay.h"
-
 #include "ovpCSignalDisplayView.h"
-#include <cfloat>
-#include <system/ovCTime.h>
 #include <openvibe/ovITimeArithmetics.h>
-
-#include <sstream>
+#include <system/ovCTime.h>
+#include <cfloat>
 #include <iostream>
+#include <sstream>
+#include "../../utils.h"
+
 
 using namespace std;
 
@@ -59,10 +59,7 @@ CSignalChannelDisplay::CSignalChannelDisplay(CSignalDisplayView* displayView, co
 	gtk_widget_set_size_request(m_DrawingArea, channelDisplayWidthRequest, channelDisplayHeightRequest);
 
 	//Set background color (White)
-	GdkColor backgroundColor;
-	backgroundColor.red = 65535;
-	backgroundColor.green = 65535;
-	backgroundColor.blue = 65535;
+	GdkColor backgroundColor = InitGDKColor(0, 65535, 65535, 65535);
 
 	gtk_widget_modify_bg(m_DrawingArea, GTK_STATE_NORMAL, &backgroundColor);
 
@@ -411,19 +408,13 @@ void CSignalChannelDisplay::draw(const GdkRectangle& /*rExposedArea*/)
 			{
 				if (firstSampleToDisplay == 0)
 				{
-					if (firstBufferToDisplayPosition == 0)
-					{
-						break;
-					}
+					if (firstBufferToDisplayPosition == 0) { break; }
 
 					firstBufferToDisplay--;
 					firstBufferToDisplayPosition--;
 					firstSampleToDisplay = samplesPerBuffer - 1;
 				}
-				else
-				{
-					firstSampleToDisplay--;
-				}
+				else { firstSampleToDisplay--; }
 
 				curX = uint32_t(getSampleXCoordinate(firstBufferToDisplayPosition, firstSampleToDisplay, 0));
 			} while (curX >= oldX);
@@ -595,10 +586,7 @@ void CSignalChannelDisplay::updateDisplayParameters()
 #else
 	// Side effect: draw a little boxes to denote discontinuity in the signal due
 	// to the runtime change of scale.  
-	GdkColor lineColor;
-	lineColor.red = 255 * 65535 / 255;
-	lineColor.green = 0 * 65535 / 255;
-	lineColor.blue = 0 * 65535 / 255;
+	GdkColor lineColor = InitGDKColor(0, 65535, 0, 0);
 	gdk_gc_set_rgb_fg_color(m_DrawingArea->style->fg_gc[GTK_WIDGET_STATE(m_DrawingArea)], &lineColor);
 
 	uint32_t firstBufferToDisplay = 0;
@@ -716,7 +704,7 @@ bool CSignalChannelDisplay::drawSignals(const uint32_t firstBufferToDisplay, con
 		return false;
 	}
 
-	GdkColor lineColor;
+	GdkColor lineColor = InitGDKColor(0, 0, 0, 0);
 
 	lastChannelToDisplay = std::min(lastChannelToDisplay, uint32_t(m_ChannelList.size() - 1));
 
@@ -732,18 +720,7 @@ bool CSignalChannelDisplay::drawSignals(const uint32_t firstBufferToDisplay, con
 		}
 		else
 		{
-			if (m_CurrentSignalMode != DisplayMode_GlobalBestFit)
-			{
-				lineColor.red = 65535;
-				lineColor.green = 0;
-				lineColor.blue = 0;
-			}
-			else
-			{
-				lineColor.red = 0;
-				lineColor.green = 0;
-				lineColor.blue = 0;
-			}
+			if (m_CurrentSignalMode != DisplayMode_GlobalBestFit) { lineColor.red = 65535; }
 		}
 		gdk_gc_set_rgb_fg_color(m_DrawingArea->style->fg_gc[GTK_WIDGET_STATE(m_DrawingArea)], &lineColor);
 
@@ -850,10 +827,7 @@ void CSignalChannelDisplay::drawProgressLine(const uint32_t firstBufferToDisplay
 		//X position of last sample that will be drawn when channel is refreshed
 		const double endX = getSampleXCoordinate(latestBufferPosition, samplesPerBuffer - 1, 0);
 
-		GdkColor lineColor;
-		lineColor.red = 0 * 65535 / 255;
-		lineColor.green = 255 * 65535 / 255;
-		lineColor.blue = 0 * 65535 / 255;
+		GdkColor lineColor = InitGDKColor(0, 0, 65535, 0);
 		gdk_gc_set_rgb_fg_color(m_DrawingArea->style->fg_gc[GTK_WIDGET_STATE(m_DrawingArea)], &lineColor);
 
 		//draw line one pixel after last sample
@@ -861,10 +835,7 @@ void CSignalChannelDisplay::drawProgressLine(const uint32_t firstBufferToDisplay
 					  uint32_t(endX) + 1, 0,
 					  uint32_t(endX) + 1, m_Height - 1);
 
-		GdkColor black;
-		black.red = 0;
-		black.green = 0;
-		black.blue = 0;
+		GdkColor black = InitGDKColor(0, 0, 0, 0);
 		gdk_gc_set_rgb_fg_color(m_DrawingArea->style->fg_gc[GTK_WIDGET_STATE(m_DrawingArea)], &black);
 	}
 }
diff --git a/plugins/processing/simple-visualization/src/box-algorithms/ovpCSignalDisplay/ovpCSignalChannelDisplay.h b/plugins/processing/simple-visualization/src/box-algorithms/ovpCSignalDisplay/ovpCSignalChannelDisplay.h
index 2511ab8ae77258e000b3bc26907f22bf0572d0aa..4c54ec48529ea633064cbee8a539c94ace49a129 100644
--- a/plugins/processing/simple-visualization/src/box-algorithms/ovpCSignalDisplay/ovpCSignalChannelDisplay.h
+++ b/plugins/processing/simple-visualization/src/box-algorithms/ovpCSignalDisplay/ovpCSignalChannelDisplay.h
@@ -3,20 +3,18 @@
 #include "../../ovp_defines.h"
 #include "ovpCSignalDisplayLeftRuler.h"
 
+#include <glib-object.h>
 #include <glib.h>
 #include <glib/gprintf.h>
-#include <glib-object.h>
 #include <gtk/gtk.h>
-
 #include <openvibe/ov_all.h>
-
 #include <toolkit/ovtk_all.h>
 
-#include <memory.h>
 #include <cmath>
-
-#include <vector>
+#include <memory.h>
 #include <map>
+#include <vector>
+
 
 namespace OpenViBEPlugins
 {
diff --git a/plugins/processing/simple-visualization/src/box-algorithms/ovpCSignalDisplay/ovpCSignalDisplayLeftRuler.cpp b/plugins/processing/simple-visualization/src/box-algorithms/ovpCSignalDisplay/ovpCSignalDisplayLeftRuler.cpp
index 68f790b4011aa8a8b91b572449ad01feb31ce5d6..28da5b4c09fa36616b3a739dd6a1a37ca09b68d6 100644
--- a/plugins/processing/simple-visualization/src/box-algorithms/ovpCSignalDisplay/ovpCSignalDisplayLeftRuler.cpp
+++ b/plugins/processing/simple-visualization/src/box-algorithms/ovpCSignalDisplay/ovpCSignalDisplayLeftRuler.cpp
@@ -1,14 +1,14 @@
 #include "ovpCSignalDisplayLeftRuler.h"
 
-#include <iostream>
-#include <sstream>
 #include <cmath>
 #include <glib.h>
 #include <glib/gprintf.h>
+#include <iostream>
+#include <sstream>
+
 
 using namespace OpenViBE;
 using namespace Plugins;
-
 using namespace OpenViBEPlugins;
 using namespace SimpleVisualization;
 
@@ -84,7 +84,6 @@ void CSignalDisplayLeftRuler::draw() const
 	const double intervalWidth = m_MaximumDisplayedValue - m_MinimumDisplayedValue;
 	double valueStep = 0;
 	double baseValue = 0;
-	uint64_t maxNumberOfLabels = 0;
 
 	//if the signal is not constant
 	if (intervalWidth > 0)
@@ -93,7 +92,7 @@ void CSignalDisplayLeftRuler::draw() const
 		const auto nearestSmallerPowerOf10 = double(pow(10, floor(log10(intervalWidth))));
 
 		//get max number of labels that fit in widget
-		maxNumberOfLabels = uint64_t(leftRulerHeight / m_PixelsPerLeftRulerLabel);
+		const uint64_t maxNumberOfLabels = uint64_t(leftRulerHeight / m_PixelsPerLeftRulerLabel);
 
 		//ensure there is room for at least one label
 		if (maxNumberOfLabels > 0)
diff --git a/plugins/processing/simple-visualization/src/box-algorithms/ovpCSignalDisplay/ovpCSignalDisplayLeftRuler.h b/plugins/processing/simple-visualization/src/box-algorithms/ovpCSignalDisplay/ovpCSignalDisplayLeftRuler.h
index ed567477d5e4d2240b5181055b768239e0b2bca9..d55743cc52728a418d2ae0d45692b3781be1c598 100644
--- a/plugins/processing/simple-visualization/src/box-algorithms/ovpCSignalDisplay/ovpCSignalDisplayLeftRuler.h
+++ b/plugins/processing/simple-visualization/src/box-algorithms/ovpCSignalDisplay/ovpCSignalDisplayLeftRuler.h
@@ -3,6 +3,7 @@
 #include <openvibe/ov_all.h>
 #include <gtk/gtk.h>
 
+
 namespace OpenViBEPlugins
 {
 	namespace SimpleVisualization
diff --git a/plugins/processing/simple-visualization/src/box-algorithms/ovpCSignalDisplay/ovpCSignalDisplayView.cpp b/plugins/processing/simple-visualization/src/box-algorithms/ovpCSignalDisplay/ovpCSignalDisplayView.cpp
index ef46a53e1923f9657d9504a91a7fcd7c7f0c33eb..a35803d78b97c8011b4845c636cdc9b10e261ef8 100644
--- a/plugins/processing/simple-visualization/src/box-algorithms/ovpCSignalDisplay/ovpCSignalDisplayView.cpp
+++ b/plugins/processing/simple-visualization/src/box-algorithms/ovpCSignalDisplay/ovpCSignalDisplayView.cpp
@@ -1,7 +1,9 @@
 #include "ovpCSignalDisplayView.h"
+#include <algorithm>
 #include <iostream>
 #include <sstream>
-#include <algorithm>
+#include "../../utils.h"
+
 
 using namespace OpenViBE;
 using namespace Plugins;
@@ -15,21 +17,21 @@ using namespace std;
 
 // #define DEBUG 1
 
-void scrollModeButtonCallback(GtkWidget* widget, gpointer data);
-void unitsButtonCallback(GtkWidget* widget, gpointer data);
-void scalingModeButtonCallback(GtkWidget* widget, gpointer data);
-void toggleLeftRulerButtonCallback(GtkWidget* widget, gpointer data);
-void toggleBottomRulerButtonCallback(GtkWidget* widget, gpointer data);
-void customVerticalScaleChangedCallback(GtkSpinButton* pSpinButton, gpointer data);
-void customVerticalOffsetChangedCallback(GtkSpinButton* pSpinButton, gpointer data);
-gboolean spinButtonValueChangedCallback(GtkSpinButton* widget, gpointer data); // time scale
-void channelSelectButtonCallback(GtkButton* button, gpointer data);
-void channelSelectDialogApplyButtonCallback(GtkButton* button, gpointer data);
-void stimulationColorsButtonCallback(GtkButton* button, gpointer data);
-gint closeStimulationColorsWindow(GtkWidget* widget, GdkEvent* event, gpointer data);
-void informationButtonCallback(GtkButton* button, gpointer data);
-void multiViewButtonCallback(GtkButton* button, gpointer data);
-void multiViewDialogApplyButtonCallback(GtkButton* button, gpointer data);
+void ScrollModeButtonCallback(GtkWidget* widget, gpointer data);
+void UnitsButtonCallback(GtkWidget* widget, gpointer data);
+void ScalingModeButtonCallback(GtkWidget* widget, gpointer data);
+void ToggleLeftRulerButtonCallback(GtkWidget* widget, gpointer data);
+void ToggleBottomRulerButtonCallback(GtkWidget* widget, gpointer data);
+void CustomVerticalScaleChangedCallback(GtkSpinButton* pSpinButton, gpointer data);
+void CustomVerticalOffsetChangedCallback(GtkSpinButton* pSpinButton, gpointer data);
+gboolean SpinButtonValueChangedCallback(GtkSpinButton* widget, gpointer data); // time scale
+void ChannelSelectButtonCallback(GtkButton* button, gpointer data);
+void ChannelSelectDialogApplyButtonCallback(GtkButton* button, gpointer data);
+void StimulationColorsButtonCallback(GtkButton* button, gpointer data);
+gint CloseStimulationColorsWindow(GtkWidget* widget, GdkEvent* event, gpointer data);
+void InformationButtonCallback(GtkButton* button, gpointer data);
+void MultiViewButtonCallback(GtkButton* button, gpointer data);
+void MultiViewDialogApplyButtonCallback(GtkButton* button, gpointer data);
 
 //const char* CSignalDisplayView::m_ScalingModes[] = { "Per channel", "Global", "None" };
 const vector<string> CSignalDisplayView::m_ScalingModes = { "Per channel", "Global", "None" };
@@ -72,18 +74,18 @@ void CSignalDisplayView::construct(CBufferDatabase& /*oBufferDatabase*/, const d
 	gtk_widget_set_sensitive(GTK_WIDGET(::gtk_builder_get_object(m_BuilderInterface, "SignalDisplayScrollModeButton")), true);
 
 	//connect display mode callbacks
-	g_signal_connect(G_OBJECT(::gtk_builder_get_object(m_BuilderInterface, "SignalDisplayScrollModeButton")), "toggled", G_CALLBACK(scrollModeButtonCallback), this);
-	g_signal_connect(G_OBJECT(::gtk_builder_get_object(m_BuilderInterface, "SignalDisplayToggleUnitsButton")), "toggled", G_CALLBACK(unitsButtonCallback), this);
+	g_signal_connect(G_OBJECT(::gtk_builder_get_object(m_BuilderInterface, "SignalDisplayScrollModeButton")), "toggled", G_CALLBACK(ScrollModeButtonCallback), this);
+	g_signal_connect(G_OBJECT(::gtk_builder_get_object(m_BuilderInterface, "SignalDisplayToggleUnitsButton")), "toggled", G_CALLBACK(UnitsButtonCallback), this);
 
 	//creates the cursors
 	m_Cursor[0] = gdk_cursor_new(GDK_LEFT_PTR);
 	m_Cursor[1] = gdk_cursor_new(GDK_SIZING);
 
 	//button callbacks
-	g_signal_connect(G_OBJECT(::gtk_builder_get_object(m_BuilderInterface, "SignalDisplayChannelSelectButton")), "clicked", G_CALLBACK(channelSelectButtonCallback), this);
-	g_signal_connect(G_OBJECT(::gtk_builder_get_object(m_BuilderInterface, "SignalDisplayStimulationColorsButton")), "clicked", G_CALLBACK(stimulationColorsButtonCallback), this);
-	g_signal_connect(G_OBJECT(::gtk_builder_get_object(m_BuilderInterface, "SignalDisplayMultiViewButton")), "clicked", G_CALLBACK(multiViewButtonCallback), this);
-	g_signal_connect(G_OBJECT(::gtk_builder_get_object(m_BuilderInterface, "SignalDisplayInformationButton")), "clicked", G_CALLBACK(informationButtonCallback), this);
+	g_signal_connect(G_OBJECT(::gtk_builder_get_object(m_BuilderInterface, "SignalDisplayChannelSelectButton")), "clicked", G_CALLBACK(ChannelSelectButtonCallback), this);
+	g_signal_connect(G_OBJECT(::gtk_builder_get_object(m_BuilderInterface, "SignalDisplayStimulationColorsButton")), "clicked", G_CALLBACK(StimulationColorsButtonCallback), this);
+	g_signal_connect(G_OBJECT(::gtk_builder_get_object(m_BuilderInterface, "SignalDisplayMultiViewButton")), "clicked", G_CALLBACK(MultiViewButtonCallback), this);
+	g_signal_connect(G_OBJECT(::gtk_builder_get_object(m_BuilderInterface, "SignalDisplayInformationButton")), "clicked", G_CALLBACK(InformationButtonCallback), this);
 
 	//initialize vertical scale
 	// ::gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(::gtk_builder_get_object(m_BuilderInterface, "SignalDisplayVerticalScaleToggleButton")), m_bAutoVerticalScale);
@@ -92,25 +94,25 @@ void CSignalDisplayView::construct(CBufferDatabase& /*oBufferDatabase*/, const d
 	gtk_widget_set_sensitive(GTK_WIDGET(::gtk_builder_get_object(m_BuilderInterface, "SignalDisplayCustomVerticalScaleSpinButton")), m_ScalingMode == OVP_TypeId_SignalDisplayScaling_None);
 	gtk_widget_set_sensitive(GTK_WIDGET(::gtk_builder_get_object(m_BuilderInterface, "SignalDisplayDC")), m_ScalingMode == OVP_TypeId_SignalDisplayScaling_None);
 	gtk_spin_button_set_value(GTK_SPIN_BUTTON(::gtk_builder_get_object(m_BuilderInterface, "SignalDisplayDC")), m_CustomVerticalOffset);
-	g_signal_connect(G_OBJECT(::gtk_builder_get_object(m_BuilderInterface, "SignalDisplayDC")), "value-changed", G_CALLBACK(customVerticalOffsetChangedCallback), this);
+	g_signal_connect(G_OBJECT(::gtk_builder_get_object(m_BuilderInterface, "SignalDisplayDC")), "value-changed", G_CALLBACK(CustomVerticalOffsetChangedCallback), this);
 
 	//		::gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(::gtk_builder_get_object(m_BuilderInterface, "SignalDisplayToggleUnitsButton")), false);
 	gtk_widget_set_sensitive(GTK_WIDGET(::gtk_builder_get_object(m_BuilderInterface, "SignalDisplayToggleUnitsButton")), false);
 
 	//connect vertical scale callbacks
-	g_signal_connect(G_OBJECT(::gtk_builder_get_object(m_BuilderInterface, "SignalDisplayCustomVerticalScaleSpinButton")), "value-changed", G_CALLBACK(customVerticalScaleChangedCallback), this);
+	g_signal_connect(G_OBJECT(::gtk_builder_get_object(m_BuilderInterface, "SignalDisplayCustomVerticalScaleSpinButton")), "value-changed", G_CALLBACK(CustomVerticalScaleChangedCallback), this);
 
 	//time scale
 	//----------
 	GtkSpinButton* spinButton = GTK_SPIN_BUTTON(::gtk_builder_get_object(m_BuilderInterface, "SignalDisplayTimeScale"));
 	gtk_spin_button_set_value(spinButton, timeScale);
-	g_signal_connect(G_OBJECT(spinButton), "value-changed", G_CALLBACK(spinButtonValueChangedCallback), this);
+	g_signal_connect(G_OBJECT(spinButton), "value-changed", G_CALLBACK(SpinButtonValueChangedCallback), this);
 	//notify database of current time scale
 	m_BufferDatabase->adjustNumberOfDisplayedBuffers(gtk_spin_button_get_value(spinButton));
 
 	//channel select dialog's signals
 	//-------------------------------
-	g_signal_connect(G_OBJECT(::gtk_builder_get_object(m_BuilderInterface, "SignalDisplayChannelSelectApplyButton")), "clicked", G_CALLBACK(channelSelectDialogApplyButtonCallback), this);
+	g_signal_connect(G_OBJECT(::gtk_builder_get_object(m_BuilderInterface, "SignalDisplayChannelSelectApplyButton")), "clicked", G_CALLBACK(ChannelSelectDialogApplyButtonCallback), this);
 
 	//connect the cancel button to the dialog's hide command
 	g_signal_connect_swapped(G_OBJECT(::gtk_builder_get_object(m_BuilderInterface, "SignalDisplayChannelSelectCancelButton")),
@@ -125,15 +127,15 @@ void CSignalDisplayView::construct(CBufferDatabase& /*oBufferDatabase*/, const d
 	//-----------------------------------
 	//connect the close button to the dialog's hide command
 	g_signal_connect(G_OBJECT(::gtk_builder_get_object(m_BuilderInterface, "SignalDisplayStimulationColorsCloseButton")),
-					 "clicked", G_CALLBACK(stimulationColorsButtonCallback), this);
+					 "clicked", G_CALLBACK(StimulationColorsButtonCallback), this);
 
 	//hides the dialog if the user tries to close it
 	g_signal_connect(G_OBJECT(::gtk_builder_get_object(m_BuilderInterface, "SignalDisplayStimulationColorsDialog")),
-					 "delete_event", G_CALLBACK(closeStimulationColorsWindow), this);
+					 "delete_event", G_CALLBACK(CloseStimulationColorsWindow), this);
 
 	//multiview signals
 	//-----------------
-	g_signal_connect(G_OBJECT(::gtk_builder_get_object(m_BuilderInterface, "SignalDisplayMultiViewApplyButton")), "clicked", G_CALLBACK(multiViewDialogApplyButtonCallback), this);
+	g_signal_connect(G_OBJECT(::gtk_builder_get_object(m_BuilderInterface, "SignalDisplayMultiViewApplyButton")), "clicked", G_CALLBACK(MultiViewDialogApplyButtonCallback), this);
 
 	//connect the cancel button to the dialog's hide command
 	g_signal_connect_swapped(G_OBJECT(::gtk_builder_get_object(m_BuilderInterface, "SignalDisplayMultiViewCancelButton")),
@@ -160,7 +162,7 @@ void CSignalDisplayView::construct(CBufferDatabase& /*oBufferDatabase*/, const d
 		gtk_combo_box_append_text(comboBox, scalingMode.c_str());
 	}
 
-	g_signal_connect(G_OBJECT(comboBox), "changed", G_CALLBACK(scalingModeButtonCallback), this);
+	g_signal_connect(G_OBJECT(comboBox), "changed", G_CALLBACK(ScalingModeButtonCallback), this);
 	gtk_combo_box_set_active(comboBox, gint(m_ScalingMode.toUInteger()));
 
 	gtk_widget_set_sensitive(GTK_WIDGET(comboBox), true);
@@ -458,11 +460,11 @@ void CSignalDisplayView::init()
 
 	toggleLeftRulers(m_ShowLeftRulers);
 	gtk_toggle_tool_button_set_active(GTK_TOGGLE_TOOL_BUTTON(::gtk_builder_get_object(m_BuilderInterface, "SignalDisplayToggleLeftRulerButton")), m_ShowLeftRulers);
-	g_signal_connect(G_OBJECT(::gtk_builder_get_object(m_BuilderInterface, "SignalDisplayToggleLeftRulerButton")), "toggled", G_CALLBACK(toggleLeftRulerButtonCallback), this);
+	g_signal_connect(G_OBJECT(::gtk_builder_get_object(m_BuilderInterface, "SignalDisplayToggleLeftRulerButton")), "toggled", G_CALLBACK(ToggleLeftRulerButtonCallback), this);
 
 	toggleBottomRuler(m_ShowBottomRuler);
 	gtk_toggle_tool_button_set_active(GTK_TOGGLE_TOOL_BUTTON(::gtk_builder_get_object(m_BuilderInterface, "SignalDisplayToggleBottomRulerButton")), m_ShowBottomRuler);
-	g_signal_connect(G_OBJECT(::gtk_builder_get_object(m_BuilderInterface, "SignalDisplayToggleBottomRulerButton")), "toggled", G_CALLBACK(toggleBottomRulerButtonCallback), this);
+	g_signal_connect(G_OBJECT(::gtk_builder_get_object(m_BuilderInterface, "SignalDisplayToggleBottomRulerButton")), "toggled", G_CALLBACK(ToggleBottomRulerButtonCallback), this);
 
 	if (m_MultiViewEnabled) { changeMultiView(); }
 
@@ -965,7 +967,7 @@ boolean CSignalDisplayView::onUnitsToggledCB(const bool active)
 	return true;
 }
 
-bool CSignalDisplayView::onDisplayModeToggledCB(CIdentifier mode)
+bool CSignalDisplayView::onDisplayModeToggledCB(const CIdentifier& mode)
 {
 	m_BufferDatabase->setDisplayMode(mode);
 
@@ -1023,11 +1025,7 @@ void CSignalDisplayView::onStimulationReceivedCB(const uint64_t stimulationCode,
 	{
 		//only the lower 32 bits of the stimulation code are currently used to compute the color
 		const auto code = uint32_t(stimulationCode);
-		GdkColor color;
-		color.pixel = 0;
-		color.red = 0;
-		color.green = 0;
-		color.blue = 0;
+		GdkColor color = InitGDKColor(0, 0, 0, 0);
 
 		//go through the lower 32 bits to compute RGB components. Bit positions are
 		//inverted so that close code values result in very different colors.
@@ -1130,38 +1128,31 @@ void CSignalDisplayView::updateStimulationColorsDialog(const CString& rStimulati
 
 	GtkLabel* stimLabel = GTK_LABEL(::gtk_label_new("Stimulations"));
 	gtk_widget_set_size_request(GTK_WIDGET(stimLabel), -1, 20);
-	gtk_table_attach(stimulationColorsTable, GTK_WIDGET(stimLabel), 0, 1, 0, 1,
-					 GtkAttachOptions(GTK_EXPAND | GTK_FILL), GTK_FILL, 0, 0);
+	gtk_table_attach(stimulationColorsTable, GTK_WIDGET(stimLabel), 0, 1, 0, 1, GtkAttachOptions(GTK_EXPAND | GTK_FILL), GTK_FILL, 0, 0);
 
 	GtkLabel* colorLabel = GTK_LABEL(::gtk_label_new("Colors"));
 	gtk_widget_set_size_request(GTK_WIDGET(colorLabel), -1, 20);
-	gtk_table_attach(stimulationColorsTable, GTK_WIDGET(colorLabel), 1, 2, 0, 1,
-					 GtkAttachOptions(GTK_EXPAND | GTK_FILL), GTK_FILL, 0, 0);
+	gtk_table_attach(stimulationColorsTable, GTK_WIDGET(colorLabel), 1, 2, 0, 1, GtkAttachOptions(GTK_EXPAND | GTK_FILL), GTK_FILL, 0, 0);
 
 	GtkLabel* label = GTK_LABEL(::gtk_label_new(rStimulationLabel.toASCIIString()));
 	gtk_widget_set_size_request(GTK_WIDGET(label), labelWidthRequest, rowHeightRequest);
-	gtk_table_attach(stimulationColorsTable, GTK_WIDGET(label),
-					 0, 1, //first column
-					 stimulationColorsTable->nrows - 1, stimulationColorsTable->nrows - 1 + 1, //last row
+	gtk_table_attach(stimulationColorsTable, GTK_WIDGET(label), 0, 1,							//first column
+					 stimulationColorsTable->nrows - 1, stimulationColorsTable->nrows - 1 + 1,	//last row
 					 GtkAttachOptions(GTK_EXPAND | GTK_FILL), GtkAttachOptions(GTK_EXPAND | GTK_FILL), 0, 0);
 #if 1
 	GdkPixbuf* pixbuf = gdk_pixbuf_new(GDK_COLORSPACE_RGB, FALSE, 8, colorWidthRequest, rowHeightRequest);
-	//fill with RGBA value
-	const guint32 color = ((guint32(rStimulationColor.red * 255 / 65535)) << 24) +
-		((guint32(rStimulationColor.green * 255 / 65535)) << 16) +
-		((guint32(rStimulationColor.blue * 255 / 65535)) << 8);
+	//fill with RGBA value (255 / 65535 = 1 / 257)
+	const guint32 color = (guint32(rStimulationColor.red / 257) << 24) + (guint32(rStimulationColor.green / 257) << 16) + (guint32(rStimulationColor.blue / 257) << 8);
 	gdk_pixbuf_fill(pixbuf, color);
 	GtkWidget* image = gtk_image_new_from_pixbuf(pixbuf);
-	gtk_table_attach(stimulationColorsTable, GTK_WIDGET(image),
-					 1, 2, //2nd column
-					 stimulationColorsTable->nrows - 1, stimulationColorsTable->nrows - 1 + 1, //last row
+	gtk_table_attach(stimulationColorsTable, GTK_WIDGET(image), 1, 2,							//2nd column
+					 stimulationColorsTable->nrows - 1, stimulationColorsTable->nrows - 1 + 1,	//last row
 					 GtkAttachOptions(GTK_EXPAND | GTK_FILL), GtkAttachOptions(GTK_EXPAND | GTK_FILL), 0, 0);
 #else
 	::GtkColorButton* button = GTK_COLOR_BUTTON(::gtk_color_button_new_with_color(&rStimulationColor));
 	::gtk_widget_set_size_request(GTK_WIDGET(button), colorWidthRequest, rowHeightRequest);
 	//g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(dummyButtonCallback), NULL);
-	::gtk_table_attach(stimulationColorsTable, GTK_WIDGET(button),
-		1, 2, //2nd column
+	::gtk_table_attach(stimulationColorsTable, GTK_WIDGET(button), 1, 2, //2nd column
 		stimulationColorsTable->nrows - 1, stimulationColorsTable->nrows - 1 + 1, //last row
 		static_cast <::GtkAttachOptions>(GTK_EXPAND | GTK_FILL), static_cast <::GtkAttachOptions>(GTK_EXPAND | GTK_FILL), 0, 0);
 #endif
@@ -1180,18 +1171,17 @@ void CSignalDisplayView::refreshScale() { m_VerticalScaleRefresh = true; }	// Bu
 //CALLBACKS
 //
 
-void scrollModeButtonCallback(GtkWidget* widget, gpointer data)
+void ScrollModeButtonCallback(GtkWidget* widget, gpointer data)
 {
-	reinterpret_cast<CSignalDisplayView*>(data)->onDisplayModeToggledCB(
-		gtk_toggle_tool_button_get_active(GTK_TOGGLE_TOOL_BUTTON(widget)) != 0 ? OVP_TypeId_SignalDisplayMode_Scroll : OVP_TypeId_SignalDisplayMode_Scan);
+	reinterpret_cast<CSignalDisplayView*>(data)->onDisplayModeToggledCB(gtk_toggle_tool_button_get_active(GTK_TOGGLE_TOOL_BUTTON(widget)) != 0 ? OVP_TypeId_SignalDisplayMode_Scroll : OVP_TypeId_SignalDisplayMode_Scan);
 }
 
-void unitsButtonCallback(GtkWidget* widget, gpointer data)
+void UnitsButtonCallback(GtkWidget* widget, gpointer data)
 {
 	reinterpret_cast<CSignalDisplayView*>(data)->onUnitsToggledCB(gtk_toggle_tool_button_get_active(GTK_TOGGLE_TOOL_BUTTON(widget)) != 0);
 }
 
-void scalingModeButtonCallback(GtkWidget* widget, gpointer data)
+void ScalingModeButtonCallback(GtkWidget* widget, gpointer data)
 {
 	auto* view = reinterpret_cast<CSignalDisplayView*>(data);
 
@@ -1212,27 +1202,27 @@ void scalingModeButtonCallback(GtkWidget* widget, gpointer data)
 	}
 }
 
-void toggleLeftRulerButtonCallback(GtkWidget* widget, gpointer data)
+void ToggleLeftRulerButtonCallback(GtkWidget* widget, gpointer data)
 {
 	reinterpret_cast<CSignalDisplayView*>(data)->toggleLeftRulers(gtk_toggle_tool_button_get_active(GTK_TOGGLE_TOOL_BUTTON(widget)) != 0);
 }
 
-void toggleBottomRulerButtonCallback(GtkWidget* widget, gpointer data)
+void ToggleBottomRulerButtonCallback(GtkWidget* widget, gpointer data)
 {
 	reinterpret_cast<CSignalDisplayView*>(data)->toggleBottomRuler(gtk_toggle_tool_button_get_active(GTK_TOGGLE_TOOL_BUTTON(widget)) != 0);
 }
 
-void customVerticalScaleChangedCallback(GtkSpinButton* pSpinButton, gpointer data)
+void CustomVerticalScaleChangedCallback(GtkSpinButton* pSpinButton, gpointer data)
 {
 	reinterpret_cast<CSignalDisplayView*>(data)->onCustomVerticalScaleChangedCB(pSpinButton);
 }
 
-void customVerticalOffsetChangedCallback(GtkSpinButton* pSpinButton, gpointer data)
+void CustomVerticalOffsetChangedCallback(GtkSpinButton* pSpinButton, gpointer data)
 {
 	reinterpret_cast<CSignalDisplayView*>(data)->onCustomVerticalOffsetChangedCB(pSpinButton);
 }
 
-gboolean spinButtonValueChangedCallback(GtkSpinButton* widget, gpointer data)
+gboolean SpinButtonValueChangedCallback(GtkSpinButton* widget, gpointer data)
 {
 	auto* view = reinterpret_cast<CSignalDisplayView*>(data);
 
@@ -1266,9 +1256,8 @@ gboolean spinButtonValueChangedCallback(GtkSpinButton* widget, gpointer data)
 	return FALSE;
 }
 
-
 //called when the channel select button is pressed (opens the channel selection dialog)
-void channelSelectButtonCallback(GtkButton* /*button*/, gpointer data)
+void ChannelSelectButtonCallback(GtkButton* /*button*/, gpointer data)
 {
 	auto* view = reinterpret_cast<CSignalDisplayView*>(data);
 
@@ -1293,7 +1282,7 @@ void channelSelectButtonCallback(GtkButton* /*button*/, gpointer data)
 }
 
 //Called when the user presses the apply button of the channel selection dialog
-void channelSelectDialogApplyButtonCallback(GtkButton* /*button*/, gpointer data)
+void ChannelSelectDialogApplyButtonCallback(GtkButton* /*button*/, gpointer data)
 {
 	auto* view = reinterpret_cast<CSignalDisplayView*>(data);
 
@@ -1351,13 +1340,13 @@ void channelSelectDialogApplyButtonCallback(GtkButton* /*button*/, gpointer data
 	gtk_widget_hide(GTK_WIDGET(::gtk_builder_get_object(view->m_BuilderInterface, "SignalDisplayChannelSelectDialog")));
 }
 
-gint closeStimulationColorsWindow(GtkWidget* /*widget*/, GdkEvent* /*event*/, gpointer data)
+gint CloseStimulationColorsWindow(GtkWidget* /*widget*/, GdkEvent* /*event*/, gpointer data)
 {
-	stimulationColorsButtonCallback(nullptr, data);
+	StimulationColorsButtonCallback(nullptr, data);
 	return TRUE;
 }
 
-void stimulationColorsButtonCallback(GtkButton* /*button*/, gpointer data)
+void StimulationColorsButtonCallback(GtkButton* /*button*/, gpointer data)
 {
 	auto* view = reinterpret_cast<CSignalDisplayView*>(data);
 	GtkWidget* stimulationColorsDialog = GTK_WIDGET(::gtk_builder_get_object(view->m_BuilderInterface, "SignalDisplayStimulationColorsDialog"));
@@ -1375,7 +1364,7 @@ void stimulationColorsButtonCallback(GtkButton* /*button*/, gpointer data)
 }
 
 //Called when the user presses the Information button (opens the information dialog)
-void informationButtonCallback(GtkButton* /*button*/, gpointer data)
+void InformationButtonCallback(GtkButton* /*button*/, gpointer data)
 {
 	auto* view = reinterpret_cast<CSignalDisplayView*>(data);
 
@@ -1414,7 +1403,7 @@ void informationButtonCallback(GtkButton* /*button*/, gpointer data)
 }
 
 //called when the channel select button is pressed (opens the channel selection dialog)
-void multiViewButtonCallback(GtkButton* /*button*/, gpointer data)
+void MultiViewButtonCallback(GtkButton* /*button*/, gpointer data)
 {
 	auto* view = reinterpret_cast<CSignalDisplayView*>(data);
 
@@ -1439,7 +1428,7 @@ void multiViewButtonCallback(GtkButton* /*button*/, gpointer data)
 }
 
 //Called when the user presses the apply button of the channel selection dialog
-void multiViewDialogApplyButtonCallback(GtkButton* /*button*/, gpointer data)
+void MultiViewDialogApplyButtonCallback(GtkButton* /*button*/, gpointer data)
 {
 	auto* view = reinterpret_cast<CSignalDisplayView*>(data);
 
diff --git a/plugins/processing/simple-visualization/src/box-algorithms/ovpCSignalDisplay/ovpCSignalDisplayView.h b/plugins/processing/simple-visualization/src/box-algorithms/ovpCSignalDisplay/ovpCSignalDisplayView.h
index 3c386e0f37a5beabf0314459ab06a5f01e0c6780..40f2eecd7cfc02ebbaa529ad47e4056a6c142f10 100644
--- a/plugins/processing/simple-visualization/src/box-algorithms/ovpCSignalDisplay/ovpCSignalDisplayView.h
+++ b/plugins/processing/simple-visualization/src/box-algorithms/ovpCSignalDisplay/ovpCSignalDisplayView.h
@@ -1,20 +1,16 @@
 #pragma once
 
 #include "../../ovp_defines.h"
-
 #include <openvibe/ov_all.h>
 #include <toolkit/ovtk_all.h>
-
-#include <gtk/gtk.h>
-
 #include "ovpCSignalChannelDisplay.h"
 #include "../../ovpCBufferDatabase.h"
-
 #include "../../ovpCBottomTimeRuler.h"
-
-#include <vector>
-#include <string>
+#include <gtk/gtk.h>
 #include <map>
+#include <string>
+#include <vector>
+
 
 namespace OpenViBEPlugins
 {
@@ -106,7 +102,7 @@ namespace OpenViBEPlugins
 			 * \param mode New display mode
 			 * \return True
 			 */
-			bool onDisplayModeToggledCB(OpenViBE::CIdentifier mode);
+			bool onDisplayModeToggledCB(const OpenViBE::CIdentifier& mode);
 
 			bool onUnitsToggledCB(bool active);
 
@@ -205,7 +201,7 @@ namespace OpenViBEPlugins
 			double m_MarginFactor = 0.4;
 
 			//! Normal/zooming cursors
-			GdkCursor* m_Cursor[2];
+			std::array<GdkCursor*, 2> m_Cursor;
 
 			/** \name Vertical scale */
 			//@{
diff --git a/plugins/processing/simple-visualization/src/ovpCBottomTimeRuler.cpp b/plugins/processing/simple-visualization/src/ovpCBottomTimeRuler.cpp
index 8b08b996174b505be3cda4a5e4bee646733389e4..1178b69d0f98546c2c4932f70fe42a73caf70fd0 100644
--- a/plugins/processing/simple-visualization/src/ovpCBottomTimeRuler.cpp
+++ b/plugins/processing/simple-visualization/src/ovpCBottomTimeRuler.cpp
@@ -1,7 +1,5 @@
 #include "ovpCBottomTimeRuler.h"
-
 #include <cmath>
-
 #include <sstream>
 
 using namespace OpenViBE;
@@ -31,8 +29,8 @@ gboolean ResizeBottomRulerCB(GtkWidget* /*widget*/, GtkAllocation* allocation, g
 	return FALSE;
 }
 
-CBottomTimeRuler::CBottomTimeRuler(CBufferDatabase& database, const int widthRequest, const int heightRequest) :
-	m_database(&database), m_heightRequest(heightRequest)
+CBottomTimeRuler::CBottomTimeRuler(CBufferDatabase& database, const int widthRequest, const int heightRequest) 
+	: m_database(&database), m_heightRequest(heightRequest)
 {
 	//creates the main drawing area
 	m_bottomRuler = gtk_drawing_area_new();
@@ -68,10 +66,10 @@ void CBottomTimeRuler::draw()
 	const double widthPerBuffer = double(bottomRulerWidth) / double(numberOfBufferToDisplay);
 
 	//computes the step of the values displayed on the ruler
-	double valueStep = 0;
 	const auto nearestSmallerPowerOf10 = double(pow(10, floor(log10(intervalWidth))));
 	const auto maxNumberOfLabels = uint64_t(bottomRulerWidth / m_pixelsPerLabel);
 
+	double valueStep = nearestSmallerPowerOf10;
 	if (uint64_t(floor(intervalWidth / nearestSmallerPowerOf10)) > maxNumberOfLabels)
 	{
 		valueStep = 2 * nearestSmallerPowerOf10;
@@ -80,10 +78,6 @@ void CBottomTimeRuler::draw()
 	{
 		valueStep = nearestSmallerPowerOf10 / 2;
 	}
-	else
-	{
-		valueStep = nearestSmallerPowerOf10;
-	}
 
 	if (m_database->getDisplayMode() == OVP_TypeId_SignalDisplayMode_Scroll)
 	{
diff --git a/plugins/processing/simple-visualization/src/ovpCBottomTimeRuler.h b/plugins/processing/simple-visualization/src/ovpCBottomTimeRuler.h
index 4beceb5dc4084fbd4626984b90ff0e60e5479197..1cbc4d541cf5609b774ff7f9788b6a62cbaa3478 100644
--- a/plugins/processing/simple-visualization/src/ovpCBottomTimeRuler.h
+++ b/plugins/processing/simple-visualization/src/ovpCBottomTimeRuler.h
@@ -1,8 +1,9 @@
 #pragma once
 
-#include <openvibe/ov_all.h>
 #include "ovpCBufferDatabase.h"
 #include <gtk/gtk.h>
+#include <openvibe/ov_all.h>
+
 
 namespace OpenViBEPlugins
 {
diff --git a/plugins/processing/simple-visualization/src/ovpCBufferDatabase.cpp b/plugins/processing/simple-visualization/src/ovpCBufferDatabase.cpp
index a1f454a40f13109259664b61b02ceb2206759367..4f009aa7056fc2e5029f740aca83cd03871a466a 100644
--- a/plugins/processing/simple-visualization/src/ovpCBufferDatabase.cpp
+++ b/plugins/processing/simple-visualization/src/ovpCBufferDatabase.cpp
@@ -1,11 +1,10 @@
 #include "ovpCBufferDatabase.h"
-
-#include <system/ovCMemory.h>
-#include <openvibe/ovITimeArithmetics.h>
-
 #include <algorithm>
 #include <cmath>
 #include <cstring>
+#include <system/ovCMemory.h>
+#include <openvibe/ovITimeArithmetics.h>
+
 
 using namespace OpenViBE;
 using namespace Plugins;
@@ -171,7 +170,7 @@ bool CBufferDatabase::decodeChannelLocalisationMemoryBuffer(const IMemoryBuffer*
 
 void CBufferDatabase::setDrawable(CSignalDisplayDrawable* pDrawable) { m_Drawable = pDrawable; }
 
-bool CBufferDatabase::getErrorStatus() { return m_error; }
+bool CBufferDatabase::getErrorStatus() { return m_Error; }
 
 bool CBufferDatabase::onChannelLocalisationBufferReceived(const uint32_t index)
 {
@@ -240,7 +239,7 @@ void CBufferDatabase::setMatrixDimensionCount(const uint32_t count)
 {
 	if (count != 2)
 	{
-		m_error = true;
+		m_Error = true;
 		m_ParentPlugin.getBoxAlgorithmContext()->getPlayerContext()->getLogManager() << LogLevel_Error << "Caller tried to set a " << count << "-dimensional matrix. Only 2-dimensional matrices are supported (e.g. [rows X cols]).\n";
 	}
 	if (count == 1)
@@ -253,7 +252,7 @@ void CBufferDatabase::setMatrixDimensionSize(const uint32_t index, const uint32_
 {
 	if (index >= 2)
 	{
-		m_error = true;
+		m_Error = true;
 		m_ParentPlugin.getBoxAlgorithmContext()->getPlayerContext()->getLogManager() << LogLevel_Error << "Tried to access dimension " << index << ", only 0 and 1 supported\n";
 		return;
 	}
@@ -261,7 +260,7 @@ void CBufferDatabase::setMatrixDimensionSize(const uint32_t index, const uint32_
 	if (m_DimensionSizes[index] != 0 && m_DimensionSizes[index] != size)
 	{
 		m_ParentPlugin.getBoxAlgorithmContext()->getPlayerContext()->getLogManager() << LogLevel_Error << "Upstream tried to change the data chunk size after the first header, this is not supported.\n";
-		m_error = true;
+		m_Error = true;
 		return;
 	}
 
@@ -279,11 +278,11 @@ void CBufferDatabase::setMatrixDimensionSize(const uint32_t index, const uint32_
 
 void CBufferDatabase::setMatrixDimensionLabel(const uint32_t index, const uint32_t entryIndex, const char* label)
 {
-	if (m_error) { return; }
+	if (m_Error) { return; }
 
 	if (index >= 2)
 	{
-		m_error = true;
+		m_Error = true;
 		m_ParentPlugin.getBoxAlgorithmContext()->getPlayerContext()->getLogManager() << LogLevel_Error << "Tried to access dimension " << index << ", only 0 and 1 supported\n";
 		return;
 	}
@@ -294,7 +293,7 @@ void CBufferDatabase::setMatrixDimensionLabel(const uint32_t index, const uint32
 bool CBufferDatabase::setMatrixBuffer(const double* buffer, const uint64_t startTime, const uint64_t endTime)
 {
 	//if an error has occurred, do nothing
-	if (m_error) { return false; }
+	if (m_Error) { return false; }
 
 	// Check for time-continuity
 	if (startTime < m_LastBufferEndTime && !m_WarningPrinted)
@@ -317,9 +316,7 @@ bool CBufferDatabase::setMatrixBuffer(const double* buffer, const uint64_t start
 		if (m_BufferDuration == 0)
 		{
 			m_ParentPlugin.getBoxAlgorithmContext()->getPlayerContext()->getLogManager() << LogLevel_Warning << "Error : buffer start time and end time are equal : " << startTime << "\n";
-
-			m_error = true;
-
+			m_Error = true;
 			return false;
 		}
 
@@ -340,7 +337,7 @@ bool CBufferDatabase::setMatrixBuffer(const double* buffer, const uint64_t start
 		}
 		if (m_SamplingFrequency != estimatedFrequency)
 		{
-			m_ParentPlugin.getBoxAlgorithmContext()->getPlayerContext()->getLogManager() << LogLevel_Warning
+			m_ParentPlugin.getBoxAlgorithmContext()->getPlayerContext()->getLogManager() << LogLevel_Warning 
 				<< "Sampling rate [" << estimatedFrequency << "] suggested by chunk properties differs from stream-specified rate [" << m_SamplingFrequency << "]. There may be a problem with an upstream box. Trying to use the estimated rate.\n";
 			m_SamplingFrequency = estimatedFrequency;
 		}
@@ -373,7 +370,7 @@ bool CBufferDatabase::setMatrixBuffer(const double* buffer, const uint64_t start
 		}
 	}
 
-	double* bufferToWrite = nullptr;
+	double* bufferToWrite                   = nullptr;
 	const uint64_t numberOfSamplesPerBuffer = m_DimensionSizes[0] * m_DimensionSizes[1];
 
 	//if old buffers need to be removed
@@ -444,7 +441,7 @@ bool CBufferDatabase::setMatrixBuffer(const double* buffer, const uint64_t start
 	}
 
 	//tells the drawable to redraw himself since the signal information has been updated
-	if (m_redrawOnNewData) { m_Drawable->redraw(); }
+	if (m_RedrawOnNewData) { m_Drawable->redraw(); }
 
 	return true;
 }
@@ -517,7 +514,7 @@ bool CBufferDatabase::getElectrodePosition(const uint32_t index, double* positio
 	{
 		//if(m_cartesianStreamedCoords == true)
 		//{
-		*position = *(m_channelLocalisationStreamedCoords[0].first->getBuffer() + 3 * index);
+		*position       = *(m_channelLocalisationStreamedCoords[0].first->getBuffer() + 3 * index);
 		*(position + 1) = *(m_channelLocalisationStreamedCoords[0].first->getBuffer() + 3 * index + 1);
 		*(position + 2) = *(m_channelLocalisationStreamedCoords[0].first->getBuffer() + 3 * index + 2);
 		//}
@@ -535,7 +532,7 @@ bool CBufferDatabase::getElectrodePosition(const CString& label, double* positio
 		{
 			//if(m_cartesianStreamedCoords == true)
 			//{
-			*position = *(m_channelLocalisationStreamedCoords[0].first->getBuffer() + 3 * i);
+			*position       = *(m_channelLocalisationStreamedCoords[0].first->getBuffer() + 3 * i);
 			*(position + 1) = *(m_channelLocalisationStreamedCoords[0].first->getBuffer() + 3 * i + 1);
 			*(position + 2) = *(m_channelLocalisationStreamedCoords[0].first->getBuffer() + 3 * i + 2);
 			//}
@@ -655,7 +652,7 @@ bool CBufferDatabase::fillChannelLookupTable()
 			{
 				if (strcmp(channelLabel.c_str(), m_channelLocalisationLabels[j].toASCIIString()) == 0)
 				{
-					labelRecognized = true;
+					labelRecognized           = true;
 					m_ChannelLookupIndices[i] = j;
 					break;
 				}
@@ -665,10 +662,7 @@ bool CBufferDatabase::fillChannelLookupTable()
 		//unrecognized electrode!
 		if (!labelRecognized)
 		{
-			m_ParentPlugin.getLogManager() << LogLevel_Warning
-				<< "Unrecognized electrode name (index=" << i
-				<< ", name=" << m_DimensionLabels[0][i].c_str()
-				<< ")!\n";
+			m_ParentPlugin.getLogManager() << LogLevel_Warning << "Unrecognized electrode name (index=" << i << ", name=" << m_DimensionLabels[0][i].c_str() << ")!\n";
 			res = false;
 		}
 	}
diff --git a/plugins/processing/simple-visualization/src/ovpCBufferDatabase.h b/plugins/processing/simple-visualization/src/ovpCBufferDatabase.h
index e6633c1ab727ffc04c5b91ad89c30630e6ff9c65..6f8f6fb724cb17a44a2956a802d07cf8b2e5f2a0 100644
--- a/plugins/processing/simple-visualization/src/ovpCBufferDatabase.h
+++ b/plugins/processing/simple-visualization/src/ovpCBufferDatabase.h
@@ -1,19 +1,16 @@
-#ifndef __OpenViBEPlugins_SimpleVisualization_CBufferDatabase_H__
-#define __OpenViBEPlugins_SimpleVisualization_CBufferDatabase_H__
+#pragma once
 
-#include "ovp_defines.h"
-
-#include <openvibe/ov_all.h>
-#include <toolkit/ovtk_all.h>
-
-#include <vector>
+#include <cfloat>
 #include <deque>
 #include <queue>
 #include <string>
-#include <cfloat>
-
-#include <iostream>
+#include <vector>
 #include <array>
+#include <iostream>
+
+#include "ovp_defines.h"
+#include <openvibe/ov_all.h>
+#include <toolkit/ovtk_all.h>
 
 namespace OpenViBEPlugins
 {
@@ -121,10 +118,10 @@ namespace OpenViBEPlugins
 
 			OpenViBEToolkit::TBoxAlgorithm<OpenViBE::Plugins::IBoxAlgorithm>& m_ParentPlugin;
 
-			bool m_error = false;
+			bool m_Error = false;
 
 			//! Redraws the associated SignalDisplayDrawable upon new data reception if true (default)
-			bool m_redrawOnNewData = true;
+			bool m_RedrawOnNewData = true;
 
 		protected:
 			/* \name Channel localisation */
@@ -350,7 +347,7 @@ namespace OpenViBEPlugins
 			 * \brief Set flag stating whether to redraw associated SignalDisplayDrawable objet when new data is available
 			 * \param set Value to set flag with
 			 */
-			virtual void setRedrawOnNewData(const bool set) { m_redrawOnNewData = set; }
+			virtual void setRedrawOnNewData(const bool set) { m_RedrawOnNewData = set; }
 
 		protected:
 			/**
@@ -370,5 +367,3 @@ namespace OpenViBEPlugins
 		};
 	}  // namespace SimpleVisualization
 }  // namespace OpenViBEPlugins
-
-#endif
diff --git a/plugins/processing/simple-visualization/src/ovpCSpectrumDatabase.cpp b/plugins/processing/simple-visualization/src/ovpCSpectrumDatabase.cpp
index e8415ea6dd23c63fe88691f80517fc03a09cd8d3..9976f7c258091116240b08c96725d365b2823ac7 100755
--- a/plugins/processing/simple-visualization/src/ovpCSpectrumDatabase.cpp
+++ b/plugins/processing/simple-visualization/src/ovpCSpectrumDatabase.cpp
@@ -1,8 +1,7 @@
-#include <system/ovCMemory.h>
+#include "ovpCSpectrumDatabase.h"
 #include <algorithm>
 #include <cmath>
-
-#include "ovpCSpectrumDatabase.h"
+#include <system/ovCMemory.h>
 
 using namespace OpenViBE;
 using namespace Plugins;
@@ -21,8 +20,7 @@ bool CSpectrumDatabase::initialize()
 {
 	if (m_decoder != nullptr) { return false; }
 
-	m_decoder = &m_parentPlugin.getAlgorithmManager().getAlgorithm(
-		m_parentPlugin.getAlgorithmManager().createAlgorithm(OVP_GD_ClassId_Algorithm_SpectrumStreamDecoder));
+	m_decoder = &m_parentPlugin.getAlgorithmManager().getAlgorithm(m_parentPlugin.getAlgorithmManager().createAlgorithm(OVP_GD_ClassId_Algorithm_SpectrumStreamDecoder));
 
 	m_decoder->initialize();
 
@@ -31,7 +29,7 @@ bool CSpectrumDatabase::initialize()
 
 size_t CSpectrumDatabase::getFrequencyAbscissaCount() const
 {
-	return m_FrequencyAbscissa.size();
+	return m_frequencyAbscissa.size();
 }
 
 //double CSpectrumDatabase::getFrequencyBandWidth()
@@ -46,7 +44,7 @@ size_t CSpectrumDatabase::getFrequencyAbscissaCount() const
 //	}
 //}
 
-//double CSpectrumDatabase::getFrequencyBandStart(uint32_t ui32FrequencyBandIndex)
+//double CSpectrumDatabase::getFrequencyBandStart(uint32_t frequencyBandIndex)
 //{
 //	if(m_oFrequencyBands.size() == 0)
 //	{
@@ -54,11 +52,11 @@ size_t CSpectrumDatabase::getFrequencyAbscissaCount() const
 //	}
 //	else
 //	{
-//		return m_oFrequencyBands[ui32FrequencyBandIndex].first;
+//		return m_oFrequencyBands[frequencyBandIndex].first;
 //	}
 //}
 
-//double CSpectrumDatabase::getFrequencyBandStop(uint32_t ui32FrequencyBandIndex)
+//double CSpectrumDatabase::getFrequencyBandStop(uint32_t frequencyBandIndex)
 //{
 //	if(ui32FrequencyBandIndex >= m_oFrequencyBands.size())
 //	{
@@ -66,7 +64,7 @@ size_t CSpectrumDatabase::getFrequencyAbscissaCount() const
 //	}
 //	else
 //	{
-//		return m_oFrequencyBands[ui32FrequencyBandIndex].second;
+//		return m_oFrequencyBands[frequencyBandIndex].second;
 //	}
 //}
 
@@ -79,7 +77,7 @@ bool CSpectrumDatabase::decodeHeader()
 	//store frequency bands
 	for (uint32_t i = 0; i < frequencyAbscissaMatrix->getDimensionSize(0); ++i)
 	{
-		m_FrequencyAbscissa.push_back(frequencyAbscissaMatrix->getBuffer()[i]);
+		m_frequencyAbscissa.push_back(frequencyAbscissaMatrix->getBuffer()[i]);
 	}
 
 	CStreamedMatrixDatabase::decodeHeader();
diff --git a/plugins/processing/simple-visualization/src/ovpCSpectrumDatabase.h b/plugins/processing/simple-visualization/src/ovpCSpectrumDatabase.h
index 4c85c9e7f30694aa24d582c749f3974ab78f13ae..913140c81241bfcf53b9914be677f8cfe9aae9fe 100755
--- a/plugins/processing/simple-visualization/src/ovpCSpectrumDatabase.h
+++ b/plugins/processing/simple-visualization/src/ovpCSpectrumDatabase.h
@@ -1,18 +1,18 @@
-#ifndef __OpenViBEPlugins_SimpleVisualization_CSpectrumDatabase_H__
-#define __OpenViBEPlugins_SimpleVisualization_CSpectrumDatabase_H__
+#pragma once
 
-#include "ovp_defines.h"
 #include "ovpCStreamedMatrixDatabase.h"
 
+#include "ovp_defines.h"
 #include <openvibe/ov_all.h>
 #include <toolkit/ovtk_all.h>
 
-#include <vector>
+#include <cfloat>
 #include <deque>
+#include <iostream>
 #include <queue>
 #include <string>
-#include <cfloat>
-#include <iostream>
+#include <vector>
+
 
 namespace OpenViBEPlugins
 {
@@ -38,9 +38,7 @@ namespace OpenViBEPlugins
 			 */
 			//TODO (if min/max computation should be restricted to this range)
 			/*
-			void setDisplayedFrequencyRange(
-				double minimumDisplayedFrequency,
-				double maximumDisplayedFrequency);*/
+			void setDisplayedFrequencyRange(double minimumDisplayedFrequency, double maximumDisplayedFrequency);*/
 
 			/** \name Frequency bands management */
 			//@{
@@ -55,23 +53,21 @@ namespace OpenViBEPlugins
 			 * \brief Get width of a frequency band (in Hz)
 			 * \return Frequency band width
 			 */
-			//			double getFrequencyBandWidth();
+			// double getFrequencyBandWidth();
 
 			/**
 			 * \brief Get frequency band start frequency
-			 * \param ui32FrequencyBandIndex Index of frequency band
+			 * \param frequencyBandIndex Index of frequency band
 			 * \return Frequency band start if it could be retrieved, 0 otherwise
 			 */
-			//			double getFrequencyBandStart(
-			//				uint32_t ui32FrequencyBandIndex);
+			// double getFrequencyBandStart(uint32_t frequencyBandIndex);
 
 			/**
 			 * \brief Get frequency band stop frequency
-			 * \param ui32FrequencyBandIndex Index of frequency band
+			 * \param frequencyBandIndex Index of frequency band
 			 * \return Frequency band stop if it could be retrieved, 0 otherwise
 			 */
-			//			double getFrequencyBandStop(
-			//				uint32_t ui32FrequencyBandIndex);
+			// double getFrequencyBandStop(uint32_t frequencyBandIndex);
 
 			//@}
 
@@ -79,9 +75,7 @@ namespace OpenViBEPlugins
 			bool decodeHeader() override;
 
 		private:
-			std::vector<double> m_FrequencyAbscissa;
+			std::vector<double> m_frequencyAbscissa;
 		};
 	}  // namespace SimpleVisualization
 }  // namespace OpenViBEPlugins
-
-#endif
diff --git a/plugins/processing/simple-visualization/src/ovpCStreamedMatrixDatabase.cpp b/plugins/processing/simple-visualization/src/ovpCStreamedMatrixDatabase.cpp
index e5918e6e16954499d6fc25ad52eb6791fef845f2..2544f4a2a93fb40e0f3c961e480e3b602ca33080 100644
--- a/plugins/processing/simple-visualization/src/ovpCStreamedMatrixDatabase.cpp
+++ b/plugins/processing/simple-visualization/src/ovpCStreamedMatrixDatabase.cpp
@@ -1,9 +1,7 @@
-#include <system/ovCMemory.h>
+#include "ovpCStreamedMatrixDatabase.h"
 #include <algorithm>
 #include <cmath>
-
-#include "ovpCStreamedMatrixDatabase.h"
-
+#include <system/ovCMemory.h>
 #include <openvibe/ovITimeArithmetics.h>
 
 using namespace OpenViBE;
diff --git a/plugins/processing/simple-visualization/src/ovpCStreamedMatrixDatabase.h b/plugins/processing/simple-visualization/src/ovpCStreamedMatrixDatabase.h
index 0a40226806ba5930a0fb7eb427a8912be0958946..dbd0846f9364206237ffd7cef3af64a3486210c4 100644
--- a/plugins/processing/simple-visualization/src/ovpCStreamedMatrixDatabase.h
+++ b/plugins/processing/simple-visualization/src/ovpCStreamedMatrixDatabase.h
@@ -1,17 +1,16 @@
 #pragma once
-
-#include "ovp_defines.h"
 #include "ovpIStreamDatabase.h"
-
+#include "ovp_defines.h"
 #include <openvibe/ov_all.h>
 #include <toolkit/ovtk_all.h>
 
-#include <vector>
+#include <cfloat>
 #include <deque>
+#include <iostream>
 #include <queue>
 #include <string>
-#include <cfloat>
-#include <iostream>
+#include <vector>
+
 
 namespace OpenViBEPlugins
 {
diff --git a/plugins/processing/simple-visualization/src/ovpCTimeRuler.cpp b/plugins/processing/simple-visualization/src/ovpCTimeRuler.cpp
index 61e3b8a30523a3282f6f9342ff5702c22b1382e7..c37e51945999859eeeaab0345545435d818f38bd 100644
--- a/plugins/processing/simple-visualization/src/ovpCTimeRuler.cpp
+++ b/plugins/processing/simple-visualization/src/ovpCTimeRuler.cpp
@@ -1,8 +1,7 @@
+#include "ovpCTimeRuler.h"
 #include <cmath>
 #include <sstream>
 
-#include "ovpCTimeRuler.h"
-
 using namespace OpenViBE;
 using namespace Plugins;
 
@@ -56,14 +55,13 @@ void CTimeRuler::draw()
 	const double startTime = CONVERT_TIME(m_streamDatabase.getStartTime(0));
 	const double endTime = CONVERT_TIME(m_streamDatabase.getStartTime(0) + m_streamDatabase.getMaxBufferCount() * m_streamDatabase.getBufferTimeStep());
 	const double intervalWidth = endTime - startTime;
-	double valueStep = 0;
-	double baseValue = 0;
 
 	//compute step between two values displayed on the ruler
 	const auto nearestSmallerPowerOf10 = double(pow(10, floor(log10(intervalWidth))));
 
 	const auto maxNumberOfLabels = uint64_t(bottomRulerWidth / m_pixelsPerLabel);
 
+	double valueStep = nearestSmallerPowerOf10;
 	if (uint64_t(floor(intervalWidth / nearestSmallerPowerOf10)) > maxNumberOfLabels)
 	{
 		valueStep = 2 * nearestSmallerPowerOf10;
@@ -72,13 +70,9 @@ void CTimeRuler::draw()
 	{
 		valueStep = nearestSmallerPowerOf10 / 2;
 	}
-	else
-	{
-		valueStep = nearestSmallerPowerOf10;
-	}
 
 	//recompute step base value
-	baseValue = valueStep * floor(startTime / valueStep);
+	const double baseValue = valueStep * floor(startTime / valueStep);
 
 	//X position of the first label
 	const double widthPerBuffer = double(bottomRulerWidth) / double(m_streamDatabase.getMaxBufferCount());
diff --git a/plugins/processing/simple-visualization/src/ovpCTimeRuler.h b/plugins/processing/simple-visualization/src/ovpCTimeRuler.h
index 5d5425233b0de71547b68bfe3dfd10f2f553ccd1..0bbcb3cf2210f398f9c86b62463fcd72c87e089e 100644
--- a/plugins/processing/simple-visualization/src/ovpCTimeRuler.h
+++ b/plugins/processing/simple-visualization/src/ovpCTimeRuler.h
@@ -1,10 +1,10 @@
-#ifndef __OpenViBEPlugins_SimpleVisualization_CTimeRuler_H__
-#define __OpenViBEPlugins_SimpleVisualization_CTimeRuler_H__
+#pragma once
 
-#include <openvibe/ov_all.h>
 #include "ovpIStreamDatabase.h"
+#include <openvibe/ov_all.h>
 #include <gtk/gtk.h>
 
+
 namespace OpenViBEPlugins
 {
 	namespace SimpleVisualization
@@ -22,10 +22,7 @@ namespace OpenViBEPlugins
 			 * \param widthRequest Width to be requested by widget
 			 * \param heightRequest Height to be requested by widget
 			 */
-			CTimeRuler(
-				IStreamDatabase& streamDatabase,
-				int widthRequest,
-				int heightRequest);
+			CTimeRuler(IStreamDatabase& streamDatabase, int widthRequest, int heightRequest);
 
 			/**
 			 * \brief Destructor
@@ -74,5 +71,3 @@ namespace OpenViBEPlugins
 		};
 	}  // namespace SimpleVisualization
 }  // namespace OpenViBEPlugins
-
-#endif
diff --git a/plugins/processing/simple-visualization/src/ovp_main.cpp b/plugins/processing/simple-visualization/src/ovp_main.cpp
index cfc83b0bc601fd57380854a60c902983ead04035..ca54ce4170d9eafb74b456c0dd6d4d4af7af6f3a 100755
--- a/plugins/processing/simple-visualization/src/ovp_main.cpp
+++ b/plugins/processing/simple-visualization/src/ovp_main.cpp
@@ -1,19 +1,19 @@
 #include "ovp_defines.h"
-
 #include "algorithms/ovpCAlgorithmLevelMeasure.h"
 
 //Presentation
-#include "box-algorithms/ovpCGrazVisualization.h"
-#include "box-algorithms/ovpCGrazMultiVisualization.h"
-#include "box-algorithms/ovpCBoxAlgorithmP300SpellerVisualization.h"
-#include "box-algorithms/ovpCBoxAlgorithmP300MagicCardVisualization.h"
 #include "box-algorithms/ovpCBoxAlgorithmP300IdentifierCardVisualization.h"
+#include "box-algorithms/ovpCBoxAlgorithmP300MagicCardVisualization.h"
+#include "box-algorithms/ovpCBoxAlgorithmP300SpellerVisualization.h"
 #include "box-algorithms/ovpCDisplayCueImage.h"
+#include "box-algorithms/ovpCGrazMultiVisualization.h"
+#include "box-algorithms/ovpCGrazVisualization.h"
 
 //2D plugins
-#include "box-algorithms/ovpCSignalDisplay.h"
-#include "box-algorithms/ovpCBoxAlgorithmLevelMeasure.h"
 #include "box-algorithms/ovpCBoxAlgorithmErpPlot.h"
+#include "box-algorithms/ovpCBoxAlgorithmLevelMeasure.h"
+#include "box-algorithms/ovpCSignalDisplay.h"
+
 
 OVP_Declare_Begin()
 		rPluginModuleContext.getTypeManager().registerEnumerationEntry(OV_TypeId_BoxAlgorithmFlag, OV_AttributeId_Box_FlagIsUnstable.toString(), OV_AttributeId_Box_FlagIsUnstable.toUInteger());
diff --git a/plugins/processing/simple-visualization/src/utils.h b/plugins/processing/simple-visualization/src/utils.h
new file mode 100644
index 0000000000000000000000000000000000000000..54359608554572096a2ec28f58df3090ea03c4d4
--- /dev/null
+++ b/plugins/processing/simple-visualization/src/utils.h
@@ -0,0 +1,52 @@
+#pragma once
+
+#include "ovp_defines.h"
+#include <openvibe/ov_all.h>
+#include <toolkit/ovtk_all.h>
+#include <visualization-toolkit/ovviz_all.h>
+#include <gtk/gtk.h>
+#include <sstream>
+
+//---------------------------------------------------------------------------------------------------
+/// <summary> Initializes the color of the GDK. with old compiler as vs2013 we can't initialize structure easily.....</summary>
+/// <param name="pixel"> For allocated colors, the pixel value used to draw this color on the screen.Not used anymore.</param>
+/// <param name="r"> The red component of the color. This is a value between 0 and 65535, with 65535 indicating full intensity.</param>
+/// <param name="g"> The green component of the color.</param>
+/// <param name="b"> The blue component of the color.</param>
+/// <returns> The initialized color (</returns>
+inline GdkColor InitGDKColor(const guint32 pixel = 0, const guint16 r = 0, const guint16 g = 0, const guint16 b = 0)
+{
+	GdkColor c;
+	c.pixel = pixel;
+	c.red = r;
+	c.green = g;
+	c.blue = b;
+	return c;
+}
+//---------------------------------------------------------------------------------------------------
+
+//---------------------------------------------------------------------------------------------------
+class CGdkcolorAutoCast
+{
+public:
+	CGdkcolorAutoCast(const OpenViBE::Kernel::IBox& rBox, OpenViBE::Kernel::IConfigurationManager& rConfigurationManager, const uint32_t index)
+		: m_configurationManager(rConfigurationManager)
+	{
+		rBox.getSettingValue(index, m_settingValue);
+		m_settingValue = m_configurationManager.expand(m_settingValue);
+	}
+
+	operator GdkColor() const
+	{
+		std::stringstream ss(m_settingValue.toASCIIString());
+		int r = 0, g = 0, b = 0;
+		char c;
+		ss >> r >> c >> g >> c >> b;
+		return InitGDKColor(0, guint16(r * 655.35), guint16(g * 655.35), guint16(b * 655.35));
+	}
+
+protected:
+	OpenViBE::Kernel::IConfigurationManager& m_configurationManager;
+	OpenViBE::CString m_settingValue;
+};
+//---------------------------------------------------------------------------------------------------