diff --git a/acinclude.m4 b/acinclude.m4
index 47315fdf6..f53563291 100644
--- a/acinclude.m4
+++ b/acinclude.m4
@@ -609,6 +609,18 @@ case "$BOXMODEL" in
 		AC_DEFINE(ENABLE_CHANGE_OSD_RESOLUTION, 1, [enable to change osd resolution])
 	;;
 esac
+
+# BOXMODELs that needs GraphLCD support
+case "$BOXMODEL" in
+	vusolo4k|vuduo4k|vuultimo4k|vuuno4kse)
+		AC_DEFINE(ENABLE_GRAPHLCD, 1, [include GraphLCD support])
+		enable_graphlcd=yes
+	;;
+	*)
+		enable_graphlcd=no
+	;;
+esac
+AM_CONDITIONAL(ENABLE_GRAPHLCD, test "$enable_graphlcd" = "yes")
 ])
 
 dnl backward compatiblity
diff --git a/data/locale/deutsch.locale b/data/locale/deutsch.locale
index 5512bfb50..f58c9fda8 100644
--- a/data/locale/deutsch.locale
+++ b/data/locale/deutsch.locale
@@ -856,6 +856,45 @@ fsk.from_7 ab 7
 fsk.to_12 bis 12
 fsk.to_16 bis 16
 fsk.to_7 bis 7
+glcd.brightness Helligkeit
+glcd.brightness_standby Helligkeit in Standby
+glcd.color.black Schwarz
+glcd.color.blue Blau
+glcd.color.cyan Blaugrün
+glcd.color.green Grün
+glcd.color.magenta Magenta
+glcd.color.red Rot
+glcd.color.white Weiss
+glcd.color.yellow Gelb
+glcd.color.orange Orange
+glcd.color.light_gray Hellgrau
+glcd.color.gray Grau
+glcd.color.dark_gray Dunkelgrau
+glcd.color.dark_red Dunkelrot
+glcd.color.dark_green Dunkelgrün
+glcd.color.dark_blue Dunkelblau
+glcd.color.purple Purple
+glcd.color.mint Mint
+glcd.color.golden Golden
+glcd.enable GraphLCD aktiv
+glcd.font Schrift
+glcd.head GraphLCD-Unterstützung
+glcd.mirror_osd OSD-Menü auf GraphLCD anzeigen
+glcd.mirror_video Videobild auf GraphLCD anzeigen
+glcd.restart Neu erkennen
+glcd.scroll_speed Scroll-Geschwindigkeit
+glcd.select.bar Fortschrittsbalken-Farbe
+glcd.select.bg Hintergrund-Farbe
+glcd.select.fg Vordergrund-Farbe
+glcd.show_logo Sender-Logo anzeigen
+glcd.size_bar Fortschrittsbalken-Größe
+glcd.size_channel Sender-Größe
+glcd.size_epg EPG-Größe
+glcd.size_logo Logo-Größe
+glcd.size_time Uhrzeit-Größe
+glcd.size_time_standby Uhrzeit-Größe in Standby
+glcd.time_in_standby Zeitanzeige in Standby
+glcd.volume Lautstärke
 hdd_10min 10 min.
 hdd_1min 1 min.
 hdd_20min 20 min.
diff --git a/data/locale/english.locale b/data/locale/english.locale
index dbb02e3c8..cfd8a0a71 100644
--- a/data/locale/english.locale
+++ b/data/locale/english.locale
@@ -856,6 +856,45 @@ fsk.from_7 from 7
 fsk.to_12 to 12
 fsk.to_16 to 16
 fsk.to_7 to 7
+glcd.brightness Brightness
+glcd.brightness_standby Brightness in standby
+glcd.color.black Black
+glcd.color.blue Blue
+glcd.color.cyan Blue-Green
+glcd.color.green Green
+glcd.color.magenta Magenta
+glcd.color.red Red
+glcd.color.white White
+glcd.color.yellow Yellow
+glcd.color.orange Orange
+glcd.color.light_gray Light Gray
+glcd.color.gray Gray
+glcd.color.dark_gray Dark Gray
+glcd.color.dark_red Dark Red
+glcd.color.dark_green Dark Green
+glcd.color.dark_blue Dark Blue
+glcd.color.purple Purple
+glcd.color.mint Mint
+glcd.color.golden Golden
+glcd.enable GraphLCD enabled
+glcd.font Font
+glcd.head GraphLCD-Support
+glcd.mirror_osd Show OSD menu on GraphLCD
+glcd.mirror_video Show running video on GraphLCD
+glcd.restart Rescan
+glcd.scroll_speed Scrolling Speed
+glcd.select.bar Progress bar color
+glcd.select.bg Background color
+glcd.select.fg Foreground color
+glcd.show_logo Show channel logo
+glcd.size_bar Progress bar height
+glcd.size_channel Channel height
+glcd.size_epg EPG height
+glcd.size_logo Logo height
+glcd.size_time Time height
+glcd.size_time_standby Time height in standby
+glcd.time_in_standby Display time in standby
+glcd.volume Volume
 hdd_10min 10 min.
 hdd_1min 1 min.
 hdd_20min 20 min.
diff --git a/src/Makefile.am b/src/Makefile.am
index 1c1648869..41cea7fe0 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -130,6 +130,10 @@ neutrino_LDADD = \
 	-lrt -lpthread \
 	-lz
 
+if ENABLE_GRAPHLCD
+neutrino_LDADD += -lglcddrivers -lglcdgraphics -lusb-1.0
+endif
+
 if ENABLE_GIFLIB
 neutrino_LDADD += -lgif
 else
diff --git a/src/driver/Makefile.am b/src/driver/Makefile.am
index bcfbad15a..1ddb6b376 100644
--- a/src/driver/Makefile.am
+++ b/src/driver/Makefile.am
@@ -48,6 +48,11 @@ libneutrino_driver_a_SOURCES = \
 	streamts.cpp \
 	volume.cpp
 
+if ENABLE_GRAPHLCD
+libneutrino_driver_a_SOURCES += \
+	nglcd.cpp
+endif
+
 if BOXTYPE_COOL
 libneutrino_driver_a_SOURCES += \
 	fb_accel_cs_hdx.cpp
diff --git a/src/driver/display.h b/src/driver/display.h
index 850926432..ea9185e85 100644
--- a/src/driver/display.h
+++ b/src/driver/display.h
@@ -8,3 +8,6 @@
 #if HAVE_SPARK_HARDWARE || HAVE_AZBOX_HARDWARE || HAVE_GENERIC_HARDWARE  || HAVE_ARM_HARDWARE || HAVE_MIPS_HARDWARE
 #include <driver/simple_display.h>
 #endif
+#ifdef ENABLE_GRAPHLCD
+#include <driver/nglcd.h>
+#endif
diff --git a/src/driver/nglcd.cpp b/src/driver/nglcd.cpp
new file mode 100644
index 000000000..7cbb3fbe5
--- /dev/null
+++ b/src/driver/nglcd.cpp
@@ -0,0 +1,961 @@
+/*
+	Neutrino graphlcd daemon thread
+
+	(C) 2012-2014 by martii
+
+
+	License: GPL
+
+	This program is free software; you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation; either version 2 of the License, or
+	(at your option) any later version.
+
+	This program is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with this program; if not, write to the Free Software
+	Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include <global.h>
+#include <neutrino.h>
+#include <algorithm>
+#include <system/debug.h>
+#include <system/helpers.h>
+#include <system/set_threadname.h>
+#include <driver/pictureviewer/pictureviewer.h>
+#include <hardware_caps.h>
+#include <driver/nglcd.h>
+#include <eitd/sectionsd.h>
+#include <math.h>
+
+static const char * kDefaultConfigFile = "/etc/graphlcd.conf";
+static nGLCD *nglcd = NULL;
+
+extern CPictureViewer * g_PicViewer;
+
+nGLCD::nGLCD() {
+	lcd = NULL;
+	Channel = "Neutrino";
+	Epg = std::string(g_info.hw_caps->boxvendor) + " " + std::string(g_info.hw_caps->boxname);
+
+	sem_init(&sem, 0, 1);
+
+	pthread_mutexattr_t attr;
+	pthread_mutexattr_init(&attr);
+	pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_ERRORCHECK_NP);
+	pthread_mutex_init(&mutex, &attr);
+
+	channelLocked = false;
+	doRescan = false;
+	doStandby = false;
+	doStandbyTime = false;
+	doShowVolume = false;
+	doSuspend = false;
+	doExit = false;
+	doMirrorOSD = false;
+	fontsize_channel = 0;
+	fontsize_epg = 0;
+	fontsize_time = 0;
+	fontsize_time_standby = 0;
+	fonts_initialized = false;
+	doScrollChannel = false;
+	doScrollEpg = false;
+	percent_channel = 0;
+	percent_time = 0;
+	percent_time_standby = 0;
+	percent_epg = 0;
+	percent_bar = 0;
+	percent_space = 0;
+	percent_logo = 0;
+	Scale = 0;
+	bitmap = NULL;
+	blitFlag = true;
+
+	nglcd = this;
+
+	if (!g_settings.glcd_enable)
+		doSuspend = true;
+
+	if (pthread_create (&thrGLCD, 0, nGLCD::Run, this) != 0 )
+		fprintf(stderr, "ERROR: pthread_create(nGLCD::Init)\n");
+
+	Update();
+}
+
+void nGLCD::Lock(void)
+{
+	if (nglcd)
+		pthread_mutex_lock(&nglcd->mutex);
+}
+
+void nGLCD::Unlock(void)
+{
+	if (nglcd)
+		pthread_mutex_unlock(&nglcd->mutex);
+}
+
+nGLCD::~nGLCD() {
+	Suspend();
+	nglcd = NULL;
+	if (lcd) {
+		lcd->DeInit();
+		delete lcd;
+	}
+	sem_destroy(&sem);
+	pthread_mutex_destroy(&mutex);
+}
+
+nGLCD *nGLCD::getInstance()
+{
+	if (!nglcd)
+		nglcd = new nGLCD;
+	return nglcd;
+}
+
+void nGLCD::LcdAnalogClock(int posx,int posy,int dia)
+{
+	int tm_,th_,mx_,my_,hx_,hy_;
+	double pi_ = 3.1415926535897932384626433832795, mAngleInRad, mAngleSave, hAngleInRad;
+
+	tm_ = tm->tm_min;
+	th_ = tm->tm_hour;
+
+	mAngleInRad = ((6 * tm_) * (2*pi_ / 360));
+	mAngleSave = mAngleInRad;
+	mAngleInRad -= pi_/2;
+#if BOXMODEL_VUUNO4KSE
+	mx_ = int((dia * 0.55 * cos(mAngleInRad)));
+	my_ = int((dia * 0.55 * sin(mAngleInRad)));
+#else
+	mx_ = int((dia * 0.7 * cos(mAngleInRad)));
+	my_ = int((dia * 0.7 * sin(mAngleInRad)));
+#endif
+
+	hAngleInRad = ((30 * th_)* (2*pi_ / 360));
+	hAngleInRad += mAngleSave / 12;
+	hAngleInRad -= pi_/2;
+#if BOXMODEL_VUUNO4KSE
+	hx_ = int((dia * 0.25 * cos(hAngleInRad)));
+	hy_ = int((dia * 0.25 * sin(hAngleInRad)));
+#else
+	hx_ = int((dia * 0.4 * cos(hAngleInRad)));
+	hy_ = int((dia * 0.4 * sin(hAngleInRad)));
+#endif
+
+	std::string a_clock = "";
+
+	a_clock = ICONSDIR "/a_clock.png";
+	if (access(a_clock.c_str(), F_OK) != 0)
+		a_clock = ICONSDIR "/a_clock.png";
+
+	int lcd_a_clock_width = 0, lcd_a_clock_height = 0;
+	g_PicViewer->getSize(a_clock.c_str(), &lcd_a_clock_width, &lcd_a_clock_height);
+	if (lcd_a_clock_width && lcd_a_clock_height)
+	{
+		showImage(a_clock, (uint32_t) lcd_a_clock_width, (uint32_t) lcd_a_clock_height,
+			0, 0, (uint32_t) nglcd->bitmap->Width(), (uint32_t) nglcd->bitmap->Height(), false, false);
+
+		lcd->SetScreen(bitmap->Data(), bitmap->Width(), bitmap->Height());
+		lcd->Refresh(true);
+	}
+
+	// hour
+	bitmap->DrawLine(posx,posy-8,posx+hx_,posy+hy_, g_settings.glcd_color_fg);
+	bitmap->DrawLine(posx,posy-7,posx+hx_,posy+hy_, g_settings.glcd_color_fg);
+	bitmap->DrawLine(posx,posy-6,posx+hx_,posy+hy_, g_settings.glcd_color_fg);
+	bitmap->DrawLine(posx,posy-5,posx+hx_,posy+hy_, g_settings.glcd_color_fg);
+	bitmap->DrawLine(posx,posy-4,posx+hx_,posy+hy_, g_settings.glcd_color_fg);
+	bitmap->DrawLine(posx,posy-3,posx+hx_,posy+hy_, g_settings.glcd_color_fg);
+	bitmap->DrawLine(posx,posy-2,posx+hx_,posy+hy_, g_settings.glcd_color_fg);
+	bitmap->DrawLine(posx,posy-1,posx+hx_,posy+hy_, g_settings.glcd_color_fg);
+	bitmap->DrawLine(posx+1,posy,posx+hx_,posy+hy_, g_settings.glcd_color_fg);
+	bitmap->DrawLine(posx,posy+1,posx+hx_,posy+hy_, g_settings.glcd_color_fg);
+	bitmap->DrawLine(posx,posy+2,posx+hx_,posy+hy_, g_settings.glcd_color_fg);
+	bitmap->DrawLine(posx,posy+3,posx+hx_,posy+hy_, g_settings.glcd_color_fg);
+	bitmap->DrawLine(posx,posy+4,posx+hx_,posy+hy_, g_settings.glcd_color_fg);
+	bitmap->DrawLine(posx,posy+5,posx+hx_,posy+hy_, g_settings.glcd_color_fg);
+	bitmap->DrawLine(posx,posy+6,posx+hx_,posy+hy_, g_settings.glcd_color_fg);
+	bitmap->DrawLine(posx,posy+7,posx+hx_,posy+hy_, g_settings.glcd_color_fg);
+	bitmap->DrawLine(posx,posy+8,posx+hx_,posy+hy_, g_settings.glcd_color_fg);
+
+	// minute
+	bitmap->DrawLine(posx,posy-6,posx+mx_,posy+my_, g_settings.glcd_color_fg);
+	bitmap->DrawLine(posx,posy-5,posx+mx_,posy+my_, g_settings.glcd_color_fg);
+	bitmap->DrawLine(posx,posy-4,posx+mx_,posy+my_, g_settings.glcd_color_fg);
+	bitmap->DrawLine(posx,posy-3,posx+mx_,posy+my_, g_settings.glcd_color_fg);
+	bitmap->DrawLine(posx,posy-2,posx+mx_,posy+my_, g_settings.glcd_color_fg);
+	bitmap->DrawLine(posx,posy-1,posx+mx_,posy+my_, g_settings.glcd_color_fg);
+	bitmap->DrawLine(posx+1,posy,posx+mx_,posy+my_, g_settings.glcd_color_fg);
+	bitmap->DrawLine(posx,posy+1,posx+mx_,posy+my_, g_settings.glcd_color_fg);
+	bitmap->DrawLine(posx,posy+2,posx+mx_,posy+my_, g_settings.glcd_color_fg);
+	bitmap->DrawLine(posx,posy+3,posx+mx_,posy+my_, g_settings.glcd_color_fg);
+	bitmap->DrawLine(posx,posy+4,posx+mx_,posy+my_, g_settings.glcd_color_fg);
+	bitmap->DrawLine(posx,posy+5,posx+mx_,posy+my_, g_settings.glcd_color_fg);
+	bitmap->DrawLine(posx,posy+6,posx+mx_,posy+my_, g_settings.glcd_color_fg);
+}
+
+void nGLCD::Exec() {
+	if (!lcd)
+		return;
+
+	bitmap->Clear(g_settings.glcd_color_bg);
+
+	if (Channel == "Neutrino") {
+		if (g_settings.glcd_show_logo) {
+			int start_width = 0, start_height = 0;
+			g_PicViewer->getSize(DATADIR "/neutrino/icons/start.jpg", &start_width, &start_height);
+			if (start_width && start_height) {
+				showImage(DATADIR "/neutrino/icons/start.jpg", (uint32_t) start_width, (uint32_t) start_height,
+					0, 0, (uint32_t) nglcd->bitmap->Width(), (uint32_t) nglcd->bitmap->Height(), false, true);
+
+				GLCD::cFont font_tmp;
+
+				int fw = font_epg.Width(Epg);
+				font_tmp.LoadFT2(g_settings.glcd_font, "UTF-8", fontsize_epg * (bitmap->Width() - 4) / fw);
+				fw = font_tmp.Width(Epg);
+
+				bitmap->DrawText(std::max(2,(bitmap->Width() - 4 - fw)/2),
+					10 * bitmap->Height()/100, bitmap->Width() - 4, Epg,
+					&font_tmp, g_settings.glcd_color_fg, GLCD::cColor::Transparent);
+
+				lcd->SetScreen(bitmap->Data(), bitmap->Width(), bitmap->Height());
+				lcd->Refresh(true);
+			}
+		} else {
+			nglcd->bitmap->Clear(g_settings.glcd_color_bg);
+			nglcd->lcd->Refresh(true);
+		}
+		return;
+	}
+
+	if (doStandbyTime) {
+		if (percent_time_standby) {
+
+			std::string Time;
+			if (g_settings.glcd_time_in_standby == 3)
+				LcdAnalogClock(bitmap->Width()/2, bitmap->Height()/2, 200);
+			else if (g_settings.glcd_time_in_standby == 2)
+				Time = strftime("%H:%M:%S", tm);
+			else
+				Time = strftime("%H:%M", tm);
+
+			bitmap->DrawText(std::max(2,(bitmap->Width() - 4 - font_time_standby.Width(Time))/2),
+				(bitmap->Height() - font_time_standby.Height(Time))/2, bitmap->Width() - 1, Time,
+				&font_time_standby, g_settings.glcd_color_fg, GLCD::cColor::Transparent);
+			lcd->SetScreen(bitmap->Data(), bitmap->Width(), bitmap->Height());
+			lcd->Refresh(false);
+		}
+		return;
+	}
+
+	if (CNeutrinoApp::getInstance()->recordingstatus) {
+#if BOXMODEL_VUSOLO4K || BOXMODEL_VUDUO4K || BOXMODEL_VUULTIMO4K || BOXMODEL_VUUNO4KSE || BOXMODEL_VUUNO4K
+		for (int bx = 0; bx < 9; bx++) {
+#else
+		for (int bx = 0; bx < 3; bx++) {
+#endif
+			bitmap->DrawRectangle(bx, bx, bitmap->Width() - bx + 1, bitmap->Height() - bx + 1, GLCD::cColor::Red, false);
+		}
+	} else
+	if (CNeutrinoApp::getInstance()->isMuted()) {
+#if BOXMODEL_VUSOLO4K || BOXMODEL_VUDUO4K || BOXMODEL_VUULTIMO4K || BOXMODEL_VUUNO4KSE || BOXMODEL_VUUNO4K
+		for (int bx = 0; bx < 9; bx++) {
+#else
+		for (int bx = 0; bx < 3; bx++) {
+#endif
+			bitmap->DrawRectangle(bx, bx, bitmap->Width() - bx + 1, bitmap->Height() - bx + 1, GLCD::cColor::Blue, false);
+		}
+	}
+
+	int off = percent_space;
+
+	if (g_settings.glcd_show_logo && percent_logo &&
+		showImage(channel_id, Channel, 0, off * bitmap->Height()/100, bitmap->Width() - 4, percent_logo * bitmap->Height()/100, true)) {
+		off += percent_logo;
+		off += percent_space;
+		doScrollChannel = false;
+		scrollChannelSkip = 0;
+	} else if (percent_channel) {
+		int logo_offset = 0;
+		if (g_settings.glcd_show_logo && percent_channel < percent_logo) {
+			int o = logo_offset = percent_logo - percent_channel;
+			o >>= 1;
+			off += o;
+			logo_offset -= o;
+		}
+		if (ChannelWidth) {
+			if (scrollChannelForward) {
+				if (ChannelWidth - scrollChannelSkip < bitmap->Width() - 4)
+					scrollChannelForward = false;
+			} else if (scrollChannelSkip <= 0) {
+				scrollChannelSkip = 0;
+				doScrollChannel = false;
+			}
+
+			bitmap->DrawText(std::max(2,(bitmap->Width() - 4 - ChannelWidth)/2) + scrollChannelOffset,
+				off * bitmap->Height()/100, bitmap->Width() - 4, Channel,
+				&font_channel, g_settings.glcd_color_fg, GLCD::cColor::Transparent, true, scrollChannelSkip);
+
+			if (scrollChannelOffset > 0)
+				scrollChannelOffset -= g_settings.glcd_scroll_speed;
+
+			if (scrollChannelOffset < 0)
+				scrollChannelOffset = 0;
+
+			if (scrollChannelOffset == 0) {
+				if (scrollChannelForward)
+					scrollChannelSkip += g_settings.glcd_scroll_speed;
+				else
+					scrollChannelSkip -= g_settings.glcd_scroll_speed;
+			}
+		}
+		off += percent_channel;
+		off += logo_offset;
+		off += percent_space;
+	} else
+		off = 0;
+
+	if (percent_epg) {
+		off += percent_space;
+		if (EpgWidth) {
+			if (scrollEpgForward) {
+				if (EpgWidth - scrollEpgSkip < bitmap->Width() - 4)
+					scrollEpgForward = false;
+			} else if (scrollEpgSkip <= 0) {
+				scrollEpgSkip = 0;
+				doScrollEpg = false;
+			}
+
+			bitmap->DrawText(std::max(2,(bitmap->Width() - 4 - EpgWidth)/2) + scrollEpgOffset,
+				off * bitmap->Height()/100, bitmap->Width() - 4, Epg,
+				&font_epg, g_settings.glcd_color_fg, GLCD::cColor::Transparent, true, scrollEpgSkip);
+
+			if (scrollEpgOffset > 0)
+				scrollEpgOffset -= g_settings.glcd_scroll_speed;
+
+			if (scrollEpgOffset < 0)
+				scrollEpgOffset = 0;
+
+			if (scrollEpgOffset == 0) {
+				if (scrollEpgForward)
+					scrollEpgSkip += g_settings.glcd_scroll_speed;
+				else
+					scrollEpgSkip -= g_settings.glcd_scroll_speed;
+			}
+		}
+		off += percent_epg;
+		off += percent_space;
+	}
+
+	if (percent_bar) {
+		off += percent_space;
+		int bar_top = off * bitmap->Height()/100;
+		off += percent_bar;
+		int bar_bottom = off * bitmap->Height()/100;
+		bitmap->DrawHLine(0, bar_top, bitmap->Width(), g_settings.glcd_color_fg);
+		bitmap->DrawHLine(0, bar_bottom, bitmap->Width(), g_settings.glcd_color_fg);
+		if (Scale)
+			bitmap->DrawRectangle(0, bar_top + 1, Scale * (bitmap->Width() - 1)/100,
+				bar_bottom - 1, g_settings.glcd_color_bar, true);
+		off += percent_space;
+	}
+
+	if (percent_time) {
+		off += percent_space;
+		std::string Time = strftime("%H:%M", tm);
+		bitmap->DrawText(std::max(2,(bitmap->Width() - 4 - font_time.Width(Time))/2),
+			off * bitmap->Height()/100, bitmap->Width() - 1, Time,
+			&font_time, g_settings.glcd_color_fg, GLCD::cColor::Transparent);
+	}
+
+	lcd->SetScreen(bitmap->Data(), bitmap->Width(), bitmap->Height());
+	lcd->Refresh(false);
+}
+
+void nGLCD::updateFonts() {
+	int percent;
+	percent = std::max(g_settings.glcd_percent_channel, g_settings.glcd_show_logo ? g_settings.glcd_percent_logo : 0)
+		+ g_settings.glcd_percent_epg + g_settings.glcd_percent_bar + g_settings.glcd_percent_time;
+
+	int div = 0;
+
+	if (percent_channel || percent_logo)
+		div += 2;
+	if (percent_epg)
+		div += 2;
+	if (percent_bar)
+		div += 2;
+	if (percent_time)
+		div += 2;
+
+	percent += div;
+
+	if (percent < 100)
+		percent = 100;
+
+	percent_logo = g_settings.glcd_show_logo ? g_settings.glcd_percent_logo * 100 / percent : 0;
+	percent_channel = g_settings.glcd_percent_channel * 100 / percent;
+	percent_epg = g_settings.glcd_percent_epg * 100 / percent;
+	percent_bar = g_settings.glcd_percent_bar * 100 / percent;
+	percent_time = g_settings.glcd_percent_time * 100 / percent;
+	percent_time_standby = std::min(g_settings.glcd_percent_time_standby, 100);
+
+	percent_space = (100 - std::max(percent_logo, percent_channel) - percent_time - percent_epg - percent_bar) / div;
+
+	// calculate height
+	int fontsize_channel_new = percent_channel * nglcd->lcd->Height() / 100;
+	int fontsize_epg_new = percent_epg * nglcd->lcd->Height() / 100;
+	int fontsize_time_new = percent_time * nglcd->lcd->Height() / 100;
+	int fontsize_time_standby_new = percent_time_standby * nglcd->lcd->Height() / 100;
+
+	if (!fonts_initialized || (fontsize_channel_new != fontsize_channel)) {
+		fontsize_channel = fontsize_channel_new;
+		if (!font_channel.LoadFT2(g_settings.glcd_font, "UTF-8", fontsize_channel)) {
+			g_settings.glcd_font = FONTDIR "/neutrino.ttf";
+			font_channel.LoadFT2(g_settings.glcd_font, "UTF-8", fontsize_channel);
+		}
+	}
+	if (!fonts_initialized || (fontsize_epg_new != fontsize_epg)) {
+		fontsize_epg = fontsize_epg_new;
+		if (!font_epg.LoadFT2(g_settings.glcd_font, "UTF-8", fontsize_epg)) {
+			g_settings.glcd_font = FONTDIR "/neutrino.ttf";
+			font_epg.LoadFT2(g_settings.glcd_font, "UTF-8", fontsize_epg);
+		}
+	}
+	if (!fonts_initialized || (fontsize_time_new != fontsize_time)) {
+		fontsize_time = fontsize_time_new;
+		if (!font_time.LoadFT2(g_settings.glcd_font, "UTF-8", fontsize_time)) {
+			g_settings.glcd_font = FONTDIR "/neutrino.ttf";
+			font_time.LoadFT2(g_settings.glcd_font, "UTF-8", fontsize_time);
+		}
+	}
+	if (!fonts_initialized || (fontsize_time_standby_new != fontsize_time_standby)) {
+		fontsize_time_standby = fontsize_time_standby_new;
+		if (!font_time_standby.LoadFT2(g_settings.glcd_font, "UTF-8", fontsize_time_standby)) {
+			g_settings.glcd_font = FONTDIR "/neutrino.ttf";
+			font_time_standby.LoadFT2(g_settings.glcd_font, "UTF-8", fontsize_time_standby);
+		}
+	}
+
+	fonts_initialized = true;
+}
+
+bool nGLCD::getBoundingBox(uint32_t *buffer, int width, int height, int &bb_x, int &bb_y, int &bb_w, int &bb_h)
+{
+	if (!width || !height) {
+		bb_x = bb_y = bb_w = bb_h = 0;
+		return false;
+	}
+
+	int y_min = height;
+	uint32_t *b = buffer;
+	for (int y = 0; y < height; y++)
+		for (int x = 0; x < width; x++, b++)
+			if (*b) {
+				y_min = y;
+				goto out1;
+			}
+	out1:
+
+	int y_max = y_min;
+	b = buffer + height * width - 1;
+	for (int y = height - 1; y_min < y; y--)
+		for (int x = 0; x < width; x++, b--)
+			if (*b) { 
+				y_max = y;
+				goto out2;
+			}
+	out2:
+
+	int x_min = width;
+	for (int x = 0; x < width; x++) {
+		b = buffer + x + y_min * width;
+		for (int y = y_min; y < y_max; y++, b += width)
+			if (*b) {
+				x_min = x;
+				goto out3;
+			}
+	}
+	out3:
+
+	int x_max = x_min;
+	for (int x = width - 1; x_min < x; x--) {
+		b = buffer + x + y_min * width;
+		for (int y = y_min; y < y_max; y++, b += width)
+			if (*b) {
+				x_max = x;
+				goto out4;
+			}
+	}
+	out4:
+
+	bb_x = x_min;
+	bb_y = y_min;
+	bb_w = 1 + x_max - x_min;
+	bb_h = 1 + y_max - y_min;
+
+	if (bb_x < 0)
+		bb_x = 0;
+	if (bb_y < 0)
+		bb_y = 0;
+
+	return true;
+}
+
+void* nGLCD::Run(void *arg)
+{
+	nGLCD *me = (nGLCD *) arg;
+	me->Run();
+	pthread_exit(NULL);
+}
+
+void nGLCD::Run(void)
+{
+	set_threadname("nGLCD::Run");
+
+	if (GLCD::Config.Load(kDefaultConfigFile) == false) {
+		fprintf(stderr, "Error loading config file!\n");
+		return;
+	}
+	if ((GLCD::Config.driverConfigs.size() < 1)) {
+		fprintf(stderr, "No driver config found!\n");
+		return;
+	}
+
+	struct timespec ts;
+
+	CSectionsdClient::CurrentNextInfo info_CurrentNext;
+	channel_id = -1;
+	info_CurrentNext.current_zeit.startzeit = 0;
+	info_CurrentNext.current_zeit.dauer = 0;
+	info_CurrentNext.flags = 0;
+
+	fonts_initialized = false;
+	bool broken = false;
+
+	do {
+		if (broken) {
+#ifdef GLCD_DEBUG
+			fprintf(stderr, "No graphlcd display found ... sleeping for 30 seconds\n");
+#endif
+			clock_gettime(CLOCK_REALTIME, &ts);
+			ts.tv_sec += 30;
+			sem_timedwait(&sem, &ts);
+			broken = false;
+			if (doExit)
+				break;
+			if (!g_settings.glcd_enable)
+				continue;
+		} else
+				while ((doSuspend || doStandby || !g_settings.glcd_enable) && !doExit)
+					sem_wait(&sem);
+
+		if (doExit)
+			break;
+
+		int warmUp = 10;
+		lcd = GLCD::CreateDriver(GLCD::Config.driverConfigs[0].id, &GLCD::Config.driverConfigs[0]);
+		if (!lcd) {
+#ifdef GLCD_DEBUG
+			fprintf(stderr, "CreateDriver failed.\n");
+#endif
+			broken = true;
+			continue;
+		}
+#ifdef GLCD_DEBUG
+		fprintf(stderr, "CreateDriver succeeded.\n");
+#endif
+		if (lcd->Init()) {
+			delete lcd;
+			lcd = NULL;
+#ifdef GLCD_DEBUG
+			fprintf(stderr, "LCD init failed.\n");
+#endif
+			broken = true;
+			continue;
+		}
+#ifdef GLCD_DEBUG
+		fprintf(stderr, "LCD init succeeded.\n");
+#endif
+		lcd->SetBrightness(0);
+
+		if (!bitmap)
+			bitmap = new GLCD::cBitmap(lcd->Width(), lcd->Height(), g_settings.glcd_color_bg);
+
+		UpdateBrightness();
+		Update();
+
+		doMirrorOSD = false;
+
+		while ((!doSuspend && !doStandby) && !doExit && g_settings.glcd_enable) {
+			if (doMirrorOSD && !doStandbyTime) {
+				if (blitFlag) {
+					blitFlag = false;
+					bitmap->Clear(GLCD::cColor::Black);
+					ts.tv_sec = 0; // don't wait
+					static CFrameBuffer* fb = CFrameBuffer::getInstance();
+#if !BOXMODEL_VUSOLO4K && !BOXMODEL_VUDUO4K && !BOXMODEL_VUULTIMO4K && !BOXMODEL_VUUNO4KSE
+					static int fb_width = fb->getScreenWidth(true);
+#endif
+					static int fb_height = fb->getScreenHeight(true);
+					static uint32_t *fbp = fb->getFrameBufferPointer();
+					int lcd_width = bitmap->Width();
+					int lcd_height = bitmap->Height();
+#if BOXMODEL_VUSOLO4K || BOXMODEL_VUDUO4K || BOXMODEL_VUULTIMO4K || BOXMODEL_VUUNO4KSE
+					unsigned int fb_stride = fb->getStride()/4;
+					if (!showImage(fbp, fb_stride, fb_height, 0, 0, lcd_width, lcd_height, false)) {
+#else
+					if (!showImage(fbp, fb_width, fb_height, 0, 0, lcd_width, lcd_height, false)) {
+#endif
+						usleep(500000);
+					} else {
+						lcd->SetScreen(bitmap->Data(), lcd_width, lcd_height);
+						lcd->Refresh(false);
+					}
+				} else
+					usleep(100000);
+				continue;
+			}
+			if (g_settings.glcd_mirror_video && !doStandbyTime) {
+				char ws[10];
+				snprintf(ws, sizeof(ws), "%d", bitmap->Width());
+				const char *bmpShot = "/tmp/nglcd-video.bmp";
+				my_system(4, "/bin/grab", "-vr", ws, bmpShot);
+				int bw = 0, bh = 0;
+				g_PicViewer->getSize(bmpShot, &bw, &bh);
+				if (bw > 0 && bh > 0) {
+					int lcd_width = bitmap->Width();
+					int lcd_height = bitmap->Height();
+					if (!showImage(bmpShot, (uint32_t) bw, (uint32_t) bh, 0, 0, (uint32_t) lcd_width, lcd_height, false, true))
+						usleep(1000000);
+					else {
+						lcd->SetScreen(bitmap->Data(), lcd_width, lcd_height);
+							lcd->Refresh(false);
+					}
+				}
+				else
+						usleep(1000000);
+				continue;
+			}
+
+			clock_gettime(CLOCK_REALTIME, &ts);
+			tm = localtime(&ts.tv_sec);
+			updateFonts();
+			Exec();
+			clock_gettime(CLOCK_REALTIME, &ts);
+			tm = localtime(&ts.tv_sec);
+			if (warmUp > 0) {
+				ts.tv_sec += 1;
+				warmUp--;
+			} else {
+				ts.tv_sec += 60 - tm->tm_sec;
+				ts.tv_nsec = 0;
+			}
+
+			if (!doScrollChannel && !doScrollEpg)
+				sem_timedwait(&sem, &ts);
+
+			while(!sem_trywait(&sem));
+
+			if(doRescan || doSuspend || doStandby || doExit)
+				break;
+
+			if (doShowVolume) {
+				Epg = "";
+				if (Channel.compare(g_Locale->getText(LOCALE_GLCD_VOLUME))) {
+					Channel = g_Locale->getText(LOCALE_GLCD_VOLUME);
+					ChannelWidth = font_channel.Width(Channel);
+					doScrollChannel = ChannelWidth > bitmap->Width() - 4;
+					scrollChannelSkip = 0;
+					scrollChannelForward = true;
+					if (doScrollChannel) {
+						scrollChannelOffset = bitmap->Width()/g_settings.glcd_scroll_speed;
+						ChannelWidth += scrollChannelOffset;
+					} else
+						scrollChannelOffset = 0;
+				}
+				EpgWidth = 0;
+				scrollEpgSkip = 0;
+				scrollEpgForward = true;
+				Scale = g_settings.current_volume;
+				channel_id = -1;
+			} else if (channelLocked) {
+				Lock();
+				if (Epg.compare(stagingEpg)) {
+					Epg = stagingEpg;
+					EpgWidth = font_epg.Width(Epg);
+					doScrollEpg = EpgWidth > bitmap->Width() - 4;
+					scrollEpgSkip = 0;
+					scrollEpgForward = true;
+					if (doScrollEpg) {
+						scrollEpgOffset = bitmap->Width()/g_settings.glcd_scroll_speed;
+						EpgWidth += scrollEpgOffset;
+					} else
+						scrollChannelOffset = 0;
+				}
+				if (Channel.compare(stagingChannel)) {
+					Channel = stagingChannel;
+					ChannelWidth = font_channel.Width(Channel);
+					doScrollChannel = ChannelWidth > bitmap->Width() - 4;
+					scrollChannelSkip = 0;
+					scrollChannelForward = true;
+					if (doScrollChannel) {
+						scrollChannelOffset = bitmap->Width()/g_settings.glcd_scroll_speed;
+						ChannelWidth += scrollChannelOffset;
+					} else
+						scrollChannelOffset = 0;
+				}
+				channel_id = -1;
+				Unlock();
+			} else {
+				CChannelList *channelList = CNeutrinoApp::getInstance ()->channelList;
+				if (!channelList)
+					continue;
+				t_channel_id new_channel_id = channelList->getActiveChannel_ChannelID();
+				if (!new_channel_id)
+					continue;
+
+				if ((new_channel_id != channel_id)) {
+					Channel = channelList->getActiveChannelName ();
+					ChannelWidth = font_channel.Width(Channel);
+					Epg = "";
+					EpgWidth = 0;
+					Scale = 0;
+					doScrollEpg = false;
+					doScrollChannel = ChannelWidth > bitmap->Width() - 4;
+					scrollChannelForward = true;
+					scrollChannelSkip = 0;
+					if (doScrollChannel) {
+						scrollChannelOffset = bitmap->Width()/g_settings.glcd_scroll_speed;
+						ChannelWidth += scrollChannelOffset;
+					} else
+						scrollChannelOffset = 0;
+					warmUp = 10;
+					info_CurrentNext.current_name = "";
+					info_CurrentNext.current_zeit.dauer = 0;
+				}
+
+				CEitManager::getInstance()->getCurrentNextServiceKey(channel_id & 0xFFFFFFFFFFFFULL, info_CurrentNext);
+				channel_id = new_channel_id;
+
+				if (info_CurrentNext.current_name.compare(Epg)) {
+					Epg = info_CurrentNext.current_name;
+					EpgWidth = font_epg.Width(Epg);
+					doScrollEpg = EpgWidth > bitmap->Width() - 4;
+					scrollEpgForward = true;
+					scrollEpgSkip = 0;
+					if (doScrollEpg) {
+						scrollEpgOffset = bitmap->Width()/g_settings.glcd_scroll_speed;
+						EpgWidth += scrollEpgOffset;
+					} else
+						scrollEpgOffset = 0;
+				}
+				if (info_CurrentNext.current_zeit.dauer > 0)
+					Scale = (ts.tv_sec - info_CurrentNext.current_zeit.startzeit) * 100 / info_CurrentNext.current_zeit.dauer;
+				if (Scale > 100)
+					Scale = 100;
+				else if (Scale < 0)
+					Scale = 0;
+			}
+		}
+
+		if(!g_settings.glcd_enable || doSuspend || doStandby || doExit) {
+			// for restart, don't blacken screen
+			bitmap->Clear(GLCD::cColor::Black);
+			lcd->SetBrightness(0);
+			lcd->SetScreen(bitmap->Data(), bitmap->Width(), bitmap->Height());
+			lcd->Refresh(false);
+		}
+		if (doRescan) {
+			doRescan = false;
+			Update();
+		}
+		lcd->DeInit();
+		delete lcd;
+		lcd = NULL;
+	} while(!doExit);
+}
+
+void nGLCD::Update() {
+	if (nglcd)
+		sem_post(&nglcd->sem);
+}
+
+void nGLCD::StandbyMode(bool b) {
+	if (nglcd) {
+		if (g_settings.glcd_time_in_standby) {
+			nglcd->doStandbyTime = b;
+			nglcd->doStandby = false;
+		} else {
+			nglcd->doStandbyTime = false;
+			nglcd->doStandby = b;
+		}
+		if (b) {
+			nglcd->doScrollChannel = false;
+			nglcd->doScrollEpg = false;
+		} else {
+			nglcd->doScrollChannel = true;
+			nglcd->doScrollEpg = true;
+		}
+		nglcd->doMirrorOSD = false;
+		nglcd->UpdateBrightness();
+		nglcd->Update();
+	}
+}
+
+void nGLCD::ShowVolume(bool b) {
+	if (nglcd) {
+		nglcd->doShowVolume = b;
+		nglcd->Update();
+	}
+}
+
+void nGLCD::MirrorOSD(bool b) {
+	if (nglcd) {
+		nglcd->doMirrorOSD = b;
+		nglcd->Update();
+	}
+}
+
+void nGLCD::Exit() {
+	if (nglcd) {
+		nglcd->doMirrorOSD = false;
+		nglcd->doSuspend = false;
+		nglcd->doExit = true;
+		nglcd->Update();
+		void *res;
+		pthread_join(nglcd->thrGLCD, &res);
+		delete nglcd;
+		nglcd = NULL;
+	}
+}
+
+void nGLCD::Rescan() {
+	doRescan = true;
+	Update();
+}
+
+void nGLCD::Suspend() {
+	if (nglcd) {
+		nglcd->doSuspend = true;
+		nglcd->Update();
+	}
+}
+
+void nGLCD::Resume() {
+	if (nglcd) {
+		nglcd->doSuspend = false;
+		nglcd->channelLocked = false;
+		nglcd->Update();
+	}
+}
+
+void nGLCD::lockChannel(std::string c, std::string e, int s)
+{
+	if(nglcd) {
+		nglcd->Lock();
+		nglcd->channelLocked = true;
+		nglcd->stagingChannel = c;
+		nglcd->stagingEpg = e;
+		nglcd->Scale = s;
+		nglcd->Unlock();
+		nglcd->Update();
+	}
+}
+
+void nGLCD::unlockChannel(void)
+{
+	if(nglcd) {
+		nglcd->channelLocked = false;
+		nglcd->Update();
+	}
+}
+
+bool nGLCD::showImage(fb_pixel_t *s, uint32_t sw, uint32_t sh, uint32_t dx, uint32_t dy, uint32_t dw, uint32_t dh, bool transp, bool maximize)
+{
+	int bb_x, bb_y, bb_w, bb_h;
+
+	if (nglcd->getBoundingBox(s, sw, sh, bb_x, bb_y, bb_w, bb_h) && bb_w && bb_h) {
+		if (!maximize) {
+			if (bb_h * dw > bb_w * dh) {
+				uint32_t dw_new = dh * bb_w / bb_h;
+				dx += (dw - dw_new) >> 1;
+				dw = dw_new;
+			} else {
+				uint32_t dh_new = dw * bb_h / bb_w;
+				dy += (dh - dh_new) >> 1;
+				dh = dh_new;
+			}
+		}
+		for (u_int y = 0; y < dh; y++) {
+			for (u_int x = 0; x < dw; x++) {
+				uint32_t pix = *(s + (y * bb_h / dh + bb_y) * sw + x * bb_w / dw + bb_x);
+				if (!transp || pix)
+					nglcd->bitmap->DrawPixel(x + dx, y + dy, pix);
+			}
+		}
+		return true;
+	}
+	return false;
+}
+
+bool nGLCD::showImage(const std::string & filename, uint32_t sw, uint32_t sh, uint32_t dx, uint32_t dy, uint32_t dw, uint32_t dh, bool transp, bool maximize)
+{
+	bool res = false;
+	if (!dw || !dh)
+		return res;
+	fb_pixel_t *s = g_PicViewer->getImage(filename, sw, sh);
+	if (s && sw && sh)
+		res = showImage(s, sw, sh, dx, dy, dw, dh, transp, maximize);
+	if (s)
+		free(s);
+	return res;
+}
+
+bool nGLCD::showImage(uint64_t cid, std::string cname, uint32_t dx, uint32_t dy, uint32_t dw, uint32_t dh, bool transp, bool maximize)
+{
+	std::string logo;
+	int sw, sh;
+
+	if (g_PicViewer->GetLogoName(cid, cname, logo, &sw, &sh)) {
+		return showImage(logo, (uint32_t) sw, (uint32_t) sh, dx, dy, dw, dh, transp, maximize);
+	}
+	return false;
+}
+
+void nGLCD::UpdateBrightness()
+{
+	if (nglcd && nglcd->lcd)
+		nglcd->lcd->SetBrightness((unsigned int) (nglcd->doStandbyTime ? g_settings.glcd_brightness_standby : g_settings.glcd_brightness));
+}
+
+void nGLCD::SetBrightness(unsigned int b)
+{
+	if (nglcd)
+		nglcd->SetBrightness(b);
+}
+
+void nGLCD::Blit()
+{
+	if (nglcd)
+		nglcd->blitFlag = true;
+}
+
+int nGLCD::handleMsg(const neutrino_msg_t msg, neutrino_msg_data_t /* data */)
+{
+	if (msg == NeutrinoMessages::EVT_CURRENTNEXT_EPG) {
+		Update();
+		return messages_return::handled;
+	}
+
+	return messages_return::unhandled;
+}
+
diff --git a/src/driver/nglcd.h b/src/driver/nglcd.h
new file mode 100644
index 000000000..7936319c7
--- /dev/null
+++ b/src/driver/nglcd.h
@@ -0,0 +1,137 @@
+/*
+	nglcd.h -- Neutrino GraphLCD driver
+
+	Copyright (C) 2012-2014 martii
+
+	License: GPL
+
+	This program is free software; you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation; either version 2 of the License, or
+	(at your option) any later version.
+
+	This program is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with this program; if not, write to the Free Software
+	Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+#ifdef ENABLE_GRAPHLCD
+#ifndef __glcd_h__
+#define __glcd_h__
+
+#include <string>
+#include <vector>
+#include <time.h>
+#include <string>
+#include <sys/types.h>
+#include <semaphore.h>
+#include <zapit/include/zapit/client/zapittypes.h>
+#include <neutrinoMessages.h>
+
+#pragma GCC diagnostic ignored "-Wunused-parameter"
+#include <glcdgraphics/bitmap.h>
+#include <glcdgraphics/font.h>
+#include <glcddrivers/config.h>
+#include <glcddrivers/driver.h>
+#include <glcddrivers/drivers.h>
+#pragma GCC diagnostic warning "-Wunused-parameter"
+
+class nGLCD
+{
+	private:
+		GLCD::cDriver * lcd;
+		GLCD::cFont font_channel;
+		GLCD::cFont font_epg;
+		GLCD::cFont font_time;
+		GLCD::cFont font_time_standby;
+		int fontsize_channel;
+		int fontsize_epg;
+		int fontsize_time;
+		int fontsize_time_standby;
+		int percent_channel;
+		int percent_time;
+		int percent_time_standby;
+		int percent_epg;
+		int percent_bar;
+		int percent_logo;
+		int percent_space;
+		GLCD::cBitmap * bitmap;
+		std::string Channel;
+		std::string Epg;
+		std::string stagingChannel;
+		std::string stagingEpg;
+		t_channel_id channel_id;
+		int Scale;
+		time_t now;
+		struct tm *tm;
+		int EpgWidth;
+		int ChannelWidth;
+		int scrollEpgSkip;
+		int scrollChannelSkip;
+		int scrollEpgOffset;
+		int scrollChannelOffset;
+		bool scrollEpgForward;
+		bool scrollChannelForward;
+		bool blitFlag;
+		bool channelLocked;
+		bool doRescan;
+		bool doSuspend;
+		bool doStandby;
+		bool doStandbyTime;
+		bool doExit;
+		bool doScrollChannel;
+		bool doScrollEpg;
+		bool doShowVolume;
+		bool doMirrorOSD;
+		bool fonts_initialized;
+		pthread_t thrGLCD;
+		pthread_mutex_t mutex;
+		sem_t sem;
+		void updateFonts();
+		bool showImage(fb_pixel_t *s,
+			uint32_t sw, uint32_t sh,
+			uint32_t dx, uint32_t dy, uint32_t dw, uint32_t dh,
+			bool transp = false, bool maximize = false);
+		bool showImage(const std::string & filename,
+			uint32_t sw, uint32_t sh,
+			uint32_t dx, uint32_t dy, uint32_t dw, uint32_t dh,
+			bool transp = false, bool maximize = false);
+		bool showImage(uint64_t channel_id, std::string ChannelName,
+			uint32_t dx, uint32_t dy, uint32_t dw, uint32_t dh,
+			bool transp = false, bool maximize = false);
+		bool getBoundingBox(uint32_t *buffer,
+			int width, int height,
+			int &bb_x, int &bb_y, int &bb_width, int &bb_height);
+		void LcdAnalogClock(int posx,int posy,int dia);
+		void Exec();
+		void Run(void);
+		static void* Run(void *);
+		static void Lock();
+		static void Unlock();
+	public:
+		nGLCD();
+		~nGLCD();
+		void DeInit();
+		void Rescan();
+		static nGLCD *getInstance();
+		static void lockChannel(std::string txt, std::string epg = "", int scale = 0);
+		static void unlockChannel();
+		static void MirrorOSD(bool b = true);
+		static void Update();
+		static void Suspend();
+		static void StandbyMode(bool);
+		static void ShowVolume(bool);
+		static void Resume();
+		static void Exit();
+		static void Blit();
+		static void SetBrightness(unsigned int b);
+		void UpdateBrightness();
+		int handleMsg(const neutrino_msg_t msg, neutrino_msg_data_t data);
+};
+#endif
+#endif
diff --git a/src/driver/record.cpp b/src/driver/record.cpp
index 35a8ef9cf..289f490e8 100644
--- a/src/driver/record.cpp
+++ b/src/driver/record.cpp
@@ -50,7 +50,7 @@
 #include <system/helpers.h>
 #include <system/hddstat.h>
 
-
+#include <driver/display.h>
 #include <driver/record.h>
 #include <driver/radiotext.h>
 #include <driver/streamts.h>
@@ -1117,6 +1117,9 @@ bool CRecordManager::Record(const CTimerd::RecordingInfo * const eventinfo, cons
 				t_channel_id live_channel_id = CZapit::getInstance()->GetCurrentChannelID();
 				if(eventinfo->channel_id == live_channel_id)
 					recordingstatus = 1;
+#endif
+#ifdef ENABLE_GRAPHLCD
+				nGLCD::Update();
 #endif
 			} else {
 				delete inst;
@@ -1322,6 +1325,9 @@ bool CRecordManager::Stop(const CTimerd::RecordingStopInfo * recinfo)
 	if(inst != NULL && recinfo->eventID == inst->GetRecordingId()) {
 		StopInstance(inst, false);
 		ret = true;
+#ifdef ENABLE_GRAPHLCD
+		nGLCD::Update();
+#endif
 	} else {
 		for(nextmap_iterator_t it = nextmap.begin(); it != nextmap.end(); it++) {
 			if((*it)->eventID == recinfo->eventID) {
diff --git a/src/driver/volume.cpp b/src/driver/volume.cpp
index f78003f57..225ae2282 100644
--- a/src/driver/volume.cpp
+++ b/src/driver/volume.cpp
@@ -173,6 +173,9 @@ void CVolume::setVolume(const neutrino_msg_t key)
 						}
 					}
 					g_settings.current_volume = v;
+#ifdef ENABLE_GRAPHLCD
+					nGLCD::ShowVolume(true);
+#endif
 				}
 			}
 			else if (msg == CRCInput::RC_home)
@@ -207,6 +210,9 @@ void CVolume::setVolume(const neutrino_msg_t key)
 		}
 	} while (msg != CRCInput::RC_timeout);
 
+#ifdef ENABLE_GRAPHLCD
+	nGLCD::ShowVolume(false);
+#endif
 	hideVolscale();
 }
 
diff --git a/src/gui/Makefile.am b/src/gui/Makefile.am
index ba3b462d9..c48acd85b 100644
--- a/src/gui/Makefile.am
+++ b/src/gui/Makefile.am
@@ -117,6 +117,11 @@ libneutrino_gui_a_SOURCES = \
 	xmltv_setup.cpp \
 	zapit_setup.cpp
 
+if ENABLE_GRAPHLCD
+libneutrino_gui_a_SOURCES += \
+	glcdsetup.cpp
+endif
+
 if BOXTYPE_COOL
 libneutrino_gui_a_SOURCES += \
 	streaminfo1.cpp
diff --git a/src/gui/bouquetlist.cpp b/src/gui/bouquetlist.cpp
index d74ab7627..1804b18d4 100644
--- a/src/gui/bouquetlist.cpp
+++ b/src/gui/bouquetlist.cpp
@@ -56,7 +56,6 @@
 #include <mymenu.h>
 #include <zapit/getservices.h>
 
-//NI lcd4l-support
 #include "driver/lcd4l.h"
 extern CLCD4l *LCD4l;
 
@@ -593,7 +592,9 @@ int CBouquetList::show(bool bShowChannelList)
 	}
 	hide();
 
-	//NI lcd4l-support
+#ifdef ENABLE_GRAPHLCD
+	nGLCD::unlockChannel();
+#endif
 	LCD4l->RemoveFile("/tmp/lcd/menu");
 
 	fader.StopFade();
@@ -653,7 +654,10 @@ void CBouquetList::paintItem(int pos)
 	{
 		if(npos < (int) Bouquets.size())
 			CVFD::getInstance()->showMenuText(0, lname, -1, true);
-		//NI lcd4l-support
+#ifdef ENABLE_GRAPHLCD
+		if(g_settings.glcd_enable)
+			nGLCD::lockChannel(g_Locale->getText(LOCALE_BOUQUETLIST_HEAD), lname, 0);
+#endif
 		if(g_settings.lcd4l_support)
 			LCD4l->CreateFile("/tmp/lcd/menu", lname, g_settings.lcd4l_convert);
 	}
diff --git a/src/gui/channellist.cpp b/src/gui/channellist.cpp
index 456032a86..94ce09858 100644
--- a/src/gui/channellist.cpp
+++ b/src/gui/channellist.cpp
@@ -86,7 +86,6 @@
 
 #include <eitd/sectionsd.h>
 
-//NI lcd4l-support
 #include "driver/lcd4l.h"
 extern CLCD4l *LCD4l;
 
@@ -967,7 +966,9 @@ int CChannelList::show()
 	if (edit_state)
 		editMode(false);
 
-	//NI lcd4l-support
+#ifdef ENABLE_GRAPHLCD
+	nGLCD::unlockChannel();
+#endif
 	LCD4l->RemoveFile("/tmp/lcd/menu");
 
 	if(!dont_hide){
@@ -2248,7 +2249,10 @@ void CChannelList::updateVfd()
 	} else
 		CVFD::getInstance()->showMenuText(0, chan->getName().c_str(), -1, true); // UTF-8
 
-	//NI lcd4l-support
+#ifdef ENABLE_GRAPHLCD
+	if(g_settings.glcd_enable)
+		nGLCD::lockChannel(g_Locale->getText(LOCALE_BOUQUETLIST_HEAD), chan->getName().c_str(), 0);
+#endif
 	if (g_settings.lcd4l_support)
 		LCD4l->CreateFile("/tmp/lcd/menu", chan->getName().c_str(), g_settings.lcd4l_convert);
 }
diff --git a/src/gui/glcdsetup.cpp b/src/gui/glcdsetup.cpp
new file mode 100644
index 000000000..4ac2025d8
--- /dev/null
+++ b/src/gui/glcdsetup.cpp
@@ -0,0 +1,273 @@
+/*
+	Neutrino graphlcd menue
+
+	(c) 2012 by martii
+
+
+	License: GPL
+
+	This program is free software; you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation; either version 2 of the License, or
+	(at your option) any later version.
+
+	This program is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with this program; if not, write to the Free Software
+	Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+#define __USE_FILE_OFFSET64 1
+#include "filebrowser.h"
+#include <stdio.h>
+#include <global.h>
+#include <neutrino.h>
+#include <zapit/channel.h>
+#include <driver/fontrenderer.h>
+#include <driver/rcinput.h>
+#include <daemonc/remotecontrol.h>
+#include <driver/nglcd.h>
+#include <driver/screen_max.h>
+#include "glcdsetup.h"
+#include <mymenu.h>
+
+#define KEY_GLCD_BLACK			0
+#define KEY_GLCD_WHITE			1
+#define KEY_GLCD_RED			2
+#define KEY_GLCD_GREEN			3
+#define KEY_GLCD_BLUE			4
+#define KEY_GLCD_MAGENTA		5
+#define KEY_GLCD_CYAN			6
+#define KEY_GLCD_YELLOW			7
+#define KEY_GLCD_ORANGE			8
+#define KEY_GLCD_LIGHT_GRAY		9
+#define KEY_GLCD_GRAY			10
+#define KEY_GLCD_DARK_GRAY		11
+#define KEY_GLCD_DARK_RED		12
+#define KEY_GLCD_DARK_GREEN		13
+#define KEY_GLCD_DARK_BLUE		14
+#define KEY_GLCD_PURPLE			15
+#define KEY_GLCD_MINT			16
+#define KEY_GLCD_GOLDEN			17
+#define GLCD_COLOR_OPTION_COUNT		18
+static const CMenuOptionChooser::keyval GLCD_COLOR_OPTIONS[GLCD_COLOR_OPTION_COUNT] =
+{
+	{ KEY_GLCD_BLACK,	LOCALE_GLCD_COLOR_BLACK },
+	{ KEY_GLCD_WHITE,	LOCALE_GLCD_COLOR_WHITE },
+	{ KEY_GLCD_RED,		LOCALE_GLCD_COLOR_RED },
+	{ KEY_GLCD_GREEN,	LOCALE_GLCD_COLOR_GREEN },
+	{ KEY_GLCD_BLUE,	LOCALE_GLCD_COLOR_BLUE },
+	{ KEY_GLCD_MAGENTA,	LOCALE_GLCD_COLOR_MAGENTA },
+	{ KEY_GLCD_CYAN,	LOCALE_GLCD_COLOR_CYAN },
+	{ KEY_GLCD_YELLOW,	LOCALE_GLCD_COLOR_YELLOW },
+	{ KEY_GLCD_ORANGE,	LOCALE_GLCD_COLOR_ORANGE },
+	{ KEY_GLCD_LIGHT_GRAY,	LOCALE_GLCD_COLOR_LIGHT_GRAY },
+	{ KEY_GLCD_GRAY,	LOCALE_GLCD_COLOR_GRAY },
+	{ KEY_GLCD_DARK_GRAY,	LOCALE_GLCD_COLOR_DARK_GRAY },
+	{ KEY_GLCD_DARK_RED,	LOCALE_GLCD_COLOR_DARK_RED },
+	{ KEY_GLCD_DARK_GREEN,	LOCALE_GLCD_COLOR_DARK_GREEN },
+	{ KEY_GLCD_DARK_BLUE,	LOCALE_GLCD_COLOR_DARK_BLUE },
+	{ KEY_GLCD_PURPLE,	LOCALE_GLCD_COLOR_PURPLE },
+	{ KEY_GLCD_MINT,	LOCALE_GLCD_COLOR_MINT },
+	{ KEY_GLCD_GOLDEN,	LOCALE_GLCD_COLOR_GOLDEN }
+};
+
+static const uint32_t colormap[GLCD_COLOR_OPTION_COUNT] =
+{
+	GLCD::cColor::Black,
+	GLCD::cColor::White,
+	GLCD::cColor::Red,
+	GLCD::cColor::Green,
+	GLCD::cColor::Blue,
+	GLCD::cColor::Magenta,
+	GLCD::cColor::Cyan,
+	GLCD::cColor::Yellow,
+	GLCD::cColor::Orange,
+	GLCD::cColor::Light_Gray,
+	GLCD::cColor::Gray,
+	GLCD::cColor::Dark_Gray,
+	GLCD::cColor::Dark_Red,
+	GLCD::cColor::Dark_Green,
+	GLCD::cColor::Dark_Blue,
+	GLCD::cColor::Purple,
+	GLCD::cColor::Mint,
+	GLCD::cColor::Golden
+};
+
+int GLCD_Menu::color2index(uint32_t color) {
+	for (int i = 0; i < GLCD_COLOR_OPTION_COUNT; i++)
+		if (colormap[i] == color)
+			return i;
+	return KEY_GLCD_BLACK;
+}
+
+uint32_t GLCD_Menu::index2color(int i) {
+	return (i < GLCD_COLOR_OPTION_COUNT) ? colormap[i] : GLCD::cColor::ERRCOL;
+}
+
+GLCD_Menu::GLCD_Menu()
+{
+	width = 40;
+	selected = -1;
+}
+
+int GLCD_Menu::exec(CMenuTarget* parent, const std::string & actionKey)
+{
+	int res = menu_return::RETURN_REPAINT;
+	nGLCD *nglcd = nGLCD::getInstance();
+	if(actionKey == "rescan") {
+		nglcd->Rescan();
+		return res;
+	}
+	if(actionKey == "select_font") {
+		if(parent)
+			parent->hide();
+		CFileBrowser fileBrowser;
+		CFileFilter fileFilter;
+		fileFilter.addFilter("ttf");
+		fileBrowser.Filter = &fileFilter;
+		if (fileBrowser.exec(FONTDIR) == true) {
+			g_settings.glcd_font = fileBrowser.getSelectedFile()->Name;
+			nglcd->Rescan();
+		}
+		return res;
+	}
+
+	if (parent)
+		parent->hide();
+
+	GLCD_Menu_Settings();
+
+	return res;
+}
+
+void GLCD_Menu::hide()
+{
+}
+
+bool GLCD_Menu::changeNotify (const neutrino_locale_t OptionName, void *Data)
+{
+	if (!Data)
+		return false;
+	nGLCD *nglcd = nGLCD::getInstance();
+	switch(OptionName) {
+	case LOCALE_GLCD_SELECT_FG:
+		g_settings.glcd_color_fg = GLCD_Menu::index2color(*((int *) Data));
+		break;
+	case LOCALE_GLCD_SELECT_BG:
+		g_settings.glcd_color_bg = GLCD_Menu::index2color(*((int *) Data));
+		break;
+	case LOCALE_GLCD_SELECT_BAR:
+		g_settings.glcd_color_bar = GLCD_Menu::index2color(*((int *) Data));
+		break;
+	case LOCALE_GLCD_ENABLE:
+		if (g_settings.glcd_enable)
+			nglcd->Resume();
+		else
+			nglcd->Suspend();
+		return true;
+	case LOCALE_GLCD_MIRROR_OSD:
+		nglcd->MirrorOSD(*((int *) Data));
+		break;
+	case LOCALE_GLCD_MIRROR_VIDEO:
+		nglcd->Update();
+		break;
+	case LOCALE_GLCD_BRIGHTNESS:
+	case LOCALE_GLCD_BRIGHTNESS_STANDBY:
+	case LOCALE_GLCD_SHOW_LOGO:
+	case LOCALE_GLCD_SIZE_BAR:
+	case LOCALE_GLCD_SIZE_CHANNEL:
+	case LOCALE_GLCD_SIZE_EPG:
+	case LOCALE_GLCD_SIZE_LOGO:
+	case LOCALE_GLCD_SIZE_TIME:
+	case LOCALE_GLCD_SIZE_TIME_STANDBY:
+	case LOCALE_GLCD_TIME_IN_STANDBY:
+	case LOCALE_GLCD_SCROLL_SPEED:
+		break;
+	default:
+		return false;
+	}
+	if (((OptionName == LOCALE_GLCD_TIME_IN_STANDBY || OptionName == LOCALE_GLCD_BRIGHTNESS_STANDBY) && g_settings.glcd_percent_time_standby) || OptionName == LOCALE_GLCD_SIZE_TIME_STANDBY)
+		nglcd->StandbyMode(true);
+	else
+		nglcd->StandbyMode(false);
+
+	nglcd->Update();
+	return true;
+}
+
+#define ONOFFSEC_OPTION_COUNT 3
+static const CMenuOptionChooser::keyval ONOFFSEC_OPTIONS[ONOFFSEC_OPTION_COUNT] = {
+	{ 0, LOCALE_OPTIONS_OFF },
+	{ 1, LOCALE_OPTIONS_ON },
+//	{ 2, LOCALE_CLOCK_SECONDS },
+	{ 3, LOCALE_OPTIONS_ON } // FIXME
+};
+
+void GLCD_Menu::GLCD_Menu_Settings()
+{
+	int color_bg = color2index(g_settings.glcd_color_bg);
+	int color_fg = color2index(g_settings.glcd_color_fg);
+	int color_bar = color2index(g_settings.glcd_color_bar);
+
+	CMenuWidget m(LOCALE_GLCD_HEAD, NEUTRINO_ICON_SETTINGS, width);
+	m.addIntroItems();
+	m.setSelected(selected);
+
+	m.addItem(new CMenuOptionChooser(LOCALE_GLCD_ENABLE, &g_settings.glcd_enable,
+				OPTIONS_OFF0_ON1_OPTIONS, OPTIONS_OFF0_ON1_OPTION_COUNT, true, this));
+	int shortcut = 1;
+	m.addItem(GenericMenuSeparatorLine);
+	m.addItem(new CMenuOptionChooser(LOCALE_GLCD_SELECT_FG, &color_fg,
+				GLCD_COLOR_OPTIONS, GLCD_COLOR_OPTION_COUNT, true, this,
+				CRCInput::convertDigitToKey(shortcut++)));
+	m.addItem(new CMenuOptionChooser(LOCALE_GLCD_SELECT_BG, &color_bg,
+				GLCD_COLOR_OPTIONS, GLCD_COLOR_OPTION_COUNT, true, this,
+				CRCInput::convertDigitToKey(shortcut++)));
+	m.addItem(new CMenuOptionChooser(LOCALE_GLCD_SELECT_BAR, &color_bar,
+				GLCD_COLOR_OPTIONS, GLCD_COLOR_OPTION_COUNT, true, this,
+				CRCInput::convertDigitToKey(shortcut++)));
+	m.addItem(new CMenuForwarder(LOCALE_GLCD_FONT, true, g_settings.glcd_font, this, "select_font",
+				CRCInput::convertDigitToKey(shortcut++)));
+	m.addItem(new CMenuOptionNumberChooser(LOCALE_GLCD_SIZE_CHANNEL,
+				&g_settings.glcd_percent_channel, true, 0, 100, this));
+	m.addItem(new CMenuOptionNumberChooser(LOCALE_GLCD_SIZE_EPG,
+				&g_settings.glcd_percent_epg, true, 0, 100, this));
+	m.addItem(new CMenuOptionNumberChooser(LOCALE_GLCD_SIZE_BAR,
+				&g_settings.glcd_percent_bar, true, 0, 100, this));
+	m.addItem(new CMenuOptionNumberChooser(LOCALE_GLCD_SIZE_TIME,
+				&g_settings.glcd_percent_time, true, 0, 100, this));
+	m.addItem(new CMenuOptionChooser(LOCALE_GLCD_SHOW_LOGO, &g_settings.glcd_show_logo,
+				OPTIONS_OFF0_ON1_OPTIONS, OPTIONS_OFF0_ON1_OPTION_COUNT, true, this,
+				CRCInput::convertDigitToKey(shortcut++)));
+	m.addItem(new CMenuOptionNumberChooser(LOCALE_GLCD_SIZE_LOGO,
+				&g_settings.glcd_percent_logo, true, 0, 100, this));
+	m.addItem(new CMenuOptionNumberChooser(LOCALE_GLCD_BRIGHTNESS,
+				&g_settings.glcd_brightness, true, 0, 100, this));
+	m.addItem(GenericMenuSeparatorLine);
+	m.addItem(new CMenuOptionChooser(LOCALE_GLCD_TIME_IN_STANDBY, &g_settings.glcd_time_in_standby,
+				ONOFFSEC_OPTIONS, ONOFFSEC_OPTION_COUNT, true, this,
+				CRCInput::convertDigitToKey(shortcut++)));
+	m.addItem(new CMenuOptionNumberChooser(LOCALE_GLCD_SIZE_TIME_STANDBY,
+				&g_settings.glcd_percent_time_standby, true, 0, 100, this));
+	m.addItem(new CMenuOptionNumberChooser(LOCALE_GLCD_BRIGHTNESS_STANDBY,
+				&g_settings.glcd_brightness_standby, true, 0, 100, this));
+	m.addItem(GenericMenuSeparatorLine);
+	m.addItem(new CMenuOptionNumberChooser(LOCALE_GLCD_SCROLL_SPEED,
+				&g_settings.glcd_scroll_speed, true, 1, 63, this));
+	m.addItem(GenericMenuSeparatorLine);
+	m.addItem(new CMenuOptionChooser(LOCALE_GLCD_MIRROR_OSD, &g_settings.glcd_mirror_osd,
+				OPTIONS_OFF0_ON1_OPTIONS, OPTIONS_OFF0_ON1_OPTION_COUNT, true, this, CRCInput::RC_green));
+	m.addItem(new CMenuOptionChooser(LOCALE_GLCD_MIRROR_VIDEO, &g_settings.glcd_mirror_video,
+				OPTIONS_OFF0_ON1_OPTIONS, OPTIONS_OFF0_ON1_OPTION_COUNT, true, this, CRCInput::RC_yellow));
+	m.addItem(GenericMenuSeparatorLine);
+	m.addItem(new CMenuForwarder(LOCALE_GLCD_RESTART, true, NULL, this, "rescan", CRCInput::RC_red));
+	m.exec(NULL, "");
+	selected = m.getSelected();
+	nGLCD::getInstance()->StandbyMode(false);
+	m.hide();
+}
diff --git a/src/gui/glcdsetup.h b/src/gui/glcdsetup.h
new file mode 100644
index 000000000..aa587517e
--- /dev/null
+++ b/src/gui/glcdsetup.h
@@ -0,0 +1,48 @@
+/*
+	Neutrino graphlcd menue
+
+	Copyright (C) 2012 martii
+
+	License: GPL
+
+	This program is free software; you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation; either version 2 of the License, or
+	(at your option) any later version.
+
+	This program is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with this program; if not, write to the Free Software
+	Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+#ifdef ENABLE_GRAPHLCD
+
+#ifndef __glcdsetup_h__
+#define __glcdsetup_h__
+
+#include <sys/types.h>
+#include <string.h>
+#include <system/setting_helpers.h>
+#include <driver/nglcd.h>
+
+class GLCD_Menu : public CMenuTarget, public CChangeObserver
+{
+	private:
+		int width;
+		int selected;
+		static int color2index(uint32_t color);
+	public:
+		static uint32_t index2color(int i);
+		GLCD_Menu();
+		void hide();
+		int exec(CMenuTarget* parent, const std::string & actionKey);
+		bool changeNotify(const neutrino_locale_t, void *);
+		void GLCD_Menu_Settings();
+};
+#endif // __glcdsetup_h__
+#endif // ENABLE_GRAPHLCD
diff --git a/src/gui/lcd4l_setup.cpp b/src/gui/lcd4l_setup.cpp
index 99e180655..6c847969f 100644
--- a/src/gui/lcd4l_setup.cpp
+++ b/src/gui/lcd4l_setup.cpp
@@ -51,7 +51,6 @@
 
 #include <driver/screen_max.h>
 
-// lcd4l-support
 #include "driver/lcd4l.h"
 extern CLCD4l *LCD4l;
 
diff --git a/src/gui/movieplayer.cpp b/src/gui/movieplayer.cpp
index d10385364..f530a9385 100644
--- a/src/gui/movieplayer.cpp
+++ b/src/gui/movieplayer.cpp
@@ -84,6 +84,10 @@
 //NI InfoIcons
 #include <gui/infoicons.h>
 
+#ifdef ENABLE_GRAPHLCD
+bool glcd_play = false;
+#endif
+
 #if HAVE_COOL_HARDWARE || HAVE_ARM_HARDWARE || HAVE_MIPS_HARDWARE
 #define LCD_MODE CVFD::MODE_MENU_UTF8
 #else
@@ -1354,6 +1358,16 @@ bool CMoviePlayerGui::PlayFileStart(void)
 		CZapit::getInstance()->SetVolumePercent(percent);
 	}
 
+#ifdef ENABLE_GRAPHLCD
+	nGLCD::MirrorOSD(false);
+	if (p_movie_info)
+		nGLCD::lockChannel(p_movie_info->channelName, p_movie_info->epgTitle);
+	else {
+		glcd_play = true;
+		nGLCD::lockChannel(g_Locale->getText(LOCALE_MOVIEPLAYER_HEAD), file_name.c_str(), file_prozent);
+	}
+#endif
+
 	file_prozent = 0;
 	pthread_t thrStartHint = 0;
 	if (is_file_player) {
@@ -1546,6 +1560,14 @@ void CMoviePlayerGui::PlayFileLoop(void)
 
 	while (playstate >= CMoviePlayerGui::PLAY)
 	{
+#ifdef ENABLE_GRAPHLCD
+		if (p_movie_info)
+			nGLCD::lockChannel(p_movie_info->channelName, p_movie_info->epgTitle, duration ? (100 * position / duration) : 0);
+		else {
+			glcd_play = true;
+			nGLCD::lockChannel(g_Locale->getText(LOCALE_MOVIEPLAYER_HEAD), file_name.c_str(), file_prozent);
+		}
+#endif
 		if (update_lcd || g_settings.movieplayer_display_playtime) {
 			update_lcd = false;
 			updateLcd(g_settings.movieplayer_display_playtime);
@@ -2051,6 +2073,12 @@ void CMoviePlayerGui::PlayFileEnd(bool restore)
 
 	playback->SetSpeed(1);
 	playback->Close();
+#ifdef ENABLE_GRAPHLCD
+	if (p_movie_info || glcd_play == true) {
+		glcd_play = false;
+		nGLCD::unlockChannel();
+	}
+#endif
 	if (iso_file) {
 		iso_file = false;
 		if (umount2(ISO_MOUNT_POINT, MNT_FORCE))
@@ -2199,6 +2227,10 @@ void CMoviePlayerGui::callInfoViewer(bool init_vzap_it)
 		}
 		if (!movie_info.channelName.empty() || !movie_info.epgTitle.empty())
 			p_movie_info = &movie_info;
+#ifdef ENABLE_GRAPHLCD
+		if (p_movie_info)
+			nGLCD::lockChannel(p_movie_info->channelName, p_movie_info->epgTitle);
+#endif
 	}
 
 	if (p_movie_info) {
diff --git a/src/gui/osd_setup.cpp b/src/gui/osd_setup.cpp
index e2d32de1d..06f5b3a08 100644
--- a/src/gui/osd_setup.cpp
+++ b/src/gui/osd_setup.cpp
@@ -69,7 +69,6 @@
 
 #include <hardware/video.h>
 
-// lcd4l-support
 #include "driver/lcd4l.h"
 extern CLCD4l *LCD4l;
 
diff --git a/src/gui/vfd_setup.cpp b/src/gui/vfd_setup.cpp
index 6d79edb8e..2a8a348c6 100644
--- a/src/gui/vfd_setup.cpp
+++ b/src/gui/vfd_setup.cpp
@@ -33,6 +33,9 @@
 #include <config.h>
 #endif
 
+#ifdef ENABLE_GRAPHLCD
+#include <gui/glcdsetup.h>
+#endif
 
 #include "vfd_setup.h"
 
@@ -190,6 +193,13 @@ int CVfdSetup::showSetup()
 		vfds->addItem(oj);
 	}
 
+#ifdef ENABLE_GRAPHLCD
+	GLCD_Menu glcdMenu;
+
+	vfds->addItem(GenericMenuSeparatorLine);
+	vfds->addItem(new CMenuForwarder(LOCALE_GLCD_HEAD, true, NULL, &glcdMenu, NULL, CRCInput::RC_blue));
+#endif
+
 	int res = vfds->exec(NULL, "");
 
 	//NI
diff --git a/src/gui/widget/menue.cpp b/src/gui/widget/menue.cpp
index 6e8e25dfb..a8b8f2e22 100644
--- a/src/gui/widget/menue.cpp
+++ b/src/gui/widget/menue.cpp
@@ -47,7 +47,6 @@
 
 #include <cctype>
 
-//NI lcd4l-support
 #include "driver/lcd4l.h"
 extern CLCD4l *LCD4l;
 
@@ -93,7 +92,10 @@ CMenuItem::CMenuItem(bool Active, neutrino_msg_t DirectKey, const char * const I
 	actObserv	= NULL;
 	parent_widget	= NULL;
 
-	lcd4l_text	= ""; //NI lcd4l-support
+#ifdef ENABLE_GRAPHLCD
+	graphlcd_text	= "";
+#endif
+	lcd4l_text	= "";
 }
 
 void CMenuItem::init(const int X, const int Y, const int DX, const int OFFX)
@@ -240,19 +242,28 @@ void CMenuItem::paintItemCaption(const bool select_mode, const char * right_text
 			char str[len];
 			snprintf(str, len, "%s %s", left_text, right_text);
 			CVFD::getInstance()->showMenuText(0, str, -1, true);
-			//NI lcd4l-support
-			if(g_settings.lcd4l_support)
+#ifdef ENABLE_GRAPHLCD
+			if (g_settings.glcd_enable)
+				graphlcd_text = str;
+#endif
+			if (g_settings.lcd4l_support)
 				lcd4l_text = str;
 		} 
 		else
 		{
 			CVFD::getInstance()->showMenuText(0, left_text, -1, true);
-			//NI lcd4l-support
+#ifdef ENABLE_GRAPHLCD
+			if (g_settings.glcd_enable)
+				graphlcd_text = left_text;
+#endif
 			if (g_settings.lcd4l_support)
 				lcd4l_text = left_text;
 		}
 
-		//NI lcd4l-support
+#ifdef ENABLE_GRAPHLCD
+		if (g_settings.glcd_enable)
+			nGLCD::lockChannel(g_Locale->getText(LOCALE_MAINMENU_HEAD), graphlcd_text, 0);
+#endif
 		if (g_settings.lcd4l_support)
 			LCD4l->CreateFile("/tmp/lcd/menu", lcd4l_text, g_settings.lcd4l_convert);
 	}
@@ -1020,7 +1031,9 @@ int CMenuWidget::exec(CMenuTarget* parent, const std::string &)
 			case (CRCInput::RC_right):
 			case (CRCInput::RC_ok):
 				if (hasItem() && selected > -1 && (int)items.size() > selected) {
-					//NI lcd4l-support
+#ifdef ENABLE_GRAPHLCD
+					nGLCD::unlockChannel();
+#endif
 					LCD4l->RemoveFile("/tmp/lcd/menu");
 
 					//exec this item...
@@ -1036,7 +1049,10 @@ int CMenuWidget::exec(CMenuTarget* parent, const std::string &)
 					fader.StopFade();
 					int rv = item->exec( this );
 
-					//NI lcd4l-support
+#ifdef ENABLE_GRAPHLCD
+					if (g_settings.glcd_enable)
+						nGLCD::lockChannel(g_Locale->getText(LOCALE_MAINMENU_HEAD), item->graphlcd_text, 0);
+#endif
 					if (g_settings.lcd4l_support)
 						LCD4l->CreateFile("/tmp/lcd/menu", item->lcd4l_text, g_settings.lcd4l_convert);
 
@@ -1124,7 +1140,9 @@ int CMenuWidget::exec(CMenuTarget* parent, const std::string &)
 		if(oldLcdMode != CVFD::getInstance()->getMode())
 			CVFD::getInstance()->setMode(CVFD::MODE_TVRADIO);
 
-	//NI lcd4l-support
+#ifdef ENABLE_GRAPHLCD
+	nGLCD::unlockChannel();
+#endif
 	LCD4l->RemoveFile("/tmp/lcd/menu");
 
 	for (unsigned int count = 0; count < items.size(); count++) 
diff --git a/src/gui/widget/menue.h b/src/gui/widget/menue.h
index 6cbcda974..3e2ba663a 100644
--- a/src/gui/widget/menue.h
+++ b/src/gui/widget/menue.h
@@ -209,7 +209,9 @@ class CMenuItem : public  CComponentsSignals
 		void setInfoIconRight(const char * const IconName_Info_right);
 		const char* getInfoIconRight(){return iconName_Info_right;}
 
-		//NI lcd4l-support
+#ifdef ENABLE_GRAPHLCD
+		std::string graphlcd_text;
+#endif
 		std::string lcd4l_text;
 };
 
diff --git a/src/neutrino.cpp b/src/neutrino.cpp
index 5107cc70f..4e4635c8c 100644
--- a/src/neutrino.cpp
+++ b/src/neutrino.cpp
@@ -162,7 +162,6 @@ CTimeOSD	*FileTimeOSD;
 #include "gui/infoicons.h"
 CInfoIcons	*InfoIcons;
 
-//NI lcd4l-support
 #include "driver/lcd4l.h"
 CLCD4l		*LCD4l;
 
@@ -193,7 +192,7 @@ extern cAudio * audioDecoder;
 cPowerManager *powerManager;
 cCpuFreqManager * cpuFreq;
 
-void stop_lcd4l_support(void); //NI lcd4l-support
+void stop_lcd4l_support(void);
 void stop_daemons(bool stopall = true, bool for_flash = false);
 void stop_video(void);
 
@@ -663,6 +662,38 @@ int CNeutrinoApp::loadSetup(const char * fname)
 
 	g_settings.osd_colorsettings_advanced_mode = configfile.getBool("osd_colorsettings_advanced_mode", false);
 
+#ifdef ENABLE_GRAPHLCD
+	g_settings.glcd_enable = configfile.getInt32("glcd_enable", 1);
+	g_settings.glcd_color_fg = configfile.getInt32("glcd_color_fg", GLCD::cColor::White);
+	g_settings.glcd_color_bg = configfile.getInt32("glcd_color_bg", GLCD::cColor::Black);
+	g_settings.glcd_color_bar = configfile.getInt32("glcd_color_bar", GLCD::cColor::Blue);
+	g_settings.glcd_percent_channel = configfile.getInt32("glcd_percent_channel", 22);
+	g_settings.glcd_percent_epg = configfile.getInt32("glcd_percent_epg", 16);
+	g_settings.glcd_percent_bar = configfile.getInt32("glcd_percent_bar", 8);
+	g_settings.glcd_percent_time = configfile.getInt32("glcd_percent_time", 35);
+	g_settings.glcd_percent_time_standby = configfile.getInt32("glcd_percent_time_standby", 50);
+	g_settings.glcd_percent_logo = configfile.getInt32("glcd_percent_logo", 50);
+	g_settings.glcd_mirror_osd = configfile.getInt32("glcd_mirror_osd", 0);
+	g_settings.glcd_mirror_video = configfile.getInt32("glcd_mirror_video", 0);
+	g_settings.glcd_time_in_standby = configfile.getInt32("glcd_time_in_standby", 1);
+	g_settings.glcd_show_logo = configfile.getInt32("glcd_show_logo", 1);
+	g_settings.glcd_font = configfile.getString("glcd_font", FONTDIR "/neutrino.ttf");
+#if BOXMODEL_VUUNO4KSE
+	g_settings.glcd_brightness = configfile.getInt32("glcd_brightness", 25);
+	g_settings.glcd_brightness_standby = configfile.getInt32("glcd_brightness_standby", 5);
+#else
+	g_settings.glcd_brightness = configfile.getInt32("glcd_brightness", 75);
+	g_settings.glcd_brightness_standby = configfile.getInt32("glcd_brightness_standby", 45);
+#endif
+#if BOXMODEL_VUUNO4KSE
+	g_settings.glcd_scroll_speed = configfile.getInt32("glcd_scroll_speed", 1);
+#elif BOXMODEL_VUSOLO4K || BOXMODEL_VUDUO4K || BOXMODEL_VUULTIMO4K
+	g_settings.glcd_scroll_speed = configfile.getInt32("glcd_scroll_speed", 2);
+#else
+	g_settings.glcd_scroll_speed = configfile.getInt32("glcd_scroll_speed", 5);
+#endif
+#endif
+
 	//personalize
 	g_settings.personalize_pincode = configfile.getString( "personalize_pincode", "0000" );
 	for (int i = 0; i < SNeutrinoSettings::P_SETTINGS_MAX; i++)//settings.h, settings.cpp
@@ -1584,6 +1615,27 @@ void CNeutrinoApp::saveSetup(const char * fname)
 
 	configfile.setBool("osd_colorsettings_advanced_mode", g_settings.osd_colorsettings_advanced_mode);
 
+#ifdef ENABLE_GRAPHLCD
+	configfile.setInt32("glcd_enable", g_settings.glcd_enable);
+	configfile.setInt32("glcd_color_fg", g_settings.glcd_color_fg);
+	configfile.setInt32("glcd_color_bg", g_settings.glcd_color_bg);
+	configfile.setInt32("glcd_color_bar", g_settings.glcd_color_bar);
+	configfile.setInt32("glcd_percent_channel", g_settings.glcd_percent_channel);
+	configfile.setInt32("glcd_percent_epg", g_settings.glcd_percent_epg);
+	configfile.setInt32("glcd_percent_bar", g_settings.glcd_percent_bar);
+	configfile.setInt32("glcd_percent_time", g_settings.glcd_percent_time);
+	configfile.setInt32("glcd_percent_time_standby", g_settings.glcd_percent_time_standby);
+	configfile.setInt32("glcd_percent_logo", g_settings.glcd_percent_logo);
+	configfile.setInt32("glcd_mirror_osd", g_settings.glcd_mirror_osd);
+	configfile.setInt32("glcd_mirror_video", g_settings.glcd_mirror_video);
+	configfile.setInt32("glcd_time_in_standby", g_settings.glcd_time_in_standby);
+	configfile.setInt32("glcd_show_logo", g_settings.glcd_show_logo);
+	configfile.setString("glcd_font", g_settings.glcd_font);
+	configfile.setInt32("glcd_brightness", g_settings.glcd_brightness);
+	configfile.setInt32("glcd_brightness_standby", g_settings.glcd_brightness_standby);
+	configfile.setInt32("glcd_scroll_speed", g_settings.glcd_scroll_speed);
+#endif
+
 	//personalize
 	configfile.setString("personalize_pincode", g_settings.personalize_pincode);
 	for (int i = 0; i < SNeutrinoSettings::P_SETTINGS_MAX; i++) //settings.h, settings.cpp
@@ -2662,6 +2714,10 @@ TIMER_START();
 	CVFD::getInstance()->setBacklight(g_settings.backlight_tv);
 	CVFD::getInstance()->setScrollMode(g_settings.lcd_scroll);
 
+#ifdef ENABLE_GRAPHLCD
+	nGLCD::getInstance();
+#endif
+
 	if (!scanSettings.loadSettings(NEUTRINO_SCAN_SETTINGS_FILE))
 		dprintf(DEBUG_NORMAL, "Loading of scan settings failed. Using defaults.\n");
 
@@ -2874,7 +2930,6 @@ TIMER_START();
 
 	SHTDCNT::getInstance()->init();
 
-	//NI lcd4l-support
 	LCD4l = new CLCD4l();
 	if(g_settings.lcd4l_support)
 		LCD4l->StartLCD4l();
@@ -3303,6 +3358,11 @@ void CNeutrinoApp::RealRun()
 				if(show_info && channelList->getSize()) {
 					showInfo();
 				}
+#ifdef ENABLE_GRAPHLCD
+				if (msg == NeutrinoMessages::EVT_CURRENTNEXT_EPG) {
+					nGLCD::Update();
+				}
+#endif
 			}
 			else if (msg == CRCInput::RC_timer || msg == CRCInput::RC_program)
 			{
@@ -3581,6 +3641,9 @@ int CNeutrinoApp::handleMsg(const neutrino_msg_t _msg, neutrino_msg_data_t data)
 			g_settings.audio_AnalogMode = 0;
 
 		CVFD::getInstance()->UpdateIcons();
+#ifdef ENABLE_GRAPHLCD
+		nGLCD::Update();
+#endif
 		g_RCInput->killTimer(scrambled_timer);
 		if (mode != NeutrinoModes::mode_webtv) {
 			g_Zapit->setMode43(g_settings.video_43mode);
@@ -4285,7 +4348,7 @@ void CNeutrinoApp::ExitRun(int exit_code)
 	printf("[neutrino] %s(int %d)\n", __func__, exit_code);
 	printf("[neutrino] hw_caps->can_shutdown: %d\n", g_info.hw_caps->can_shutdown);
 
-	stop_lcd4l_support(); //NI lcd4l-support
+	stop_lcd4l_support();
 
 	//NI InfoIcons
 	if(g_settings.mode_icons && g_settings.mode_icons_skin == INFOICONS_POPUP)
@@ -4408,6 +4471,11 @@ void CNeutrinoApp::ExitRun(int exit_code)
 	delete SHTDCNT::getInstance();
 	stop_video();
 
+#ifdef ENABLE_GRAPHLCD
+	if (exit_code == CNeutrinoApp::EXIT_SHUTDOWN)
+		nGLCD::SetBrightness(0);
+#endif
+
 	Cleanup();
 
 	printf("[neutrino] This is the end. Exiting with code %d\n", exit_code);
@@ -4575,6 +4643,9 @@ void CNeutrinoApp::standbyMode( bool bOnOff, bool fromDeepStandby )
 		if ( FILE *f = fopen("/tmp/.ni-standby", "w") )
 			fclose(f);
 
+#ifdef ENABLE_GRAPHLCD
+		nGLCD::StandbyMode(true);
+#endif
 		CVFD::getInstance()->ShowText("Standby ...");
 		if( mode == NeutrinoModes::mode_scart ) {
 			//g_Controld->setScartMode( 0 );
@@ -4667,6 +4738,10 @@ void CNeutrinoApp::standbyMode( bool bOnOff, bool fromDeepStandby )
 		g_InfoViewer->getEPG(0, dummy);
 		g_RCInput->killTimer(fst_timer);
 
+#ifdef ENABLE_GRAPHLCD
+		nGLCD::StandbyMode(false);
+#endif
+
 		if(init_cec_setting){
 			//init cec settings
 			CCECSetup cecsetup;
@@ -4997,7 +5072,7 @@ int CNeutrinoApp::exec(CMenuTarget* parent, const std::string & actionKey)
 			CHint * hint = new CHint(LOCALE_SERVICEMENU_RESTART_HINT);
 			hint->paint();
 
-			stop_lcd4l_support(); //NI lcd4l-support
+			stop_lcd4l_support();
 
 			saveSetup(NEUTRINO_SETTINGS_FILE);
 
@@ -5077,7 +5152,6 @@ void CNeutrinoApp::stopDaemonsForFlash()
 /**************************************************************************************
 *          Main programm - no function here                                           *
 **************************************************************************************/
-//NI lcd4l-support
 void stop_lcd4l_support()
 {
 	if(LCD4l) {
@@ -5110,6 +5184,10 @@ void stop_daemons(bool stopall, bool for_flash)
 	tuxtxt_stop();
 	tuxtxt_close();
 
+#ifdef ENABLE_GRAPHLCD
+	nGLCD::Exit();
+#endif
+
 	if (g_Radiotext) {
 		delete g_Radiotext;
 		g_Radiotext = NULL;
@@ -5190,7 +5268,7 @@ void sighandler (int signum)
 	switch (signum) {
 	case SIGTERM:
 	case SIGINT:
-		stop_lcd4l_support(); //NI lcd4l-support
+		stop_lcd4l_support();
 		delete cHddStat::getInstance();
 		delete CRecordManager::getInstance();
 		//CNeutrinoApp::getInstance()->saveSetup(NEUTRINO_SETTINGS_FILE);
@@ -5424,7 +5502,7 @@ void CNeutrinoApp::saveKeys(const char * fname)
 	}
 }
 
-void CNeutrinoApp::StopSubtitles()
+void CNeutrinoApp::StopSubtitles(bool enable_glcd_mirroring)
 {
 	//printf("[neutrino] %s\n", __FUNCTION__);
 	int ttx, dvbpid, ttxpid, ttxpage;
@@ -5438,6 +5516,10 @@ void CNeutrinoApp::StopSubtitles()
 		tuxtx_pause_subtitle(true);
 		frameBuffer->paintBackground();
 	}
+#ifdef ENABLE_GRAPHLCD
+	if (enable_glcd_mirroring)
+		nGLCD::MirrorOSD(g_settings.glcd_mirror_osd);
+#endif
 	if (mode == NeutrinoModes::mode_webtv)
 		CMoviePlayerGui::getInstance(true).clearSubtitle(true);
 }
@@ -5445,6 +5527,9 @@ void CNeutrinoApp::StopSubtitles()
 void CNeutrinoApp::StartSubtitles(bool show)
 {
 	//printf("%s: %s\n", __FUNCTION__, show ? "Show" : "Not show");
+#ifdef ENABLE_GRAPHLCD
+	nGLCD::MirrorOSD(false);
+#endif
 	if(!show)
 		return;
 	dvbsub_start(0);
diff --git a/src/neutrino.h b/src/neutrino.h
index 7b04c9ed7..9d3ff6bb1 100644
--- a/src/neutrino.h
+++ b/src/neutrino.h
@@ -208,7 +208,7 @@ public:
 	void MarkChannelsInit(void) { channels_init = true; };
 	void quickZap(int msg);
 	void numericZap(int msg);
-	void StopSubtitles();
+	void StopSubtitles(bool enable_glcd_mirroring = true);
 	void StartSubtitles(bool show = true);
 	bool StartPip(const t_channel_id channel_id);
 	void SelectSubtitles();
diff --git a/src/system/flashtool.cpp b/src/system/flashtool.cpp
index 115419214..febbc4166 100644
--- a/src/system/flashtool.cpp
+++ b/src/system/flashtool.cpp
@@ -49,7 +49,6 @@
 #define writesize oobsize
 #endif
 
-//NI lcd4l-support
 #include "driver/lcd4l.h"
 extern CLCD4l *LCD4l;
 
diff --git a/src/system/locals.h b/src/system/locals.h
index 0e9dd2bf7..acb3897c9 100644
--- a/src/system/locals.h
+++ b/src/system/locals.h
@@ -883,6 +883,45 @@ typedef enum
 	LOCALE_FSK_TO_12,
 	LOCALE_FSK_TO_16,
 	LOCALE_FSK_TO_7,
+	LOCALE_GLCD_BRIGHTNESS,
+	LOCALE_GLCD_BRIGHTNESS_STANDBY,
+	LOCALE_GLCD_COLOR_BLACK,
+	LOCALE_GLCD_COLOR_BLUE,
+	LOCALE_GLCD_COLOR_CYAN,
+	LOCALE_GLCD_COLOR_GREEN,
+	LOCALE_GLCD_COLOR_MAGENTA,
+	LOCALE_GLCD_COLOR_RED,
+	LOCALE_GLCD_COLOR_WHITE,
+	LOCALE_GLCD_COLOR_YELLOW,
+	LOCALE_GLCD_COLOR_ORANGE,
+	LOCALE_GLCD_COLOR_LIGHT_GRAY,
+	LOCALE_GLCD_COLOR_GRAY,
+	LOCALE_GLCD_COLOR_DARK_GRAY,
+	LOCALE_GLCD_COLOR_DARK_RED,
+	LOCALE_GLCD_COLOR_DARK_GREEN,
+	LOCALE_GLCD_COLOR_DARK_BLUE,
+	LOCALE_GLCD_COLOR_PURPLE,
+	LOCALE_GLCD_COLOR_MINT,
+	LOCALE_GLCD_COLOR_GOLDEN,
+	LOCALE_GLCD_ENABLE,
+	LOCALE_GLCD_FONT,
+	LOCALE_GLCD_HEAD,
+	LOCALE_GLCD_MIRROR_OSD,
+	LOCALE_GLCD_MIRROR_VIDEO,
+	LOCALE_GLCD_RESTART,
+	LOCALE_GLCD_SCROLL_SPEED,
+	LOCALE_GLCD_SELECT_BAR,
+	LOCALE_GLCD_SELECT_BG,
+	LOCALE_GLCD_SELECT_FG,
+	LOCALE_GLCD_SHOW_LOGO,
+	LOCALE_GLCD_SIZE_BAR,
+	LOCALE_GLCD_SIZE_CHANNEL,
+	LOCALE_GLCD_SIZE_EPG,
+	LOCALE_GLCD_SIZE_LOGO,
+	LOCALE_GLCD_SIZE_TIME,
+	LOCALE_GLCD_SIZE_TIME_STANDBY,
+	LOCALE_GLCD_TIME_IN_STANDBY,
+	LOCALE_GLCD_VOLUME,
 	LOCALE_HDD_10MIN,
 	LOCALE_HDD_1MIN,
 	LOCALE_HDD_20MIN,
diff --git a/src/system/locals_intern.h b/src/system/locals_intern.h
index 1737efdf2..0f09ab19c 100644
--- a/src/system/locals_intern.h
+++ b/src/system/locals_intern.h
@@ -883,6 +883,45 @@ const char * locale_real_names[] =
 	"fsk.to_12",
 	"fsk.to_16",
 	"fsk.to_7",
+	"glcd.brightness",
+	"glcd.brightness_standby",
+	"glcd.color.black",
+	"glcd.color.blue",
+	"glcd.color.cyan",
+	"glcd.color.green",
+	"glcd.color.magenta",
+	"glcd.color.red",
+	"glcd.color.white",
+	"glcd.color.yellow",
+	"glcd.color.orange",
+	"glcd.color.light_gray",
+	"glcd.color.gray",
+	"glcd.color.dark_gray",
+	"glcd.color.dark_red",
+	"glcd.color.dark_green",
+	"glcd.color.dark_blue",
+	"glcd.color.purple",
+	"glcd.color.mint",
+	"glcd.color.golden",
+	"glcd.enable",
+	"glcd.font",
+	"glcd.head",
+	"glcd.mirror_osd",
+	"glcd.mirror_video",
+	"glcd.restart",
+	"glcd.scroll_speed",
+	"glcd.select.bar",
+	"glcd.select.bg",
+	"glcd.select.fg",
+	"glcd.show_logo",
+	"glcd.size_bar",
+	"glcd.size_channel",
+	"glcd.size_epg",
+	"glcd.size_logo",
+	"glcd.size_time",
+	"glcd.size_time_standby",
+	"glcd.time_in_standby",
+	"glcd.volume",
 	"hdd_10min",
 	"hdd_1min",
 	"hdd_20min",
diff --git a/src/system/settings.h b/src/system/settings.h
index 3e8501d61..5dbb0ffc0 100644
--- a/src/system/settings.h
+++ b/src/system/settings.h
@@ -796,6 +796,36 @@ struct SNeutrinoSettings
 	int infoClockSeconds;
 	int infoClockBackground;
 
+	// graphlcd
+	int glcd_enable;
+	uint32_t glcd_color_fg;
+	uint32_t glcd_color_bg;
+	uint32_t glcd_color_bar;
+	std::string glcd_font;
+	int glcd_percent_channel;
+	int glcd_percent_epg;
+	int glcd_percent_bar;
+	int glcd_percent_time;
+	int glcd_percent_time_standby;
+	int glcd_percent_logo;
+	int glcd_mirror_osd;
+	int glcd_mirror_video;
+	int glcd_time_in_standby;
+	int glcd_show_logo;
+	int glcd_brightness;
+	int glcd_brightness_standby;
+	int glcd_scroll_speed;
+
+	// lcd4linux
+	int lcd4l_support;
+	std::string lcd4l_logodir;
+	int lcd4l_brightness;
+	int lcd4l_brightness_standby;
+	int lcd4l_display_type;
+	int lcd4l_skin;
+	int lcd4l_skin_radio;
+	int lcd4l_convert;
+
 	// lcdd
 	enum LCD_SETTINGS {
 		LCD_BRIGHTNESS         = 0,
@@ -904,16 +934,6 @@ struct SNeutrinoSettings
 	int font_scaling_x;
 	int font_scaling_y;
 
-	// lcd4linux
-	int lcd4l_support;
-	std::string lcd4l_logodir;
-	int lcd4l_brightness;
-	int lcd4l_brightness_standby;
-	int lcd4l_display_type;
-	int lcd4l_skin;
-	int lcd4l_skin_radio;
-	int lcd4l_convert;
-
 	int		ca_init;
 	int		show_menu_hints_line;
 	int		inetradio_autostart;