Version 0.8.0 beta

Makefile

@@ -27,7 +27,7 @@ SKINDESIGNER_SCRIPTDIR ?= $(LIBDIR)/$(PLUGIN)/scripts
 ### The compiler options:
 export CFLAGS   = $(call PKGCFG,cflags)
 export CXXFLAGS = $(call PKGCFG,cxxflags)
-
+CXXFLAGS += -std=c++11
 ### Allow user defined options to overwrite defaults:
 
 -include $(PLGCFG)
@@ -65,51 +65,49 @@ OBJS = $(PLUGIN).o \
        displayreplay.o \
        displaytracks.o \
        displayvolume.o \
-       displayplugin.o \
-       libcore/cairoimage.o \
-       libcore/curlfuncs.o \
-       libcore/pixmapcontainer.o \
-       libcore/fontmanager.o \
-       libcore/imagecache.o \
-       libcore/helpers.o \
-       libcore/imageloader.o \
-       libcore/libxmlwrapper.o \
-       libcore/recfolderinfo.o \
-       libcore/skinsetup.o \
-       libcore/skinrepo.o \
-       libcore/extrecinfo.o \
-       libcore/timers.o \
-       libtemplate/globals.o \
-       libtemplate/parameter.o \
-       libtemplate/template.o \
-       libtemplate/templateview.o \
-       libtemplate/templateviewelement.o \
-       libtemplate/templateviewlist.o \
-       libtemplate/templateviewgrid.o \
-       libtemplate/templatepixmap.o \
-       libtemplate/templateviewtab.o \
-       libtemplate/templatefunction.o \
-       libtemplate/templateloopfunction.o \
-       libtemplate/xmlparser.o \
-       views/animation.o \
-       views/view.o \
-       views/viewgrid.o \
-       views/viewhelpers.o \
-       views/displayviewelements.o \
-       views/displaychannelview.o \
-       views/displaymenurootview.o \
-       views/displaymenuview.o \
-       views/displaymenulistview.o \
-       views/displaymenuitemview.o \
-       views/displaymenuitemcurrentview.o \
-       views/displaymenudetailview.o \
-       views/displaymenutabview.o \
-       views/displaymessageview.o \
-       views/displayreplayview.o \
-       views/displayreplayonpauseview.o \
-       views/displayvolumeview.o \
-       views/displayaudiotracksview.o \
-       views/displaypluginview.o
+       extensions/cairoimage.o \
+       extensions/curlfuncs.o \
+       extensions/fontmanager.o \
+       extensions/imagecache.o \
+       extensions/helpers.o \
+       extensions/imageloader.o \
+       extensions/libxmlwrapper.o \
+       extensions/pluginmanager.o \
+       extensions/recfolderinfo.o \
+       extensions/scrapmanager.o \
+       extensions/skinsetup.o \
+       extensions/skinrepo.o \
+       extensions/extrecinfo.o \
+       extensions/timers.o \
+       coreengine/animation.o \
+       coreengine/attribute.o \
+       coreengine/attributes.o \
+       coreengine/functions.o \
+       coreengine/complextypes.o \
+       coreengine/globals.o \
+       coreengine/gridelement.o \
+       coreengine/osdwrapper.o \
+       coreengine/view.o \
+       coreengine/viewdisplaychannel.o \
+       coreengine/viewdisplaymenu.o \
+       coreengine/viewdisplaymessage.o \
+       coreengine/viewdisplayreplay.o \
+       coreengine/viewdisplaytracks.o \
+       coreengine/viewdisplayvolume.o \
+       coreengine/viewdisplayplugin.o \
+       coreengine/viewelement.o \
+       coreengine/viewelementplugin.o \
+       coreengine/viewelementscommon.o \
+       coreengine/viewelementsdisplaychannel.o \
+       coreengine/viewelementsdisplaymenu.o \
+       coreengine/viewelementsdisplayreplay.o \
+       coreengine/viewelementsdisplaytracks.o \
+       coreengine/viewgrid.o \
+       coreengine/viewlist.o \
+       coreengine/viewdetail.o \
+       coreengine/listelements.o \
+       coreengine/area.o \
+       coreengine/xmlparser.o
 
 ### The main target:
 
@@ -138,7 +136,7 @@ $(SOFILE): SUB_LIBS = libskindesignerapi/libskindesignerapi.so.$(shell pkg-confi
 ### Implicit rules:
 
 %.o: %.c
-	$(CXX) $(CXXFLAGS) -c $(DEFINES) $(SUB_DEFINES) $(INCLUDES) -o $@ $<
+	$(CXX) $(CXXFLAGS) -std=c++11 -c $(DEFINES) $(SUB_DEFINES) $(INCLUDES) -o $@ $<
 
 ### Dependencies:
 
@@ -178,7 +176,7 @@ install-i18n: $(I18Nmsgs)
 ### Targets:
 
 $(SOFILE): $(OBJS)
-	$(CXX) $(CXXFLAGS) $(LDFLAGS) -shared $(OBJS) $(LIBS) $(SUB_LIBS) -o $@
+	$(CXX) $(CXXFLAGS) -std=c++11  $(LDFLAGS) -shared $(OBJS) $(LIBS) $(SUB_LIBS) -o $@
 
 install-lib: $(SOFILE)
 	install -D $^ $(DESTDIR)$(LIBDIR)/$^.$(APIVERSION)
@@ -209,4 +207,4 @@ dist: $(I18Npo) clean
 
 clean: clean-subprojects
 	@-rm -f $(PODIR)/*.mo $(PODIR)/*.pot
-	@-rm -f $(OBJS) $(DEPFILE) *.so *.tgz core* *~
+	@-rm -f $(OBJS) $(DEPFILE) *.so *.tgz *~

config.c

@@ -1,6 +1,6 @@
 #include "config.h"
-#include "libcore/helpers.h"
-#include "libcore/imageloader.h"
+#include "extensions/helpers.h"
+#include "extensions/imageloader.h"
 
 cDesignerConfig::cDesignerConfig() {
     tmplGlobals = NULL;
@@ -9,6 +9,7 @@ cDesignerConfig::cDesignerConfig() {
     installerSkinPathSet = false;
     logoPathSet = false;
     //Common
+    cacheImagesInitial = 1;
     numLogosPerSizeInitial = 30;
     limitLogoCache = 1;
     numLogosMax = 200;
@@ -18,11 +19,8 @@ cDesignerConfig::cDesignerConfig() {
     rerunAmount = 10;
     rerunDistance = 2;
     rerunMaxChannel = 0;
-    //menu display style, display menu items 
-    //one after each other or in one step
-    blockFlush = 1;
-    //frames per second for fading and shifting
-    framesPerSecond = 40;
+    //max number of custom int and string tokens
+    numCustomTokens = 10;
     //remember current skin and theme, osd size and osd fonts
     SetSkin();
     SetOSDSize();
@@ -475,98 +473,6 @@ cString cDesignerConfig::GetSkinRessourcePath(void) {
     return cString::sprintf("%s%s", *skinPath, osdSkin.c_str());
 }
 
-void cDesignerConfig::AddPluginMenus(string name, map< int, string > menus) {
-    pluginMenus.insert(pair< string, map < int, string > >(name, menus));
-}
-
-void cDesignerConfig::AddPluginViews(string name, 
-                                     map< int, string > views,
-                                     multimap< int, pair <int, string> > subViews,
-                                     map< int, map <int, string> > viewElements,
-                                     map< int, map <int, string> > viewGrids) {
-    pluginViews.insert(pair< string, map < int, string > >(name, views));
-    pluginSubViews.insert(pair< string, multimap< int, pair <int, string> > >(name, subViews));
-    pluginViewElements.insert(pair< string, map< int, map <int, string> > >(name, viewElements));
-    pluginViewGrids.insert(pair< string, map< int, map <int, string> > >(name, viewGrids));
-}
-
-void cDesignerConfig::InitPluginMenuIterator(void) {
-    plugMenuIt = pluginMenus.begin();
-}
-
-map <int,string> *cDesignerConfig::GetPluginTemplates(string &name) {
-    if (plugMenuIt == pluginMenus.end())
-        return NULL;
-    name = plugMenuIt->first;
-    map <int,string> *templates = &plugMenuIt->second;
-    plugMenuIt++;
-    return templates; 
-}
-
-void cDesignerConfig::InitPluginViewIterator(void) {
-    plugViewIt = pluginViews.begin();
-}
-
-map <int,string> *cDesignerConfig::GetPluginViews(string &name) {
-    if (plugViewIt == pluginViews.end())
-        return NULL;
-    name = plugViewIt->first;
-    map <int,string> *views = &plugViewIt->second;
-    plugViewIt++;
-    return views; 
-}
-
-map <int,string> cDesignerConfig::GetPluginSubViews(string name, int viewID) {
-    map <int,string> subViews;
-
-    map < string, multimap< int, pair <int, string> > >::iterator hit = pluginSubViews.find(name);
-    if (hit == pluginSubViews.end())
-        return subViews;
-
-    multimap< int, pair<int, string> > subs = hit->second;
-
-    pair < multimap< int, pair<int, string> >::iterator, multimap< int, pair<int, string> >::iterator> viewSubViews;
-    viewSubViews = subs.equal_range(viewID); 
-
-    for (multimap< int, pair<int, string> >::iterator it=viewSubViews.first; it!=viewSubViews.second; ++it) {
-        pair<int, string> subViewFound = it->second;
-        subViews.insert(pair<int,string>(subViewFound.first, subViewFound.second));
-    }
-    return subViews;
-}
-
-int cDesignerConfig::GetPluginViewElementID(string pluginName, string viewElementName, int viewID) {
-    map < string, map< int, map <int, string> > >::iterator hit = pluginViewElements.find(pluginName);
-    if (hit == pluginViewElements.end())
-        return -1;
-    map< int, map <int, string> >::iterator hit2 = (hit->second).find(viewID);
-    if (hit2 == (hit->second).end())
-        return -1;
-    
-    map <int, string> viewElements = hit2->second;
-    for (map <int, string>::iterator it = viewElements.begin(); it != viewElements.end(); it++) {
-        if (!(it->second).compare(viewElementName))
-            return it->first;
-    }
-    return -1;
-}
-
-int cDesignerConfig::GetPluginViewGridID(string pluginName, string viewGridName, int viewID) {
-    map < string, map< int, map <int, string> > >::iterator hit = pluginViewGrids.find(pluginName);
-    if (hit == pluginViewGrids.end())
-        return -1;
-    map< int, map <int, string> >::iterator hit2 = (hit->second).find(viewID);
-    if (hit2 == (hit->second).end())
-        return -1;
-    
-    map <int, string> viewGrids = hit2->second;
-    for (map <int, string>::iterator it = viewGrids.begin(); it != viewGrids.end(); it++) {
-        if (!(it->second).compare(viewGridName))
-            return it->first;
-    }
-    return -1;
-}
-
 cString cDesignerConfig::CheckSlashAtEnd(std::string path) {
     try {
         if (!(path.at(path.size()-1) == '/'))
@@ -578,14 +484,14 @@ cString cDesignerConfig::CheckSlashAtEnd(std::string path) {
 bool cDesignerConfig::SetupParse(const char *Name, const char *Value) {
     bool pluginSetupParam = true;
     if      (!strcasecmp(Name, "DebugImageLoading"))       debugImageLoading = atoi(Value);
+    else if (!strcasecmp(Name, "CacheImagesInitial"))      cacheImagesInitial = atoi(Value);
     else if (!strcasecmp(Name, "LimitChannelLogoCache"))   limitLogoCache = atoi(Value);
     else if (!strcasecmp(Name, "NumberLogosInitially"))    numLogosPerSizeInitial = atoi(Value);
     else if (!strcasecmp(Name, "NumberLogosMax"))          numLogosMax = atoi(Value);
     else if (!strcasecmp(Name, "RerunAmount"))             rerunAmount = atoi(Value);
     else if (!strcasecmp(Name, "RerunDistance"))           rerunDistance = atoi(Value);
     else if (!strcasecmp(Name, "RerunMaxChannel"))         rerunMaxChannel = atoi(Value);
-    else if (!strcasecmp(Name, "BlockFlush"))              blockFlush = atoi(Value);
-    else if (!strcasecmp(Name, "FramesPerSecond"))         framesPerSecond = atoi(Value);
+    else if (!strcasecmp(Name, "NumCustomTokens"))         numCustomTokens = atoi(Value);
     else pluginSetupParam = false;
 
     if (!pluginSetupParam) {

config.h

@@ -8,11 +8,13 @@
 #include <vdr/skins.h>
 #include <vdr/plugin.h>
 #include "designer.h"
-#include "libcore/fontmanager.h"
-#include "libcore/imagecache.h"
-#include "libcore/recfolderinfo.h"
-#include "libcore/skinsetup.h"
-#include "libcore/skinrepo.h"
+#include "extensions/pluginmanager.h"
+#include "extensions/fontmanager.h"
+#include "extensions/imagecache.h"
+#include "extensions/recfolderinfo.h"
+#include "extensions/skinsetup.h"
+#include "extensions/skinrepo.h"
+#include "libskindesignerapi/skindesignerapi.h"
 
 #define SCRIPTOUTPUTPATH "/tmp/skindesigner"
 
@@ -32,13 +34,6 @@ private:
     string fontSml;
     string osdLanguage;
     cGlobals *tmplGlobals;
-    map < string, map < int, string > > pluginMenus;
-    map < string, map < int, string > >::iterator plugMenuIt;
-    map < string, map < int, string > > pluginViews;
-    map < string, map < int, string > >::iterator plugViewIt;
-    map < string, multimap< int, pair <int, string> > > pluginSubViews;
-    map < string, map< int, map <int, string> > > pluginViewElements;
-    map < string, map< int, map <int, string> > > pluginViewGrids;
     vector<cSkinDesigner*> skinRefs;
     vector<cSkinDesigner*>::iterator skinRefsIterator;
     vector<string> deliveredSkins;
@@ -100,15 +95,6 @@ public:
     void SetOsdLanguage(void) { osdLanguage = Setup.OSDLanguage; };
     bool OsdLanguageChanged(void);
     cString GetSkinRessourcePath(void);
-    void AddPluginMenus(string name, map< int, string > menus);
-    void AddPluginViews(string name, map< int, string > views, multimap< int, pair <int, string> > subViews, map< int, map <int, string> > viewElements, map< int, map <int, string> > viewGrids);
-    void InitPluginMenuIterator(void);
-    map <int,string> *GetPluginTemplates(string &name);
-    void InitPluginViewIterator(void);
-    map <int,string> *GetPluginViews(string &name);
-    map <int,string> GetPluginSubViews(string name, int viewID);
-    int GetPluginViewElementID(string pluginName, string viewElementName, int viewID);
-    int GetPluginViewGridID(string pluginName, string viewGridName, int viewID);
     cString skinPath;
     cString installerSkinPath;
     cString logoPath;
@@ -117,6 +103,7 @@ public:
     bool replaceDecPoint;
     char decPoint;
     //Setup Parameter
+    int cacheImagesInitial;
     int numLogosPerSizeInitial;
     int limitLogoCache;
     int numLogosMax;
@@ -124,20 +111,21 @@ public:
     int rerunAmount;
     int rerunDistance;
     int rerunMaxChannel;
-    int blockFlush;
-    int framesPerSecond;
+    int numCustomTokens;
     //TemplateReload on Setup Close
     bool setupCloseDoReload;
 };
 
 #ifdef DEFINE_CONFIG
     cDesignerConfig config;
+    cSDPluginManager *plgManager = NULL;
     cFontManager *fontManager = NULL;
     cImageCache *imgCache = NULL;
     cTheme Theme;
     cRecordingsFolderInfo recFolderInfo(Recordings);
 #else
     extern cDesignerConfig config;
+    extern cSDPluginManager *plgManager;
     extern cFontManager *fontManager;
     extern cImageCache *imgCache;
     extern cTheme Theme;

coreengine/animation.c

@@ -0,0 +1,347 @@
+#include "animation.h"
+#include <math.h>
+
+/******************************************************************
+* cAnimation
+******************************************************************/
+cAnimation::cAnimation(cScrollable *scrollable) : cThread("scroller") {
+    this->scrollable = scrollable;
+    this->detachable = NULL;
+    this->fadable = NULL;
+    this->shiftable = NULL;
+    this->blinkable = NULL;
+    waitOnWakeup = false;
+    doAnimation = true;
+    modeIn = false;
+    blinkFunc = -1;
+}
+
+cAnimation::cAnimation(cDetachable *detachable, bool wait, bool animation) : cThread("detached") {
+    this->scrollable = NULL;
+    this->detachable = detachable;
+    this->fadable = NULL;
+    this->shiftable = NULL;
+    this->blinkable = NULL;
+    waitOnWakeup = wait;
+    doAnimation = animation;
+    modeIn = false;
+    blinkFunc = -1;
+}
+
+cAnimation::cAnimation(cFadable *fadable, bool fadein) : cThread("fadable") {
+    this->scrollable = NULL;
+    this->detachable = NULL;
+    this->fadable = fadable;
+    this->shiftable = NULL;
+    this->blinkable = NULL;
+    waitOnWakeup = false;
+    doAnimation = true;
+    modeIn = fadein;
+    blinkFunc = -1;
+}
+
+cAnimation::cAnimation(cShiftable *shiftable, cPoint &start, cPoint &end, bool shiftin) : cThread("shiftable") {
+    this->scrollable = NULL;
+    this->detachable = NULL;
+    this->fadable = NULL;
+    this->shiftable = shiftable;
+    this->blinkable = NULL;
+    waitOnWakeup = false;
+    doAnimation = true;
+    modeIn = shiftin;
+    shiftstart = start;
+    shiftend = end;
+    blinkFunc = -1;
+}
+
+cAnimation::cAnimation(cBlinkable *blinkable, int func) : cThread("blinking") {
+    this->scrollable = NULL;
+    this->detachable = NULL;
+    this->fadable = NULL;
+    this->shiftable = NULL;
+    this->blinkable = blinkable;
+    waitOnWakeup = false;
+    doAnimation = true;
+    modeIn = false;
+    blinkFunc = func;
+}
+
+cAnimation::~cAnimation(void) {
+    sleepWait.Signal();
+    Cancel(2);
+}
+
+void cAnimation::WakeUp(void) {
+    sleepWait.Signal();
+}
+
+void cAnimation::Stop(bool deletePixmaps) { 
+    sleepWait.Signal();
+    Cancel(2);
+    if (scrollable && deletePixmaps)
+        scrollable->StopScrolling();
+}
+
+void cAnimation::Action(void) {
+    if (scrollable) {
+        Scroll();
+    } else if (detachable) {
+        Detach();
+    } else if (fadable) {
+        Fade();
+    } else if (shiftable) {
+        Shift();
+    } else if (blinkable) {
+        Blink();
+    }
+}
+
+void cAnimation::Sleep(int duration) {
+    //sleep should wake up itself, so no infinit wait allowed
+    if (duration <= 0)
+        return;
+    sleepWait.Wait(duration);
+}
+
+void cAnimation::Wait(void) {
+    //wait has to be waked up from outside
+    sleepWait.Wait(0);
+}
+
+void cAnimation::Scroll(void) {
+    int delay = scrollable->ScrollDelay();
+    Sleep(delay);
+    if (!Running()) return;    
+    
+    eOrientation orientation = scrollable->ScrollOrientation();
+    int scrollTotal = 0;
+    if (orientation == eOrientation::horizontal) {
+        scrollTotal = scrollable->ScrollWidth();
+    } else if (orientation == eOrientation::vertical) {
+        scrollTotal = scrollable->ScrollHeight();
+    }
+
+    eScrollMode mode = scrollable->ScrollMode();
+    bool carriageReturn = (mode == eScrollMode::carriagereturn) ? true : false;
+    
+    eScrollSpeed speed = scrollable->ScrollSpeed();
+    int frameTime = 30;
+    if (speed == eScrollSpeed::slow)
+        frameTime = 50;
+    else if (speed == eScrollSpeed::medium)
+        frameTime = 30;
+    else if (speed == eScrollSpeed::fast)
+        frameTime = 15;
+
+    if (!Running()) return;    
+    
+    scrollable->StartScrolling();
+    
+    int drawPortX = 0;
+    int drawPortY = 0;
+    int scrollDelta = 1;
+
+    bool doSleep = false;
+    while (Running()) {
+        if (doSleep) {
+            Sleep(delay);
+            doSleep = false;
+        }
+        if (!Running()) return;
+        uint64_t now = cTimeMs::Now();
+        
+        cPoint drawPortPoint(0,0);
+        if (orientation == eOrientation::horizontal) {
+
+            drawPortX -= scrollDelta;
+            if (abs(drawPortX) > scrollTotal) {
+                Sleep(delay);
+                if (carriageReturn) {
+                    drawPortX = 0;
+                    doSleep = true;
+                } else {
+                    scrollDelta *= -1;
+                    drawPortX -= scrollDelta;
+                }
+            }            
+            drawPortPoint.SetX(drawPortX);
+
+        } else if (orientation == eOrientation::vertical) {
+
+            drawPortY -= scrollDelta;
+            if (abs(drawPortY) > scrollTotal) {
+                Sleep(delay);
+                drawPortY = 0;
+                doSleep = true;
+            } 
+            drawPortPoint.SetY(drawPortY);
+
+        }
+        
+        if (!Running()) return;
+        scrollable->SetDrawPort(drawPortPoint);
+
+        if (!Running()) return;
+        scrollable->Flush();
+
+        if (orientation == eOrientation::horizontal && !carriageReturn && (drawPortX == 0)) {
+            scrollDelta *= -1;
+            doSleep = true;
+        }
+
+        int delta = cTimeMs::Now() - now;
+        if (delta < frameTime)
+            Sleep(frameTime - delta);
+    }
+}
+
+void cAnimation::Detach(void) {
+    if (waitOnWakeup) {
+        Wait();
+        int delay = 100 + detachable->Delay();
+        Sleep(delay);        
+    } else {
+        int delay = detachable->Delay();
+        Sleep(delay);
+    }
+    if (!Running()) return;
+    detachable->ParseDetached();
+    if (!Running()) return;
+    detachable->RenderDetached();
+    if (!Running()) return;
+    detachable->Flush();
+    if (!Running()) return;
+    if (doAnimation) {
+        detachable->StartAnimation();        
+    }
+}
+
+void cAnimation::Fade(void) {
+    int fadetime = fadable->FadeTime();
+    int frametime = 1000 / FPS;
+    int step = 100.0f / ((double)fadetime / (double)frametime);
+    uint64_t start = cTimeMs::Now();
+    int transparency = 0;
+    if (modeIn) {
+        transparency = 100 - step;
+    } else {
+        transparency = step;
+    }
+    //wait configured delay if not already done by detacher
+    if (!fadable->Detached()) {
+        int delay = fadable->Delay();
+        if (delay > 0)
+            Sleep(delay);
+    }
+    while (Running() || !modeIn) {
+        uint64_t now = cTimeMs::Now();
+        if (Running() || !modeIn)
+            fadable->SetTransparency(transparency, !modeIn);
+        if (Running() || !modeIn)
+            fadable->Flush();
+        int delta = cTimeMs::Now() - now;
+        if ((Running()  || !modeIn) && (delta < frametime)) {
+            Sleep(frametime - delta);
+        }
+        if ((int)(now - start) > fadetime) {
+            if ((Running() && modeIn) && transparency > 0) {
+                fadable->SetTransparency(0);
+                fadable->Flush();
+            } else if (!modeIn && transparency < 100) {
+                fadable->SetTransparency(100, true);
+                fadable->Flush();                
+            } 
+            break;
+        }
+        if (modeIn) {
+            transparency -= step;
+            if (transparency < 0)
+                transparency = 0;
+        } else {
+            transparency += step;
+            if (transparency > 100)
+                transparency = 100;            
+        }
+    }
+}
+
+void cAnimation::Shift(void) {
+    int shifttime = shiftable->ShiftTime();
+    eShiftMode mode = (eShiftMode)shiftable->ShiftMode();
+    //in shiftmode slowedDown shifting is done starting with slowratio % faster
+    //at start. Then speed reduces linear to (100 - slowratio)% at end
+    //for me 60 is a nice value :-) 
+    int slowRatio = 60;
+
+    int frametime = 1000 / FPS;
+    int steps = (double)shifttime / (double)frametime;
+    int stepXLinear = 0;
+    int stepYLinear = 0;
+    if (shiftstart.X() == shiftend.X()) {
+        stepYLinear = (shiftend.Y() - shiftstart.Y()) / steps;
+    } else if (shiftstart.Y() == shiftend.Y()) {
+        stepXLinear = (shiftend.X() - shiftstart.X()) / steps;
+    } else {
+        stepXLinear = (shiftend.X() - shiftstart.X()) / steps;
+        stepYLinear = (shiftend.Y() - shiftstart.Y()) / steps;        
+    }
+    int stepX = stepXLinear;
+    int stepY = stepYLinear;
+
+    cPoint pos;
+    if (modeIn)
+        pos = shiftstart;
+    else
+        pos = shiftend;
+
+    //wait configured delay if not already done by detacher
+    if (!shiftable->Detached()) {
+        int delay = shiftable->Delay();
+        if (delay > 0)
+            Sleep(delay);
+    }
+    uint64_t start = cTimeMs::Now();
+    while (Running() || !modeIn) {
+        uint64_t now = cTimeMs::Now();
+        if (Running() || !modeIn)
+            shiftable->SetPosition(pos, shiftend);
+        if (Running() || !modeIn)
+            shiftable->Flush();
+        int delta = cTimeMs::Now() - now;
+        if ((Running()  || !modeIn) && (delta < frametime)) {
+            cCondWait::SleepMs(frametime - delta);
+        }
+        if ((int)(now - start) > shifttime) {
+            if ((Running() && modeIn) && pos != shiftend) {
+                shiftable->SetPosition(shiftend, shiftend);
+                shiftable->Flush();
+            }
+            break;
+        }
+        if (mode == eShiftMode::slowedDown) {
+            double t = (double)(now - start) / (double)shifttime;
+            double factor = 1.0f + (double)slowRatio / 100.0f - 2.0f * ((double)slowRatio / 100.0f) * t;
+            stepX = stepXLinear * factor;
+            stepY = stepYLinear * factor;
+        }
+        if (modeIn) {
+            pos.Set(pos.X() + stepX, pos.Y() + stepY);
+        } else {
+            pos.Set(pos.X() - stepX, pos.Y() - stepY);
+        }
+    }
+
+}
+
+void cAnimation::Blink(void) {
+    int freq = blinkable->BlinkFreq(blinkFunc);
+    bool blinkOn = false;
+    while (Running()) {
+        Sleep(freq);
+        if (Running()) {
+            blinkable->DoBlink(blinkFunc, blinkOn);
+            blinkable->Flush();  
+        }
+        blinkOn = !blinkOn;
+    }
+}

coreengine/animation.h

@@ -0,0 +1,126 @@
+#ifndef __ANIMATION_H
+#define __ANIMATION_H
+
+#include <vdr/skins.h>
+#include <vdr/thread.h>
+#include "definitions.h"
+
+#define FPS 50
+
+/******************************************************************
+* cScrollable
+******************************************************************/
+class cScrollable {
+protected:
+    cScrollable(void) {};
+    ~cScrollable(void) {};
+public:
+    virtual int ScrollDelay(void) = 0;
+    virtual int ScrollWidth(void) = 0;
+    virtual int ScrollHeight(void) = 0;
+    virtual eScrollMode ScrollMode(void) = 0;
+    virtual eScrollSpeed ScrollSpeed(void) = 0;
+    virtual eOrientation ScrollOrientation(void) = 0;
+    virtual void StartScrolling(void) = 0;
+    virtual void StopScrolling(void) = 0;
+    virtual void SetDrawPort(cPoint &point) = 0;
+    virtual void Flush(void) = 0;
+};
+
+/******************************************************************
+* cDetachable
+******************************************************************/
+class cDetachable {
+protected:
+    cDetachable(void) {};
+    ~cDetachable(void) {};
+public:
+    virtual int Delay(void) = 0;
+    virtual void ParseDetached(void) = 0;
+    virtual void RenderDetached(void) = 0;
+    virtual void StartAnimation(void) = 0;
+    virtual void Flush(void) = 0;
+};
+
+/******************************************************************
+* cFadable
+******************************************************************/
+class cFadable {
+protected:
+    cFadable(void) {};
+    ~cFadable(void) {};
+public:
+    virtual bool Detached(void) = 0;
+    virtual int Delay(void) = 0;
+    virtual int FadeTime(void) = 0;
+    virtual void SetTransparency(int transparency, bool force = false) = 0;
+    virtual void Flush(void) = 0;
+};
+
+/******************************************************************
+* cShiftable
+******************************************************************/
+class cShiftable {
+protected:
+    cShiftable(void) {};
+    ~cShiftable(void) {};
+public:
+    virtual bool Detached(void) = 0;
+    virtual int Delay(void) = 0;
+    virtual int ShiftTime(void) = 0;
+    virtual int ShiftMode(void) = 0;
+    virtual void SetPosition(cPoint &position, cPoint &reference, bool force = false) = 0;
+    virtual void Flush(void) = 0;
+};
+
+/******************************************************************
+* cBlinkable
+******************************************************************/
+class cBlinkable {
+protected:
+    cBlinkable(void) {};
+    ~cBlinkable(void) {};
+public:
+    virtual int BlinkFreq(int func) = 0;
+    virtual void DoBlink(int func, bool on) = 0;
+    virtual void Flush(void) = 0;
+};
+
+/******************************************************************
+* cAnimation
+******************************************************************/
+class cAnimation : public cThread, public cListObject {
+private:
+    cCondWait sleepWait;
+    cScrollable *scrollable;
+    cDetachable *detachable;
+    cFadable    *fadable;
+    cShiftable  *shiftable;
+    cBlinkable  *blinkable;
+    bool waitOnWakeup;
+    bool doAnimation;
+    bool modeIn;
+    int blinkFunc;
+    cPoint shiftstart;
+    cPoint shiftend;
+    void Sleep(int duration);
+    void Wait(void);
+    void Scroll(void);
+    void Detach(void);    
+    void Blink(void);
+protected:
+    virtual void Action(void);
+public:
+    cAnimation(cScrollable *scrollable);
+    cAnimation(cDetachable *detachable, bool wait, bool animation);
+    cAnimation(cFadable    *fadable, bool fadein);
+    cAnimation(cShiftable  *shiftable, cPoint &start, cPoint &end, bool shiftin);
+    cAnimation(cBlinkable  *blinkable, int func);
+    ~cAnimation(void);
+    void WakeUp(void);
+    void Fade(void);
+    void Shift(void);
+    void Stop(bool deletePixmaps);
+};
+
+#endif //__ANIMATION_H

coreengine/area.c

@@ -0,0 +1,767 @@
+#include "area.h"
+#include "../config.h"
+
+/******************************************************************
+* cAreaNode
+******************************************************************/
+cAreaNode::cAreaNode(void) {
+    globals = NULL;
+    isTab = false;
+    activeTab = false;
+}
+
+cAreaNode::~cAreaNode(void) {
+}
+
+void cAreaNode::SetContainer(int x, int y, int width, int height) {
+    container.SetX(x);
+    container.SetY(y);
+    container.SetWidth(width);
+    container.SetHeight(height);
+}
+
+/******************************************************************
+* cArea
+******************************************************************/
+cArea::cArea(void) {
+    sdOsd = NULL;
+    init = true;
+    isBackgroundArea = false;
+    attribs = new cAreaAttribs((int)eAreaAttribs::count);
+    scrolling = false;
+    isScrolling = false;
+    scrollFunc = NULL;
+    blinking = false;
+    areaContainer = NULL;
+    pix = NULL;
+}
+
+cArea::cArea(const cArea &other) {
+    sdOsd = other.sdOsd;
+    init = true;
+    isBackgroundArea = false;
+    pix = NULL;
+    globals = other.globals;
+    attribs = new cAreaAttribs(*other.attribs);
+    //area container is set from outside during cloning of areacontainer
+    areaContainer = NULL;
+    //scrolling is set from outside by ScrollFunc(), see below
+    scrolling = other.scrolling;
+    isScrolling = false;
+    blinking = false;
+    scrollFunc = NULL;
+
+    for (cFunction *func = other.functions.First(); func; func = other.functions.Next(func)) {
+        if (cFuncFill *f = dynamic_cast<cFuncFill*>(func)) {
+            cFuncFill *fFill = new cFuncFill(*f);
+            fFill->SetOwner(this);
+            functions.Add(fFill);
+        } else if (cFuncDrawRectangle *f = dynamic_cast<cFuncDrawRectangle*>(func)) {
+            cFuncDrawRectangle *fDrawRect = new cFuncDrawRectangle(*f);
+            fDrawRect->SetOwner(this);
+            functions.Add(fDrawRect);
+        } else if (cFuncDrawEllipse *f = dynamic_cast<cFuncDrawEllipse*>(func)) {
+            cFuncDrawEllipse *fDrawEllipse = new cFuncDrawEllipse(*f);
+            fDrawEllipse->SetOwner(this);
+            functions.Add(fDrawEllipse);
+        } else if (cFuncDrawSlope *f = dynamic_cast<cFuncDrawSlope*>(func)) {
+            cFuncDrawSlope *fDrawSlope = new cFuncDrawSlope(*f);
+            fDrawSlope->SetOwner(this);
+            functions.Add(fDrawSlope);
+        } else if (cFuncDrawText *f = dynamic_cast<cFuncDrawText*>(func)) {
+            cFuncDrawText *fDrawText = new cFuncDrawText(*f);
+            fDrawText->SetOwner(this);
+            functions.Add(fDrawText);
+        } else if (cFuncDrawTextVertical *f = dynamic_cast<cFuncDrawTextVertical*>(func)) {
+            cFuncDrawTextVertical *fDrawTextVertical = new cFuncDrawTextVertical(*f);
+            fDrawTextVertical->SetOwner(this);
+            functions.Add(fDrawTextVertical);
+        } else if (cFuncDrawTextBox *f = dynamic_cast<cFuncDrawTextBox*>(func)) {
+            cFuncDrawTextBox *fDrawTextBox = new cFuncDrawTextBox(*f);
+            fDrawTextBox->SetOwner(this);
+            functions.Add(fDrawTextBox);
+        } else if (cFuncDrawImage *f = dynamic_cast<cFuncDrawImage*>(func)) {
+            cFuncDrawImage *fDrawImage = new cFuncDrawImage(*f);
+            fDrawImage->SetOwner(this);
+            functions.Add(fDrawImage);
+        } else {
+            esyslog("skindesigner: ERROR: unknown function in area cloning!!!");
+        }
+    }
+    
+    //func references have to be set from outside if already cached clone is wanted
+    for (cFunction *f = functions.First(); f; f = functions.Next(f)) {
+        f->CacheFuncReferences();
+    }
+    if (scrolling) {
+        SetScrollFunc();
+    }
+}
+
+cArea::~cArea(void) {
+    StopBlinkers();
+    delete attribs;
+}
+
+void cArea::SetGlobals(cGlobals *globals) {
+    this->globals = globals;
+    attribs->SetGlobals(globals);
+    for (cFunction *f = functions.First(); f; f = functions.Next(f)) {
+        f->SetGlobals(globals);
+    }
+}
+
+void cArea::SetTokenContainer(skindesignerapi::cTokenContainer *tokenContainer) {
+    attribs->SetTokenContainer(tokenContainer);
+    for (cFunction *f = functions.First(); f; f = functions.Next(f)) {
+        f->SetTokenContainer(tokenContainer);
+    }
+}
+
+void cArea::SetTokenContainerDeep(skindesignerapi::cTokenContainer *tokenContainer) {
+    attribs->SetTokenContainerDeep(tokenContainer);
+    for (cFunction *f = functions.First(); f; f = functions.Next(f)) {
+        f->SetTokenContainerDeep(tokenContainer);
+    }
+}
+
+void cArea::SetAttributes(vector<stringpair> &attributes) {
+    attribs->Set(attributes); 
+}
+
+bool cArea::ValidFunction(const char *func) {
+    if (!strcmp(func, "fill")) return true;
+    if (!strcmp(func, "drawtext")) return true;
+    if (!strcmp(func, "drawtextbox")) return true;
+    if (!strcmp(func, "drawtextvertical")) return true;
+    if (!strcmp(func, "drawimage")) return true;
+    if (!strcmp(func, "drawrectangle")) return true;
+    if (!strcmp(func, "drawellipse")) return true;
+    if (!strcmp(func, "drawslope")) return true;
+    esyslog("skindesigner: unknown function \"%s\"", func);
+    return false;
+}
+
+cFunction *cArea::AddFunction(const char *name, vector<stringpair> attribs, cFuncLoop *loopFunc) {
+    cFunction *f = NULL;
+    if (!strcmp(name, "fill")) {
+        f = new cFuncFill(this, (int)eFillAttribs::count);
+    } else if (!strcmp(name, "drawrectangle")) {
+        f = new cFuncDrawRectangle(this, (int)eDrawRectangleAttribs::count);
+    } else if (!strcmp(name, "drawellipse")) {
+        f = new cFuncDrawEllipse(this, (int)eDrawEllipseAttribs::count);
+    } else if (!strcmp(name, "drawslope")) {
+        f = new cFuncDrawSlope(this, (int)eDrawSlopeAttribs::count);
+    } else if (!strcmp(name, "drawtext")) {
+        f = new cFuncDrawText(this, (int)eDrawTextAttribs::count);        
+    } else if (!strcmp(name, "drawtextvertical")) {
+        f = new cFuncDrawTextVertical(this, (int)eDrawTextAttribs::count);        
+    } else if (!strcmp(name, "drawtextbox")) {
+        f = new cFuncDrawTextBox(this, (int)eDrawTextBoxAttribs::count);        
+    } else if (!strcmp(name, "drawimage")) {
+        f = new cFuncDrawImage(this, (int)eDrawImageAttribs::count);        
+    } else if (!strcmp(name, "loop")) {
+        f = new cFuncLoop(this, (int)eLoopAttribs::count);
+    }
+    if (!f) {
+        esyslog("skindesigner: TODO: function \"%s\" not implemented", name);
+        return NULL;
+    }
+    f->Set(attribs);
+    if (!loopFunc)
+        functions.Add(f);
+    else
+        loopFunc->AddFunction(f);
+    return f;
+}
+
+cFunction *cArea::GetFunction(const char *name) {
+    for (cFunction *f = functions.First(); f; f = functions.Next(f)) {
+        const char *funcName = f->Name();
+        if (funcName && !strcmp(funcName, name)) {
+            return f;
+        }
+        cFuncLoop *loopFunc = dynamic_cast<cFuncLoop*>(f);
+        if (loopFunc) {
+            cFunction *lf = loopFunc->GetFunction(name);
+            if (lf)
+                return lf;
+        }
+    }
+    if (!areaContainer)
+        return NULL;
+    return areaContainer->GetFunction(name);
+}
+
+void cArea::SetX(int x) {
+    attribs->SetX(x);
+}
+
+void cArea::SetY(int y) {
+    attribs->SetY(y);
+}
+
+void cArea::SetWidth(int width) {
+    attribs->SetWidth(width);
+    for (cFunction *f = functions.First(); f; f = functions.Next(f)) {
+        f->SetContainer(0, 0, attribs->Width(), attribs->Height());
+    }
+}
+
+void cArea::SetHeight(int height) {
+    attribs->SetHeight(height);
+    for (cFunction *f = functions.First(); f; f = functions.Next(f)) {
+        f->SetContainer(0, 0, attribs->Width(), attribs->Height());
+    }
+}
+
+void cArea::Cache(void) {
+    attribs->SetContainer(container.X(), container.Y(), container.Width(), container.Height());
+    attribs->Cache();
+    attribs->CheckDynamic();
+    isBackgroundArea = attribs->BackgroundArea();
+
+    for (cFunction *f = functions.First(); f; f = functions.Next(f)) {
+        if (!attribs->Dynamic()) {
+            f->SetContainer(0, 0, attribs->Width(), attribs->Height());
+        } else {
+            f->SetContainer(0, 0, -1, -1);            
+        }
+        f->Cache();
+    }
+    for (cFunction *f = functions.First(); f; f = functions.Next(f)) {
+        f->CacheFuncReferences();
+    }
+    if (scrolling) {
+        SetScrollFunc();
+    }
+}
+
+void cArea::Close(void) {
+    StopBlinkers();
+    if (pix) {
+        sdOsd->DestroyPixmap(pix);
+        pix = NULL;
+    }
+    init = true;
+}
+
+void cArea::Clear(void) {
+    if (!init && isBackgroundArea) {
+        return;
+    }
+    if (pix) {
+        pix->Fill(clrTransparent);
+    }
+}
+
+void cArea::Hide(void) {
+    StopBlinkers();
+    if (pix) {
+        pix->SetLayer(-1);
+    }
+}
+
+void cArea::Show(void) {
+    StartBlinkers();
+    if (pix) {
+        pix->SetLayer(attribs->Layer());
+    }
+}
+
+void cArea::Render(void) {
+    if (attribs->DoDebug())
+        Debug();
+
+    if (init) {
+        InitFunctions();
+        init = false;    
+    }
+
+    if (!isScrolling && scrollFunc && attribs->Orientation() == (int)eOrientation::horizontal) {
+        scrollFunc->Scrolling(false);
+    } else if (isScrolling && scrollFunc && attribs->Orientation() == (int)eOrientation::horizontal) {
+        scrollFunc->Scrolling(true);
+    }
+
+    if (!pix) {
+        if (!IsTab())
+            CreatePixmap();
+        else {
+            int overlap = ScrollHeight();
+            if (overlap > 0) {
+                cRect drawport;
+                drawport.SetX(0);
+                drawport.SetY(0);
+                drawport.SetWidth(attribs->Width());
+                drawport.SetHeight(overlap + attribs->Height());
+                CreatePixmap(drawport);
+            } else {
+                CreatePixmap();
+            }
+        }
+    }
+
+    for (cFunction *f = functions.First(); f; f = functions.Next(f)) {
+        if (f->DoDebug())
+            f->Debug();
+        if (!f->DoExecute())
+            continue;
+        if (pix) {
+            f->Render(pix);
+        }
+    }
+
+    StartBlinkers();
+}
+
+bool cArea::Execute(void) { 
+    return attribs->DoExecute(); 
+}
+
+void cArea::SetTransparency(int transparency, bool absolute) {
+    if (transparency < 0 || transparency > 100)
+        return;
+    int alpha = (100 - transparency)*255/100;
+    if (!absolute) {
+        int pixTransparency = attribs->Transparency();
+        if (pixTransparency > 0) {
+            alpha = (100 - pixTransparency) * alpha / 100;            
+        }
+    }
+    if (pix) {
+        pix->SetAlpha(alpha);
+    }
+}
+
+bool cArea::Scrolling(void) { 
+    if (!scrolling)
+        return false;
+    if (!Execute())
+        return false;
+    if (ScrollOrientation() == eOrientation::horizontal) {
+        if (!scrollFunc)
+            return false;
+        if (scrollFunc->X() + scrollFunc->FuncWidth() > attribs->Width())
+            return true;
+    } else if (ScrollOrientation() == eOrientation::vertical) {
+        int maxHeight = 0;
+        for (cFunction *f = functions.First(); f; f = functions.Next(f)) {
+            int funcHeight = f->FuncY() + f->FuncHeight();
+            if (funcHeight > maxHeight)
+                maxHeight = funcHeight;
+        }
+        if (maxHeight > attribs->Height())
+            return true;
+    }
+    return false;
+}
+
+int cArea::ScrollWidth(void) {
+    if (!scrollFunc)
+        return 0;
+    return scrollFunc->X() + scrollFunc->FuncWidth() + 10 - attribs->Width();
+}
+
+int cArea::ScrollHeight(void) {
+    int maxHeight = 0;
+    for (cFunction *f = functions.First(); f; f = functions.Next(f)) {
+        if (!f->DoExecute())
+            continue;
+        int funcHeight = f->FuncY() + f->FuncHeight();
+        if (funcHeight > maxHeight)
+            maxHeight = funcHeight;
+    }
+    return maxHeight - attribs->Height();
+}
+  
+int cArea::ScrollDelay(void) { 
+    return attribs->Delay(); 
+}
+
+eScrollMode cArea::ScrollMode(void) {
+    return (eScrollMode)attribs->Mode(); 
+}
+
+eScrollSpeed cArea::ScrollSpeed(void) {
+    return (eScrollSpeed)attribs->ScrollSpeed();
+}
+
+eOrientation cArea::ScrollOrientation(void) {
+    return (eOrientation)attribs->Orientation();
+}
+
+void cArea::StartScrolling(void) {
+    cRect drawport;
+    drawport.SetX(0);
+    drawport.SetY(0);
+    if (ScrollOrientation() == eOrientation::horizontal) {
+        drawport.SetWidth(ScrollWidth() + attribs->Width());
+        drawport.SetHeight(attribs->Height());
+    } else if (ScrollOrientation() == eOrientation::vertical) {
+        drawport.SetWidth(attribs->Width());
+        drawport.SetHeight(ScrollHeight() + attribs->Height() + 10);
+    }
+    isScrolling = true;
+    CreatePixmap(drawport);
+    Render();
+}
+
+void cArea::StopScrolling(void) {
+    isScrolling = false;
+    if (pix && !(pix->ViewPort().Size() == pix->DrawPort().Size())) {
+        sdOsd->DestroyPixmap(pix);
+        pix = NULL;        
+    }
+}
+
+void cArea::SetViewPort(cRect &vp) {
+    if (!pix)
+        return;
+    pix->SetViewPort(vp);
+}
+
+void cArea::SetPosition(cPoint &pos, cPoint &ref) {
+    if (!pix)
+        return;
+    int x = (attribs->X() - ref.X()) + pos.X();
+    int y = (attribs->Y() - ref.Y()) + pos.Y();
+    pix->SetViewPort(cRect(x, y, pix->ViewPort().Width(), pix->ViewPort().Height()));
+}
+
+void cArea::SetDrawPort(cPoint &point) {
+    if (!pix)
+        return;
+    pix->SetDrawPortPoint(point);
+}
+
+cRect cArea::ViewPort(void) {
+    if (!pix)
+        return cRect::Null;
+    cRect vp = pix->ViewPort();
+    return vp;
+}
+
+cRect cArea::CoveringArea(void) {
+    return ViewPort();
+}
+
+cRect cArea::DrawPort(void) {
+    if (!pix)
+        return cRect::Null;
+    cRect dp = pix->DrawPort();
+    return dp;
+}
+
+int cArea::BlinkFreq(int func) {
+    cFunction *blinkFunc = functions.Get(func);
+    if (!blinkFunc)
+        return -1;
+    return blinkFunc->BlinkFreq();
+}
+
+void cArea::DoBlink(int func, bool on) {
+    cFunction *blinker = functions.Get(func);
+    if (!blinker)
+        return;
+    if (on) {
+        if (pix) {
+            blinker->Render(pix);
+        }
+    } else {
+        cRect blinkRect = cRect(blinker->GetX((eAlign)blinker->Align(), 0, 0), 
+                                blinker->GetY((eAlign)blinker->Valign(), 0, 0), 
+                                blinker->FuncWidth(), 
+                                blinker->FuncHeight());
+        if (pix) {
+            pix->DrawRectangle(blinkRect, clrTransparent);
+        }
+    }
+}
+
+void cArea::Debug(bool full) {
+    esyslog("skindesigner:    --> area");
+    esyslog("skindesigner:    container %d %d %dx%d", container.X(), container.Y(), container.Width(), container.Height());
+    attribs->Debug();
+    if (!full)
+        return;
+    for (cFunction *f = functions.First(); f; f = functions.Next(f)) {
+        f->Debug();
+    }
+}
+
+void cArea::Flush(void) {
+    sdOsd->Flush();
+}
+/******************************************************************
+* Private Functions
+******************************************************************/
+void cArea::InitFunctions(void) {
+    if (!attribs->Dynamic())
+        return;
+    for (cFunction *f = functions.First(); f; f = functions.Next(f)) {
+        f->SetContainer(0, 0, attribs->Width(), attribs->Height());
+    }
+}
+
+void cArea::CreatePixmap(cRect drawPort) {
+    if (pix) {
+        sdOsd->DestroyPixmap(pix);
+        pix = NULL;
+    }
+    if (attribs->Width() <=0 || attribs->Height() <= 0) {
+        return;
+    }
+
+    int layer = attribs->Layer();
+    cRect viewPort(attribs->X(), attribs->Y(), attribs->Width(), attribs->Height());
+    pix = sdOsd->CreatePixmap(layer, viewPort, drawPort);
+    if (pix)
+        pix->Clear();
+
+    int pixTransparency = attribs->Transparency();
+    if (pixTransparency > 0) {
+        SetTransparency(pixTransparency, true);
+    }
+}
+
+void cArea::SetScrollFunc(void) {
+    //if area has only one function, take this anyway
+    if (functions.Count() == 1) {
+        scrollFunc = functions.First();
+        return;
+    }
+    //else use scrollelement name
+    const char *scrollFuncName = attribs->GetScrollElement();
+    if (!scrollFuncName)
+        return;
+    for (cFunction *f = functions.First(); f; f = functions.Next(f)) {
+        if (!f->Name())
+            continue;
+        if (!strcmp(f->Name(), scrollFuncName)) {
+            scrollFunc = f;
+            return;
+        }
+    }
+}
+
+void cArea::StartBlinkers(void) {
+    if (blinking)
+        return;
+    blinking = true;
+    int func = 0;
+    for (cFunction *f = functions.First(); f; f = functions.Next(f)) {
+        if (!f->DoExecute()) {
+            func++;
+            continue;
+        }
+        if (f->Blinking()) {
+            cAnimation *blink = new cAnimation((cBlinkable*)this, func);
+            blinkers.Add(blink);
+            blink->Start();
+        }
+        func++;
+    }
+}
+
+void cArea::StopBlinkers(void) {
+    blinking = false;
+    blinkers.Clear();
+}
+
+/******************************************************************
+* cAreaContainer
+******************************************************************/
+cAreaContainer::cAreaContainer(void) {
+    attribs = new cAreaContainerAttribs((int)eAreaContainerAttribs::count);
+}
+
+cAreaContainer::cAreaContainer(const cAreaContainer &other) {
+    globals = other.globals;
+    attribs = new cAreaContainerAttribs(*other.attribs);
+    for (cArea *area = other.areas.First(); area; area = other.areas.Next(area)) {
+        cArea *a = new cArea(*area);
+        a->SetAreaContainer(this);
+        areas.Add(a);
+    }
+}
+
+cAreaContainer::~cAreaContainer(void) {
+    delete attribs;
+}
+    
+void cAreaContainer::SetAttributes(vector<stringpair> &attributes) {
+    attribs->Set(attributes); 
+}
+
+void cAreaContainer::SetGlobals(cGlobals *globals) {
+    this->globals = globals;
+    attribs->SetGlobals(globals);
+    for (cArea *area = areas.First(); area; area = areas.Next(area)) {
+        area->SetGlobals(globals);
+    }
+}
+
+void cAreaContainer::SetTokenContainer(skindesignerapi::cTokenContainer *tokenContainer) {
+    attribs->SetTokenContainer(tokenContainer);
+    for (cArea *area = areas.First(); area; area = areas.Next(area)) {
+        area->SetTokenContainer(tokenContainer);
+    }
+}
+
+void cAreaContainer::SetTokenContainerDeep(skindesignerapi::cTokenContainer *tokenContainer) {
+    attribs->SetTokenContainerDeep(tokenContainer);
+    for (cArea *area = areas.First(); area; area = areas.Next(area)) {
+        area->SetTokenContainerDeep(tokenContainer);
+    }
+}
+
+void cAreaContainer::AddArea(cArea *area) {
+    area->SetAreaContainer(this);
+    areas.Add(area);
+}
+
+cFunction *cAreaContainer::GetFunction(const char *name) {
+    cFunction *fRef = NULL;
+    for (cArea *area = areas.First(); area; area = areas.Next(area)) {
+        fRef = area->GetFunction(name);
+        if (fRef)
+            return fRef;
+    }
+    return NULL;
+}
+
+void cAreaContainer::SetX(int x) {
+    attribs->SetX(x);
+    for (cArea *area = areas.First(); area; area = areas.Next(area)) {
+        area->SetX(x);
+    }
+}
+
+void cAreaContainer::SetY(int y) {
+    attribs->SetY(y);
+    for (cArea *area = areas.First(); area; area = areas.Next(area)) {
+        area->SetY(y);
+    }
+}
+
+void cAreaContainer::SetWidth(int width) {
+    attribs->SetWidth(width);
+    for (cArea *area = areas.First(); area; area = areas.Next(area)) {
+        area->SetWidth(width);
+    }
+}
+
+void cAreaContainer::SetHeight(int height) {
+    attribs->SetHeight(height);
+    for (cArea *area = areas.First(); area; area = areas.Next(area)) {
+        area->SetHeight(height);
+    }
+}
+
+void cAreaContainer::Cache(void) {
+    attribs->SetContainer(container.X(), container.Y(), container.Width(), container.Height());
+    attribs->Cache();
+    int x = attribs->X() > -1 ? attribs->X() : container.X();
+    int y = attribs->Y() > -1 ? attribs->Y() : container.Y();
+    int width = attribs->Width() > -1 ? attribs->Width() : container.Width();
+    int height = attribs->Height() > -1 ? attribs->Height() : container.Height();
+    for (cArea *area = areas.First(); area; area = areas.Next(area)) {
+        area->SetContainer(x, y, width, height);
+        if (attribs->Width() > -1) {
+            area->SetWidth(width);
+        }
+        if (attribs->Height() > -1) {
+            area->SetHeight(height);
+        }
+        area->Cache();
+    }
+}
+
+void cAreaContainer::Close(void) {
+    for (cArea *area = areas.First(); area; area = areas.Next(area)) {
+        area->Close();
+    }
+}
+
+void cAreaContainer::Clear(void) {
+    for (cArea *area = areas.First(); area; area = areas.Next(area)) {
+        area->Clear();
+    }
+}
+
+void cAreaContainer::Hide(void) {
+    for (cArea *area = areas.First(); area; area = areas.Next(area)) {
+        area->Hide();
+    }
+}
+
+void cAreaContainer::Show(void) {
+    for (cArea *area = areas.First(); area; area = areas.Next(area)) {
+        area->Show();
+    }
+}
+
+void cAreaContainer::Render(void) {
+    for (cArea *area = areas.First(); area; area = areas.Next(area)) {
+        if (area->Execute())
+            area->Render();
+    }
+}
+
+bool cAreaContainer::Execute(void) { 
+    return attribs->DoExecute(); 
+}
+
+void cAreaContainer::SetTransparency(int transparency, bool absolute) {
+    for (cArea *area = areas.First(); area; area = areas.Next(area)) {
+        area->SetTransparency(transparency, absolute);
+    }
+}
+
+void cAreaContainer::SetViewPort(cRect &vp) {
+    for (cArea *area = areas.First(); area; area = areas.Next(area)) {
+        area->SetViewPort(vp);
+    }    
+}
+
+void cAreaContainer::SetPosition(cPoint &pos, cPoint &ref) {
+    for (cArea *area = areas.First(); area; area = areas.Next(area)) {
+        area->SetPosition(pos, ref);
+    }    
+}
+
+cRect cAreaContainer::CoveringArea(void) {
+    cRect unionArea;
+    for (cArea *area = areas.First(); area; area = areas.Next(area)) {
+        unionArea.Combine(area->CoveringArea());
+    }
+    return unionArea;
+}
+
+bool cAreaContainer::Scrolling(void) {
+    for (cArea *area = areas.First(); area; area = areas.Next(area)) {
+        if (area->Scrolling())
+            return true;
+    }
+    return false;
+}
+
+cArea *cAreaContainer::ScrollingArea(void) { 
+    for (cArea *area = areas.First(); area; area = areas.Next(area)) {
+        if (area->Execute() && area->Scrolling())
+            return area;
+    }
+    return NULL;
+}
+
+void cAreaContainer::Debug(bool full) {
+    esyslog("skindesigner:    --> area container");
+    esyslog("skindesigner:    container %d %d %dx%d", container.X(), container.Y(), container.Width(), container.Height());
+    attribs->Debug();
+    if (!full)
+        return;
+    for (cArea *area = areas.First(); area; area = areas.Next(area)) {
+        area->Debug(full);
+    }
+}

coreengine/area.h

@@ -0,0 +1,178 @@
+#ifndef __TEMPLATEAREA_H
+#define __TEMPLATEAREA_H
+
+#include <iostream>
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdint.h>
+
+#include "osdwrapper.h"
+#include "definitions.h"
+#include "globals.h"
+#include "../libskindesignerapi/tokencontainer.h"
+#include "attributes.h"
+#include "functions.h"
+#include "animation.h"
+
+class cArea;
+/******************************************************************
+* cAreaNode
+******************************************************************/
+class cAreaNode : public cListObject {
+protected:
+    cGlobals *globals;
+    cRect container;
+    bool isTab;
+    bool activeTab;
+public:
+    cAreaNode(void);
+    virtual ~cAreaNode(void);
+    virtual void SetGlobals(cGlobals *globals) {};
+    virtual void SetTokenContainer(skindesignerapi::cTokenContainer *tokenContainer) {};
+    virtual void SetTokenContainerDeep(skindesignerapi::cTokenContainer *tokenContainer) {};
+    void SetContainer(int x, int y, int width, int height);
+    virtual void SetAttributes(vector<stringpair> &attributes) {};
+    virtual void SetX(int x) {};
+    virtual void SetY(int y) {};
+    virtual void SetWidth(int width) {};
+    virtual void SetHeight(int height) {};
+    void SetTab(void) { isTab = true; };
+    bool IsTab(void) { return isTab; };
+    void SetActiveTab(bool active) { activeTab = active; };
+    bool ActiveTab(void) { return activeTab; };
+    virtual int GetWidth(void) { return 0; };
+    virtual void Cache(void) {};
+    virtual void Close(void) {};
+    virtual void Clear(void) {};
+    virtual void Hide(void) {};
+    virtual void Show(void) {};
+    virtual void Render(void) {};
+    virtual bool Execute(void) { return true; };
+    virtual void SetTransparency(int transparency, bool absolute = false) {};
+    virtual void SetViewPort(cRect &vp) {};
+    virtual void SetPosition(cPoint &pos, cPoint &ref) {};
+    virtual cRect CoveringArea(void) { return cRect::Null; };
+    virtual bool Scrolling(void) { return false; };
+    virtual cArea *ScrollingArea(void) { return NULL; };
+    virtual cFunction *GetFunction(const char *name) { return NULL; };
+    virtual const char *Name(void) { return NULL; };
+    virtual bool BackgroundArea(void) { return false; };
+    virtual void Debug(bool full = false) {};
+};
+
+class cAreaContainer;
+/******************************************************************
+* cArea
+******************************************************************/
+class cArea : public cAreaNode, public cScrollable, public cBlinkable {
+private:
+    cSdOsd *sdOsd;
+    bool init;
+    bool isBackgroundArea;
+    cPixmap *pix;
+    cAreaAttribs *attribs;
+    cAreaContainer *areaContainer;
+    cList<cFunction> functions;
+    bool scrolling;
+    bool isScrolling;
+    cFunction *scrollFunc;
+    cList<cAnimation> blinkers;
+    bool blinking;
+    void InitFunctions(void);
+    void CreatePixmap(cRect drawPort = cRect::Null);
+    void SetScrollFunc(void);
+    void StartBlinkers(void);
+    void StopBlinkers(void);
+public:
+    cArea(void);
+    cArea(const cArea &other);
+    virtual ~cArea(void);
+    void SetOsd(cSdOsd *osd) { sdOsd = osd; };
+    void SetGlobals(cGlobals *globals);
+    void SetTokenContainer(skindesignerapi::cTokenContainer *tokenContainer);
+    void SetTokenContainerDeep(skindesignerapi::cTokenContainer *tokenContainer);
+    void SetAttributes(vector<stringpair> &attributes);
+    void SetScrolling(void) { scrolling = true; };
+    void SetAreaContainer(cAreaContainer *ac) { areaContainer = ac; };
+    bool ValidFunction(const char *func);
+    cFunction *AddFunction(const char *name, vector<stringpair> attribs, cFuncLoop *loopFunc = NULL);
+    cFunction *GetFunction(const char *name);
+    void SetX(int x);
+    void SetY(int y);
+    void SetWidth(int width);
+    void SetHeight(int height);
+    void Cache(void);
+    int GetWidth(void) { return attribs->Width(); };
+    void Close(void);
+    void Clear(void);
+    void Hide(void);
+    void Show(void);
+    void Render(void);
+    bool Execute(void);
+    void SetTransparency(int transparency, bool absolute = false);
+    cRect CoveringArea(void);
+    //Scrollable
+    bool Scrolling(void);
+    int ScrollWidth(void);
+    int ScrollHeight(void);
+    int ScrollDelay(void);
+    eScrollMode ScrollMode(void);
+    eScrollSpeed ScrollSpeed(void);
+    eOrientation ScrollOrientation(void);
+    cArea *ScrollingArea(void) { return this; };
+    void StartScrolling(void);
+    void StopScrolling(void);
+    cRect ViewPort(void);
+    void SetDrawPort(cPoint &point);
+    void SetViewPort(cRect &vp);
+    void SetPosition(cPoint &pos, cPoint &ref);
+    cRect DrawPort(void);
+    int ScrollStep(void) { return attribs->ScrollStep(); };
+    //Blinkable
+    int BlinkFreq(int func);
+    void DoBlink(int func, bool on);
+    //Common
+    const char *Name(void) { return attribs->Name(); };
+    bool BackgroundArea(void) { return attribs->BackgroundArea(); };
+    void Flush(void);
+    void Debug(bool full = false);
+};
+
+/******************************************************************
+* cAreaContainer
+******************************************************************/
+class cAreaContainer : public cAreaNode {
+private:
+    cAreaContainerAttribs *attribs;
+    cList<cArea> areas;
+public:
+    cAreaContainer(void);
+    cAreaContainer(const cAreaContainer &other);
+    virtual ~cAreaContainer(void);
+    void SetGlobals(cGlobals *globals);
+    void SetTokenContainer(skindesignerapi::cTokenContainer *tokenContainer);
+    void SetTokenContainerDeep(skindesignerapi::cTokenContainer *tokenContainer);
+    void SetAttributes(vector<stringpair> &attributes);
+    void AddArea(cArea *area);
+    cFunction *GetFunction(const char *name);
+    void SetX(int x);
+    void SetY(int y);
+    void SetWidth(int width);
+    void SetHeight(int height);
+    void Cache(void);
+    void Close(void);
+    void Clear(void);
+    void Hide(void);
+    void Show(void);
+    void Render(void);
+    bool Execute(void);
+    void SetTransparency(int transparency, bool absolute = false);
+    void SetViewPort(cRect &vp);
+    void SetPosition(cPoint &pos, cPoint &ref);
+    cRect CoveringArea(void);
+    bool Scrolling(void);
+    cArea *ScrollingArea(void);
+    void Debug(bool full = false);
+};
+
+#endif //__TEMPLATEAREA_H

coreengine/attribute.c

@@ -0,0 +1,478 @@
+#include "attribute.h"
+#include "../config.h"
+
+/***************************************************************************
+* cAttributes
+***************************************************************************/
+cAttributes::cAttributes(int numAttributes) {
+    globals = NULL;
+    tokenContainer = NULL;
+    numAttribs = (int)eCommonAttribs::count + numAttributes;
+    attribs = new int[numAttribs];
+    for (int i=0; i < numAttribs; i++)
+        attribs[i] = ATTR_UNKNOWN;
+    attribCtors = new cNumericExpr*[numAttribs];
+    for (int i=0; i < numAttribs; i++)
+        attribCtors[i] = NULL;
+    cond = NULL;
+    SetCommonAttributesDefs();
+}
+
+cAttributes::cAttributes(const cAttributes &other) : cAttributes(other.numAttribs - (int)eCommonAttribs::count){
+    globals = other.globals;
+    for (int i=0; i < numAttribs; i++) {
+        attribs[i] = other.attribs[i];
+        if (other.attribCtors[i]) {
+            attribCtors[i] = new cNumericExpr(*other.attribCtors[i]);
+            attribCtors[i]->SetContainer(&container);    
+        }
+    }
+    cond = NULL;
+    if (other.cond) {
+        cond = new cCondition(*other.cond);
+    }
+    attribIDs = other.attribIDs;
+    attribNames = other.attribNames;
+}
+
+cAttributes::~cAttributes(void) {
+    delete[] attribs;
+    for (int i=0; i < numAttribs; i++) {
+        delete attribCtors[i];
+    }
+    delete[] attribCtors;
+    delete cond;
+}
+
+void cAttributes::SetTokenContainer(skindesignerapi::cTokenContainer *tokenContainer) {
+    this->tokenContainer = tokenContainer;
+}
+
+void cAttributes::SetTokenContainerDeep(skindesignerapi::cTokenContainer *tokenContainer) {
+    this->tokenContainer = tokenContainer;
+    if (cond) {
+        cond->SetTokenContainer(tokenContainer);
+    }
+    for (int i=0; i < numAttribs; i++) {
+        if (!attribCtors[i])
+            continue;
+        attribCtors[i]->SetTokenContainer(tokenContainer);
+    }
+}
+
+void cAttributes::SetContainer(int x, int y, int width, int height) {
+    container.SetX(x);
+    container.SetY(y);
+    container.SetWidth(width);
+    container.SetHeight(height);
+}
+
+void cAttributes::SetX(int x) {
+    attribs[(int)eCommonAttribs::x] = x;
+}
+
+void cAttributes::SetY(int y) {
+    attribs[(int)eCommonAttribs::y] = y;
+}
+
+void cAttributes::SetWidth(int width) {
+    attribs[(int)eCommonAttribs::width] = width;
+}
+
+void cAttributes::SetHeight(int height) {
+    attribs[(int)eCommonAttribs::height] = height;
+}
+
+void cAttributes::Cache(void) {
+    if (cond) {
+        cond->SetGlobals(globals);
+        cond->SetTokenContainer(tokenContainer);
+        cond->Prepare();
+    }
+    for (int i=0; i < numAttribs; i++) {
+        if (!attribCtors[i])
+            continue;
+        attribCtors[i]->SetContainer(&container);
+        attribCtors[i]->SetGlobals(globals);
+        attribCtors[i]->SetTokenContainer(tokenContainer);
+        if (attribCtors[i]->CacheStatic()) {
+            int val = attribCtors[i]->GetValue();
+            attribs[i] = val;
+            delete attribCtors[i];
+            attribCtors[i] = NULL;
+        } else {
+            attribCtors[i]->PrepareTokens();
+        }
+    }
+}
+
+int cAttributes::GetValue(int id) {
+    if (!attribCtors[id + (int)eCommonAttribs::count])
+        return attribs[(int)id + (int)eCommonAttribs::count];
+    return attribCtors[id + (int)eCommonAttribs::count]->Calculate();
+}
+
+
+int cAttributes::X(void) { 
+    int x = 0;
+    if (!attribCtors[(int)eCommonAttribs::x])
+        x = attribs[(int)eCommonAttribs::x];
+    else
+        x = attribCtors[(int)eCommonAttribs::x]->Calculate();
+    x += container.X();
+    return x;
+}
+
+int cAttributes::Y(void) { 
+    int y = 0;
+    if (!attribCtors[(int)eCommonAttribs::y])
+        y = attribs[(int)eCommonAttribs::y];
+    else
+        y = attribCtors[(int)eCommonAttribs::y]->Calculate();
+    y += container.Y();
+    return y;
+}
+
+int cAttributes::Width(void) {
+    if (!attribCtors[(int)eCommonAttribs::width])
+        return attribs[(int)eCommonAttribs::width];
+    return attribCtors[(int)eCommonAttribs::width]->Calculate();
+}
+
+int cAttributes::Height(void) { 
+    if (!attribCtors[(int)eCommonAttribs::height])
+        return attribs[(int)eCommonAttribs::height];
+    return attribCtors[(int)eCommonAttribs::height]->Calculate();
+}
+
+bool cAttributes::DoExecute(void) {
+    if (!cond)
+        return true;
+    return cond->True();
+}
+
+
+void cAttributes::Debug(void) {
+    esyslog("skindesigner:            container %d %d %dx%d", container.X(), container.Y(), container.Width(), container.Height());
+    for (int i=0; i < numAttribs; i++) {
+        if (attribs[i] != ATTR_UNKNOWN) {
+            if (i == (int)eCommonAttribs::debug)
+                continue;
+            const char *attName = "attribute";
+            if (i < (int)eCommonAttribs::count)
+                attName = CommonAttributeName(i);
+            else
+                attName = AttributeName(i - (int)eCommonAttribs::count);
+            dsyslog("skindesigner:            fixed Value %s = %d", attName, attribs[i]);
+        }
+        if (attribCtors[i]) {
+            const char *attName = "attribute";
+            if (i < (int)eCommonAttribs::count)
+                attName = CommonAttributeName(i);
+            else
+                attName = AttributeName(i - (int)eCommonAttribs::count);
+            dsyslog("skindesigner:            %s constructor:", attName);
+            attribCtors[i]->Debug();
+        }
+    }
+    if (cond) {
+        cond->Debug();
+    }
+}
+
+/***************************************************************************
+* Protected Functions
+***************************************************************************/
+int cAttributes::CommonAttributeId(const char *att) {
+    if (!strcmp(att, "condition"))
+        return ATTR_COND;
+    map<string, int>::iterator hit = commonAttribIDs.find(att);
+    if (hit != commonAttribIDs.end())
+        return hit->second;
+    return ATTR_UNKNOWN;
+}
+
+const char *cAttributes::CommonAttributeName(int id) {
+    if (id < 0 || id >= (int)eCommonAttribs::count)
+        return "";
+    map<int, string>::iterator hit = commonAttribNames.find(id);
+    if (hit != commonAttribNames.end())
+        return hit->second.c_str();
+    return "";
+}
+
+int cAttributes::AttributeId(const char *att) {
+    int id = CommonAttributeId(att);
+    if (id != ATTR_UNKNOWN)
+        return id;
+    map<string, int>::iterator hit = attribIDs.find(att);
+    if (hit != attribIDs.end())
+        id = (int)hit->second + (int)eCommonAttribs::count;
+    return id;
+}
+
+const char *cAttributes::AttributeName(int id) {
+    map<int, string>::iterator hit = attribNames.find(id);
+    if (hit != attribNames.end())
+        return hit->second.c_str();
+    return "";    
+}
+
+bool cAttributes::SetCommon(int id, const char *val) {
+    if (id == ATTR_COND) {
+        cond = new cCondition(val);
+        return true;
+    }
+    if (id == (int)eCommonAttribs::debug) {
+        SetBool(id, val);
+        return true;    
+    } else if (id == (int)eCommonAttribs::x || id == (int)eCommonAttribs::width) {
+        attribCtors[id] = new cNumericExpr(val);
+        return true;
+    } else if (id == (int)eCommonAttribs::y || id == (int)eCommonAttribs::height) {
+        attribCtors[id] = new cNumericExpr(val);
+        attribCtors[id]->SetVertical();
+        return true;
+    }
+    return false;
+}
+
+bool cAttributes::IdEqual(int id, int compId) {
+    if (compId + (int)eCommonAttribs::count == id)
+        return true;
+    return false;
+}
+
+
+void cAttributes::SetBool(int id, const char *val) {
+    if (!strcmp(val, "true")) {
+        attribs[id] = 1;
+    } else {
+        attribs[id] = 0;
+    }
+}
+
+void cAttributes::SetViewElementMode(int id, const char *val) {
+    eViewElementMode mode = eViewElementMode::regular;
+    if (!strcmp(val, "light"))
+        mode = eViewElementMode::light;
+    attribs[id] = (int)mode;
+}
+
+void cAttributes::SetShiftType(int id, const char *val) {
+    eShiftType shiftType = eShiftType::none;
+    if (!strcmp(val, "left"))
+        shiftType = eShiftType::left;
+    else if (!strcmp(val, "right"))
+        shiftType = eShiftType::right;
+    else if (!strcmp(val, "top"))
+        shiftType = eShiftType::top;
+    else if (!strcmp(val, "bottom"))
+        shiftType = eShiftType::bottom;
+    else {
+        esyslog("skindesigner: unknown shift type \"%s\"", val);
+        return;
+    }
+    attribs[id] = (int)shiftType;
+}
+
+void cAttributes::SetShiftMode(int id, const char *val) {
+    eShiftMode shiftMode = eShiftMode::linear;
+    if (!strcmp(val, "slowed"))
+        shiftMode = eShiftMode::slowedDown;
+    attribs[id] = (int)shiftMode;
+}
+
+void cAttributes::SetScrollMode(int id, const char *val) {
+    eScrollMode mode = eScrollMode::none;
+    if (!strcmp(val, "forthandback"))
+        mode = eScrollMode::forthandback;
+    else if (!strcmp(val, "carriagereturn"))
+        mode = eScrollMode::carriagereturn;
+    attribs[id] = (int)mode;
+}
+
+void cAttributes::SetScrollSpeed(int id, const char *val) {
+    eScrollSpeed speed = eScrollSpeed::medium;
+    if (!strcmp(val, "slow"))
+        speed = eScrollSpeed::slow;
+    else if (!strcmp(val, "fast"))
+        speed = eScrollSpeed::fast;
+    else if (!strcmp(val, "medium"))
+        speed = eScrollSpeed::medium;
+    attribs[id] = (int)speed;
+}
+
+void cAttributes::SetOrientation(int id, const char *val) {
+    eOrientation orientation = eOrientation::none;
+    if (!strcmp(val, "horizontal"))
+        orientation = eOrientation::horizontal;
+    else if (!strcmp(val, "vertical"))
+        orientation = eOrientation::vertical;
+    else if (!strcmp(val, "absolute"))
+        orientation = eOrientation::absolute;
+    attribs[id] = (int)orientation;
+}
+
+void cAttributes::SetAlign(int id, const char *val) {
+    eAlign align = eAlign::left;
+    if (!strcmp(val, "center")) {
+        align = eAlign::center;
+    } else if (!strcmp(val, "right")) {
+        align = eAlign::right;
+    } else if (!strcmp(val, "top")) {
+        align = eAlign::top;
+    } else if (!strcmp(val, "bottom")) {
+        align = eAlign::bottom;
+    } else if (!strcmp(val, "left")) {
+        align = eAlign::left;
+    }
+    attribs[id] = (int)align;
+}
+
+void cAttributes::SetDirection(int id, const char *val) {
+    eDirection direction = eDirection::none;
+    if (!strcmp(val, "bottomup"))
+        direction = eDirection::bottomup;
+    else if (!strcmp(val, "topdown"))
+        direction = eDirection::topdown;
+    attribs[id] = (int)direction;
+}
+
+/***************************************************************************
+* Private Functions
+***************************************************************************/
+void cAttributes::SetCommonAttributesDefs(void) {
+    commonAttribIDs.insert(pair<string, int>("x", (int)eCommonAttribs::x));
+    commonAttribIDs.insert(pair<string, int>("y", (int)eCommonAttribs::y));
+    commonAttribIDs.insert(pair<string, int>("width", (int)eCommonAttribs::width));
+    commonAttribIDs.insert(pair<string, int>("height", (int)eCommonAttribs::height));
+    commonAttribIDs.insert(pair<string, int>("debug", (int)eCommonAttribs::debug));
+    commonAttribNames.insert(pair<int, string>((int)eCommonAttribs::x, "x"));
+    commonAttribNames.insert(pair<int, string>((int)eCommonAttribs::y, "y"));
+    commonAttribNames.insert(pair<int, string>((int)eCommonAttribs::width, "width"));
+    commonAttribNames.insert(pair<int, string>((int)eCommonAttribs::height, "height"));
+    commonAttribNames.insert(pair<int, string>((int)eCommonAttribs::debug, "debug"));
+}
+
+/***************************************************************************
+* cFunction
+***************************************************************************/
+cFunction::cFunction(cArea *owner, int numAttributes) : cAttributes(numAttributes) {
+    funcType = "Unknown";
+    owningArea = owner;
+    color = NULL;
+    name = NULL;
+    scrolling = false;
+}
+
+cFunction::cFunction(const cFunction &other) : cAttributes(other) {
+    funcType = other.funcType;
+    owningArea = NULL;
+    color = NULL;
+    if (other.color)
+        color = new cColor(*other.color);
+    name = NULL;
+    if (other.name)
+        name = strdup(other.name);
+    scrolling = other.scrolling;
+}
+
+cFunction::~cFunction(void) {
+    delete color;
+    free(name);
+}
+
+void cFunction::SetLoopInfo(cLoopInfo *loopInfo) {
+    for (int i=0; i < numAttribs; i++) {
+        if (!attribCtors[i])
+            continue;
+        attribCtors[i]->SetLoopInfo(loopInfo);
+    }
+    if (cond)
+        cond->SetLoopInfo(loopInfo);
+}
+
+void cFunction::Cache(void) {
+    if (color) {
+        color->SetGlobals(globals);
+        color->Cache();
+    }
+    cAttributes::Cache();
+}
+
+void cFunction::CacheFuncReferences(void) {
+    for (int i=0; i < numAttribs; i++) {
+        if (!attribCtors[i])
+            continue;
+        vector<cFactor*> refFactors = attribCtors[i]->GetRefFactors();
+        for (vector<cFactor*>::iterator it = refFactors.begin(); it != refFactors.end(); it++) {
+            cFactor *f = *it;
+            if (!f->funcRefName)
+                continue;
+            cFunction *fRef = owningArea->GetFunction(f->funcRefName);
+            if (fRef) {
+                f->funcRef = fRef;
+            }
+        }
+    }
+}
+
+int cFunction::GetX(eAlign align, int x0, int colWidth) {
+    int containerWidth = colWidth > 0 ? colWidth : container.Width();
+    int x = x0 + X();
+    if (align == eAlign::right) {
+        x = x0 + containerWidth - FuncWidth();
+    } else if (align == eAlign::center) {
+        x = x0 + (containerWidth - FuncWidth()) / 2;
+    }
+    return x;
+}
+
+int cFunction::GetY(eAlign valign, int y0, int rowHeight) {
+    int containerHeight = rowHeight > 0 ? rowHeight : container.Height();
+    int y = y0 + Y();
+    if (valign == eAlign::bottom) {
+        y = y0 + containerHeight - FuncHeight();
+    } else if (valign == eAlign::center) {
+        y = y0 + (containerHeight - FuncHeight()) / 2;
+    }
+    return y;
+}
+
+void cFunction::Debug(void) {
+    esyslog("skindesigner:        ---> Function %s", funcType);
+    cAttributes::Debug();
+    if (name) {
+        esyslog("skindesigner:            name %s", name);
+    }
+    if (color) {
+        color->Debug();
+    }
+}
+
+/***************************************************************************
+* Protected Functions
+***************************************************************************/
+
+void cFunction::SetColor(const char *val) {
+    color = new cColor(val);
+}
+
+void cFunction::SetAnimType(int id, const char *val) {
+    eAnimType animType = eAnimType::none;
+    if (!strcmp(val, "blink"))
+        animType = eAnimType::blink;
+    else if (!strcmp(val, "animated"))
+        animType = eAnimType::animated;
+    attribs[id] = (int)animType; 
+}
+
+void cFunction::SetOverflow(int id, const char *val) {
+    eOverflowType overflowType = eOverflowType::none;
+    if (!strcmp(val, "linewrap"))
+        overflowType = eOverflowType::wrap;
+    else if (!strcmp(val, "cut"))
+        overflowType = eOverflowType::cut;
+    attribs[id] = (int)overflowType;
+}

coreengine/attribute.h

@@ -0,0 +1,126 @@
+#ifndef __ATTRIBUTE_H
+#define __ATTRIBUTE_H
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string>
+#include <map>
+#include <vector>
+#include <vdr/skins.h>
+#include "globals.h"
+#include "../libskindesignerapi/tokencontainer.h"
+#include "definitions.h"
+#include "complextypes.h"
+
+class cArea;
+/******************************************************************
+* cAttributes
+******************************************************************/
+class cAttributes {
+private:
+    map<string, int> commonAttribIDs;
+    map<int, string> commonAttribNames;
+    void SetCommonAttributesDefs(void);
+protected:
+    cGlobals *globals;
+    skindesignerapi::cTokenContainer *tokenContainer;
+    cRect container;
+    int numAttribs;
+    int *attribs;
+    cNumericExpr **attribCtors;
+    cCondition *cond;
+    map<string, int> attribIDs;
+    map<int, string> attribNames;
+    int CommonAttributeId(const char *att);
+    const char *CommonAttributeName(int id);
+    int AttributeId(const char *att);
+    const char *AttributeName(int id);
+    bool SetCommon(int id, const char *val);
+    virtual bool IdEqual(int id, int compId);
+    void SetBool(int id, const char *val);
+    void SetViewElementMode(int id, const char *val);
+    void SetShiftType(int id, const char *val);
+    void SetShiftMode(int id, const char *val);
+    void SetScrollMode(int id, const char *val);
+    void SetScrollSpeed(int id, const char *val);
+    void SetOrientation(int id, const char *val);
+    void SetDirection(int id, const char *val);
+    void SetAlign(int id, const char *val);
+public:
+    cAttributes(int numAttributes);
+    cAttributes(const cAttributes &other);
+    virtual ~cAttributes(void);
+    void SetGlobals(cGlobals *globals) { this->globals = globals; };
+    void SetTokenContainer(skindesignerapi::cTokenContainer *tokenContainer);
+    virtual void SetTokenContainerDeep(skindesignerapi::cTokenContainer *tokenContainer);
+    virtual void SetContainer(int x, int y, int width, int height);
+    virtual void Set(vector<stringpair> &attributes) {};
+    void SetX(int width);
+    void SetY(int height);
+    void SetWidth(int width);
+    void SetHeight(int height);
+    virtual void Cache(void);
+    int GetValue(int id);
+    int X(void);
+    int Y(void);
+    int Width(void);
+    int Height(void);
+    int DoDebug(void) { return attribs[(int)eCommonAttribs::debug] == 1 ? true : false; };
+    bool DoExecute(void);
+    virtual void Debug(void);
+};
+/******************************************************************
+* cLoopInfo
+******************************************************************/
+class cLoopInfo {
+public:
+    int colWidth;
+    int rowHeight;
+    int index;
+    int row;
+    cLoopInfo(void) {
+        colWidth = 0;
+        rowHeight = 0;
+        index = 0;
+        row = 0;
+    };
+};
+/******************************************************************
+* cFunction
+******************************************************************/
+class cFunction : public cAttributes, public cListObject {
+private:
+    cArea *owningArea;
+protected:
+    const char *funcType;
+    cColor *color;
+    char *name;
+    bool scrolling;
+    void SetColor(const char *val);
+    void SetAnimType(int id, const char *val);
+    void SetOverflow(int id, const char *val);
+public:
+    cFunction(cArea *owner, int numAttributes);
+    cFunction(const cFunction &other);
+    virtual ~cFunction(void);
+    virtual void SetLoopInfo(cLoopInfo *loopInfo);
+    void SetOwner(cArea *owner) { owningArea = owner; };
+    const char *Name(void) { return name; };
+    virtual void Cache(void);
+    void CacheFuncReferences(void);
+    void Scrolling(bool scrolling) { this->scrolling = scrolling; };
+    virtual void Render(cPixmap *p, int x0 = 0, int y0 = 0, int colWidth = 0, int rowHeight = 0) {};
+    virtual int FuncX(void) { return X(); };
+    virtual int FuncY(void) { return Y(); };
+    virtual int FuncWidth(void) { return Width(); };
+    virtual int FuncHeight(void) { return Height(); };
+    virtual int Align(void) { return (int)eAlign::left; };
+    virtual int Valign(void) { return (int)eAlign::top; };
+    int GetX(eAlign align, int x0, int colWidth);
+    int GetY(eAlign valign, int y0, int rowHeight);
+    virtual bool Blinking(void) { return false; };
+    virtual int BlinkFreq(void) { return -1; };
+    virtual void Debug(void);
+};
+
+#endif //__ATTRIBUTE_H

coreengine/attributes.c

@@ -0,0 +1,447 @@
+#include "attributes.h"
+#include "../config.h"
+
+/***************************************************************************
+* cViewAttribs
+***************************************************************************/
+cViewAttribs::cViewAttribs(int numAttributes) : cAttributes(numAttributes) {
+    orientation = NULL;
+    SetAttributesDefs();
+}
+
+cViewAttribs::~cViewAttribs(void) {
+    delete orientation;
+}
+
+void cViewAttribs::Set(vector<stringpair> &attributes) {
+    for (vector<stringpair>::iterator att = attributes.begin(); att != attributes.end(); att++) {
+        const char *attName = (*att).first.c_str();
+        const char *attVal = (*att).second.c_str();
+        int id = AttributeId(attName);
+        if (id == ATTR_UNKNOWN) {
+            esyslog("skindesigner: unknown view attribute \"%s\" = \"%s\"", attName, attVal);
+            continue;
+        }
+        if (SetCommon(id, attVal))
+            continue;
+        if (IdEqual(id, (int)eViewAttribs::shifttype)) {
+            SetShiftType(id, attVal);
+        } else if (IdEqual(id, (int)eViewAttribs::shiftmode)) {
+            SetShiftMode(id, attVal);
+        } else if (IdEqual(id, (int)eViewAttribs::orientation)) {
+            SetOrientationDynamic(id, attVal);
+        } else if (IdEqual(id, (int)eViewAttribs::hideroot)) {
+            SetBool(id, attVal);
+        } else {
+            attribCtors[id] = new cNumericExpr(attVal);
+            if ( (id == (int)eViewAttribs::starty + (int)eCommonAttribs::count) ||
+                 (id == (int)eViewAttribs::scaletvy + (int)eCommonAttribs::count) ||
+                 (id == (int)eViewAttribs::scaletvheight + (int)eCommonAttribs::count) ) {
+                attribCtors[id]->SetVertical();                
+            }
+        }   
+    }
+}
+
+void cViewAttribs::SetAttributesDefs(void) {
+    attribIDs.insert(pair<string, int>("fadetime", (int)eViewAttribs::fadetime));
+    attribIDs.insert(pair<string, int>("shifttime", (int)eViewAttribs::shifttime));
+    attribIDs.insert(pair<string, int>("shifttype", (int)eViewAttribs::shifttype));
+    attribIDs.insert(pair<string, int>("shiftmode", (int)eViewAttribs::shiftmode));
+    attribIDs.insert(pair<string, int>("startx", (int)eViewAttribs::startx));
+    attribIDs.insert(pair<string, int>("starty", (int)eViewAttribs::starty));
+    attribIDs.insert(pair<string, int>("scaletvx", (int)eViewAttribs::scaletvx));
+    attribIDs.insert(pair<string, int>("scaletvy", (int)eViewAttribs::scaletvy));
+    attribIDs.insert(pair<string, int>("scaletvwidth", (int)eViewAttribs::scaletvwidth));
+    attribIDs.insert(pair<string, int>("scaletvheight", (int)eViewAttribs::scaletvheight));
+    attribIDs.insert(pair<string, int>("orientation", (int)eViewAttribs::orientation));
+    attribIDs.insert(pair<string, int>("debuggrid", (int)eViewAttribs::debuggrid));
+    attribIDs.insert(pair<string, int>("hideroot", (int)eViewAttribs::hideroot));
+    attribNames.insert(pair<int, string>((int)eViewAttribs::fadetime, "fadetime"));
+    attribNames.insert(pair<int, string>((int)eViewAttribs::shifttime, "shifttime"));
+    attribNames.insert(pair<int, string>((int)eViewAttribs::shifttype, "shifttype"));
+    attribNames.insert(pair<int, string>((int)eViewAttribs::shiftmode, "shiftmode"));
+    attribNames.insert(pair<int, string>((int)eViewAttribs::startx, "startx"));
+    attribNames.insert(pair<int, string>((int)eViewAttribs::starty, "starty"));
+    attribNames.insert(pair<int, string>((int)eViewAttribs::scaletvx, "scaletvx"));
+    attribNames.insert(pair<int, string>((int)eViewAttribs::scaletvy, "scaletvy"));
+    attribNames.insert(pair<int, string>((int)eViewAttribs::scaletvwidth, "scaletvwidth"));
+    attribNames.insert(pair<int, string>((int)eViewAttribs::scaletvheight, "scaletvheight"));
+    attribNames.insert(pair<int, string>((int)eViewAttribs::orientation, "orientation"));
+    attribNames.insert(pair<int, string>((int)eViewAttribs::debuggrid, "debuggrid"));
+    attribNames.insert(pair<int, string>((int)eViewAttribs::hideroot, "hideroot"));
+}
+
+void cViewAttribs::Cache(void) {
+    tokenContainer = new skindesignerapi::cTokenContainer();
+    cAttributes::Cache();
+    if (orientation) {
+        orientation->SetGlobals(globals);
+        orientation->SetTokenContainer(tokenContainer);
+        orientation->Cache();
+        char *res = orientation->DeterminateText();
+        if (res) {
+            SetOrientation((int)eViewAttribs::orientation + (int)eCommonAttribs::count, res);
+        }
+        free(res);
+    }
+}
+
+void cViewAttribs::Debug(void) {
+    esyslog("skindesigner:        --> View Attribs");
+    cAttributes::Debug();
+}
+
+eOrientation cViewAttribs::Orientation(void) {
+    int orientation = GetValue((int)eViewAttribs::orientation);
+    if (orientation == -1)
+        return eOrientation::vertical;
+    if (orientation == (int)eOrientation::none)
+        return eOrientation::vertical;
+    return (eOrientation)orientation;
+}
+
+cRect cViewAttribs::TvFrame(void) {
+    int frameX = GetValue((int)eViewAttribs::scaletvx);
+    int frameY = GetValue((int)eViewAttribs::scaletvy);
+    int frameWidth = GetValue((int)eViewAttribs::scaletvwidth);
+    int frameHeight = GetValue((int)eViewAttribs::scaletvheight);
+    if (frameX < 0 || frameY < 0 || frameWidth <= 0 || frameHeight <= 0)
+        return cRect::Null;
+    frameX += cOsd::OsdLeft();
+    frameY += cOsd::OsdTop();
+    return cRect(frameX, frameY, frameWidth, frameHeight);
+}
+
+void cViewAttribs::SetOrientationDynamic(int id, const char *val) {
+    if (strchr(val, '{') && strchr(val, '}')) {
+        orientation = new cTextExpr(val);
+    } else {
+        SetOrientation(id, val);
+    }
+}
+
+/***************************************************************************
+* cViewElementAttribs
+***************************************************************************/
+cViewElementAttribs::cViewElementAttribs(int numAttributes) : cAttributes(numAttributes) {
+    name = NULL;
+    SetAttributesDefs();
+}
+
+cViewElementAttribs::cViewElementAttribs(const cViewElementAttribs &other) : cAttributes(other) {
+    name = NULL;
+}
+
+cViewElementAttribs::~cViewElementAttribs(void) {
+    free(name);
+}
+
+void cViewElementAttribs::Set(vector<stringpair> &attributes) {
+    for (vector<stringpair>::iterator att = attributes.begin(); att != attributes.end(); att++) {
+        const char *attName = (*att).first.c_str();
+        const char *attVal = (*att).second.c_str();
+        int id = AttributeId(attName);
+        if (id == ATTR_UNKNOWN) {
+            esyslog("skindesigner: unknown view element attribute \"%s\" = \"%s\"", attName, attVal);
+            continue;
+        }
+        if (SetCommon(id, attVal))
+            continue;
+        if (IdEqual(id, (int)eViewElementAttribs::mode)) {
+            SetViewElementMode(id, attVal);
+        } else if (IdEqual(id, (int)eViewElementAttribs::shifttype)) {
+            SetShiftType(id, attVal);
+        } else if (IdEqual(id, (int)eViewElementAttribs::shiftmode)) {
+            SetShiftMode(id, attVal);
+        } else if (IdEqual(id, (int)eViewElementAttribs::orientation)) {
+            SetOrientation(id, attVal);
+        } else if (IdEqual(id, (int)eViewElementAttribs::name)) {
+            name = strdup(attVal);
+        } else {
+            attribCtors[id] = new cNumericExpr(attVal);
+            if (id == (int)eViewElementAttribs::starty + (int)eCommonAttribs::count) {
+                attribCtors[id]->SetVertical();                
+            }
+        }
+    }
+}
+
+void cViewElementAttribs::SetAttributesDefs(void) {
+    attribIDs.insert(pair<string, int>("delay", (int)eViewElementAttribs::delay));
+    attribIDs.insert(pair<string, int>("fadetime", (int)eViewElementAttribs::fadetime));
+    attribIDs.insert(pair<string, int>("shifttime", (int)eViewElementAttribs::shifttime));
+    attribIDs.insert(pair<string, int>("shifttype", (int)eViewElementAttribs::shifttype));
+    attribIDs.insert(pair<string, int>("shiftmode", (int)eViewElementAttribs::shiftmode));
+    attribIDs.insert(pair<string, int>("startx", (int)eViewElementAttribs::startx));
+    attribIDs.insert(pair<string, int>("starty", (int)eViewElementAttribs::starty));
+    attribIDs.insert(pair<string, int>("orientation", (int)eViewElementAttribs::orientation));
+    attribIDs.insert(pair<string, int>("mode", (int)eViewElementAttribs::mode));
+    attribIDs.insert(pair<string, int>("name", (int)eViewElementAttribs::name));
+    attribNames.insert(pair<int, string>((int)eViewElementAttribs::delay, "delay"));
+    attribNames.insert(pair<int, string>((int)eViewElementAttribs::fadetime, "fadetime"));
+    attribNames.insert(pair<int, string>((int)eViewElementAttribs::shifttime, "shifttime"));
+    attribNames.insert(pair<int, string>((int)eViewElementAttribs::shifttype, "shifttype"));
+    attribNames.insert(pair<int, string>((int)eViewElementAttribs::shiftmode, "shiftmode"));
+    attribNames.insert(pair<int, string>((int)eViewElementAttribs::startx, "startx"));
+    attribNames.insert(pair<int, string>((int)eViewElementAttribs::starty, "starty"));
+    attribNames.insert(pair<int, string>((int)eViewElementAttribs::orientation, "orientation"));
+    attribNames.insert(pair<int, string>((int)eViewElementAttribs::mode, "mode"));
+    attribNames.insert(pair<int, string>((int)eViewElementAttribs::name, "name"));
+}
+
+eOrientation cViewElementAttribs::Orientation(void) {
+    int orientation = GetValue((int)eViewElementAttribs::orientation);
+    if (orientation == -1)
+        return eOrientation::vertical;
+    if (orientation == (int)eOrientation::none)
+        return eOrientation::vertical;
+    return (eOrientation)orientation;
+}
+
+void cViewElementAttribs::Debug(void) {
+    esyslog("skindesigner:   ---> View Element Attribs");
+    cAttributes::Debug();
+}
+
+/***************************************************************************
+* cViewListAttribs
+***************************************************************************/
+cViewListAttribs::cViewListAttribs(int numAttributes) : cAttributes(numAttributes) {
+    determinateFont = NULL;
+    SetAttributesDefs();
+}
+
+cViewListAttribs::~cViewListAttribs(void) {
+    free(determinateFont);
+}
+
+void cViewListAttribs::Set(vector<stringpair> &attributes) {
+    for (vector<stringpair>::iterator att = attributes.begin(); att != attributes.end(); att++) {
+        const char *attName = (*att).first.c_str();
+        const char *attVal = (*att).second.c_str();
+        int id = AttributeId(attName);
+        if (id == ATTR_UNKNOWN) {
+            esyslog("skindesigner: unknown view list attribute \"%s\" = \"%s\"", attName, attVal);
+            continue;
+        }
+        if (SetCommon(id, attVal))
+            continue;
+        if (IdEqual(id, (int)eViewListAttribs::align)) {
+            SetAlign(id, attVal);
+        } else if (IdEqual(id, (int)eViewListAttribs::determinatefont)) {
+            determinateFont = strdup(attVal);
+        } else if (IdEqual(id, (int)eViewListAttribs::orientation)) {
+            SetOrientation(id, attVal);
+        } else {
+            attribCtors[id] = new cNumericExpr(attVal);
+        }
+    }
+}
+
+int cViewListAttribs::NumListElements(void) { 
+    return GetValue((int)eViewListAttribs::numlistelements); 
+}
+
+int cViewListAttribs::MenuItemWidth(void) {
+    return GetValue((int)eViewListAttribs::menuitemwidth); 
+}
+
+const char *cViewListAttribs::DeterminateFont(void) {
+    return determinateFont; 
+}
+
+eAlign cViewListAttribs::Align(void) { 
+    int align = GetValue((int)eViewListAttribs::align);
+    if (align < 0)
+        return eAlign::top;
+    return (eAlign)align; 
+}
+
+eOrientation cViewListAttribs::Orientation(void) {
+    int orientation = GetValue((int)eViewListAttribs::orientation);
+    if (orientation < 0)
+        return eOrientation::vertical;
+    return (eOrientation)orientation; 
+}
+
+void cViewListAttribs::SetAttributesDefs(void) {
+    attribIDs.insert(pair<string, int>("align", (int)eViewListAttribs::align));
+    attribIDs.insert(pair<string, int>("menuitemwidth", (int)eViewListAttribs::menuitemwidth));
+    attribIDs.insert(pair<string, int>("determinatefont", (int)eViewListAttribs::determinatefont));
+    attribIDs.insert(pair<string, int>("numlistelements", (int)eViewListAttribs::numlistelements));
+    attribIDs.insert(pair<string, int>("orientation", (int)eViewListAttribs::orientation));
+    attribIDs.insert(pair<string, int>("condition", (int)eViewListAttribs::condition));
+    attribNames.insert(pair<int, string>((int)eViewListAttribs::align, "align"));
+    attribNames.insert(pair<int, string>((int)eViewListAttribs::menuitemwidth, "menuitemwidth"));
+    attribNames.insert(pair<int, string>((int)eViewListAttribs::determinatefont, "determinatefont"));
+    attribNames.insert(pair<int, string>((int)eViewListAttribs::numlistelements, "numlistelements"));
+    attribNames.insert(pair<int, string>((int)eViewListAttribs::orientation, "orientation"));
+    attribNames.insert(pair<int, string>((int)eViewListAttribs::condition, "condition"));
+}
+
+void cViewListAttribs::Debug(void) {
+    esyslog("skindesigner:   ---> View List Attribs");
+    esyslog("skindesigner:        DeterminateFont %s", determinateFont);
+    cAttributes::Debug();
+}
+
+/***************************************************************************
+* cAreaAttribs
+***************************************************************************/
+cAreaAttribs::cAreaAttribs(int numAttributes) : cAttributes(numAttributes) {
+    name = NULL;
+    scrollElement = NULL;
+    dynamic = false;
+    SetAttributesDefs();
+}
+
+cAreaAttribs::cAreaAttribs(const cAreaAttribs &other) : cAttributes(other) {
+    name = NULL;
+    if (other.name)
+        name = new cTextExpr(*other.name);
+    scrollElement = NULL;
+    if (other.scrollElement)
+        scrollElement = strdup(other.scrollElement);
+    dynamic = false;
+}
+
+cAreaAttribs::~cAreaAttribs(void) {
+    delete name;
+    free(scrollElement);
+}
+
+void cAreaAttribs::Set(vector<stringpair> &attributes) {
+    for (vector<stringpair>::iterator att = attributes.begin(); att != attributes.end(); att++) {
+        const char *attName = (*att).first.c_str();
+        const char *attVal = (*att).second.c_str();
+        int id = AttributeId(attName);
+        if (id == ATTR_UNKNOWN) {
+            esyslog("skindesigner: unknown area attribute \"%s\" = \"%s\"", attName, attVal);
+            continue;
+        }
+        if (SetCommon(id, attVal))
+            continue;
+        if (IdEqual(id, (int)eAreaAttribs::scrollelement)) {
+            scrollElement = strdup(attVal);
+        } else if (IdEqual(id, (int)eAreaAttribs::mode)) {
+            SetScrollMode(id, attVal);
+        } else if (IdEqual(id, (int)eAreaAttribs::orientation)) {
+            SetOrientation(id, attVal);
+        } else if (IdEqual(id, (int)eAreaAttribs::scrollspeed)) {
+            SetScrollSpeed(id, attVal);
+        } else if (IdEqual(id, (int)eAreaAttribs::background)) {
+            SetBool(id, attVal);
+        } else if (IdEqual(id, (int)eAreaAttribs::name)) {
+            name = new cTextExpr(attVal);
+        } else {
+            attribCtors[id] = new cNumericExpr(attVal);    
+        }
+    }
+}
+
+int cAreaAttribs::Layer(void) {
+    if (GetValue((int)eAreaAttribs::layer) > 0) {
+        return GetValue((int)eAreaAttribs::layer);
+    }
+    return 1;
+}
+
+bool cAreaAttribs::BackgroundArea(void) {
+    int isBackground = GetValue((int)eAreaAttribs::background);
+    if (isBackground == 1)
+        return true;
+    return false; 
+}
+
+void cAreaAttribs::CheckDynamic(void) {
+    for (int i = (int)eCommonAttribs::x; i <= (int)eCommonAttribs::height; ++i ) {
+        if (attribCtors[i] && attribCtors[i]->Dynamic()) {
+            dynamic = true;
+            return;
+        }
+    }
+}
+
+const char *cAreaAttribs::Name(void) { 
+    if (name)
+        return name->DeterminateText(); 
+    return NULL;
+}
+
+void cAreaAttribs::SetAttributesDefs(void) {
+    attribIDs.insert(pair<string, int>("layer", (int)eAreaAttribs::layer));
+    attribIDs.insert(pair<string, int>("transparency", (int)eAreaAttribs::transparency));
+    attribIDs.insert(pair<string, int>("mode", (int)eAreaAttribs::mode));
+    attribIDs.insert(pair<string, int>("orientation", (int)eAreaAttribs::orientation));
+    attribIDs.insert(pair<string, int>("scrollelement", (int)eAreaAttribs::scrollelement));
+    attribIDs.insert(pair<string, int>("scrollspeed", (int)eAreaAttribs::scrollspeed));
+    attribIDs.insert(pair<string, int>("delay", (int)eAreaAttribs::delay));
+    attribIDs.insert(pair<string, int>("background", (int)eAreaAttribs::background));
+    attribIDs.insert(pair<string, int>("name", (int)eAreaAttribs::name));
+    attribIDs.insert(pair<string, int>("scrollheight", (int)eAreaAttribs::scrollheight));
+    attribNames.insert(pair<int, string>((int)eAreaAttribs::layer, "layer"));
+    attribNames.insert(pair<int, string>((int)eAreaAttribs::transparency, "transparency"));
+    attribNames.insert(pair<int, string>((int)eAreaAttribs::mode, "mode"));
+    attribNames.insert(pair<int, string>((int)eAreaAttribs::orientation, "orientation"));
+    attribNames.insert(pair<int, string>((int)eAreaAttribs::scrollelement, "scrollelement"));
+    attribNames.insert(pair<int, string>((int)eAreaAttribs::scrollspeed, "scrollspeed"));
+    attribNames.insert(pair<int, string>((int)eAreaAttribs::delay, "delay"));
+    attribNames.insert(pair<int, string>((int)eAreaAttribs::background, "background"));
+    attribNames.insert(pair<int, string>((int)eAreaAttribs::name, "name"));
+    attribNames.insert(pair<int, string>((int)eAreaAttribs::scrollheight, "scrollheight"));
+}
+
+void cAreaAttribs::Cache(void) {
+    cAttributes::Cache();
+    if (name) {
+        name->SetGlobals(globals);
+        name->SetTokenContainer(tokenContainer);
+        name->Cache();
+    }
+}
+
+void cAreaAttribs::Debug(void) {
+    if (!name) {
+        esyslog("skindesigner:        ---> Area Attribs");
+    } else {
+        esyslog("skindesigner:        ---> Tab %s Attribs", name->DeterminateText());        
+    }
+    cAttributes::Debug();
+}
+
+/***************************************************************************
+* cAreaContainerAttribs
+***************************************************************************/
+cAreaContainerAttribs::cAreaContainerAttribs(int numAttributes) : cAttributes(numAttributes) {
+    SetAttributesDefs();
+}
+
+cAreaContainerAttribs::cAreaContainerAttribs(const cAreaContainerAttribs &other) : cAttributes(other) {
+}
+
+cAreaContainerAttribs::~cAreaContainerAttribs(void) {
+}
+
+void cAreaContainerAttribs::Set(vector<stringpair> &attributes) {
+    for (vector<stringpair>::iterator att = attributes.begin(); att != attributes.end(); att++) {
+        const char *attName = (*att).first.c_str();
+        const char *attVal = (*att).second.c_str();
+        int id = AttributeId(attName);
+        if (id == ATTR_UNKNOWN) {
+            esyslog("skindesigner: unknown area container attribute \"%s\" = \"%s\"", attName, attVal);
+            continue;
+        }
+        if (SetCommon(id, attVal))
+            continue;
+    }
+}
+
+void cAreaContainerAttribs::SetAttributesDefs(void) {
+}
+
+void cAreaContainerAttribs::Debug(void) {
+    esyslog("skindesigner:            ---> Area Container Attribs");
+    cAttributes::Debug();
+}
+

coreengine/attributes.h

@@ -0,0 +1,111 @@
+#ifndef __ATTRIBUTES_H
+#define __ATTRIBUTES_H
+
+#include "attribute.h"
+/******************************************************************
+* cViewAttribs
+******************************************************************/
+class cViewAttribs : public cAttributes {
+private:
+    cTextExpr *orientation;
+    void SetAttributesDefs(void);
+    void SetOrientationDynamic(int id, const char *val);
+public:
+    cViewAttribs(int numAttributes);
+    virtual ~cViewAttribs(void);
+    void Set(vector<stringpair> &attributes);
+    eOrientation Orientation(void);
+    int FadeTime(void) { return GetValue((int)eViewAttribs::fadetime); };
+    int ShiftTime(void) { return GetValue((int)eViewAttribs::shifttime); };
+    cPoint ShiftStartpoint(void) { return cPoint(GetValue((int)eViewAttribs::startx), GetValue((int)eViewAttribs::starty)); };
+    int ShiftType(void) { return GetValue((int)eViewAttribs::shifttype); };
+    int ShiftMode(void) { return GetValue((int)eViewAttribs::shiftmode); };
+    cRect TvFrame(void);
+    void Cache(void);
+    void Debug(void);
+};
+/******************************************************************
+* cViewElementAttribs
+******************************************************************/
+class cViewElementAttribs : public cAttributes {
+private:
+    char *name;
+    void SetAttributesDefs(void);
+public:
+    cViewElementAttribs(int numAttributes);
+    cViewElementAttribs(const cViewElementAttribs &other);
+    virtual ~cViewElementAttribs(void);
+    void Set(vector<stringpair> &attributes);
+    int Mode(void) { return GetValue((int)eViewElementAttribs::mode); };
+    int Delay(void) { return GetValue((int)eViewElementAttribs::delay); };
+    eOrientation Orientation(void);
+    int FadeTime(void) { return GetValue((int)eViewElementAttribs::fadetime); };
+    int ShiftTime(void) { return GetValue((int)eViewElementAttribs::shifttime); };
+    cPoint ShiftStartpoint(void) { return cPoint(GetValue((int)eViewElementAttribs::startx), GetValue((int)eViewElementAttribs::starty)); };
+    int ShiftType(void) { return GetValue((int)eViewElementAttribs::shifttype); };
+    int ShiftMode(void) { return GetValue((int)eViewElementAttribs::shiftmode); };
+    const char *Name(void) { return name; };
+    void Debug(void);
+};
+/******************************************************************
+* cViewListAttribs
+******************************************************************/
+class cViewListAttribs : public cAttributes {
+private:
+    char *determinateFont;
+    void SetAttributesDefs(void);
+public:
+    cViewListAttribs(int numAttributes);
+    virtual ~cViewListAttribs(void);
+    void Set(vector<stringpair> &attributes);
+    int NumListElements(void);
+    int MenuItemWidth(void);
+    const char *DeterminateFont(void);
+    eAlign Align(void);
+    eOrientation Orientation(void);
+    void Debug(void);
+};
+/******************************************************************
+* cAreaAttribs
+******************************************************************/
+class cAreaAttribs : public cAttributes {
+private:
+    cTextExpr *name;
+    char *scrollElement;
+    void SetAttributesDefs(void);
+    bool dynamic;
+public:
+    cAreaAttribs(int numAttributes);
+    cAreaAttribs(const cAreaAttribs &other);
+    virtual ~cAreaAttribs(void);
+    void Set(vector<stringpair> &attributes);
+    const char *GetScrollElement(void) { return scrollElement; };
+    int Orientation(void) { return GetValue((int)eAreaAttribs::orientation); };
+    int Delay(void) { return GetValue((int)eAreaAttribs::delay); };
+    int Mode(void) { return GetValue((int)eAreaAttribs::mode); };
+    int ScrollSpeed(void) { return GetValue((int)eAreaAttribs::scrollspeed); };
+    int Transparency(void) { return GetValue((int)eAreaAttribs::transparency); };    
+    int Layer(void);
+    int ScrollStep(void) { return GetValue((int)eAreaAttribs::scrollheight); };
+    bool BackgroundArea(void);
+    const char *Name(void);
+    void CheckDynamic(void);
+    bool Dynamic(void) {return dynamic; };
+    void Cache(void);
+    void Debug(void);
+};
+/******************************************************************
+* cAreaContainerAttribs
+******************************************************************/
+class cAreaContainerAttribs : public cAttributes {
+private:
+    void SetAttributesDefs(void);
+public:
+    cAreaContainerAttribs(int numAttributes);
+    cAreaContainerAttribs(const cAreaContainerAttribs &other);
+    virtual ~cAreaContainerAttribs(void);
+    void Set(vector<stringpair> &attributes);
+    void Debug(void);
+};
+
+#endif //__ATTRIBUTES_H

coreengine/complextypes.h

@@ -0,0 +1,318 @@
+#ifndef __COMPLEXTYPES_H
+#define __COMPLEXTYPES_H
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string>
+#include <vector>
+#include <vdr/skins.h>
+#include "globals.h"
+#include "../libskindesignerapi/tokencontainer.h"
+
+class cLoopInfo;
+class cFunction;
+/******************************************************************
+* helpers
+******************************************************************/
+char *RemoveSpace(char *e);
+void ReplaceDecimalpoint(char *e);
+void ReplaceStart(char *e, int num);
+void ReplaceEnd(char *e, int num);
+
+/******************************************************************
+* cCondition
+******************************************************************/
+enum class eCondOp {
+    tAnd,
+    tOr
+};
+
+enum class eCondType {
+    token,
+    negtoken,
+    lowerInt,
+    equalInt,
+    greaterInt,
+    isset,
+    empty,
+    equalString,
+    notEqualString,
+    contains,
+    notContains
+};
+
+enum class eCondTokenType {
+    inttoken,
+    stringtoken,
+    looptoken
+};
+
+class cCond : public cListObject {
+public:
+    cCond(const char *expression);
+    cCond(const cCond &other);
+    virtual ~cCond(void);
+    void Debug(void);
+    char *expr;
+    eCondOp operation;
+    eCondType type;
+    eCondTokenType tokenType;
+    bool constant;
+    bool isTrue;
+    int tokenIndex;
+    int compareValue;
+    char *compareStrValue;
+};
+
+class cCondition {
+private:
+    char *expr;
+    cGlobals *globals;
+    skindesignerapi::cTokenContainer *tokenContainer;
+    cLoopInfo *loopInfo;
+    cList<cCond> conds;
+    void Tokenize(void);
+    void PrepareTokens(void);
+    void SetTokenCond(cCond *c);
+    void SetIntegerCond(cCond *c);
+    void SetStringCond(cCond *c);
+    void SetStringCompareCond(cCond *c);
+    void SetTokenIndex(cCond *c, const char *token);
+public:
+    cCondition(const char *expression);
+    cCondition(const cCondition &other);
+    virtual ~cCondition(void);
+    void SetGlobals(cGlobals *globals) { this->globals = globals; };
+    void SetTokenContainer(skindesignerapi::cTokenContainer *tokenContainer) {this->tokenContainer = tokenContainer; };
+    void SetLoopInfo(cLoopInfo *loopInfo) { this->loopInfo = loopInfo; };
+    void Prepare(void);
+    bool True(void);
+    void Debug(void);
+};
+
+/******************************************************************
+* cNumericExpr
+******************************************************************/
+enum class eFactorType {
+    constant = 0,
+    stringtoken,
+    inttoken,
+    looptoken,
+    xref,
+    yref,
+    widthref,
+    heightref,
+    areawidth,
+    areaheight,
+    columnwidth,
+    rowheight
+};
+
+class cFactor: public cListObject {
+public:
+    cFactor(void) {
+        multiplication = true;
+        type = eFactorType::constant;
+        constValue = 1.0f;
+        tokenIndex = -1;
+        funcRefName = NULL;
+        funcRef = NULL;
+    };
+    cFactor(const cFactor &other) {
+        multiplication = other.multiplication;
+        type = other.type;
+        constValue = other.constValue;
+        tokenIndex = other.tokenIndex;
+        funcRefName = NULL;
+        if (other.funcRefName)
+            funcRefName = strdup(other.funcRefName);
+        funcRef = other.funcRef;
+    }
+    ~cFactor(void) {
+        free(funcRefName);
+    };
+    bool multiplication;
+    eFactorType type;
+    double constValue;
+    int tokenIndex;
+    char *funcRefName;
+    cFunction *funcRef;
+};
+
+class cSummand : public cListObject {
+public:
+    cSummand(const char *summand);
+    cSummand(const cSummand &other);
+    ~cSummand(void);
+    void Debug(void);
+    char *summand;
+    bool positive;
+    cList<cFactor> factors;
+};
+
+class cNumericExpr {
+private:
+    cGlobals *globals;
+    cRect *container;
+    skindesignerapi::cTokenContainer *tokenContainer;
+    cLoopInfo *loopInfo;
+    char *expr;
+    cList<cSummand> summands;
+    bool horizontal;
+    int value;
+    bool dynamic;
+    //common string functions
+    bool IsNumeric(const char *e);
+    bool IsNumericExpression(const char *e);
+    bool PercentValue(const char *e);
+    char *ReplacePercentValue(char *e);
+    char *ReplaceToken(char *e, const char* token, int value);
+    char *ReplaceTokens(char *e, const char* token, int value);
+    //calculate numeric expressions
+    int EvaluateExpression(char *e);
+    double EvaluateExpressionDouble(char *e);
+    double ParseAtom(char*& e);
+    double ParseFactors(char*& e);
+    double ParseSummands(char*& e);
+    //prepare expressions with tokens
+    void CreateSummands(void);
+    void CreateFactors(void);
+    bool SetTokenFactor(cFactor *f, char *tokenName);
+    bool SetReferenceFactor(cFactor *f, char *tokenName);
+    bool SetGeometryFactor(cFactor *f, char *tokenName);
+    void ConsolidateSummand(void);
+    void ConsolidateFactors(void);
+public:
+    cNumericExpr(const char *expression);
+    cNumericExpr(const cNumericExpr &other);
+    virtual ~cNumericExpr(void);
+    void SetContainer(cRect *container) { this->container = container; };
+    void SetGlobals(cGlobals *globals) { this->globals = globals; };
+    void SetTokenContainer(skindesignerapi::cTokenContainer *tokenContainer) { this->tokenContainer = tokenContainer; };
+    void SetLoopInfo(cLoopInfo *loopInfo) { this->loopInfo = loopInfo; };
+    void SetVertical(void) { horizontal = false; };
+    bool CacheStatic(void);
+    void PrepareTokens(void);
+    vector<cFactor*> GetRefFactors(void);
+    int GetValue(void) { return value; };
+    bool Dynamic(void) { return dynamic; };
+    int Calculate(void);
+    void Debug(void);
+};
+
+/******************************************************************
+* cColor
+******************************************************************/
+class cColor {
+private:
+    cGlobals *globals;
+    char *expr;
+    tColor value;
+public:
+    cColor(const char *expression);
+    cColor(const cColor &other);
+    virtual ~cColor(void);
+    void SetGlobals(cGlobals *globals) { this->globals = globals; };
+    void Cache(void);
+    tColor Color(void);
+    void Debug(void);
+};
+
+/******************************************************************
+* cTextExpr
+******************************************************************/
+enum class eTexttokenType {
+    constant = 0,
+    stringtoken,
+    inttoken,
+    looptoken,
+    printftoken,
+    condstringtoken,
+    condinttoken,
+};
+
+enum class ePrintfVarType {
+    stringtoken,
+    inttoken,
+    looptoken
+};
+
+struct sPrintfInfo {
+    ePrintfVarType type;
+    int index;
+};
+
+class cTextToken: public cListObject {
+public:
+    cTextToken(void) {
+        type = eTexttokenType::constant;
+        constValue = NULL;
+        printfExpr = NULL;
+        printfResult = NULL;
+        tokenIndex = -1;
+        condStart = NULL;
+        condEnd = NULL;
+    };
+    cTextToken(const cTextToken &other) {
+        type = other.type;
+        constValue = NULL;
+        if (other.constValue)
+            constValue = strdup(other.constValue);
+        printfExpr = NULL;
+        if (other.printfExpr)
+            printfExpr = strdup(other.printfExpr);
+        printfVarIndices = other.printfVarIndices;
+        printfResult = NULL;
+        if (other.printfResult)
+            printfResult = strdup(other.printfResult);
+        tokenIndex = other.tokenIndex;
+        condStart = NULL;
+        if (other.condStart)
+            condStart = strdup(other.condStart);
+        condEnd = NULL;
+        if (other.condEnd)
+            condEnd = strdup(other.condEnd);
+    };
+    ~cTextToken(void) {
+        free(constValue);
+        free(printfExpr);
+    };
+    eTexttokenType type;
+    char *constValue;
+    int tokenIndex;
+    char *printfExpr;
+    vector<sPrintfInfo> printfVarIndices;
+    char *printfResult;
+    char *condStart;
+    char *condEnd;
+};
+
+class cTextExpr {
+private:
+    cGlobals *globals;
+    skindesignerapi::cTokenContainer *tokenContainer;
+    cLoopInfo *loopInfo;
+    char *expr;
+    cList<cTextToken> textTokens;
+    void Translate(void);
+    void Tokenize(void);
+    void PrepareTokens(void);
+    bool CheckGlobals(cTextToken *t);
+    bool ParsePrintfToken(cTextToken *t);
+    void DeterminatePrintfToken(cTextToken *t);
+    void ParseCondToken(cTextToken *t);
+    char *CopyTextPart(char *start, char *stop, bool incLastChar= true);
+public:
+    cTextExpr(const char *expression);
+    cTextExpr(const cTextExpr &other);
+    virtual ~cTextExpr(void);
+    void SetGlobals(cGlobals *globals) { this->globals = globals; };
+    void SetTokenContainer(skindesignerapi::cTokenContainer *tokenContainer) { this->tokenContainer = tokenContainer; };
+    void SetLoopInfo(cLoopInfo *loopInfo) { this->loopInfo = loopInfo; };
+    void CorrectImagePath(void);
+    void Cache(void);
+    char *DeterminateText(void);
+    void Debug(const char *exprName);
+};
+
+#endif //__COMPLEXTYPES_H

coreengine/functions.h

@@ -0,0 +1,220 @@
+#ifndef __FUNCTIONS_H
+#define __FUNCTIONS_H
+
+#include "functions.h"
+
+class cFuncFill : public cFunction {
+private:
+    void SetAttributesDefs(void);
+public:
+    cFuncFill(cArea *owner, int numAttributes);
+    cFuncFill(const cFuncFill &other);
+    virtual ~cFuncFill(void);
+    void Set(vector<stringpair> &attributes);
+    void Render(cPixmap *p, int x0 = 0, int y0 = 0, int colWidth = 0, int rowHeight = 0);
+};
+
+class cFuncDrawRectangle : public cFunction {
+private:
+    void SetAttributesDefs(void);
+public:
+    cFuncDrawRectangle(cArea *owner, int numAttributes);
+    cFuncDrawRectangle(const cFuncDrawRectangle &other);
+    virtual ~cFuncDrawRectangle(void);
+    void Set(vector<stringpair> &attributes);
+    void Render(cPixmap *p, int x0 = 0, int y0 = 0, int colWidth = 0, int rowHeight = 0);
+    bool Blinking(void) { return GetValue((int)eDrawRectangleAttribs::animtype) == (int)eAnimType::blink; };
+    int BlinkFreq(void) { return GetValue((int)eDrawRectangleAttribs::animfreq); };
+    int Align(void) { return GetValue((int)eDrawRectangleAttribs::align); };
+    int Valign(void) { return GetValue((int)eDrawRectangleAttribs::valign); };
+};
+
+class cFuncDrawEllipse : public cFunction {
+private:
+    void SetAttributesDefs(void);
+public:
+    cFuncDrawEllipse(cArea *owner, int numAttributes);
+    cFuncDrawEllipse(const cFuncDrawEllipse &other);
+    virtual ~cFuncDrawEllipse(void);
+    void Set(vector<stringpair> &attributes);
+    void Render(cPixmap *p, int x0 = 0, int y0 = 0, int colWidth = 0, int rowHeight = 0);
+    bool Blinking(void) { return GetValue((int)eDrawEllipseAttribs::animtype) == (int)eAnimType::blink; };
+    int BlinkFreq(void) { return GetValue((int)eDrawEllipseAttribs::animfreq); };
+    int Align(void) { return GetValue((int)eDrawEllipseAttribs::align); };
+    int Valign(void) { return GetValue((int)eDrawEllipseAttribs::valign); };
+};
+
+class cFuncDrawSlope : public cFunction {
+private:
+    void SetAttributesDefs(void);
+public:
+    cFuncDrawSlope(cArea *owner, int numAttributes);
+    cFuncDrawSlope(const cFuncDrawSlope &other);
+    virtual ~cFuncDrawSlope(void);
+    void Set(vector<stringpair> &attributes);
+    void Render(cPixmap *p, int x0 = 0, int y0 = 0, int colWidth = 0, int rowHeight = 0);
+    bool Blinking(void) { return GetValue((int)eDrawSlopeAttribs::animtype) == (int)eAnimType::blink; };
+    int BlinkFreq(void) { return GetValue((int)eDrawSlopeAttribs::animfreq); };
+    int Align(void) { return GetValue((int)eDrawSlopeAttribs::align); };
+    int Valign(void) { return GetValue((int)eDrawSlopeAttribs::valign); };
+};
+
+class cTextDrawer {
+private:
+    static cMutex fontLock;
+protected:
+    const cFont *font;
+    char *fontName;
+    int fontSize;
+    void CacheFont(cGlobals *globals, int size);
+    void LoadFont(int size);
+    int TextWidth(const char *text);
+    int FontHeight(void);
+public:
+    cTextDrawer(void);
+    virtual ~cTextDrawer(void);
+};
+
+class cFuncDrawText : public cFunction, public cTextDrawer {
+private:
+    cTextExpr *text;
+    void SetAttributesDefs(void);
+    char *Cut(char *expr, int width);
+public:
+    cFuncDrawText(cArea *owner, int numAttributes);
+    cFuncDrawText(const cFuncDrawText &other);
+    virtual ~cFuncDrawText(void);
+    void SetLoopInfo(cLoopInfo *loopInfo);
+    void SetTokenContainerDeep(skindesignerapi::cTokenContainer *tokenContainer);
+    void Set(vector<stringpair> &attributes);
+    void Cache(void);
+    void Render(cPixmap *p, int x0 = 0, int y0 = 0, int colWidth = 0, int rowHeight = 0);
+    int FuncX(void);
+    int FuncY(void);
+    int FuncWidth(void);
+    int FuncHeight(void);
+    int AvrgFontWidth(void);
+    const cFont *GetFont(void);
+    bool Blinking(void) { return GetValue((int)eDrawTextAttribs::animtype) == (int)eAnimType::blink; };
+    int BlinkFreq(void) { return GetValue((int)eDrawTextAttribs::animfreq); };
+    int Align(void) { return GetValue((int)eDrawTextAttribs::align); };
+    int Valign(void) { return GetValue((int)eDrawTextAttribs::valign); };
+    void Debug(void);
+};
+
+class cFuncDrawTextVertical : public cFunction, public cTextDrawer {
+private:
+    cTextExpr *text;
+    void SetAttributesDefs(void);
+public:
+    cFuncDrawTextVertical(cArea *owner, int numAttributes);
+    cFuncDrawTextVertical(const cFuncDrawTextVertical &other);
+    virtual ~cFuncDrawTextVertical(void);
+    void SetLoopInfo(cLoopInfo *loopInfo);
+    void SetTokenContainerDeep(skindesignerapi::cTokenContainer *tokenContainer);
+    void Set(vector<stringpair> &attributes);
+    void Cache(void);
+    void Render(cPixmap *p, int x0 = 0, int y0 = 0, int colWidth = 0, int rowHeight = 0);
+    int FuncWidth(void);
+    int FuncHeight(void);
+    bool Blinking(void) { return GetValue((int)eDrawTextAttribsVertical::animtype) == (int)eAnimType::blink; };
+    int BlinkFreq(void) { return GetValue((int)eDrawTextAttribsVertical::animfreq); };
+    int Align(void) { return GetValue((int)eDrawTextAttribsVertical::align); };
+    int Valign(void) { return GetValue((int)eDrawTextAttribsVertical::valign); };
+    void Debug(void);
+};
+
+class cTextFloater;
+
+class cFuncDrawTextBox : public cFunction, public cTextDrawer {
+private:
+    cTextExpr *text;
+    cTextFloater *floater;
+    void SetFloater(void);
+    void SetAttributesDefs(void);
+    void SetFloatMode(int id, const char *val);
+public:
+    cFuncDrawTextBox(cArea *owner, int numAttributes);
+    cFuncDrawTextBox(const cFuncDrawTextBox &other);
+    virtual ~cFuncDrawTextBox(void);
+    void SetLoopInfo(cLoopInfo *loopInfo);
+    void SetTokenContainerDeep(skindesignerapi::cTokenContainer *tokenContainer);
+    void Set(vector<stringpair> &attributes);
+    void Cache(void);
+    void Render(cPixmap *p, int x0 = 0, int y0 = 0, int colWidth = 0, int rowHeight = 0);
+    int FuncWidth(void);
+    int FuncHeight(void);
+    void Debug(void);
+};
+
+class cFuncDrawImage : public cFunction {
+private:
+    cTextExpr *path;
+    void SetAttributesDefs(void);
+    void SetImageType(int id, const char *val);
+    void PreCacheImage(void);
+public:
+    cFuncDrawImage(cArea *owner, int numAttributes);
+    cFuncDrawImage(const cFuncDrawImage &other);
+    virtual ~cFuncDrawImage(void);
+    void SetLoopInfo(cLoopInfo *loopInfo);
+    void SetTokenContainerDeep(skindesignerapi::cTokenContainer *tokenContainer);
+    void Set(vector<stringpair> &attributes);
+    void Cache(void);
+    void Render(cPixmap *p, int x0 = 0, int y0 = 0, int colWidth = 0, int rowHeight = 0);
+    bool Blinking(void) { return GetValue((int)eDrawImageAttribs::animtype) == (int)eAnimType::blink; };
+    int BlinkFreq(void) { return GetValue((int)eDrawImageAttribs::animfreq); };
+    int Align(void) { return GetValue((int)eDrawImageAttribs::align); };
+    int Valign(void) { return GetValue((int)eDrawImageAttribs::valign); };
+    void Debug(void);
+};
+
+class cFuncLoop : public cFunction {
+private:
+    cLoopInfo loopInfo;
+    cList<cFunction> functions;
+    void SetAttributesDefs(void);
+    int ColumnWidth(void);
+    int RowHeight(void);
+public:
+    cFuncLoop(cArea *owner, int numAttributes);
+    virtual ~cFuncLoop(void);
+    void Set(vector<stringpair> &attributes);
+    void SetContainer(int x, int y, int width, int height);
+    void Cache(void);
+    void AddFunction(cFunction *f);
+    cFunction *GetFunction(const char *name);
+    void Render(cPixmap *p, int x0 = 0, int y0 = 0, int colWidth = 0, int rowHeight = 0);
+    int FuncWidth(void);
+    int FuncHeight(void);
+    void Debug(void);
+};
+
+class cTextFloater {
+private:
+    char *text;
+    char *eol;
+    int lines;
+    int lastLine;
+public:
+    cTextFloater(void);
+    cTextFloater(const char *text, const cFont *font, int width, int height = 0, int floatWidth = 0, int floatHeight = 0, int maxLines = 0);
+    ~cTextFloater();
+    void Set(const char *Text, const cFont *font, int width, int height = 0, int floatWidth = 0, int floatHeight = 0, int maxLines = 0);
+    ///< Wraps the Text to make it fit into the area defined by the given Width
+    ///< when displayed with the given Font.
+    ///< Wrapping is done by inserting the necessary number of newline
+    ///< characters into the string.
+    ///< if height is set, new lines are only set till height is reached
+    ///< if floatwidth and floatheight are set, the first lines (depending on 
+    ///< size of floatheight) are set to floatwidth
+    const char *Text(void);
+    ///< Returns the full wrapped text.
+    int Lines(void) { return lines; }
+    ///< Returns the actual number of lines needed to display the full wrapped text.
+    const char *GetLine(int line);
+    ///< Returns the given Line. The first line is numbered 0.
+};
+
+
+#endif //__FUNCTIONS_H

coreengine/globals.c

@@ -89,6 +89,7 @@ void cGlobals::ReplaceIntVars(string &value) {
 }
 
 bool cGlobals::GetInt(string name, int &val) {
+    DeleteCurledBrackets(name);
     map < string, int >::iterator hit = intVars.find(name);
     if (hit != intVars.end()) {
         val = hit->second;
@@ -146,10 +147,10 @@ void cGlobals::ReplaceStringVars(string &value) {
             value = value.replace(foundToken, token.size(), it->second);
         }
     }
-
 }
 
-bool cGlobals::GetString(string &name, string &value) {
+bool cGlobals::GetString(string name, string &value) {
+    DeleteCurledBrackets(name);
     map<string,string>::iterator hit = stringVars.find(name);
     if (hit == stringVars.end())
         return false;
@@ -157,7 +158,6 @@ bool cGlobals::GetString(string &name, string &value) {
     return true;
 }
 
-
 bool cGlobals::AddTranslation(string name,  map < string, string > transl) {
     translations.erase(name);
     translations.insert(pair<string, map < string, string > >(name, transl));
@@ -207,20 +207,20 @@ string cGlobals::DoTranslate(string token) {
     return translation;
 }
 
-void cGlobals::AddCustomInt(string &name, int value) {
-    customIntTokens.erase(name);
-    customIntTokens.insert(pair<string,int>(name, value));
+void cGlobals::AddCustomInt(int num, int value) {
+    customIntTokens.erase(num);
+    customIntTokens.insert(pair<int,int>(num, value));
     customTokenChange = time(0);
 }
 
-void cGlobals::AddCustomString(string &name, string &value) {
-    customStringTokens.erase(name);
-    customStringTokens.insert(pair<string,string>(name, value));
+void cGlobals::AddCustomString(int num, string &value) {
+    customStringTokens.erase(num);
+    customStringTokens.insert(pair<int,string>(num, value));
     customTokenChange = time(0);
 }
 
-bool cGlobals::GetCustomInt(string name, int &val) {
-    map < string, int >::iterator hit = customIntTokens.find(name);
+bool cGlobals::GetCustomInt(int num, int &val) {
+    map < int, int >::iterator hit = customIntTokens.find(num);
     if (hit != customIntTokens.end()) {
         val = hit->second;
         return true;
@@ -228,12 +228,21 @@ bool cGlobals::GetCustomInt(string name, int &val) {
     return false;
 }
 
-map <string, string> cGlobals::GetCustomStringTokens(void) { 
+bool cGlobals::GetCustomString(int num, string &val) {
+    map < int, string >::iterator hit = customStringTokens.find(num);
+    if (hit != customStringTokens.end()) {
+        val = hit->second;
+        return true;
+    }
+    return false;
+}
+
+map <int, string> cGlobals::GetCustomStringTokens(void) { 
     lastCustomTokenQuery = time(0);
     return customStringTokens;
 }
 
-map <string, int> cGlobals::GetCustomIntTokens(void) { 
+map <int, int> cGlobals::GetCustomIntTokens(void) { 
     lastCustomTokenQuery = time(0);
     return customIntTokens; 
 }
@@ -246,12 +255,16 @@ bool cGlobals::CustomTokenChange(void) {
     return false;
 }
 
-void cGlobals::ListCustomTokens(void) {
-    for (map<string, string>::iterator it = customStringTokens.begin(); it != customStringTokens.end(); it++) {
-        dsyslog("skindesigner: custom string token \"%s\" = \"%s\"", (it->first).c_str(), (it->second).c_str());
+void cGlobals::ResetCustomTokenChange(void) {
+    lastCustomTokenQuery = 0;
 }
-    for (map<string, int>::iterator it = customIntTokens.begin(); it != customIntTokens.end(); it++) {
-        dsyslog("skindesigner: custom int token \"%s\" = \"%d\"", (it->first).c_str(), it->second);
+
+void cGlobals::ListCustomTokens(void) {
+    for (map<int, string>::iterator it = customStringTokens.begin(); it != customStringTokens.end(); it++) {
+        dsyslog("skindesigner: custom string token %d = \"%s\"", it->first, (it->second).c_str());
+    }
+    for (map<int, int>::iterator it = customIntTokens.begin(); it != customIntTokens.end(); it++) {
+        dsyslog("skindesigner: custom int token %d = \"%d\"", it->first, it->second);
     }
 }
 
@@ -281,3 +294,12 @@ void cGlobals::Debug(void) {
         }
     }
 }
+
+void cGlobals::DeleteCurledBrackets(string &token) {
+    if (token.find("{") != 0)
+        return;
+    if (token.find("}") != token.size() - 1)
+        return;
+    token = token.substr(1, token.size() - 2);
+}
+

coreengine/globals.h

@@ -10,6 +10,7 @@
 #include <map>
 #include <set>
 #include <sstream>
+#include <algorithm>
 #include <vdr/plugin.h>
 
 using namespace std;
@@ -24,14 +25,15 @@ private:
     time_t lastCustomTokenQuery;
     string language;
     string DoTranslate(string token);
+    void DeleteCurledBrackets(string &token);
     map <string, tColor> colors;
     map <string, string> fonts;
     map <string, int> intVars;
     map <string, double> doubleVars;
     map <string, string> stringVars;
     map <string, map< string, string > > translations;
-    map <string, string> customStringTokens;
-    map <string, int> customIntTokens;
+    map <int, string> customStringTokens;
+    map <int, int> customIntTokens;
 public:
     cGlobals(void);
     virtual ~cGlobals(void) {};
@@ -47,15 +49,17 @@ public:
     void ReplaceDoubleVars(string &value);
     void AddString(string &name, string &value);
     void ReplaceStringVars(string &value);
-    bool GetString(string &name, string &value);
+    bool GetString(string name, string &value);
     bool AddTranslation(string name,  map < string, string > transl);
     bool Translate(string text, string &translation);
-    void AddCustomInt(string &name, int value);
-    void AddCustomString(string &name, string &value);
-    bool GetCustomInt(string name, int &val);
-    map <string, string> GetCustomStringTokens(void);
-    map <string, int> GetCustomIntTokens(void);
+    void AddCustomInt(int num, int value);
+    void AddCustomString(int num, string &value);
+    bool GetCustomInt(int num, int &val);
+    bool GetCustomString(int num, string &val);
+    map <int, string> GetCustomStringTokens(void);
+    map <int, int> GetCustomIntTokens(void);
     bool CustomTokenChange(void);
+    void ResetCustomTokenChange(void);
     void ListCustomTokens(void);
     void Debug(void);
 };

coreengine/gridelement.c

@@ -0,0 +1,57 @@
+#include "gridelement.h"
+#include "../config.h"
+
+cGridElement::cGridElement(void) {
+    current = false;
+    indexCurrent = -1;
+    viewId = -1;
+    plugId = -1;
+}
+
+cGridElement::cGridElement(const cGridElement &other) : cViewElement(other) {
+    current = false;
+    viewId = other.viewId;
+    plugId = other.plugId;
+    tokenContainer = new skindesignerapi::cTokenContainer(*other.tokenContainer);
+    indexCurrent = other.indexCurrent;
+    InheritTokenContainerDeep();
+}
+
+cGridElement::~cGridElement(void) {
+}
+
+void cGridElement::SetTokenContainer(void) {
+    skindesignerapi::cTokenContainer *tkGe = plgManager->GetTokenContainerGE(plugId, viewId, id);
+    if (!tkGe)
+        return;
+    tokenContainer = new skindesignerapi::cTokenContainer(*tkGe);
+    indexCurrent = tokenContainer->GetNumDefinedIntTokens();
+    tokenContainer->DefineIntToken("{current}", indexCurrent);
+    InheritTokenContainer();
+}
+
+void cGridElement::Set(skindesignerapi::cTokenContainer *tk) {
+    tokenContainer->Clear();
+    tokenContainer->SetTokens(tk);
+    SetDirty();
+}
+
+void cGridElement::SetCurrent(bool current) {
+    this->current = current;
+    SetDirty();
+}
+
+bool cGridElement::Parse(bool forced) {
+    if (!dirty)
+        return false;
+    tokenContainer->AddIntToken(indexCurrent, current);
+    return true;
+}
+
+int cGridElement::Width(void) {
+    return container.Width();
+}
+
+int cGridElement::Height(void) {
+    return container.Height();
+}

coreengine/gridelement.h

@@ -0,0 +1,27 @@
+#ifndef __GRIDELEMENT_H
+#define __GRIDELEMENT_H
+
+#include "viewelement.h"
+
+class cGridElement : public cViewElement {
+private:
+    int viewId;
+    int plugId;
+    bool current;
+    int indexCurrent;
+public:
+    cGridElement(void);
+    cGridElement(const cGridElement &other);
+    virtual ~cGridElement(void);
+    void SetPluginId(int plugId) { this->plugId = plugId; };
+    void SetViewId(int viewId) { this->viewId = viewId; };
+    void SetTokenContainer(void);
+    skindesignerapi::cTokenContainer *GetTokenContainer(void) { return tokenContainer; };
+    void Set(skindesignerapi::cTokenContainer *tk);
+    void SetCurrent(bool current);
+    bool Parse(bool forced = true);
+    int Width(void);
+    int Height(void);
+};
+
+#endif //__GRIDELEMENT_H

coreengine/listelements.h

@@ -0,0 +1,337 @@
+#ifndef __LISTELEMENTS_H
+#define __LISTELEMENTS_H
+
+#include "viewelement.h"
+#include "../extensions/scrapmanager.h"
+
+#define MAX_TABS 6
+/******************************************************************
+* cListElement
+******************************************************************/
+class cListElement : public cViewElement {
+protected:
+    eMenuCategory menuCat;
+    int num;
+    bool current;
+    bool wasCurrent;
+    bool selectable;
+    cViewElement *currentElement;
+    char *ParseSeparator(const char *text);
+public:
+    cListElement(void);
+    cListElement(const cListElement &other);
+    virtual ~cListElement(void) {};
+    void SetMenuCategory(eMenuCategory menuCat) { this->menuCat = menuCat; };
+    void SetNumber(int number) { num = number; };
+    void SetCurrent(bool cur);
+    bool Current(void) { return current; };
+    void WakeCurrent(void);
+    void SetSelectable(bool sel) { selectable = sel; };
+    bool DoScroll(void) { return current; };
+    virtual void RenderCurrent(void) { };
+    void Close(void);
+    void Clear(void);
+};
+
+/******************************************************************
+* cCurrentElement
+******************************************************************/
+class cCurrentElement : public cViewElement {
+protected:
+    int listX;
+    int listY;
+    int listWidth;
+    int listHeight;
+public:
+    cCurrentElement(void);
+    virtual ~cCurrentElement(void) {};
+    void SetListPosition(int x, int y, int width, int height);
+    void SetListTokens(skindesignerapi::cTokenContainer *tokenContainer);
+};
+
+/******************************************************************
+* cLeMenuDefault
+******************************************************************/
+class cLeMenuDefault : public cListElement {
+private:
+    char *text;
+    int *colX;
+    int *colWidths;
+    const char *plugName;
+    const char *GetTabbedText(const char *s, int tab);
+    void SetMenuCategory(void);
+    void CheckProgressBar(const char *text, int tab);
+public:
+    cLeMenuDefault(void);
+    cLeMenuDefault(const cLeMenuDefault &other);
+    virtual ~cLeMenuDefault(void);
+    void SetListInfo(int *colX, int *colWidths);
+    void SetText(const char *text);
+    void SetPlugin(const char *plugName) { this->plugName = plugName; };
+    void SetTokenContainer(void);
+    bool Parse(bool forced = true);
+};
+
+/******************************************************************
+* cVeMenuMain
+******************************************************************/
+class cVeMenuMain {
+protected:
+    char *text;
+    char *number;
+    char *label;
+    void SplitText(void);
+public:
+    cVeMenuMain(void);
+    virtual ~cVeMenuMain(void);
+    void SetText(const char *text);
+};
+
+/******************************************************************
+* cLeMenuMain
+******************************************************************/
+class cCeMenuMain;
+class cLeMenuMain : public cListElement, public cVeMenuMain {
+private:
+    cCeMenuMain *currentMain;
+public:
+    cLeMenuMain(void);
+    cLeMenuMain(const cLeMenuMain &other);
+    virtual ~cLeMenuMain(void);
+    void SetTokenContainer(void);
+    void SetCurrentElement(cCeMenuMain *cur) { currentMain = cur; currentElement = (cViewElement*)cur; };
+    void ClearCurrentElement(void);
+    void SetText(const char *text);
+    bool Parse(bool forced = true);
+    void RenderCurrent(void);
+    const char *PluginName(void);
+};
+
+/******************************************************************
+* cCeMenuMain
+******************************************************************/
+class cCeMenuMain : public cCurrentElement, public cVeMenuMain {
+private:
+public:
+    cCeMenuMain(void);
+    virtual ~cCeMenuMain(void);
+    void SetTokenContainer(void);
+    void SetText(const char *text);
+    bool Parse(bool forced = true);
+};
+
+/******************************************************************
+* cVeMenuSchedules
+******************************************************************/
+class cVeMenuSchedules {
+protected:
+    const cEvent *event;
+    const cChannel *channel;
+    bool withDate;
+    eTimerMatch timerMatch;
+    bool epgSearchFav;
+public:
+    cVeMenuSchedules(void);
+    virtual ~cVeMenuSchedules(void){};
+    void SetEpgSearchFav(bool isFav) { epgSearchFav = isFav; };
+};
+
+/******************************************************************
+* cLeMenuSchedules
+******************************************************************/
+class cCeMenuSchedules;
+class cLeMenuSchedules : public cListElement, public cVeMenuSchedules {
+private:
+    cCeMenuSchedules *currentSchedules;
+public:
+    cLeMenuSchedules(void);
+    cLeMenuSchedules(const cLeMenuSchedules &other);
+    virtual ~cLeMenuSchedules(void);
+    void SetTokenContainer(void);
+    void SetCurrentElement(cCeMenuSchedules *cur) { currentSchedules = cur; currentElement = (cViewElement*)cur; };
+    void ClearCurrentElement(void);
+    void Set(const cEvent *event, const cChannel *channel, bool withDate, eTimerMatch timerMatch);
+    bool Parse(bool forced = true);
+    void RenderCurrent(void);
+};
+
+/******************************************************************
+* cCeMenuSchedules
+******************************************************************/
+class cCeMenuSchedules : public cCurrentElement, public cVeMenuSchedules, public cScrapManager {
+private:
+    eMenuCategory menuCat;
+    int schedulesIndex;
+public:
+    cCeMenuSchedules(void);
+    virtual ~cCeMenuSchedules(void);
+    void SetTokenContainer(void);
+    void Set(const cEvent *event, const cChannel *channel, bool withDate, eTimerMatch timerMatch, eMenuCategory menuCat);
+    bool Parse(bool forced = true);
+};
+
+/******************************************************************
+* cLeMenuChannels
+******************************************************************/
+class cCeMenuChannels;
+class cLeMenuChannels : public cListElement {
+private:
+    cCeMenuChannels *currentChannel;
+    const cChannel *channel;
+    bool withProvider;
+public:
+    cLeMenuChannels(void);
+    cLeMenuChannels(const cLeMenuChannels &other);
+    virtual ~cLeMenuChannels(void);
+    void SetTokenContainer(void);
+    void SetCurrentElement(cCeMenuChannels *cur) { currentChannel = cur; currentElement = (cViewElement*)cur; };
+    void ClearCurrentElement(void);
+    void Set(const cChannel *channel, bool withProvider);
+    bool Parse(bool forced = true);
+    void RenderCurrent(void);
+};
+
+/******************************************************************
+* cCeMenuChannels
+******************************************************************/
+class cCeMenuChannels : public cCurrentElement {
+private:
+    const cChannel *channel;
+    bool withProvider;
+    int schedulesIndex;
+public:
+    cCeMenuChannels(void);
+    virtual ~cCeMenuChannels(void);
+    void SetTokenContainer(void);
+    void Set(const cChannel *channel, bool withProvider);
+    bool Parse(bool forced = true);
+};
+
+/******************************************************************
+* cLeMenuTimers
+******************************************************************/
+class cCeMenuTimers;
+class cLeMenuTimers : public cListElement {
+private:
+    cCeMenuTimers *currentTimer;
+    const cTimer *timer;
+public:
+    cLeMenuTimers(void);
+    virtual ~cLeMenuTimers(void);
+    void SetTokenContainer(void);
+    void SetCurrentElement(cCeMenuTimers *cur) { currentTimer = cur; currentElement = (cViewElement*)cur; };
+    void ClearCurrentElement(void);
+    void Set(const cTimer *timer);
+    bool Parse(bool forced = true);
+    void RenderCurrent(void);
+};
+
+/******************************************************************
+* cCeMenuTimers
+******************************************************************/
+class cCeMenuTimers : public cCurrentElement {
+private:
+    const cTimer *timer;
+public:
+    cCeMenuTimers(void);
+    virtual ~cCeMenuTimers(void);
+    void SetTokenContainer(void);
+    void Set(const cTimer *timer);
+    bool Parse(bool forced = true);
+};
+
+/******************************************************************
+* cLeMenuRecordings
+******************************************************************/
+class cCeMenuRecordings;
+class cLeMenuRecordings : public cListElement, public cScrapManager {
+private:
+    cCeMenuRecordings *currentRecording;
+    const cRecording *recording;
+    int level;
+    int total;
+    int New;
+    char *RecName(const char *path, int level);
+    char *FolderName(const char *path, int level);
+public:
+    cLeMenuRecordings(void);
+    virtual ~cLeMenuRecordings(void);
+    void SetTokenContainer(void);
+    void SetCurrentElement(cCeMenuRecordings *cur) { currentRecording = cur; currentElement = (cViewElement*)cur; };
+    void ClearCurrentElement(void);
+    void Set(const cRecording *recording, int level, int total, int New);
+    bool Parse(bool forced = true);
+    void RenderCurrent(void);
+};
+
+/******************************************************************
+* cCeMenuRecordings
+******************************************************************/
+class cCeMenuRecordings : public cCurrentElement, public cScrapManager {
+private:
+    const cRecording *recording;
+    int level;
+    int total;
+    int New;
+public:
+    cCeMenuRecordings(void);
+    virtual ~cCeMenuRecordings(void);
+    void SetTokenContainer(void);
+    void Set(const cRecording *recording, int level, int total, int New);
+    bool Parse(bool forced = true);
+};
+
+/******************************************************************
+* cLeMenuPlugin
+******************************************************************/
+class cCeMenuPlugin;
+class cLeMenuPlugin : public cListElement {
+private:
+    int plugId;
+    int plugMenuId;
+    cCeMenuPlugin *currentPlugin;
+public:
+    cLeMenuPlugin(void);
+    virtual ~cLeMenuPlugin(void);
+    void SetTokenContainer(void);
+    void SetPlugId(int id) { plugId = id; };
+    void SetPlugMenuId(int id) { plugMenuId = id; };
+    void SetCurrentElement(cCeMenuPlugin *cur) { currentPlugin = cur; currentElement = (cViewElement*)cur; };
+    void ClearCurrentElement(void);
+    void Set(skindesignerapi::cTokenContainer *tk);
+    bool Parse(bool forced = true);
+    void RenderCurrent(void);
+};
+
+/******************************************************************
+* cCeMenuPlugin
+******************************************************************/
+class cCeMenuPlugin : public cCurrentElement {
+private:
+    int plugId;
+    int plugMenuId;
+public:
+    cCeMenuPlugin(void);
+    virtual ~cCeMenuPlugin(void);
+    void SetTokenContainer(void);
+    void SetPlugId(int id) { plugId = id; };
+    void SetPlugMenuId(int id) { plugMenuId = id; };
+    void Set(skindesignerapi::cTokenContainer *tk);
+    bool Parse(bool forced = true);
+};
+
+/******************************************************************
+* cLeAudioTracks
+******************************************************************/
+class cLeAudioTracks : public cListElement {
+private:
+    char *text;
+public:
+    cLeAudioTracks(void);
+    virtual ~cLeAudioTracks(void);
+    void SetTokenContainer(void);
+    void Set(const char *text);
+    bool Parse(bool forced = true);
+};
+
+#endif //__LISTELEMENTS_H

coreengine/osdwrapper.c

@@ -0,0 +1,71 @@
+#include "osdwrapper.h"
+
+cSdOsd::cSdOsd(void) {
+    osd = NULL;
+    flushLocked = false;
+}
+
+cSdOsd::~cSdOsd(void) {
+    DeleteOsd();
+}
+
+void cSdOsd::Lock(void) {
+    mutex.Lock();
+}
+
+void cSdOsd::Unlock(void) {
+    mutex.Unlock();
+}
+
+void cSdOsd::LockFlush(void) {
+    Lock();
+    flushLocked = true;
+    Unlock();
+}
+
+void cSdOsd::UnlockFlush(void) {
+    Lock();
+    flushLocked = false;
+    Unlock();
+}
+
+bool cSdOsd::CreateOsd(int x, int y, int width, int height) {
+    cOsd *newOsd = cOsdProvider::NewOsd(cOsd::OsdLeft() + x, cOsd::OsdTop() + y);
+    if (newOsd) {
+        tArea Area = { 0, 0, width - 1, height - 1,  32 };
+        if (newOsd->SetAreas(&Area, 1) == oeOk) {
+            Lock();
+            osd = newOsd;
+            Unlock();
+            return true;
+        }
+    }
+    return false;
+}
+
+void cSdOsd::DeleteOsd(void) {
+    Lock();
+    delete osd;
+    osd = NULL;
+    Unlock();
+}
+
+cPixmap *cSdOsd::CreatePixmap(int layer, cRect &viewPort, cRect &drawPort) {
+    if (osd) {
+        return osd->CreatePixmap(layer, viewPort, drawPort);
+    }
+    return NULL;
+}
+
+void cSdOsd::DestroyPixmap(cPixmap *pix) {
+    if (osd) {
+        osd->DestroyPixmap(pix);
+    }
+}
+
+void cSdOsd::Flush(void) {
+    Lock();
+    if (osd && !flushLocked)
+        osd->Flush();
+    Unlock();    
+}

coreengine/osdwrapper.h

@@ -0,0 +1,26 @@
+#ifndef __OSDWRAPPER_H
+#define __OSDWRAPPER_H
+
+#include <vdr/osd.h>
+#include <vdr/thread.h>
+
+class cSdOsd {
+private:
+    cOsd *osd;
+    cMutex mutex;
+    bool flushLocked;
+public:
+    cSdOsd(void);
+    virtual ~cSdOsd(void);
+    void Lock(void);
+    void Unlock(void);
+    void LockFlush(void);
+    void UnlockFlush(void);
+    bool CreateOsd(int x, int y, int width, int height);
+    void DeleteOsd(void);
+    cPixmap *CreatePixmap(int layer, cRect &viewPort, cRect &drawPort);
+    void DestroyPixmap(cPixmap *pix);
+    void Flush(void);
+};
+
+#endif //__OSDWRAPPER_H

coreengine/view.c

@@ -0,0 +1,419 @@
+#include "../config.h"
+#include "view.h"
+
+// --- cView -------------------------------------------------------------
+
+cView::cView(void) {
+    globals = NULL;
+    viewName = NULL;
+    attribs = new cViewAttribs((int)eViewAttribs::count);
+    numViewElements = 0;
+    viewElements = NULL;
+    viewElementsHorizontal = NULL;
+    fader = NULL;
+    shifter = NULL;
+    currentTvFrame = NULL;
+    newTvFrame = NULL;
+    menuInit = false;
+}
+
+cView::~cView() {
+    for (int i=0; i< numViewElements; i++)
+        delete viewElements[i];
+    delete[] viewElements;
+    if (viewElementsHorizontal) {
+        for (int i=0; i< numViewElements; i++)
+            delete viewElementsHorizontal[i];
+        delete[] viewElementsHorizontal;
+    }
+    delete attribs;
+    free(viewName);
+    delete fader;
+    delete shifter;
+    sdOsd.DeleteOsd();
+}
+
+/*******************************************************************
+* Public Functions
+*******************************************************************/
+bool cView::ReadFromXML(void) {
+    const char *xmlFile;
+    switch (viewId) {
+        case eViewType::DisplayChannel:
+            xmlFile = "displaychannel.xml";
+            break;
+        case eViewType::DisplayMenu:
+            xmlFile = "displaymenu.xml";
+            break;
+        case eViewType::DisplayMessage:
+            xmlFile = "displaymessage.xml";
+            break;
+        case eViewType::DisplayReplay:
+            xmlFile = "displayreplay.xml";
+            break;
+        case eViewType::DisplayVolume:
+            xmlFile = "displayvolume.xml";
+            break;
+        case eViewType::DisplayTracks:
+            xmlFile = "displayaudiotracks.xml";
+            break;
+        default:
+            return false;
+    }
+    cXmlParser parser;
+    parser.SetOsd(&sdOsd);
+    if (!parser.ReadView(this, xmlFile)) {
+        return false;
+    }
+    if (!parser.ParseView()) {
+        return false;
+    }
+
+    //read additional plugin menu templates
+    bool ok = true;
+    if (viewId == eViewType::DisplayMenu) {
+        plgManager->InitPluginMenuIterator();
+        map <int,skindesignerapi::sPlugMenu> *plugMenus = NULL;
+        string plugName = "";
+        int plugId = -1;
+        while ( plugMenus = plgManager->GetPluginMenus(plugName, plugId) ) {
+            for (map <int,skindesignerapi::sPlugMenu>::iterator it = plugMenus->begin(); it != plugMenus->end(); it++) {
+                int templateNumber = it->first;
+                int menuType = it->second.type;
+                cString templateName = cString::sprintf("plug-%s-%s", plugName.c_str(), it->second.tplname.c_str());
+                if (parser.ReadPluginView(*templateName)) {
+                    ok = parser.ParsePluginView(plugName, plugId, templateNumber, menuType);
+                } else {
+                    dsyslog("skindesigner: template %s for plugin %s not available", *templateName, plugName.c_str());
+                }
+            }
+        }
+    }
+    return ok;
+}
+
+void cView::SetGlobals(cGlobals *globals) {
+    this->globals = globals;
+    attribs->SetGlobals(globals);
+    for (int i=0; i < numViewElements; ++i) {
+        if (viewElements[i]) {
+            viewElements[i]->SetGlobals(globals);
+        }
+        if (viewElementsHorizontal && viewElementsHorizontal[i]) {
+            viewElementsHorizontal[i]->SetGlobals(globals);
+        }
+    }
+}
+
+void cView::SetContainer(int x, int y, int width, int height) {
+    container.SetX(x);
+    container.SetY(y);
+    container.SetWidth(width);
+    container.SetHeight(height);
+}
+
+void cView::SetAttributes(vector<stringpair> &attributes) { 
+    attribs->Set(attributes); 
+}
+
+void cView::AddViewElement(const char *sViewElement, cViewElement *viewElement) {
+    int id = ViewElementId(sViewElement);
+    if (id == ATTR_UNKNOWN)
+        return;
+    viewElement->SetId(id);    
+    viewElement->SetTokenContainer();
+    eOrientation orientation = viewElement->Orientation();
+    if (viewElementsHorizontal && orientation == eOrientation::horizontal) {
+        viewElementsHorizontal[id] = viewElement;
+    } else {
+        viewElements[id] = viewElement;
+    }
+}
+
+bool cView::ValidViewElement(const char *viewElement) {
+    if (ViewElementId(viewElement) != ATTR_UNKNOWN)
+        return true;
+    return false;
+}
+
+bool cView::ValidViewList(const char *viewList) {
+    if (!strcmp(viewList, "menuitems"))
+        return true;
+    return false;
+}
+
+void cView::PreCache(void) {
+    if (container.Width() == 0) {
+        SetContainer(0, 0, cOsd::OsdWidth(), cOsd::OsdHeight());
+        attribs->SetContainer(0, 0, cOsd::OsdWidth(), cOsd::OsdHeight());
+        attribs->Cache();
+    }
+    //set frame for scaling tv picture
+    tvFrame = attribs->TvFrame();
+    //cache viewelements
+    for (int i=0; i < numViewElements; i++) {
+        if (!viewElements[i])
+            continue;
+        viewElements[i]->SetContainer(0, 0, attribs->Width(), attribs->Height());
+        viewElements[i]->Cache();
+    }
+    if (viewElementsHorizontal) {   
+        for (int i=0; i < numViewElements; i++) {
+            if (!viewElementsHorizontal[i])
+                continue;
+            viewElementsHorizontal[i]->SetContainer(0, 0, attribs->Width(), attribs->Height());
+            viewElementsHorizontal[i]->Cache();
+        }
+    }
+
+    //cleanup viewelements
+    for (int i=0; i < numViewElements; i++) {
+        if (!viewElements[i])
+            continue;
+        if (!viewElements[i]->Execute()) {
+            delete viewElements[i];
+            viewElements[i] = NULL;
+        }
+    }
+    if (viewElementsHorizontal) {   
+        for (int i=0; i < numViewElements; i++) {
+            if (!viewElementsHorizontal[i])
+                continue;
+            if (!viewElementsHorizontal[i]->Execute()) {
+                delete viewElementsHorizontal[i];
+                viewElementsHorizontal[i] = NULL;
+            }
+        }
+    }
+    //set viewelement objects for each view
+    SetViewElementObjects();
+}
+
+bool cView::Init(void) {
+    int osdX = attribs->X();
+    int osdY = attribs->Y();
+    int osdWidth  = attribs->Width();
+    int osdHeight = attribs->Height();
+    return sdOsd.CreateOsd(osdX, osdY, osdWidth, osdHeight);
+}
+
+void cView::Clear(int ve) {
+    if (!viewElements[ve])
+        return;
+    viewElements[ve]->Clear();    
+}
+
+void cView::Render(int ve, bool force) {
+    if (!viewElements[ve])
+        return;
+    if (viewElements[ve]->Parse(force))
+        viewElements[ve]->Render();
+}
+
+void cView::Close(void) {
+    delete fader;
+    fader = NULL;
+    delete shifter;
+    shifter = NULL;
+    if (initFinished && ShiftTime() > 0) {
+        cRect shiftbox = CoveredArea();
+        cPoint ref = cPoint(shiftbox.X(), shiftbox.Y());
+        cPoint end = ShiftStart(shiftbox);
+        shifter = new cAnimation((cShiftable*)this, end, ref, false);
+        shifter->Shift();
+        delete shifter;
+        shifter = NULL;
+    } else if (initFinished && FadeTime() > 0) {
+        fader = new cAnimation((cFadable*)this, false);
+        fader->Fade();
+        delete fader;
+        fader = NULL;
+    }
+    if (initFinished)
+        UnScaleTv();
+    ClearVariables();
+    for (int i=0; i < numViewElements; i++) {
+        if (!viewElements[i])
+            continue;
+        viewElements[i]->Close();
+    }
+    sdOsd.DeleteOsd();
+}
+
+int cView::FadeTime(void) {
+    return attribs->FadeTime();
+}
+
+void cView::SetTransparency(int transparency, bool force) {
+    for (int i = 0; i < numViewElements; i++) {
+        if (viewElements[i] && (!viewElements[i]->Fading() || force)) {
+            viewElements[i]->SetTransparency(transparency);
+        }
+    }
+}
+
+int cView::ShiftTime(void) {
+    return attribs->ShiftTime();
+}
+
+int cView::ShiftMode(void) {
+    return attribs->ShiftMode();
+}
+
+void cView::SetPosition(cPoint &position, cPoint &reference, bool force) {
+    for (int i = 0; i < numViewElements; i++) {
+        if (viewElements[i] && (!viewElements[i]->Shifting() || force)) {
+            viewElements[i]->SetPosition(position, reference);
+        }
+    }
+}
+
+void cView::Flush(void) {
+    if (init) {
+        init = false;
+        StartAnimation();
+        menuInit = true;
+        //LockFlush was set at startup of view to avoid display
+        //of not positioned pixmaps for shifting and fading 
+        sdOsd.UnlockFlush();
+    }
+    if (menuInit) {
+        ScaleTv();
+        WakeViewElements();
+        menuInit = false;
+    }
+    sdOsd.Flush();
+}
+
+void cView::Debug(void) {
+    esyslog("skindesigner: ---> view %s", viewName);
+    for (int i=0; i < numViewElements; i++) {
+        if (!viewElements[i])
+            continue;
+        esyslog("skindesigner: debugging ve %d", i);
+        viewElements[i]->Debug(true);
+    }
+}
+
+/*******************************************************************
+* Protected Functions
+*******************************************************************/
+void cView::ClearVariables(void) { 
+    init = true;
+    initFinished = false;
+    newTvFrame = NULL;
+    currentTvFrame = NULL;
+    menuInit = false;
+}
+
+int cView::ViewElementId(const char *name) {
+    map<string, int>::iterator hit = viewElementNames.find(name);
+    if (hit != viewElementNames.end())
+        return (int)hit->second;
+    return ATTR_UNKNOWN;
+}
+
+void cView::StartAnimation(void) {
+    if (ShiftTime() > 0) {
+        cRect shiftbox = CoveredArea();
+        cPoint ref = cPoint(shiftbox.X(), shiftbox.Y());
+        cPoint start = ShiftStart(shiftbox);
+        SetPosition(start, ref);
+        shifter = new cAnimation((cShiftable*)this, start, ref, true);
+        shifter->Start();
+    } else if (FadeTime() > 0) {
+        if (fader)
+            return;
+        SetTransparency(100);
+        sdOsd.Flush();
+        fader = new cAnimation((cFadable*)this, true);
+        fader->Start();
+    }
+    initFinished = true;
+}
+
+void cView::WakeViewElements(void) {
+    for (int i = 0; i < numViewElements; i++) {
+        if (viewElements[i]) {
+            viewElements[i]->WakeUp();
+        }
+    }
+    if (!viewElementsHorizontal)
+        return;
+    for (int i = 0; i < numViewElements; i++) {
+        if (viewElementsHorizontal[i]) {
+            viewElementsHorizontal[i]->WakeUp();
+        }
+    }
+}
+
+cPoint cView::ShiftStart(cRect &shiftbox) {
+    eShiftType type = (eShiftType)attribs->ShiftType();
+    cPoint start;
+    if (type == eShiftType::none) {
+        start = attribs->ShiftStartpoint();
+    } else if (type == eShiftType::left) {
+        start.SetX(-shiftbox.Width());
+        start.SetY(shiftbox.Y());
+    } else if (type == eShiftType::right) {
+        start.SetX(attribs->Width());
+        start.SetY(shiftbox.Y());        
+    } else if (type == eShiftType::top) {
+        start.SetX(shiftbox.X());
+        start.SetY(-shiftbox.Height());        
+    } else if (type == eShiftType::bottom) {
+        start.SetX(shiftbox.X());
+        start.SetY(attribs->Height());
+    }
+    return start;
+}
+
+cRect cView::CoveredArea(void) {
+    cRect unionArea;
+    for (int i = 0; i < numViewElements; i++) {
+        if (viewElements[i] && !viewElements[i]->Shifting()) {
+            unionArea.Combine(viewElements[i]->CoveredArea());
+        }
+    }
+    return unionArea;
+}
+
+void cView::ScaleTv(void) {
+    bool scale = false;
+    if (newTvFrame) {
+        if (currentTvFrame) {
+            if (*newTvFrame != *currentTvFrame) {
+                scale = true;                
+            }
+        } else {
+            scale = true;
+        }
+        currentTvFrame = newTvFrame;
+    } else {
+        if (tvFrame != cRect::Null) {
+            scale = true;
+            currentTvFrame = &tvFrame;
+        }
+    }
+    if (currentTvFrame && scale) {
+        DoScaleTv(currentTvFrame);
+    }
+}
+
+void cView::UnScaleTv(void) {
+    if (currentTvFrame) {
+        DoScaleTv(&cRect::Null);
+        currentTvFrame = NULL;
+    }
+}
+
+void cView::DoScaleTv(const cRect *frame) {
+    if (*frame == cRect::Null) {
+        cDevice::PrimaryDevice()->ScaleVideo(cRect::Null);
+    } else {
+        cRect scalingWindow = cDevice::PrimaryDevice()->CanScaleVideo(*frame);
+        if (scalingWindow != cRect::Null) {
+            cDevice::PrimaryDevice()->ScaleVideo(scalingWindow);
+        }
+    }
+}

coreengine/view.h

@@ -0,0 +1,93 @@
+#ifndef __VIEW_H
+#define __VIEW_H
+
+#include <iostream>
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdint.h>
+#include <string>
+
+#include "osdwrapper.h"
+#include "globals.h"
+#include "../libskindesignerapi/tokencontainer.h"
+#include "viewelementplugin.h"
+#include "viewelementscommon.h"
+#include "viewelementsdisplaychannel.h"
+#include "viewelementsdisplaymenu.h"
+#include "viewelementsdisplayreplay.h"
+#include "viewelementsdisplaytracks.h"
+#include "viewlist.h"
+class cView;
+#include "xmlparser.h"
+#include "animation.h"
+
+using namespace std;
+
+class cView : public cFadable, public cShiftable {
+private:
+    void DoScaleTv(const cRect *frame);
+protected:
+    cSdOsd sdOsd;
+    cViewAttribs *attribs;
+    cRect container;
+    bool init;
+    bool initFinished;
+    eViewType viewId;
+    cGlobals *globals;
+    char *viewName;
+    int numViewElements;
+    cViewElement **viewElements;
+    cViewElement **viewElementsHorizontal;
+    map<string,int> viewElementNames;
+    cAnimation *fader;
+    cAnimation *shifter;
+    cRect tvFrame;
+    cRect *currentTvFrame;
+    cRect *newTvFrame;
+    bool menuInit;
+    int ViewElementId(const char *name);
+    virtual void ClearVariables(void);
+    virtual void SetViewElementObjects(void) { };
+    virtual void StartAnimation(void);
+    virtual void WakeViewElements(void);
+    cPoint ShiftStart(cRect &shiftbox);
+    virtual cRect CoveredArea(void);
+    void ScaleTv(void);
+    void UnScaleTv(void);
+public:
+    cView(void);
+    virtual ~cView(void);
+    //Loading and Caching functionality
+    bool ReadFromXML(void);
+    virtual void SetGlobals(cGlobals *globals);    
+    const char *GetViewName(void) { return viewName; };
+    void SetContainer(int x, int y, int width, int height);
+    void SetAttributes(vector<stringpair> &attributes);
+    void AddViewElement(const char *sViewElement, cViewElement *viewElement);
+    bool ValidViewElement(const char *viewElement);
+    virtual void AddViewList(cViewList *viewList) { };
+    bool ValidViewList(const char *viewList);
+    virtual void PreCache(void);
+    cRect *GetTvFrame(void) { return &tvFrame; };
+    virtual const cFont *GetTextAreaFont(void) { return NULL; };
+    virtual int GetTextAreaWidth(void) { return 0; };
+    virtual int GetListWidth(void) { return 0; };
+    //View API
+    virtual bool Init(void);
+    void Clear(int ve);
+    void Render(int ve, bool force = false);
+    virtual void Close(void);
+    virtual void Flush(void);
+    virtual void Debug(void);
+    bool Detached(void) { return false; };
+    int Delay(void) { return 0; };
+    //Fadable
+    int FadeTime(void);
+    virtual void SetTransparency(int transparency, bool force = false);
+    //Shiftable
+    int ShiftTime(void);
+    int ShiftMode(void);
+    virtual void SetPosition(cPoint &position, cPoint &reference, bool force = false);
+};
+
+#endif //__VIEW_H

coreengine/viewdetail.c

@@ -0,0 +1,978 @@
+#include "viewdetail.h"
+#include "../config.h"
+/******************************************************************
+* cViewDetail
+******************************************************************/
+cViewDetail::cViewDetail(void) {
+    activeTab = NULL;
+    activeTabIndex = -1;
+    numTabs = 0;
+    plugId = -1;
+    plugMenuId = -1;
+}
+
+cViewDetail::~cViewDetail(void) {
+}
+
+void cViewDetail::SetActiveTab(void) {
+    for (cAreaNode *node = areaNodes.First(); node; node = areaNodes.Next(node)) {
+        if (node->ActiveTab()) {
+            activeTab = dynamic_cast<cArea*>(node);
+            activeTabIndex = 0;
+            return;
+        }
+    }
+}
+
+int cViewDetail::GetWidth(void) {
+    cAreaNode *node = areaNodes.First();
+    if (!node)
+        return 0;
+    return node->GetWidth();
+}
+
+void cViewDetail::ResetTabs(void) {
+    activeTab = NULL;
+    activeTabIndex = -1;
+}
+
+void cViewDetail::Clear(void) {
+    cViewElement::Close();    
+}
+
+void cViewDetail::Close(void) {
+    cViewElement::Close();    
+    activeTab = NULL;
+    activeTabIndex = -1;
+    numTabs = 0;
+}
+
+void cViewDetail::Render(void) {
+    if (!dirty || blocked)
+        return;
+
+    if (attribs->DoDebug())
+        Debug();
+    
+    if (!activeTab)
+        SetActiveTab();
+    if (!activeTab)
+        return;
+
+    activeTab->Clear();
+    if (activeTab->Execute()) {
+        activeTab->Render();
+    }
+
+    dirty = false;
+}
+
+void cViewDetail::Scrollbar(int &barheight, int &offset, bool &end) {
+    if (!activeTab)
+        return;
+    cRect tabViewPort = activeTab->ViewPort();
+    cRect tabDrawPort = activeTab->DrawPort();
+    int totalHeight = tabDrawPort.Height();
+    int screenHeight = tabViewPort.Height();
+    int y = (-1)*tabDrawPort.Y();
+    if (totalHeight == 0) {
+        return;
+    }
+    if (totalHeight <= screenHeight)
+        barheight = 1000;
+    else {
+        barheight = (double)screenHeight / (double) totalHeight * 1000; 
+    }
+    offset = (double)y / (double) totalHeight * 1000;
+    end = true;
+}
+
+bool cViewDetail::ScrollUp(bool page) {
+    if (!activeTab)
+        return false;
+    cRect tabDrawPort = activeTab->DrawPort();
+    int scrollStep = activeTab->ScrollStep();
+    if (page) {
+        cRect tabViewPort = activeTab->ViewPort();
+        scrollStep = tabViewPort.Height();
+    }
+    int aktHeight = tabDrawPort.Y();
+    if (aktHeight >= 0) {
+        return false;
+    }
+    int newY = aktHeight + scrollStep;
+    if (newY > 0)
+        newY = 0;
+    cPoint dp(0, newY);
+    activeTab->SetDrawPort(dp);
+    return true;
+}
+
+bool cViewDetail::ScrollDown(bool page) {
+    if (!activeTab)
+        return false;
+    cRect tabViewPort = activeTab->ViewPort();
+    cRect tabDrawPort = activeTab->DrawPort();
+    int scrollStep = activeTab->ScrollStep();
+    if (page) {
+        scrollStep = tabViewPort.Height();
+    }
+    int aktHeight = tabDrawPort.Y();
+    int totalHeight = tabDrawPort.Height();
+    int screenHeight = tabViewPort.Height();
+
+    if (totalHeight - ((-1)*aktHeight) == screenHeight) {
+        return false;
+    }
+    int newY = aktHeight - scrollStep;
+    if ((-1)*newY > totalHeight - screenHeight)
+        newY = (-1)*(totalHeight - screenHeight);
+    cPoint dp(0, newY);
+    activeTab->SetDrawPort(dp);
+    return true;
+}
+
+int cViewDetail::GetTabs(vector<const char*> &tabs) {
+    int i=0;
+    for (cAreaNode *node = areaNodes.First(); node; node = areaNodes.Next(node)) {
+        if (!node->Execute())
+            continue;
+        tabs.push_back(node->Name());
+        if (node->ActiveTab()) {
+            activeTabIndex = i;
+        }
+        i++;
+    }
+    numTabs = i;
+    return activeTabIndex;
+}
+
+void cViewDetail::NextTab(void) {
+    cArea *nextActiveTab = NULL;
+    for (cAreaNode *node = areaNodes.Next(activeTab); node; node = areaNodes.Next(node)) {
+        if (node->Execute()) {
+            nextActiveTab = dynamic_cast<cArea*>(node);
+            activeTabIndex++;
+            break;
+        }
+    }
+    if (!nextActiveTab) {
+        nextActiveTab = dynamic_cast<cArea*>(areaNodes.First());
+        activeTabIndex = 0;
+    }
+    activeTab = nextActiveTab;
+}
+
+void cViewDetail::PrevTab(void) {
+    cArea *prevActiveTab = NULL;
+    for (cAreaNode *node = areaNodes.Prev(activeTab); node; node = areaNodes.Prev(node)) {
+        if (node->Execute()) {
+            prevActiveTab = dynamic_cast<cArea*>(node);
+            activeTabIndex--;
+            break;
+        }
+    }
+    if (!prevActiveTab) {
+        int numActiveTabs = 0;
+        for (cAreaNode *node = areaNodes.First(); node; node = areaNodes.Next(node)) {
+            if (node->Execute()) {
+                numActiveTabs++;
+            }
+        }
+        for (cAreaNode *node = areaNodes.Last(); node; node = areaNodes.Prev(node)) {
+            if (node->Execute()) {
+                prevActiveTab = dynamic_cast<cArea*>(node);
+                activeTabIndex = numActiveTabs-1;
+                break;
+            }
+        }
+    }
+    activeTab = prevActiveTab;
+}
+
+void cViewDetail::SetTransparency(int transparency, bool forceDetached) {
+    if (activeTab)
+        activeTab->SetTransparency(transparency);
+}
+
+/******************************************************************
+* cViewDetailEpg
+******************************************************************/
+cViewDetailEpg::cViewDetailEpg(void) {
+    event = NULL;
+    rerunsIndex = -1;
+    actorsIndex = -1;
+}
+
+cViewDetailEpg::~cViewDetailEpg(void) {
+}
+
+void cViewDetailEpg::SetTokenContainer(void) {
+    tokenContainer = new skindesignerapi::cTokenContainer();
+    tokenContainer->DefineStringToken("{title}", (int)eDmDetailedEpgST::title);
+    tokenContainer->DefineStringToken("{shorttext}", (int)eDmDetailedEpgST::shorttext);
+    tokenContainer->DefineStringToken("{description}", (int)eDmDetailedEpgST::description);
+    tokenContainer->DefineStringToken("{start}", (int)eDmDetailedEpgST::start);
+    tokenContainer->DefineStringToken("{stop}", (int)eDmDetailedEpgST::stop);
+    tokenContainer->DefineStringToken("{day}", (int)eDmDetailedEpgST::day);
+    tokenContainer->DefineStringToken("{date}", (int)eDmDetailedEpgST::date);
+    tokenContainer->DefineStringToken("{durationminutes}", (int)eDmDetailedEpgST::durationminutes);
+    tokenContainer->DefineStringToken("{vps}", (int)eDmDetailedEpgST::vps);
+    tokenContainer->DefineStringToken("{channelname}", (int)eDmDetailedEpgST::channelname);
+    tokenContainer->DefineStringToken("{channelid}", (int)eDmDetailedEpgST::channelid);
+    tokenContainer->DefineStringToken("{epgpic1path}", (int)eDmDetailedEpgST::epgpic1path);
+    tokenContainer->DefineStringToken("{epgpic2path}", (int)eDmDetailedEpgST::epgpic2path);
+    tokenContainer->DefineStringToken("{epgpic3path}", (int)eDmDetailedEpgST::epgpic3path);
+    tokenContainer->DefineStringToken("{movietitle}", (int)eScraperST::movietitle);
+    tokenContainer->DefineStringToken("{movieoriginalTitle}", (int)eScraperST::movieoriginalTitle);
+    tokenContainer->DefineStringToken("{movietagline}", (int)eScraperST::movietagline);
+    tokenContainer->DefineStringToken("{movieoverview}", (int)eScraperST::movieoverview);
+    tokenContainer->DefineStringToken("{moviegenres}", (int)eScraperST::moviegenres);
+    tokenContainer->DefineStringToken("{moviehomepage}", (int)eScraperST::moviehomepage);
+    tokenContainer->DefineStringToken("{moviereleasedate}", (int)eScraperST::moviereleasedate);
+    tokenContainer->DefineStringToken("{moviepopularity}", (int)eScraperST::moviepopularity);
+    tokenContainer->DefineStringToken("{movievoteaverage}", (int)eScraperST::movievoteaverage);
+    tokenContainer->DefineStringToken("{posterpath}", (int)eScraperST::posterpath);
+    tokenContainer->DefineStringToken("{fanartpath}", (int)eScraperST::fanartpath);
+    tokenContainer->DefineStringToken("{moviecollectionName}", (int)eScraperST::moviecollectionName);
+    tokenContainer->DefineStringToken("{collectionposterpath}", (int)eScraperST::collectionposterpath);
+    tokenContainer->DefineStringToken("{collectionfanartpath}", (int)eScraperST::collectionfanartpath);
+    tokenContainer->DefineStringToken("{seriesname}", (int)eScraperST::seriesname);
+    tokenContainer->DefineStringToken("{seriesoverview}", (int)eScraperST::seriesoverview);
+    tokenContainer->DefineStringToken("{seriesfirstaired}", (int)eScraperST::seriesfirstaired);
+    tokenContainer->DefineStringToken("{seriesnetwork}", (int)eScraperST::seriesnetwork);
+    tokenContainer->DefineStringToken("{seriesgenre}", (int)eScraperST::seriesgenre);
+    tokenContainer->DefineStringToken("{seriesrating}", (int)eScraperST::seriesrating);
+    tokenContainer->DefineStringToken("{seriesstatus}", (int)eScraperST::seriesstatus);
+    tokenContainer->DefineStringToken("{episodetitle}", (int)eScraperST::episodetitle);
+    tokenContainer->DefineStringToken("{episodefirstaired}", (int)eScraperST::episodefirstaired);
+    tokenContainer->DefineStringToken("{episodegueststars}", (int)eScraperST::episodegueststars);
+    tokenContainer->DefineStringToken("{episodeoverview}", (int)eScraperST::episodeoverview);
+    tokenContainer->DefineStringToken("{episoderating}", (int)eScraperST::episoderating);
+    tokenContainer->DefineStringToken("{episodeimagepath}", (int)eScraperST::episodeimagepath);
+    tokenContainer->DefineStringToken("{seasonposterpath}", (int)eScraperST::seasonposterpath);
+    tokenContainer->DefineStringToken("{seriesposter1path}", (int)eScraperST::seriesposter1path);
+    tokenContainer->DefineStringToken("{seriesposter2path}", (int)eScraperST::seriesposter2path);
+    tokenContainer->DefineStringToken("{seriesposter3path}", (int)eScraperST::seriesposter3path);
+    tokenContainer->DefineStringToken("{seriesfanart1path}", (int)eScraperST::seriesfanart1path);
+    tokenContainer->DefineStringToken("{seriesfanart2path}", (int)eScraperST::seriesfanart2path);
+    tokenContainer->DefineStringToken("{seriesfanart3path}", (int)eScraperST::seriesfanart3path);
+    tokenContainer->DefineStringToken("{seriesbanner1path}", (int)eScraperST::seriesbanner1path);
+    tokenContainer->DefineStringToken("{seriesbanner2path}", (int)eScraperST::seriesbanner2path);
+    tokenContainer->DefineStringToken("{seriesbanner3path}", (int)eScraperST::seriesbanner3path);
+    tokenContainer->DefineIntToken("{daynumeric}", (int)eDmDetailedEpgIT::daynumeric);
+    tokenContainer->DefineIntToken("{month}", (int)eDmDetailedEpgIT::month);
+    tokenContainer->DefineIntToken("{year}", (int)eDmDetailedEpgIT::year);
+    tokenContainer->DefineIntToken("{running}", (int)eDmDetailedEpgIT::running);
+    tokenContainer->DefineIntToken("{elapsed}", (int)eDmDetailedEpgIT::elapsed);
+    tokenContainer->DefineIntToken("{duration}", (int)eDmDetailedEpgIT::duration);
+    tokenContainer->DefineIntToken("{durationhours}", (int)eDmDetailedEpgIT::durationhours);
+    tokenContainer->DefineIntToken("{channelnumber}", (int)eDmDetailedEpgIT::channelnumber);
+    tokenContainer->DefineIntToken("{channellogoexists}", (int)eDmDetailedEpgIT::channellogoexists);
+    tokenContainer->DefineIntToken("{hasreruns}", (int)eDmDetailedEpgIT::hasreruns);
+    tokenContainer->DefineIntToken("{epgpic1avaialble}", (int)eDmDetailedEpgIT::epgpic1avaialble);
+    tokenContainer->DefineIntToken("{epgpic2avaialble}", (int)eDmDetailedEpgIT::epgpic2avaialble);
+    tokenContainer->DefineIntToken("{epgpic3avaialble}", (int)eDmDetailedEpgIT::epgpic3avaialble);
+    tokenContainer->DefineIntToken("{ismovie}", (int)eScraperIT::ismovie);
+    tokenContainer->DefineIntToken("{moviebudget}", (int)eScraperIT::moviebudget);
+    tokenContainer->DefineIntToken("{movierevenue}", (int)eScraperIT::movierevenue);
+    tokenContainer->DefineIntToken("{movieadult}", (int)eScraperIT::movieadult);
+    tokenContainer->DefineIntToken("{movieruntime}", (int)eScraperIT::movieruntime);
+    tokenContainer->DefineIntToken("{isseries}", (int)eScraperIT::isseries);
+    tokenContainer->DefineIntToken("{posterwidth}", (int)eScraperIT::posterwidth);
+    tokenContainer->DefineIntToken("{posterheight}", (int)eScraperIT::posterheight);
+    tokenContainer->DefineIntToken("{fanartwidth}", (int)eScraperIT::fanartwidth);
+    tokenContainer->DefineIntToken("{fanartheight}", (int)eScraperIT::fanartheight);
+    tokenContainer->DefineIntToken("{movieiscollection}", (int)eScraperIT::movieiscollection);
+    tokenContainer->DefineIntToken("{collectionposterwidth}", (int)eScraperIT::collectionposterwidth);
+    tokenContainer->DefineIntToken("{collectionposterheight}", (int)eScraperIT::collectionposterheight);
+    tokenContainer->DefineIntToken("{collectionfanartwidth}", (int)eScraperIT::collectionfanartwidth);
+    tokenContainer->DefineIntToken("{collectionfanartheight}", (int)eScraperIT::collectionfanartheight);
+    tokenContainer->DefineIntToken("{epgpicavailable}", (int)eScraperIT::epgpicavailable);
+    tokenContainer->DefineIntToken("{episodenumber}", (int)eScraperIT::episodenumber);
+    tokenContainer->DefineIntToken("{episodeseason}", (int)eScraperIT::episodeseason);
+    tokenContainer->DefineIntToken("{episodeimagewidth}", (int)eScraperIT::episodeimagewidth);
+    tokenContainer->DefineIntToken("{episodeimageheight}", (int)eScraperIT::episodeimageheight);
+    tokenContainer->DefineIntToken("{seasonposterwidth}", (int)eScraperIT::seasonposterwidth);
+    tokenContainer->DefineIntToken("{seasonposterheight}", (int)eScraperIT::seasonposterheight);
+    tokenContainer->DefineIntToken("{seriesposter1width}", (int)eScraperIT::seriesposter1width);
+    tokenContainer->DefineIntToken("{seriesposter1height}", (int)eScraperIT::seriesposter1height);
+    tokenContainer->DefineIntToken("{seriesposter2width}", (int)eScraperIT::seriesposter2width);
+    tokenContainer->DefineIntToken("{seriesposter2height}", (int)eScraperIT::seriesposter2height);
+    tokenContainer->DefineIntToken("{seriesposter3width}", (int)eScraperIT::seriesposter3width);
+    tokenContainer->DefineIntToken("{seriesposter3height}", (int)eScraperIT::seriesposter3height);
+    tokenContainer->DefineIntToken("{seriesfanart1width}", (int)eScraperIT::seriesfanart1width);
+    tokenContainer->DefineIntToken("{seriesfanart1height}", (int)eScraperIT::seriesfanart1height);
+    tokenContainer->DefineIntToken("{seriesfanart2width}", (int)eScraperIT::seriesfanart2width);
+    tokenContainer->DefineIntToken("{seriesfanart2height}", (int)eScraperIT::seriesfanart2height);
+    tokenContainer->DefineIntToken("{seriesfanart3width}", (int)eScraperIT::seriesfanart3width);
+    tokenContainer->DefineIntToken("{seriesfanart3height}", (int)eScraperIT::seriesfanart3height);
+    tokenContainer->DefineIntToken("{seriesbanner1width}", (int)eScraperIT::seriesbanner1width);
+    tokenContainer->DefineIntToken("{seriesbanner1height}", (int)eScraperIT::seriesbanner1height);
+    tokenContainer->DefineIntToken("{seriesbanner2width}", (int)eScraperIT::seriesbanner2width);
+    tokenContainer->DefineIntToken("{seriesbanner2height}", (int)eScraperIT::seriesbanner2height);
+    tokenContainer->DefineIntToken("{seriesbanner3width}", (int)eScraperIT::seriesbanner3width);
+    tokenContainer->DefineIntToken("{seriesbanner3height}", (int)eScraperIT::seriesbanner3height);
+    tokenContainer->DefineLoopToken("{reruns[title]}", (int)eRerunsLT::title);
+    tokenContainer->DefineLoopToken("{reruns[shorttext]}", (int)eRerunsLT::shorttext);
+    tokenContainer->DefineLoopToken("{reruns[date]}", (int)eRerunsLT::date);
+    tokenContainer->DefineLoopToken("{reruns[day]}", (int)eRerunsLT::day);
+    tokenContainer->DefineLoopToken("{reruns[start]}", (int)eRerunsLT::start);
+    tokenContainer->DefineLoopToken("{reruns[stop]}", (int)eRerunsLT::stop);
+    tokenContainer->DefineLoopToken("{reruns[channelname]}", (int)eRerunsLT::channelname);
+    tokenContainer->DefineLoopToken("{reruns[channelnumber]}", (int)eRerunsLT::channelnumber);
+    tokenContainer->DefineLoopToken("{reruns[channelid]}", (int)eRerunsLT::channelid);
+    tokenContainer->DefineLoopToken("{reruns[channellogoexists]}", (int)eRerunsLT::channellogoexists);
+    tokenContainer->DefineLoopToken("{actors[name]}", (int)eScraperLT::name);
+    tokenContainer->DefineLoopToken("{actors[role]}", (int)eScraperLT::role);
+    tokenContainer->DefineLoopToken("{actors[thumb]}", (int)eScraperLT::thumb);
+    tokenContainer->DefineLoopToken("{actors[thumbwidth]}", (int)eScraperLT::thumbwidth);
+    tokenContainer->DefineLoopToken("{actors[thumbheight]}", (int)eScraperLT::thumbheight);
+    rerunsIndex = tokenContainer->LoopIndex("reruns");
+    actorsIndex = tokenContainer->LoopIndex("actors");
+    InheritTokenContainer();
+}
+
+bool cViewDetailEpg::Parse(bool forced) {
+    if (!cViewElement::Parse())
+        return false;
+    if (!event)
+        return false;
+
+    tokenContainer->Clear();
+    tokenContainer->AddStringToken((int)eDmDetailedEpgST::title, event->Title());
+    tokenContainer->AddStringToken((int)eDmDetailedEpgST::shorttext, event->ShortText());
+    tokenContainer->AddStringToken((int)eDmDetailedEpgST::description, event->Description());
+    tokenContainer->AddStringToken((int)eDmDetailedEpgST::start, *(event->GetTimeString()));
+    tokenContainer->AddStringToken((int)eDmDetailedEpgST::stop, *(event->GetEndTimeString()));
+    time_t startTime = event->StartTime();
+    tokenContainer->AddStringToken((int)eDmDetailedEpgST::day, *WeekDayName(startTime));
+    tokenContainer->AddStringToken((int)eDmDetailedEpgST::date, *ShortDateString(startTime));
+    struct tm * sStartTime = localtime(&startTime);
+    tokenContainer->AddIntToken((int)eDmDetailedEpgIT::year, sStartTime->tm_year + 1900);
+    tokenContainer->AddIntToken((int)eDmDetailedEpgIT::daynumeric, sStartTime->tm_mday);
+    tokenContainer->AddIntToken((int)eDmDetailedEpgIT::month, sStartTime->tm_mon+1);
+    const cChannel *channel = Channels.GetByChannelID(event->ChannelID());
+    if (channel) {
+        tokenContainer->AddStringToken((int)eDmDetailedEpgST::channelname, channel->Name());
+        tokenContainer->AddIntToken((int)eDmDetailedEpgIT::channelnumber, channel->Number());
+    }
+    cString channelID = event->ChannelID().ToString();
+    tokenContainer->AddStringToken((int)eDmDetailedEpgST::channelid, *channelID);
+    tokenContainer->AddIntToken((int)eDmDetailedEpgIT::channellogoexists, imgCache->LogoExists(*channelID));
+
+    bool isRunning = false;
+    time_t now = time(NULL);
+    if ((now >= event->StartTime()) && (now <= event->EndTime()))
+        isRunning = true;
+    tokenContainer->AddIntToken((int)eDmDetailedEpgIT::running, isRunning);
+    if (isRunning) {
+        tokenContainer->AddIntToken((int)eDmDetailedEpgIT::elapsed, (now - event->StartTime())/60);
+    } else {
+        tokenContainer->AddIntToken((int)eDmDetailedEpgIT::elapsed, 0);
+    }
+    tokenContainer->AddIntToken((int)eDmDetailedEpgIT::duration, event->Duration() / 60);
+    tokenContainer->AddIntToken((int)eDmDetailedEpgIT::durationhours, event->Duration() / 3600);
+    tokenContainer->AddStringToken((int)eDmDetailedEpgST::durationminutes, *cString::sprintf("%.2d", (event->Duration() / 60)%60));
+    if (event->Vps())
+        tokenContainer->AddStringToken((int)eDmDetailedEpgST::vps, *event->GetVpsString());
+
+    cList<Epgsearch_searchresults_v1_0::cServiceSearchResult> *reruns = LoadReruns();
+    int numReruns = NumReruns(reruns);
+    vector<int> loopInfo;
+    //num reruns
+    loopInfo.push_back(numReruns);
+    //num actors
+    bool scrapInfoAvailable = LoadFullScrapInfo(event, NULL);
+    int numActors = NumActors();
+    loopInfo.push_back(numActors);
+    tokenContainer->CreateLoopTokenContainer(&loopInfo);
+    if (numReruns > 0) {
+        tokenContainer->AddIntToken((int)eDmDetailedEpgIT::hasreruns, 1);
+        SetReruns(reruns);
+    }
+    if (scrapInfoAvailable) {
+        SetFullScrapInfo(tokenContainer, actorsIndex);
+    }
+    SetDirty();
+    return true;
+}
+
+cList<Epgsearch_searchresults_v1_0::cServiceSearchResult> *cViewDetailEpg::LoadReruns(void) {
+    cPlugin *epgSearchPlugin = cPluginManager::GetPlugin("epgsearch");
+    if (!epgSearchPlugin)
+        return NULL;
+
+    if (isempty(event->Title()))
+        return NULL;
+
+    Epgsearch_searchresults_v1_0 data;
+    data.query = (char*)event->Title();
+    data.mode = 0;
+    data.channelNr = 0;
+    data.useTitle = true;
+    data.useSubTitle = true;
+    data.useDescription = false;
+
+    cList<Epgsearch_searchresults_v1_0::cServiceSearchResult> *result = NULL;
+    if (epgSearchPlugin->Service("Epgsearch-searchresults-v1.0", &data))
+        result = data.pResultList;
+    return result;
+}
+
+int cViewDetailEpg::NumReruns(cList<Epgsearch_searchresults_v1_0::cServiceSearchResult> *reruns) {
+    if (!reruns || reruns->Count() < 2)
+        return 0;
+
+    int maxNumReruns = config.rerunAmount;
+    int rerunDistance = config.rerunDistance * 3600;
+    int rerunMaxChannel = config.rerunMaxChannel;
+
+    int i = 0;
+    for (Epgsearch_searchresults_v1_0::cServiceSearchResult *r = reruns->First(); r && i < maxNumReruns; r = reruns->Next(r)) {
+        time_t eventStart = event->StartTime();
+        time_t rerunStart = r->event->StartTime();
+        cChannel *channel = Channels.GetByChannelID(r->event->ChannelID(), true, true);
+        //check for identical event
+        if ((event->ChannelID() == r->event->ChannelID()) && (eventStart == rerunStart))
+            continue;
+        //check for timely distance
+        if (rerunDistance > 0)
+            if (rerunStart - eventStart < rerunDistance)
+                continue;
+        //check for maxchannel
+        if (rerunMaxChannel > 0)
+            if (channel && channel->Number() > rerunMaxChannel)
+                continue;
+        i++;
+    }
+    return i;
+}
+
+void cViewDetailEpg::SetReruns(cList<Epgsearch_searchresults_v1_0::cServiceSearchResult> *reruns) {
+    if (!reruns || reruns->Count() < 2)
+        return;
+
+    int maxNumReruns = config.rerunAmount;
+    int rerunDistance = config.rerunDistance * 3600;
+    int rerunMaxChannel = config.rerunMaxChannel;
+
+    int i = 0;
+    for (Epgsearch_searchresults_v1_0::cServiceSearchResult *r = reruns->First(); r && i < maxNumReruns; r = reruns->Next(r)) {
+        time_t eventStart = event->StartTime();
+        time_t rerunStart = r->event->StartTime();
+        cChannel *channel = Channels.GetByChannelID(r->event->ChannelID(), true, true);
+        //check for identical event
+        if ((event->ChannelID() == r->event->ChannelID()) && (eventStart == rerunStart))
+            continue;
+        //check for timely distance
+        if (rerunDistance > 0)
+            if (rerunStart - eventStart < rerunDistance)
+                continue;
+        //check for maxchannel
+        if (rerunMaxChannel > 0)
+            if (channel && channel->Number() > rerunMaxChannel)
+                continue;
+        tokenContainer->AddLoopToken(rerunsIndex, i, (int)eRerunsLT::title, r->event->Title());
+        tokenContainer->AddLoopToken(rerunsIndex, i, (int)eRerunsLT::shorttext, r->event->ShortText());
+        tokenContainer->AddLoopToken(rerunsIndex, i, (int)eRerunsLT::start, *(r->event->GetTimeString()));
+        tokenContainer->AddLoopToken(rerunsIndex, i, (int)eRerunsLT::stop, *(r->event->GetEndTimeString()));
+        tokenContainer->AddLoopToken(rerunsIndex, i, (int)eRerunsLT::date, *ShortDateString(r->event->StartTime()));
+        tokenContainer->AddLoopToken(rerunsIndex, i, (int)eRerunsLT::day, *WeekDayName(r->event->StartTime()));
+        cString channelID = r->event->ChannelID().ToString();
+        tokenContainer->AddLoopToken(rerunsIndex, i, (int)eRerunsLT::channelid, *channelID);
+        bool logoExists = imgCache->LogoExists(*channelID);
+        tokenContainer->AddLoopToken(rerunsIndex, i, (int)eRerunsLT::channellogoexists, logoExists ? "1" : "0");
+        if (channel) {
+            cString channelNumber = cString::sprintf("%d", channel->Number());
+            tokenContainer->AddLoopToken(rerunsIndex, i, (int)eRerunsLT::channelname, channel->ShortName(true));
+            tokenContainer->AddLoopToken(rerunsIndex, i, (int)eRerunsLT::channelnumber, *channelNumber);
+        } else {
+            tokenContainer->AddLoopToken(rerunsIndex, i, (int)eRerunsLT::channelname, "");
+            tokenContainer->AddLoopToken(rerunsIndex, i, (int)eRerunsLT::channelnumber, "");
+        }
+        i++;
+    }
+}
+
+/******************************************************************
+* cViewDetailRec
+******************************************************************/
+cViewDetailRec::cViewDetailRec(void) {
+    recording = NULL;
+    actorsIndex = -1;
+}
+
+cViewDetailRec::~cViewDetailRec(void) {
+}
+
+void cViewDetailRec::SetTokenContainer(void) {
+    tokenContainer = new skindesignerapi::cTokenContainer();
+    tokenContainer->DefineStringToken("{name}", (int)eDmDetailedRecST::name);
+    tokenContainer->DefineStringToken("{epgname}", (int)eDmDetailedRecST::epgname);
+    tokenContainer->DefineStringToken("{shorttext}", (int)eDmDetailedRecST::shorttext);
+    tokenContainer->DefineStringToken("{description}", (int)eDmDetailedRecST::description);
+    tokenContainer->DefineStringToken("{day}", (int)eDmDetailedRecST::day);
+    tokenContainer->DefineStringToken("{date}", (int)eDmDetailedRecST::date);
+    tokenContainer->DefineStringToken("{time}", (int)eDmDetailedRecST::time);
+    tokenContainer->DefineStringToken("{durationminutes}", (int)eDmDetailedRecST::durationminutes);
+    tokenContainer->DefineStringToken("{durationeventminutes}", (int)eDmDetailedRecST::durationeventminutes);
+    tokenContainer->DefineStringToken("{recchannelname}", (int)eDmDetailedRecST::recchannelname);
+    tokenContainer->DefineStringToken("{recchannelid}", (int)eDmDetailedRecST::recchannelid);
+    tokenContainer->DefineStringToken("{recordingsize}", (int)eDmDetailedRecST::recordingsize);
+    tokenContainer->DefineStringToken("{recordingsizecutted}", (int)eDmDetailedRecST::recordingsizecutted);
+    tokenContainer->DefineStringToken("{recordinglength}", (int)eDmDetailedRecST::recordinglength);
+    tokenContainer->DefineStringToken("{recordinglengthcutted}", (int)eDmDetailedRecST::recordinglengthcutted);
+    tokenContainer->DefineStringToken("{recordingbitrate}", (int)eDmDetailedRecST::recordingbitrate);
+    tokenContainer->DefineStringToken("{recordingformat}", (int)eDmDetailedRecST::recordingformat);
+    tokenContainer->DefineStringToken("{searchtimer}", (int)eDmDetailedRecST::searchtimer);
+    tokenContainer->DefineStringToken("{recimg1path}", (int)eDmDetailedRecST::recimg1path);
+    tokenContainer->DefineStringToken("{recimg2path}", (int)eDmDetailedRecST::recimg2path);
+    tokenContainer->DefineStringToken("{recimg3path}", (int)eDmDetailedRecST::recimg3path);
+    tokenContainer->DefineStringToken("{movietitle}", (int)eScraperST::movietitle);
+    tokenContainer->DefineStringToken("{movieoriginalTitle}", (int)eScraperST::movieoriginalTitle);
+    tokenContainer->DefineStringToken("{movietagline}", (int)eScraperST::movietagline);
+    tokenContainer->DefineStringToken("{movieoverview}", (int)eScraperST::movieoverview);
+    tokenContainer->DefineStringToken("{moviegenres}", (int)eScraperST::moviegenres);
+    tokenContainer->DefineStringToken("{moviehomepage}", (int)eScraperST::moviehomepage);
+    tokenContainer->DefineStringToken("{moviereleasedate}", (int)eScraperST::moviereleasedate);
+    tokenContainer->DefineStringToken("{moviepopularity}", (int)eScraperST::moviepopularity);
+    tokenContainer->DefineStringToken("{movievoteaverage}", (int)eScraperST::movievoteaverage);
+    tokenContainer->DefineStringToken("{posterpath}", (int)eScraperST::posterpath);
+    tokenContainer->DefineStringToken("{fanartpath}", (int)eScraperST::fanartpath);
+    tokenContainer->DefineStringToken("{moviecollectionName}", (int)eScraperST::moviecollectionName);
+    tokenContainer->DefineStringToken("{collectionposterpath}", (int)eScraperST::collectionposterpath);
+    tokenContainer->DefineStringToken("{collectionfanartpath}", (int)eScraperST::collectionfanartpath);
+    tokenContainer->DefineStringToken("{seriesname}", (int)eScraperST::seriesname);
+    tokenContainer->DefineStringToken("{seriesoverview}", (int)eScraperST::seriesoverview);
+    tokenContainer->DefineStringToken("{seriesfirstaired}", (int)eScraperST::seriesfirstaired);
+    tokenContainer->DefineStringToken("{seriesnetwork}", (int)eScraperST::seriesnetwork);
+    tokenContainer->DefineStringToken("{seriesgenre}", (int)eScraperST::seriesgenre);
+    tokenContainer->DefineStringToken("{seriesrating}", (int)eScraperST::seriesrating);
+    tokenContainer->DefineStringToken("{seriesstatus}", (int)eScraperST::seriesstatus);
+    tokenContainer->DefineStringToken("{episodetitle}", (int)eScraperST::episodetitle);
+    tokenContainer->DefineStringToken("{episodefirstaired}", (int)eScraperST::episodefirstaired);
+    tokenContainer->DefineStringToken("{episodegueststars}", (int)eScraperST::episodegueststars);
+    tokenContainer->DefineStringToken("{episodeoverview}", (int)eScraperST::episodeoverview);
+    tokenContainer->DefineStringToken("{episoderating}", (int)eScraperST::episoderating);
+    tokenContainer->DefineStringToken("{episodeimagepath}", (int)eScraperST::episodeimagepath);
+    tokenContainer->DefineStringToken("{seasonposterpath}", (int)eScraperST::seasonposterpath);
+    tokenContainer->DefineStringToken("{seriesposter1path}", (int)eScraperST::seriesposter1path);
+    tokenContainer->DefineStringToken("{seriesposter2path}", (int)eScraperST::seriesposter2path);
+    tokenContainer->DefineStringToken("{seriesposter3path}", (int)eScraperST::seriesposter3path);
+    tokenContainer->DefineStringToken("{seriesfanart1path}", (int)eScraperST::seriesfanart1path);
+    tokenContainer->DefineStringToken("{seriesfanart2path}", (int)eScraperST::seriesfanart2path);
+    tokenContainer->DefineStringToken("{seriesfanart3path}", (int)eScraperST::seriesfanart3path);
+    tokenContainer->DefineStringToken("{seriesbanner1path}", (int)eScraperST::seriesbanner1path);
+    tokenContainer->DefineStringToken("{seriesbanner2path}", (int)eScraperST::seriesbanner2path);
+    tokenContainer->DefineStringToken("{seriesbanner3path}", (int)eScraperST::seriesbanner3path);
+    tokenContainer->DefineIntToken("{daynumeric}", (int)eDmDetailedRecIT::daynumeric);
+    tokenContainer->DefineIntToken("{month}", (int)eDmDetailedRecIT::month);
+    tokenContainer->DefineIntToken("{year}", (int)eDmDetailedRecIT::year);
+    tokenContainer->DefineIntToken("{duration}", (int)eDmDetailedRecIT::duration);
+    tokenContainer->DefineIntToken("{durationhours}", (int)eDmDetailedRecIT::durationhours);
+    tokenContainer->DefineIntToken("{durationevent}", (int)eDmDetailedRecIT::durationevent);
+    tokenContainer->DefineIntToken("{durationeventhours}", (int)eDmDetailedRecIT::durationeventhours);
+    tokenContainer->DefineIntToken("{recchannelnumber}", (int)eDmDetailedRecIT::recchannelnumber);
+    tokenContainer->DefineIntToken("{cutted}", (int)eDmDetailedRecIT::cutted);
+    tokenContainer->DefineIntToken("{recimg1avaialble}", (int)eDmDetailedRecIT::recimg1avaialble);
+    tokenContainer->DefineIntToken("{recimg2avaialble}", (int)eDmDetailedRecIT::recimg2avaialble);
+    tokenContainer->DefineIntToken("{recimg3avaialble}", (int)eDmDetailedRecIT::recimg3avaialble);
+    tokenContainer->DefineIntToken("{ismovie}", (int)eScraperIT::ismovie);
+    tokenContainer->DefineIntToken("{moviebudget}", (int)eScraperIT::moviebudget);
+    tokenContainer->DefineIntToken("{movierevenue}", (int)eScraperIT::movierevenue);
+    tokenContainer->DefineIntToken("{movieadult}", (int)eScraperIT::movieadult);
+    tokenContainer->DefineIntToken("{movieruntime}", (int)eScraperIT::movieruntime);
+    tokenContainer->DefineIntToken("{isseries}", (int)eScraperIT::isseries);
+    tokenContainer->DefineIntToken("{posterwidth}", (int)eScraperIT::posterwidth);
+    tokenContainer->DefineIntToken("{posterheight}", (int)eScraperIT::posterheight);
+    tokenContainer->DefineIntToken("{fanartwidth}", (int)eScraperIT::fanartwidth);
+    tokenContainer->DefineIntToken("{fanartheight}", (int)eScraperIT::fanartheight);
+    tokenContainer->DefineIntToken("{movieiscollection}", (int)eScraperIT::movieiscollection);
+    tokenContainer->DefineIntToken("{collectionposterwidth}", (int)eScraperIT::collectionposterwidth);
+    tokenContainer->DefineIntToken("{collectionposterheight}", (int)eScraperIT::collectionposterheight);
+    tokenContainer->DefineIntToken("{collectionfanartwidth}", (int)eScraperIT::collectionfanartwidth);
+    tokenContainer->DefineIntToken("{collectionfanartheight}", (int)eScraperIT::collectionfanartheight);
+    tokenContainer->DefineIntToken("{epgpicavailable}", (int)eScraperIT::epgpicavailable);
+    tokenContainer->DefineIntToken("{episodenumber}", (int)eScraperIT::episodenumber);
+    tokenContainer->DefineIntToken("{episodeseason}", (int)eScraperIT::episodeseason);
+    tokenContainer->DefineIntToken("{episodeimagewidth}", (int)eScraperIT::episodeimagewidth);
+    tokenContainer->DefineIntToken("{episodeimageheight}", (int)eScraperIT::episodeimageheight);
+    tokenContainer->DefineIntToken("{seasonposterwidth}", (int)eScraperIT::seasonposterwidth);
+    tokenContainer->DefineIntToken("{seasonposterheight}", (int)eScraperIT::seasonposterheight);
+    tokenContainer->DefineIntToken("{seriesposter1width}", (int)eScraperIT::seriesposter1width);
+    tokenContainer->DefineIntToken("{seriesposter1height}", (int)eScraperIT::seriesposter1height);
+    tokenContainer->DefineIntToken("{seriesposter2width}", (int)eScraperIT::seriesposter2width);
+    tokenContainer->DefineIntToken("{seriesposter2height}", (int)eScraperIT::seriesposter2height);
+    tokenContainer->DefineIntToken("{seriesposter3width}", (int)eScraperIT::seriesposter3width);
+    tokenContainer->DefineIntToken("{seriesposter3height}", (int)eScraperIT::seriesposter3height);
+    tokenContainer->DefineIntToken("{seriesfanart1width}", (int)eScraperIT::seriesfanart1width);
+    tokenContainer->DefineIntToken("{seriesfanart1height}", (int)eScraperIT::seriesfanart1height);
+    tokenContainer->DefineIntToken("{seriesfanart2width}", (int)eScraperIT::seriesfanart2width);
+    tokenContainer->DefineIntToken("{seriesfanart2height}", (int)eScraperIT::seriesfanart2height);
+    tokenContainer->DefineIntToken("{seriesfanart3width}", (int)eScraperIT::seriesfanart3width);
+    tokenContainer->DefineIntToken("{seriesfanart3height}", (int)eScraperIT::seriesfanart3height);
+    tokenContainer->DefineIntToken("{seriesbanner1width}", (int)eScraperIT::seriesbanner1width);
+    tokenContainer->DefineIntToken("{seriesbanner1height}", (int)eScraperIT::seriesbanner1height);
+    tokenContainer->DefineIntToken("{seriesbanner2width}", (int)eScraperIT::seriesbanner2width);
+    tokenContainer->DefineIntToken("{seriesbanner2height}", (int)eScraperIT::seriesbanner2height);
+    tokenContainer->DefineIntToken("{seriesbanner3width}", (int)eScraperIT::seriesbanner3width);
+    tokenContainer->DefineIntToken("{seriesbanner3height}", (int)eScraperIT::seriesbanner3height);
+    tokenContainer->DefineLoopToken("{actors[name]}", (int)eScraperLT::name);
+    tokenContainer->DefineLoopToken("{actors[role]}", (int)eScraperLT::role);
+    tokenContainer->DefineLoopToken("{actors[thumb]}", (int)eScraperLT::thumb);
+    tokenContainer->DefineLoopToken("{actors[thumbwidth]}", (int)eScraperLT::thumbwidth);
+    tokenContainer->DefineLoopToken("{actors[thumbheight]}", (int)eScraperLT::thumbheight);
+    actorsIndex = tokenContainer->LoopIndex("actors");
+    InheritTokenContainer();
+}
+
+bool cViewDetailRec::Parse(bool forced) {
+    if (!cViewElement::Parse())
+        return false;
+    if (!recording)
+        return false;
+    tokenContainer->Clear();
+    tokenContainer->AddStringToken((int)eDmDetailedRecST::name, recording->Name());
+    tokenContainer->AddIntToken((int)eDmDetailedRecIT::cutted, recording->IsEdited());
+
+    const cRecordingInfo *info = recording->Info();
+    if (info) {
+        tokenContainer->AddStringToken((int)eDmDetailedRecST::epgname, info->Title());
+        tokenContainer->AddStringToken((int)eDmDetailedRecST::shorttext, info->ShortText());
+        tokenContainer->AddStringToken((int)eDmDetailedRecST::description, info->Description());
+        const cEvent *event = info->GetEvent();
+        if (event) {
+            cString recDate = event->GetDateString();
+            cString recTime = event->GetTimeString();
+            if (strstr(*recDate, "1970")) {
+                time_t start = recording->Start();
+                recDate = DateString(start);
+                recTime = TimeString(start);
+            }
+            int duration = event->Duration() / 60;
+            int recDuration = recording->LengthInSeconds();
+            recDuration = (recDuration>0) ? (recDuration / 60) : 0;
+            tokenContainer->AddStringToken((int)eDmDetailedRecST::date, *recDate);
+            tokenContainer->AddStringToken((int)eDmDetailedRecST::time, *recTime);
+            time_t startTime = event->StartTime();
+            struct tm * sStartTime = localtime(&startTime);
+            tokenContainer->AddIntToken((int)eDmDetailedRecIT::year, sStartTime->tm_year + 1900);
+            tokenContainer->AddIntToken((int)eDmDetailedRecIT::daynumeric, sStartTime->tm_mday);
+            tokenContainer->AddIntToken((int)eDmDetailedRecIT::month, sStartTime->tm_mon+1);
+            tokenContainer->AddIntToken((int)eDmDetailedRecIT::duration, recDuration);
+            tokenContainer->AddIntToken((int)eDmDetailedRecIT::durationhours, recDuration / 60);
+            tokenContainer->AddStringToken((int)eDmDetailedRecST::durationminutes, *cString::sprintf("%.2d", recDuration%60));
+            tokenContainer->AddIntToken((int)eDmDetailedRecIT::durationevent, duration);
+            tokenContainer->AddIntToken((int)eDmDetailedRecIT::durationeventhours, duration / 60);
+            tokenContainer->AddStringToken((int)eDmDetailedRecST::durationeventminutes, *cString::sprintf("%.2d", duration%60));
+        }
+    }
+    SetRecInfos();
+    SetRecordingImages(recording->FileName());
+
+    vector<int> loopInfo;
+    bool scrapInfoAvailable = LoadFullScrapInfo(NULL, recording);
+    int numActors = NumActors();
+    loopInfo.push_back(numActors);
+    tokenContainer->CreateLoopTokenContainer(&loopInfo);
+    if (scrapInfoAvailable) {
+        SetFullScrapInfo(tokenContainer, actorsIndex);
+    }
+
+    SetDirty();
+    return true;
+}
+
+void cViewDetailRec::SetRecInfos(void) {
+    unsigned long long nRecSize = -1;
+    unsigned long long nFileSize[1000];
+    nFileSize[0] = 0;
+    int i = 0;
+    struct stat filebuf;
+    cString filename;
+    int rc = 0;
+    do {
+        if (recording->IsPesRecording())
+            filename = cString::sprintf("%s/%03d.vdr", recording->FileName(), ++i);
+        else
+            filename = cString::sprintf("%s/%05d.ts", recording->FileName(), ++i);
+        rc = stat(filename, &filebuf);
+        if (rc == 0)
+            nFileSize[i] = nFileSize[i-1] + filebuf.st_size;
+        else
+            if (ENOENT != errno) {
+                nRecSize = -1;
+            }
+    } while (i <= 999 && !rc);
+    nRecSize = nFileSize[i-1];
+
+    cMarks marks;
+    bool fHasMarks = marks.Load(recording->FileName(), recording->FramesPerSecond(), recording->IsPesRecording()) && marks.Count();
+    cIndexFile *index = new cIndexFile(recording->FileName(), false, recording->IsPesRecording());
+
+    int nCutLength = 0;
+    long nCutInFrame = 0;
+    unsigned long long nRecSizeCut = nRecSize < 0 ? -1 : 0;
+    unsigned long long nCutInOffset = 0;
+
+    if (fHasMarks && index) {
+        uint16_t FileNumber;
+        off_t FileOffset;
+
+        bool fCutIn = true;
+        cMark *mark = marks.First();
+        while (mark) {
+            int pos = mark->Position();
+            index->Get(pos, &FileNumber, &FileOffset); //TODO: will disc spin up?
+            if (fCutIn) {
+                nCutInFrame = pos;
+                fCutIn = false;
+                if (nRecSize >= 0)
+                    nCutInOffset = nFileSize[FileNumber-1] + FileOffset;
+            } else {
+                nCutLength += pos - nCutInFrame;
+                fCutIn = true;
+                if (nRecSize >= 0)
+                    nRecSizeCut += nFileSize[FileNumber-1] + FileOffset - nCutInOffset;
+            }
+            cMark *nextmark = marks.Next(mark);
+            mark = nextmark;
+        }
+        if (!fCutIn) {
+            nCutLength += index->Last() - nCutInFrame;
+            index->Get(index->Last() - 1, &FileNumber, &FileOffset);
+            if (nRecSize >= 0)
+                nRecSizeCut += nFileSize[FileNumber-1] + FileOffset - nCutInOffset;
+        }
+    }
+
+    if (nRecSize < 0) {
+        if ((nRecSize = ReadSizeVdr(recording->FileName())) < 0) {
+            nRecSize = DirSizeMB(recording->FileName());
+        }
+    }
+    if (nRecSize >= 0) {
+        cString strRecSize = "";
+        cString strRecSizeCut = "";
+
+        if (fHasMarks) {
+            if (nRecSize > MEGABYTE(1023)) {
+                strRecSize = cString::sprintf("%.2f GB", (float)nRecSize / MEGABYTE(1024));
+                strRecSizeCut = cString::sprintf("%.2f GB", (float)nRecSizeCut / MEGABYTE(1024));
+            } else {
+                strRecSize = cString::sprintf("%lld MB", nRecSize / MEGABYTE(1));
+                strRecSizeCut = cString::sprintf("%lld MB", nRecSizeCut / MEGABYTE(1));
+            }
+        } else {
+            if (nRecSize > MEGABYTE(1023)) {
+                strRecSize = cString::sprintf("%.2f GB", (float)nRecSize / MEGABYTE(1024));
+                strRecSizeCut = strRecSize;
+            } else {
+                strRecSize = cString::sprintf("%lld MB", nRecSize / MEGABYTE(1));
+                strRecSizeCut = strRecSize;
+            }
+        }
+        tokenContainer->AddStringToken((int)eDmDetailedRecST::recordingsize, *strRecSize);
+        tokenContainer->AddStringToken((int)eDmDetailedRecST::recordingsizecutted, *strRecSizeCut);
+    }
+
+    const cRecordingInfo *info = recording->Info();
+    if (info) {
+        cChannel *channel = Channels.GetByChannelID(info->ChannelID());
+        if (channel) {
+            tokenContainer->AddStringToken((int)eDmDetailedRecST::recchannelname, channel->Name());
+            tokenContainer->AddStringToken((int)eDmDetailedRecST::recchannelid, *channel->GetChannelID().ToString());
+            tokenContainer->AddIntToken((int)eDmDetailedRecIT::recchannelnumber, channel->Number());
+        }        
+    }
+
+
+    if (index) {
+        int nLastIndex = index->Last();
+        if (nLastIndex) {
+            string strLength = *IndexToHMSF(nLastIndex, false, recording->FramesPerSecond());
+            string strLengthCutted = "";
+            if (fHasMarks) {
+                strLengthCutted = *IndexToHMSF(nCutLength, false, recording->FramesPerSecond());
+            } else {
+                strLengthCutted = strLength;
+            }
+            string strBitrate = *cString::sprintf("%.2f MBit/s", (float)nRecSize / nLastIndex * recording->FramesPerSecond() * 8 / MEGABYTE(1));
+            tokenContainer->AddStringToken((int)eDmDetailedRecST::recordinglength, strLength.c_str());
+            tokenContainer->AddStringToken((int)eDmDetailedRecST::recordinglengthcutted, strLengthCutted.c_str());
+            tokenContainer->AddStringToken((int)eDmDetailedRecST::recordingbitrate, strBitrate.c_str());
+        }
+        delete index;
+    }
+    
+    tokenContainer->AddStringToken((int)eDmDetailedRecST::recordingformat, recording->IsPesRecording() ? "PES" : "TS");
+    
+    bool searchTimerFound = false;
+    if (info) {
+        const char *aux = NULL;
+        aux = info->Aux();
+        if (aux) {
+            string strAux = aux;
+            string auxEpgsearch = StripXmlTag(strAux, "epgsearch");
+            if (!auxEpgsearch.empty()) {
+                string searchTimer = StripXmlTag(auxEpgsearch, "searchtimer");
+                if (!searchTimer.empty()) {
+                    tokenContainer->AddStringToken((int)eDmDetailedRecST::searchtimer, searchTimer.c_str());
+                    searchTimerFound = true;
+                }
+            }
+        }
+    }
+    if (!searchTimerFound)
+        tokenContainer->AddStringToken((int)eDmDetailedRecST::searchtimer, "n.a.");
+}
+
+int cViewDetailRec::ReadSizeVdr(const char *strPath) {
+    int dirSize = -1;
+    char buffer[20];
+    char *strFilename = NULL;
+    if (-1 != asprintf(&strFilename, "%s/size.vdr", strPath)) {
+        struct stat st;
+        if (stat(strFilename, &st) == 0) {
+                int fd = open(strFilename, O_RDONLY);
+            if (fd >= 0) {
+                if (safe_read(fd, &buffer, sizeof(buffer)) >= 0) {
+                    dirSize = atoi(buffer);
+                }
+                close(fd);
+            }
+        }
+        free(strFilename);
+    }
+    return dirSize;
+}
+
+string cViewDetailRec::StripXmlTag(string &Line, const char *Tag) {
+        // set the search strings
+        stringstream strStart, strStop;
+        strStart << "<" << Tag << ">";
+        strStop << "</" << Tag << ">";
+        // find the strings
+        string::size_type locStart = Line.find(strStart.str());
+        string::size_type locStop = Line.find(strStop.str());
+        if (locStart == string::npos || locStop == string::npos)
+                return "";
+        // extract relevant text
+        int pos = locStart + strStart.str().size();
+        int len = locStop - pos;
+        return len < 0 ? "" : Line.substr(pos, len);
+}
+
+void cViewDetailRec::SetRecordingImages(const char *recPath) {
+    if (!recPath) {
+        return;
+    }
+    DIR *dirHandle;
+    struct dirent *dirEntry;
+    dirHandle = opendir(recPath);
+    if (!dirHandle) {
+        return;        
+    }
+    int picsFound = 0;
+    int indexStr = (int)eDmDetailedRecST::recimg1path;
+    int indexInt = (int)eDmDetailedRecIT::recimg1avaialble;
+    while ( 0 != (dirEntry = readdir(dirHandle))) {
+        if (endswith(dirEntry->d_name, "jpg")) {
+            tokenContainer->AddStringToken(indexStr, *cString::sprintf("%s/%s", recPath, dirEntry->d_name));
+            tokenContainer->AddIntToken(indexInt, 1);
+            picsFound++;
+        }
+        if (picsFound == 3) {
+            break;
+        }
+    }
+    closedir(dirHandle);
+}
+
+/******************************************************************
+* cViewDetailText
+******************************************************************/
+cViewDetailText::cViewDetailText(void) {
+    text = NULL;
+}
+
+cViewDetailText::~cViewDetailText(void) {
+}
+
+void cViewDetailText::SetTokenContainer(void) {
+    tokenContainer = new skindesignerapi::cTokenContainer();
+    tokenContainer->DefineStringToken("{text}", (int)eDmDetailedTextST::text);
+    InheritTokenContainer();    
+}
+
+bool cViewDetailText::Parse(bool forced) {
+    if (!cViewElement::Parse())
+        return false;
+    if (!text)
+        return false;
+    tokenContainer->Clear();
+    tokenContainer->AddStringToken((int)eDmDetailedTextST::text, text);
+    SetDirty();
+    return true;
+}
+
+/******************************************************************
+* cViewDetailPlugin
+******************************************************************/
+cViewDetailPlugin::cViewDetailPlugin(void) {
+}
+
+cViewDetailPlugin::~cViewDetailPlugin(void) {
+}
+
+void cViewDetailPlugin::SetTokenContainer(void) {
+    if (plugId == -1 || plugMenuId == -1)
+        return;
+    skindesignerapi::cTokenContainer *tkPlugMenu = plgManager->GetTokenContainer(plugId, plugMenuId);
+    tokenContainer = new skindesignerapi::cTokenContainer(*tkPlugMenu);
+    InheritTokenContainer();
+}
+
+void cViewDetailPlugin::Set(skindesignerapi::cTokenContainer *tk) {
+    tokenContainer->Clear();
+    tokenContainer->SetTokens(tk);
+}
+
+bool cViewDetailPlugin::Parse(bool forced) {
+    if (!cViewElement::Parse())
+        return false;
+    SetDirty();
+    return true;
+}
+
+/******************************************************************
+* cViewDetailAdvancedPlugin
+******************************************************************/
+cViewDetailAdvancedPlugin::cViewDetailAdvancedPlugin(int viewId, int plugId) {
+    this->plugId = plugId;
+    plugViewId = viewId;
+}
+
+cViewDetailAdvancedPlugin::~cViewDetailAdvancedPlugin(void) {
+}
+
+void cViewDetailAdvancedPlugin::SetTokenContainer(void) {
+    if (plugId == -1 || plugViewId == -1)
+        return;
+    skindesignerapi::cTokenContainer *tkDetail = plgManager->GetTokenContainerTab(plugId, plugViewId);
+    tokenContainer = new skindesignerapi::cTokenContainer(*tkDetail);
+    InheritTokenContainer();
+}
+
+void cViewDetailAdvancedPlugin::Set(skindesignerapi::cTokenContainer *tk) {
+    tokenContainer->Clear();
+    tokenContainer->SetTokens(tk);
+}
+
+bool cViewDetailAdvancedPlugin::Parse(bool forced) {
+    if (!cViewElement::Parse())
+        return false;
+    SetDirty();
+    return true;
+}

coreengine/viewdetail.h

@@ -0,0 +1,114 @@
+#ifndef __VIEWDETAIL_H
+#define __VIEWDETAIL_H
+
+#include "../services/epgsearch.h"
+#include "../extensions/scrapmanager.h"
+#include "viewelement.h"
+/******************************************************************
+* cViewDetail
+******************************************************************/
+class cViewDetail : public cViewElement, public cScrapManager {
+protected:
+    int plugId;
+    int plugMenuId;
+    cArea *activeTab;
+    int activeTabIndex;
+    int numTabs;
+    void SetActiveTab(void);
+public:
+    cViewDetail(void);
+    virtual ~cViewDetail(void);
+    void SetPlugId(int id) { plugId = id; };
+    void SetPlugMenuId(int id) { plugMenuId = id; };
+    int GetWidth(void);
+    void ResetTabs(void);
+    void Clear(void);
+    void Close(void);
+    void Render(void);
+    void Scrollbar(int &barheight, int &offset, bool &end);
+    bool ScrollUp(bool page = false);
+    bool ScrollDown(bool page = false);
+    int GetTabs(vector<const char*> &tabs);
+    int NumTabs(void) { return numTabs; };
+    int ActiveTab(void) { return activeTabIndex; };
+    void NextTab(void);
+    void PrevTab(void);
+    void SetTransparency(int transparency, bool forceDetached = false);
+};
+/******************************************************************
+* cViewDetailEpg
+******************************************************************/
+class cViewDetailEpg : public cViewDetail {
+protected:
+    const cEvent *event;
+    int rerunsIndex;
+    int actorsIndex;
+    cList<Epgsearch_searchresults_v1_0::cServiceSearchResult> *LoadReruns(void);
+    int NumReruns(cList<Epgsearch_searchresults_v1_0::cServiceSearchResult> *reruns);
+    void SetReruns(cList<Epgsearch_searchresults_v1_0::cServiceSearchResult> *reruns);
+public:
+    cViewDetailEpg(void);
+    virtual ~cViewDetailEpg(void);
+    void SetTokenContainer(void);
+    void SetEvent(const cEvent *event) { this->event = event; };
+    bool Parse(bool forced = false);
+};
+/******************************************************************
+* cViewDetailRec
+******************************************************************/
+class cViewDetailRec : public cViewDetail {
+protected:
+    const cRecording *recording;
+    int actorsIndex;
+    void SetRecInfos(void);
+    int ReadSizeVdr(const char *strPath);
+    string StripXmlTag(string &Line, const char *Tag);
+    void SetRecordingImages(const char *recPath);
+public:
+    cViewDetailRec(void);
+    virtual ~cViewDetailRec(void);
+    void SetTokenContainer(void);
+    void SetRecording(const cRecording *recording) { this->recording = recording; };
+    bool Parse(bool forced = false);
+};
+/******************************************************************
+* cViewDetailText
+******************************************************************/
+class cViewDetailText : public cViewDetail {
+protected:
+    const char *text;
+public:
+    cViewDetailText(void);
+    virtual ~cViewDetailText(void);
+    void SetTokenContainer(void);
+    void SetText(const char *text) { this->text = text; };
+    bool Parse(bool forced = false);
+};
+
+/******************************************************************
+* cViewDetailPlugin
+******************************************************************/
+class cViewDetailPlugin : public cViewDetail {
+protected:
+public:
+    cViewDetailPlugin(void);
+    virtual ~cViewDetailPlugin(void);
+    void SetTokenContainer(void);
+    void Set(skindesignerapi::cTokenContainer *tk);
+    bool Parse(bool forced = false);
+};
+
+/******************************************************************
+* cViewDetailAdvancedPlugin
+******************************************************************/
+class cViewDetailAdvancedPlugin : public cViewDetail {
+protected:
+    int plugViewId;
+public:
+    cViewDetailAdvancedPlugin(int viewId, int plugId);
+    virtual ~cViewDetailAdvancedPlugin(void);
+    void SetTokenContainer(void);
+    void Set(skindesignerapi::cTokenContainer *tk);
+    bool Parse(bool forced = false);
+};
+#endif //__VIEWDETAIL_H

coreengine/viewdisplaychannel.c

@@ -0,0 +1,199 @@
+#include "viewdisplaychannel.h"
+#include "../config.h"
+
+/************************************************************************************
+* cViewChannel
+************************************************************************************/
+
+cViewChannel::cViewChannel(void) {
+    veCustomTokens = NULL;
+    ClearVariables();
+    viewId = eViewType::DisplayChannel;
+    viewName = strdup("displaychannel");
+    numViewElements = (int)eVeDisplayChannel::count;
+    viewElements = new cViewElement*[numViewElements];
+    for (int i=0; i < numViewElements; i++) {
+        viewElements[i] = NULL;
+    }
+    SetViewElements();
+    veMessage = NULL;
+    veChannelInfo = NULL;
+    veChannelGroup = NULL;
+    veEpgInfo = NULL;
+    veProgressBar = NULL;
+    veStatusInfo = NULL;
+    veScraperContent = NULL;
+    veEcmInfo = NULL;
+}
+
+cViewChannel::~cViewChannel() {
+}
+
+void cViewChannel::SetViewElements(void) {
+    viewElementNames.insert(pair<string, int>("background", (int)eVeDisplayChannel::background));
+    viewElementNames.insert(pair<string, int>("channelgroup", (int)eVeDisplayChannel::channelgroup));
+    viewElementNames.insert(pair<string, int>("channelinfo", (int)eVeDisplayChannel::channelinfo));
+    viewElementNames.insert(pair<string, int>("epginfo", (int)eVeDisplayChannel::epginfo));
+    viewElementNames.insert(pair<string, int>("progressbar", (int)eVeDisplayChannel::progressbar));
+    viewElementNames.insert(pair<string, int>("statusinfo", (int)eVeDisplayChannel::statusinfo));
+    viewElementNames.insert(pair<string, int>("audioinfo", (int)eVeDisplayChannel::audioinfo));
+    viewElementNames.insert(pair<string, int>("ecminfo", (int)eVeDisplayChannel::ecminfo));
+    viewElementNames.insert(pair<string, int>("screenresolution", (int)eVeDisplayChannel::screenresolution));
+    viewElementNames.insert(pair<string, int>("signalquality", (int)eVeDisplayChannel::signalquality));
+    viewElementNames.insert(pair<string, int>("devices", (int)eVeDisplayChannel::devices));
+    viewElementNames.insert(pair<string, int>("currentweather", (int)eVeDisplayChannel::currentweather));
+    viewElementNames.insert(pair<string, int>("scrapercontent", (int)eVeDisplayChannel::scrapercontent));
+    viewElementNames.insert(pair<string, int>("datetime", (int)eVeDisplayChannel::datetime));
+    viewElementNames.insert(pair<string, int>("time", (int)eVeDisplayChannel::time));
+    viewElementNames.insert(pair<string, int>("message", (int)eVeDisplayChannel::message));
+    viewElementNames.insert(pair<string, int>("customtokens", (int)eVeDisplayChannel::customtokens));
+}
+
+void cViewChannel::SetViewElementObjects(void) {
+    for (int i = 0; i < numViewElements; i++) {
+        if (!viewElements[i])
+            continue;
+        if (dynamic_cast<cVeMessage*>(viewElements[i])) 
+        {
+            veMessage = dynamic_cast<cVeMessage*>(viewElements[i]);
+        }
+        else if (dynamic_cast<cVeDcChannelInfo*>(viewElements[i])) {
+
+            veChannelInfo = dynamic_cast<cVeDcChannelInfo*>(viewElements[i]);
+        }
+        else if (dynamic_cast<cVeDcChannelGroup*>(viewElements[i])) 
+        {
+            veChannelGroup = dynamic_cast<cVeDcChannelGroup*>(viewElements[i]);
+        }
+        else if (dynamic_cast<cVeDcEpgInfo*>(viewElements[i])) 
+        {
+            veEpgInfo = dynamic_cast<cVeDcEpgInfo*>(viewElements[i]);
+        }
+        else if (dynamic_cast<cVeDcProgressBar*>(viewElements[i])) 
+        {
+            veProgressBar = dynamic_cast<cVeDcProgressBar*>(viewElements[i]);
+        }
+        else if (dynamic_cast<cVeDcStatusInfo*>(viewElements[i])) 
+        {
+            veStatusInfo = dynamic_cast<cVeDcStatusInfo*>(viewElements[i]);
+        }
+        else if (dynamic_cast<cVeDcScraperContent*>(viewElements[i])) 
+        {
+            veScraperContent = dynamic_cast<cVeDcScraperContent*>(viewElements[i]);
+        }
+        else if (dynamic_cast<cVeDcEcmInfo*>(viewElements[i])) 
+        {
+            veEcmInfo = dynamic_cast<cVeDcEcmInfo*>(viewElements[i]);
+        }
+        else if (dynamic_cast<cVeCustomTokens*>(viewElements[i])) 
+        {
+            veCustomTokens = dynamic_cast<cVeCustomTokens*>(viewElements[i]);
+        }
+        else if (dynamic_cast<cVeDevices*>(viewElements[i])) 
+        {
+            viewElements[i]->SetDetached();
+        }
+    }
+}
+
+void cViewChannel::ClearVariables(void) {
+    cView::ClearVariables();
+    channelChange = false;
+    displayChannelGroups = false;
+    if (veCustomTokens)
+        veCustomTokens->Reset();
+}
+
+void cViewChannel::SetChannel(const cChannel *channel, int number) {
+    channelChange = true;
+    bool wasChannelGroups = displayChannelGroups;
+    displayChannelGroups = false;
+
+    if (veChannelInfo) {
+        veChannelInfo->Set(channel, number);
+    }
+
+    if (channel) {
+        if (!channel->GroupSep()) {
+            if (wasChannelGroups)
+                Clear((int)eVeDisplayChannel::channelgroup);
+            if (veStatusInfo)
+                veStatusInfo->Set(channel);
+            if (veEcmInfo)
+                veEcmInfo->Set(channel);
+        } else {
+            displayChannelGroups = true;
+            Clear((int)eVeDisplayChannel::channelinfo);
+            Clear((int)eVeDisplayChannel::epginfo);
+            Clear((int)eVeDisplayChannel::statusinfo);
+            Clear((int)eVeDisplayChannel::progressbar);
+            Clear((int)eVeDisplayChannel::screenresolution);
+            Clear((int)eVeDisplayChannel::signalquality);
+            Clear((int)eVeDisplayChannel::audioinfo);
+            Clear((int)eVeDisplayChannel::ecminfo);
+            Clear((int)eVeDisplayChannel::devices);
+            Clear((int)eVeDisplayChannel::customtokens);
+            if (veChannelGroup)
+                veChannelGroup->Set(channel);
+        }
+    }
+}
+
+void cViewChannel::SetEvents(const cEvent *present, const cEvent *following) {
+    Clear((int)eVeDisplayChannel::epginfo);
+    Clear((int)eVeDisplayChannel::progressbar);
+    Clear((int)eVeDisplayChannel::scrapercontent);
+    if (veProgressBar)
+        veProgressBar->Set(present);
+
+    if (!present && !following)
+        return;
+    
+    if (veEpgInfo)
+        veEpgInfo->Set(present, following);
+
+    if (veScraperContent)
+        veScraperContent->Set(present);
+}
+
+void cViewChannel::SetMessage(eMessageType type, const char *text) {
+    if (veMessage) {
+        if (text)
+            veMessage->Set(type, text);
+        else
+            veMessage->Clear();
+    }
+}
+
+void cViewChannel::Flush(void) {
+    if (init) {
+        sdOsd.LockFlush();
+        Render((int)eVeDisplayChannel::background);
+        Render((int)eVeDisplayChannel::progressbar);
+        Render((int)eVeDisplayChannel::currentweather);
+    }
+    
+    if (!displayChannelGroups) {
+        //normal display
+        Render((int)eVeDisplayChannel::channelinfo);
+        Render((int)eVeDisplayChannel::epginfo);
+        Render((int)eVeDisplayChannel::statusinfo);
+        Render((int)eVeDisplayChannel::scrapercontent);
+        Render((int)eVeDisplayChannel::progressbar, channelChange);
+        Render((int)eVeDisplayChannel::screenresolution);
+        Render((int)eVeDisplayChannel::signalquality);
+        Render((int)eVeDisplayChannel::audioinfo);
+        Render((int)eVeDisplayChannel::ecminfo);
+        Render((int)eVeDisplayChannel::devices);
+        Render((int)eVeDisplayChannel::customtokens);
+        Render((int)eVeDisplayChannel::message);
+    } else {
+        //channelgroup display
+        Render((int)eVeDisplayChannel::channelgroup);
+    }
+    Render((int)eVeDisplayChannel::datetime);
+    Render((int)eVeDisplayChannel::time);
+    channelChange = false;
+    cView::Flush();
+}
+

coreengine/viewdisplaychannel.h

@@ -0,0 +1,31 @@
+#ifndef __VIEWDISPLAYCHANNEL_H
+#define __VIEWDISPLAYCHANNEL_H
+
+#include "view.h"
+
+class cViewChannel : public cView {
+private:
+    cVeMessage             *veMessage;
+    cVeCustomTokens        *veCustomTokens;
+    cVeDcChannelInfo       *veChannelInfo;
+    cVeDcChannelGroup      *veChannelGroup;
+    cVeDcEpgInfo           *veEpgInfo;
+    cVeDcProgressBar       *veProgressBar;
+    cVeDcStatusInfo        *veStatusInfo;
+    cVeDcScraperContent    *veScraperContent;
+    cVeDcEcmInfo           *veEcmInfo;
+    bool channelChange;
+    bool displayChannelGroups;
+    void SetViewElements(void);
+    void ClearVariables(void);
+    void SetViewElementObjects(void);
+public:
+    cViewChannel(void);
+    virtual ~cViewChannel(void);
+    void SetChannel(const cChannel *channel, int number);
+    void SetEvents(const cEvent *present, const cEvent *following);
+    void SetMessage(eMessageType type, const char *text);
+    void Flush(void);
+};
+
+#endif //__VIEWDISPLAYCHANNEL_H

coreengine/viewdisplaymenu.h

@@ -0,0 +1,316 @@
+#ifndef __VIEWDISPLAYMENU_H
+#define __VIEWDISPLAYMENU_H
+
+#include "view.h"
+#include "viewdetail.h"
+
+/***********************************************************
+* cViewMenu
+***********************************************************/
+class cSubView;
+class cViewMenuDefault;
+class cViewMenuMain;
+class cViewMenuSetup;
+class cViewMenuSchedules;
+class cViewMenuChannels;
+class cViewMenuTimers;
+class cViewMenuRecordings;
+class cViewMenuDetail;
+
+class cViewMenu : public cView {
+protected:
+    map<string,int> subviewNames;
+    cSubView **subViews;
+    int numSubviews;
+    cSubView *activeSubview;
+    cSubView *activeSubviewLast;
+    cViewMenuDefault    *menuDefault;
+    cViewMenuMain       *menuMain;
+    cViewMenuSetup      *menuSetup;
+    cViewMenuSchedules  *menuSchedules;
+    cViewMenuChannels   *menuChannels;
+    cViewMenuTimers     *menuTimers;
+    cViewMenuRecordings *menuRecordings;
+    cViewMenuDetail     *menuDetailedEpg;
+    cViewMenuDetail     *menuDetailedRec;
+    cViewMenuDetail     *menuDetailedText;
+    eMenuCategory menuCat;
+    //name of current plugin for menu icon
+    const char *plugName;
+    //external plugin menus
+    bool pluginIdSet;
+    int plugId;
+    int plugMenuId;
+    //status variables
+    bool menuChange;
+    bool listChange;
+    bool detailViewInit;
+    void SetViewElements(void);
+    void SetViewElementObjects(void);
+    void SetSubViews(void);
+    void ClearVariables(void);
+    int SubviewId(const char *name);
+    bool SetPluginSubView(eMenuCategory menuCat);
+    void WakeViewElements(void);
+public:
+    cViewMenu(void);
+    virtual ~cViewMenu(void);
+    void SetGlobals(cGlobals *globals);
+    void PreCache(void);
+    bool ValidSubView(const char *subView);
+    static cSubView *CreateSubview(const char *name);
+    static cSubView *CreatePluginview(const char *plugname, int plugId, int menuNumber, int menuType);
+    void AddSubview(const char *sSubView, cSubView *subView);
+    void AddPluginview(cSubView *plugView);
+    void SetSubView(eMenuCategory MenuCat);
+    void SetSortMode(eMenuSortMode sortMode);
+    void SetPluginMenu(int plugId, int plugMenuId);
+    int NumListItems(void);
+    eMenuOrientation MenuOrientation(void);
+    const cFont *GetTextAreaFont(void);
+    int GetTextAreaWidth(void);
+    int GetListWidth(void);
+    void SetTitleHeader(const char *title);
+    void SetChannelHeader(const cEvent *event);
+    void SetMessage(eMessageType type, const char *text);
+    void SetMenuButtons(const char *red, const char *green, const char *yellow, const char *blue);
+    void SetScrollbar(int total, int offset);
+    void SetTabs(int tab1, int tab2, int tab3, int tab4, int tab5);
+    void SetItem(const char *text, int index, bool current, bool selectable);
+    bool SetItemEvent(const cEvent *event, int index, bool current, bool selectable, const cChannel *channel, bool withDate, eTimerMatch timerMatch);
+    bool SetItemTimer(const cTimer *timer, int index, bool current, bool selectable);
+    bool SetItemChannel(const cChannel *channel, int index, bool current, bool selectable, bool withProvider);
+    bool SetItemRecording(const cRecording *recording, int index, bool current, bool selectable, int level, int total, int New);
+    bool SetItemPlugin(skindesignerapi::cTokenContainer *tk, int index, bool current, bool selectable);
+    void SetEvent(const cEvent *event);
+    void SetRecording(const cRecording *recording);
+    void SetText(const char *text);
+    bool SetPluginText(skindesignerapi::cTokenContainer *tk);
+    void SetCurrentRecording(const char *currentRec);
+    void KeyDetailView(bool up, bool page);
+    bool Init(void);
+    void Close(void);
+    void Clear(void);
+    void Flush(void);
+    void SetTransparency(int transparency, bool forceDetached = false);
+    void Debug(void);
+};
+
+/***********************************************************
+* cSubView
+***********************************************************/
+class cSubView : public cView {
+protected:
+    eMenuCategory menuCat;
+    int plugId;
+    int plugMenuId;
+    cViewList *viewList;
+    cViewList *viewListVertical;
+    cViewList *viewListHorizontal;
+    cViewElement *background;
+    cVeDmHeader *header;
+    cVeDateTime *datetime;
+    cVeTime *time;
+    cVeMessage *message;
+    cVeDmSortmode *sortmode;
+    cVeDmColorbuttons *colorbuttons;
+    cVeDmScrollbar *scrollbar;
+    virtual void SetViewElementObjects(void);
+    virtual void SetViewElements(void);
+public:
+    cSubView(const char *name);
+    virtual ~cSubView(void);
+    virtual void SetGlobals(cGlobals *globals);
+    virtual void PreCache(void);
+    bool ViewElementSet(int ve);
+    bool ViewElementHorizontalSet(int ve);
+    void SetViewElement(eVeDisplayMenu ve, cViewElement *viewElement);
+    void SetViewElementHorizontal(eVeDisplayMenu ve, cViewElement *viewElement);
+    void AddViewList(cViewList *viewList);
+    virtual void AddTab(cArea *tab) {};
+    int NumListItems(void);
+    eMenuOrientation MenuOrientation(void);
+    void SetMenuCategory(eMenuCategory menuCat) { this->menuCat = menuCat; };
+    void SetPlugId(int id) { plugId = id; };
+    void SetPlugMenuId(int id) { plugMenuId = id; };
+    void SetTitle(const char *title);
+    void SetMessage(eMessageType type, const char *text);
+    void SetChannel(const cChannel *channel);
+    void SetMenuButtons(const char *red, const char *green, const char *yellow, const char *blue);
+    void SetScrollbar(int total, int offset);
+    void SetSortMode(eMenuSortMode sortMode);
+    virtual void Close(void);
+    virtual void Clear(void);
+    void ClearViewList(void);
+    void WakeViewElements(void);
+    virtual void DrawStaticVEs(void);
+    virtual void DrawDynamicVEs(void);
+    void DrawList(void);
+    virtual void DrawDetailedView(void) {};
+    virtual void UpdateDetailedView(void) {};
+    void SetTransparency(int transparency, bool forceDetached = false);
+};
+/***********************************************************
+* cViewMenuDefault
+***********************************************************/
+class cViewMenuDefault : public cSubView {
+private:
+    cViewListDefault *listDefault;
+    void SetViewElementObjects(void);
+public:
+    cViewMenuDefault(const char *name);
+    virtual ~cViewMenuDefault(void);
+    void SetTabs(int tab1, int tab2, int tab3, int tab4, int tab5);
+    void SetPlugin(const char *plugName);
+    void SetItem(const char *text, int index, bool current, bool selectable);
+    const cFont *GetTextAreaFont(void);
+    int GetListWidth(void);
+};
+/***********************************************************
+* cViewMenuMain
+***********************************************************/
+class cViewMenuMain : public cSubView {
+private:
+    cViewListMain *listMain;
+    cVeDmTimers *timers;
+    cVeDevices *devices;
+    cVeCurrentWeather *weather;
+    cVeDmDiscusage *discusage;
+    cVeDmSystemload *load;
+    cVeDmSystemmemory *memory;
+    cVeDmVdrstatistics *vdrstats;
+    cVeDmTemperatures *temperatures;
+    cVeDmCurrentschedule *currentSchedule;
+    cVeDmLastrecordings *lastRecordings;
+    cVeCustomTokens *customTokens;
+    uint64_t lastDrawDynamic;
+    void ClearVariables(void);
+    void SetViewElements(void);
+    void SetViewElementObjects(void);
+public:
+    cViewMenuMain(const char *name);
+    virtual ~cViewMenuMain(void);
+    void Clear(void);
+    void SetItem(const char *text, int index, bool current, bool selectable);
+    void SetCurrentRecording(const char *currentRec);
+    void DrawStaticVEs(void);
+    void DrawDynamicVEs(void);
+    const char *GetPlugin(void);
+};
+/***********************************************************
+* cViewMenuSetup
+***********************************************************/
+class cViewMenuSetup : public cSubView {
+private:
+    cViewListMain *listSetup;
+    void SetViewElementObjects(void);
+public:
+    cViewMenuSetup(const char *name);
+    virtual ~cViewMenuSetup(void);
+    void SetItem(const char *text, int index, bool current, bool selectable);
+};
+/***********************************************************
+* cViewMenuSchedules
+***********************************************************/
+class cViewMenuSchedules : public cSubView {
+private:
+    cViewListSchedules *listSchedules;
+    void SetViewElementObjects(void);
+public:
+    cViewMenuSchedules(const char *name);
+    virtual ~cViewMenuSchedules(void);
+    void SetItem(const cEvent *event, int index, bool current, bool selectable, const cChannel *channel, bool withDate, eTimerMatch timerMatch);
+};
+/***********************************************************
+* cViewMenuChannels
+***********************************************************/
+class cViewMenuChannels : public cSubView {
+private:
+    cViewListChannels *listChannels;
+    void SetViewElementObjects(void);
+public:
+    cViewMenuChannels(const char *name);
+    virtual ~cViewMenuChannels(void);
+    void SetItem(const cChannel *channel, int index, bool current, bool selectable, bool withProvider);
+};
+/***********************************************************
+* cViewMenuTimers
+***********************************************************/
+class cViewMenuTimers : public cSubView {
+private:
+    cViewListTimers *listTimers;
+    void SetViewElementObjects(void);
+public:
+    cViewMenuTimers(const char *name);
+    virtual ~cViewMenuTimers(void);
+    void SetItem(const cTimer *timer, int index, bool current, bool selectable);
+};
+/***********************************************************
+* cViewMenuRecordings
+***********************************************************/
+class cViewMenuRecordings : public cSubView {
+private:
+    cViewListRecordings *listRecordings;
+    void SetViewElementObjects(void);
+public:
+    cViewMenuRecordings(const char *name);
+    virtual ~cViewMenuRecordings(void);
+    void SetItem(const cRecording *recording, int index, bool current, bool selectable, int level, int total, int New);
+};
+
+/***********************************************************
+* cViewMenuPlugins
+***********************************************************/
+class cViewMenuPlugin : public cSubView {
+private:
+    cViewListPlugin *listPlugin;
+    void SetViewElementObjects(void);
+public:
+    cViewMenuPlugin(const char *name);
+    virtual ~cViewMenuPlugin(void);
+    void SetItem(skindesignerapi::cTokenContainer *tk, int index, bool current, bool selectable);
+};
+
+/***********************************************************
+* cViewMenuDetail
+***********************************************************/
+class cViewMenuDetail : public cSubView {
+private:
+    bool firstTab;
+    cVeDmDetailheaderEpg *detailedheaderEpg;
+    cVeDmDetailheaderRec *detailedheaderRec;
+    cVeDmDetailheaderPlugin *detailedheaderPlug;
+    cVeDmTablabels *tablabels;
+    cViewDetail *detailView;
+    cViewDetailEpg *detailViewEpg;
+    cViewDetailRec *detailViewRec;
+    cViewDetailText *detailViewText;
+    cViewDetailPlugin *detailViewPlugin;
+    void SetDetailedView(void);
+    void SetViewElements(void);
+    void SetViewElementObjects(void);
+    void DrawScrollbar(void);
+public:
+    cViewMenuDetail(const char *name);
+    virtual ~cViewMenuDetail(void);
+    void SetGlobals(cGlobals *globals);
+    void AddTab(cArea *tab);
+    void PreCache(void);
+    int GetWidth(void);
+    void SetEvent(const cEvent *event);
+    void SetRecording(const cRecording *recording);
+    void SetText(const char *text);
+    void SetPluginText(skindesignerapi::cTokenContainer *tk);
+    void Clear(void);
+    void Close(void);
+    void DrawStaticVEs(void);
+    void DrawDynamicVEs(void);
+    void DrawDetailedView(void);
+    void KeyLeft(void);
+    void KeyRight(void);
+    void KeyUp(void);
+    void KeyDown(void);
+    void SetTransparency(int transparency, bool forceDetached = false);
+};
+
+#endif //__VIEWDISPLAYMENU_H

coreengine/viewdisplaymessage.c

@@ -0,0 +1,54 @@
+#include "viewdisplaymessage.h"
+#include "../config.h"
+
+/************************************************************************************
+* cViewMessage
+************************************************************************************/
+
+cViewMessage::cViewMessage(void) {
+    ClearVariables();
+    viewId = eViewType::DisplayMessage;
+    viewName = strdup("displaymessage");
+    numViewElements = (int)eVeDisplayMessage::count;
+    viewElements = new cViewElement*[numViewElements];
+    for (int i=0; i < numViewElements; i++) {
+        viewElements[i] = NULL;
+    }
+    SetViewElements();
+    veMessage = NULL;
+}
+
+cViewMessage::~cViewMessage() {
+}
+
+void cViewMessage::SetViewElements(void) {
+    viewElementNames.insert(pair<string, int>("background", (int)eVeDisplayMessage::background));
+    viewElementNames.insert(pair<string, int>("message", (int)eVeDisplayMessage::message));
+}
+
+void cViewMessage::SetViewElementObjects(void) {
+    if (!viewElements[(int)eVeDisplayMessage::message])
+        return;
+    veMessage = dynamic_cast<cVeMessage*>(viewElements[(int)eVeDisplayMessage::message]);
+}
+
+void cViewMessage::ClearVariables(void) {
+    init = true;
+}
+
+void cViewMessage::SetMessage(eMessageType type, const char *text) {
+    if (!text)
+        veMessage->Clear();
+    else
+        veMessage->Set(type, text);
+}
+
+void cViewMessage::Flush(void) {
+    if (init) {
+        sdOsd.LockFlush();
+        Render((int)eVeDisplayMessage::background);
+    }
+    Render((int)eVeDisplayMessage::message);
+    cView::Flush();
+}
+

coreengine/viewdisplaymessage.h

@@ -0,0 +1,19 @@
+#ifndef __VIEWDISPLAYMESSAGE_H
+#define __VIEWDISPLAYMESSAGE_H
+
+#include "view.h"
+
+class cViewMessage : public cView {
+private:
+    cVeMessage *veMessage;
+    void SetViewElements(void);
+    void SetViewElementObjects(void);
+    void ClearVariables(void);
+public:
+    cViewMessage(void);
+    virtual ~cViewMessage(void);
+    void SetMessage(eMessageType type, const char *text);
+    void Flush(void);
+};
+
+#endif //__VIEWDISPLAYMESSAGE_H

coreengine/viewdisplayplugin.c

@@ -0,0 +1,556 @@
+#include "viewdisplayplugin.h"
+#include "../config.h"
+/***********************************************************
+* cViewPlugin
+***********************************************************/
+cViewPlugin::cViewPlugin(int id, int plugId) {
+    this->id = id;
+    this->plugId = plugId;
+    viewId = eViewType::DisplayPlugin;
+    viewName = strdup("displayplugin");
+    if (id == 0)
+        numViews = plgManager->GetNumSubviews(plugId) + 1;
+    else
+        numViews = 1;
+    views = new cViewPlugin*[numViews];
+    views[0] = this;
+    for (int i=1; i < numViews; i++) {
+        views[i] = NULL;
+    }
+    numViewElements = plgManager->GetNumViewElements(plugId, id);
+    viewElements = new cViewElement*[numViewElements];
+    for (int i=0; i < numViewElements; i++) {
+        viewElements[i] = NULL;
+    }
+    SetViewElements();
+    numViewGrids = plgManager->GetNumViewGrids(plugId, id);
+    viewGrids = new cViewGrid*[numViewGrids];
+    for (int i=0; i < numViewGrids; i++) {
+        viewGrids[i] = NULL;
+    }
+    SetViewGrids();
+    tabView = NULL;
+    viewChanged = true;
+    newViewId = 0;
+}
+
+cViewPlugin::~cViewPlugin(void) {
+    for (int i=0; i< numViewGrids; i++)
+        delete viewGrids[i];
+    delete[] viewGrids;
+    delete tabView;
+    for (int i=1; i < numViews; i++) {
+        delete views[i];
+    }
+    delete[] views;
+}
+
+/***********************************************************
+* Public Functions
+***********************************************************/
+bool cViewPlugin::ReadFromXML(const char *plugName, const char *tplName, cSdOsd *osd) {
+    cString xmlFile = cString::sprintf("plug-%s-%s", plugName, tplName);
+    cXmlParser parser;
+    if (osd)
+        parser.SetOsd(osd);
+    else
+        parser.SetOsd(&sdOsd);
+    if (!parser.ReadView(this, *xmlFile)) {
+        return false;
+    }
+    if (!parser.ParsePluginView()) {
+        return false;
+    }
+    return true;
+}
+
+bool cViewPlugin::ReadSubViews(const char *plugName) {
+    plgManager->InitPluginSubviewIterator(plugId);
+    int svId = -1;
+    string svTpl = "";
+    while (plgManager->GetNextSubView(svId, svTpl)) {
+        cViewPlugin *plugSubView = new cViewPlugin(svId, plugId);
+        if (!plugSubView->ReadFromXML(plugName, svTpl.c_str(), &sdOsd))
+            return false;
+        views[svId] = plugSubView;
+    }
+    return true;
+}
+
+
+void cViewPlugin::SetGlobals(cGlobals *globals) {
+    cView::SetGlobals(globals);
+    for (int i=0; i < numViewGrids; i++) {
+        if (viewGrids[i])
+            viewGrids[i]->SetGlobals(globals);
+    }
+    for (int i=1; i < numViews; i++) {
+        views[i]->SetGlobals(globals);
+    }
+    if (tabView) {
+        tabView->SetGlobals(globals);
+    }
+}
+
+void cViewPlugin::AddViewElement(cVePlugin *viewElement) {
+    int veId = ViewElementId(viewElement->Name());
+    if (veId == ATTR_UNKNOWN)
+        return;
+    viewElement->SetId(veId);
+    viewElement->SetPluginId(plugId);
+    viewElement->SetViewId(id);
+    viewElement->SetTokenContainer();
+    viewElements[veId] = viewElement;
+}
+
+void cViewPlugin::AddViewGrid(cViewGrid *viewGrid) {
+    int gId = GridId(viewGrid->Name());
+    if (gId == ATTR_UNKNOWN)
+        return;
+    viewGrid->SetId(gId);
+    viewGrid->SetPluginId(plugId);
+    viewGrid->SetViewId(id);
+    viewGrid->SetTokenContainer();
+    viewGrids[gId] = viewGrid;
+}
+
+void cViewPlugin::AddTab(cArea *tab) {
+    if (!tabView) {
+        tabView = new cPluginTabView(id, plugId);
+        tabView->SetOsd(&sdOsd);
+    }
+    tabView->AddTab(tab);
+}
+
+void cViewPlugin::AddScrollbar(cVeDmScrollbar *scrollbar) {
+    if (!tabView) {
+        tabView = new cPluginTabView(id, plugId);
+        tabView->SetOsd(&sdOsd);
+    }
+    int id = ViewElementId("scrollbar");
+    scrollbar->SetId(id);
+    scrollbar->SetTokenContainer();
+    tabView->AddScrollbar(scrollbar);
+}
+
+void cViewPlugin::AddTablabels(cVeDmTablabels *tablabels) {
+    if (!tabView) {
+        tabView = new cPluginTabView(id, plugId);
+        tabView->SetOsd(&sdOsd);
+    }
+    int id = ViewElementId("tablabels");
+    tablabels->SetId(id);
+    tablabels->SetTokenContainer();
+    tabView->AddTablabels(tablabels);
+}
+
+void cViewPlugin::PreCache(void) {
+    if (container.Width() > 0) {
+        attribs->SetContainer(container.X(), container.Y(), container.Width(), container.Height());
+        attribs->Cache();
+    }
+    cView::PreCache();
+    for (int i=0; i < numViewGrids; i++) {
+        if (viewGrids[i]) {
+            viewGrids[i]->SetContainer(0, 0, attribs->Width(), attribs->Height());
+            viewGrids[i]->PreCache();
+        }
+    }
+    for (int i=1; i < numViews; i++) {
+        views[i]->SetContainer(0, 0, attribs->Width(), attribs->Height());
+        views[i]->PreCache();
+    }
+    if (tabView) {
+        tabView->PreCache(0, 0, attribs->Width(), attribs->Height());
+    }
+}
+
+cVePlugin *cViewPlugin::GetViewElement(int veId) {
+    if (!viewElements[veId])
+        return NULL;
+    cVePlugin *ve = dynamic_cast<cVePlugin*>(viewElements[veId]);
+    return ve;
+}
+
+cViewGrid *cViewPlugin::GetViewGrid(int gId) {
+    return viewGrids[gId];
+}
+
+cPluginTabView *cViewPlugin::GetViewTab(void) {
+    return tabView;    
+}
+
+void cViewPlugin::Hide(void) {
+    for (int i=0; i < numViewGrids; i++) {
+        if (viewGrids[i])
+            viewGrids[i]->Hide();
+    }
+    for (int i=0; i < numViewElements; i++) {
+        if (viewElements[i])
+            viewElements[i]->Hide();
+    }
+}
+
+void cViewPlugin::Show(void) {
+    for (int i=0; i < numViewGrids; i++) {
+        if (viewGrids[i])
+            viewGrids[i]->Show();
+    }
+    for (int i=0; i < numViewElements; i++) {
+        if (viewElements[i])
+            viewElements[i]->Show();
+    }
+}
+/***********************************************************
+* libskindesigner api interface
+***********************************************************/
+bool cViewPlugin::InitOsd(void) {
+    return Init();
+}
+
+void cViewPlugin::CloseOsd(void) {
+    viewChanged = true;
+    newViewId = 0;
+    Close();
+    for (int i=0 ; i < numViewGrids; i++) {
+        if (viewGrids[i])
+            viewGrids[i]->Close();
+    }
+    for (int i=1 ; i < numViews; i++) {
+        if (views[i])
+            views[i]->Close();
+    }
+}
+
+void cViewPlugin::Deactivate(int viewId, bool hide) {
+    for (int i=0; i < numViewElements; i++) {
+        if (viewElements[i])
+            viewElements[i]->StopScrolling(false);
+    }
+    if (hide)
+        views[viewId]->Hide();
+}
+
+void cViewPlugin::Activate(int viewId) {
+    viewChanged = true;
+    newViewId = viewId;
+    views[viewId]->Show();
+}
+
+void cViewPlugin::SetViewElementTokens(int veId, int viewId, skindesignerapi::cTokenContainer *tk) {
+    cVePlugin *ve = views[viewId]->GetViewElement(veId);
+    if (!ve)
+        return;
+    ve->Set(tk);
+}
+
+void cViewPlugin::ClearViewElement(int veId, int viewId) {
+    cVePlugin *ve = views[viewId]->GetViewElement(veId);
+    if (!ve)
+        return;
+    ve->StopScrolling();
+    ve->Clear();
+}
+
+void cViewPlugin::DisplayViewElement(int veId, int viewId) {
+    cVePlugin *ve = views[viewId]->GetViewElement(veId);
+    if (!ve)
+        return;
+    if (ve->Parse())
+        ve->Render();
+}
+
+void cViewPlugin::SetGrid(long gId, int viewId, int viewGridId,  double x, double y, double width, double height, skindesignerapi::cTokenContainer *tk){
+    cViewGrid *grid = views[viewId]->GetViewGrid(viewGridId);
+    if (!grid)
+        return;
+    grid->CheckSize(gId);
+    grid->PositionGrid(gId, x, y, width, height);
+    if (tk) {
+        //only set tokens new if necessary
+        grid->SetTokens(gId, tk);
+    }
+}
+
+void cViewPlugin::SetGridCurrent(long gId, int viewId, int viewGridId, bool current) {
+    if (gId < 0)
+        return;
+    cViewGrid *grid = views[viewId]->GetViewGrid(viewGridId);
+    if (!grid)
+        return;
+    grid->SetCurrentGrid(gId, current);    
+}
+
+void cViewPlugin::DeleteGrid(long gId, int viewId, int viewGridId) {
+    cViewGrid *grid = views[viewId]->GetViewGrid(viewGridId);
+    if (!grid)
+        return;
+    grid->DeleteGrid(gId);
+}
+
+void cViewPlugin::DisplayGrids(int viewId, int viewGridId) {
+    cViewGrid *grid = views[viewId]->GetViewGrid(viewGridId);
+    if (!grid)
+        return;
+    grid->Render();
+}
+
+void cViewPlugin::ClearGrids(int viewId, int viewGridId) {
+    cViewGrid *grid = views[viewId]->GetViewGrid(viewGridId);
+    if (!grid)
+        return;
+    grid->ClearGrids();
+}
+
+void cViewPlugin::SetTabTokens(int viewId, skindesignerapi::cTokenContainer *tk) {
+    cPluginTabView *tab = views[viewId]->GetViewTab();
+    if (!tab)
+        return;
+    tab->SetOsd(&sdOsd);
+    tab->Set(tk);
+}
+
+void cViewPlugin::TabLeft(int viewId) {
+    cPluginTabView *tab = views[viewId]->GetViewTab();
+    if (!tab)
+        return;
+    tab->KeyLeft(); 
+}
+
+void cViewPlugin::TabRight(int viewId) {
+    cPluginTabView *tab = views[viewId]->GetViewTab();
+    if (!tab)
+        return;
+    tab->KeyRight(); 
+}
+
+void cViewPlugin::TabUp(int viewId) {
+    cPluginTabView *tab = views[viewId]->GetViewTab();
+    if (!tab)
+        return;
+    tab->KeyUp(); 
+}
+
+void cViewPlugin::TabDown(int viewId) {
+    cPluginTabView *tab = views[viewId]->GetViewTab();
+    if (!tab)
+        return;
+    tab->KeyDown(); 
+}
+
+void cViewPlugin::DisplayTabs(int viewId) {
+    cPluginTabView *tab = views[viewId]->GetViewTab();
+    if (!tab)
+        return;
+    tab->Render();  
+}
+
+void cViewPlugin::ClearTab(int viewId) {
+    cPluginTabView *tab = views[viewId]->GetViewTab();
+    if (!tab)
+        return;
+    tab->Clear(); 
+}
+
+void cViewPlugin::Flush(void) {
+    if (viewChanged) {
+        viewChanged = false;
+        newTvFrame = views[newViewId]->GetTvFrame();
+        menuInit = true;
+    }
+    cView::Flush();
+}
+
+bool cViewPlugin::ChannelLogoExists(string channelId) {
+    return imgCache->LogoExists(channelId);
+}
+
+string cViewPlugin::GetEpgImagePath(void) {
+    return *config.epgImagePath;
+}
+
+/***********************************************************
+* Private Functions
+***********************************************************/
+void cViewPlugin::SetViewElements(void) {
+    plgManager->InitViewElementIterator(plugId, id);
+    int veId = -1;
+    string veName = "";
+    while (plgManager->GetNextViewElement(veId, veName)) {
+        viewElementNames.insert(pair<string, int>(veName, veId));
+    }
+}
+
+void cViewPlugin::SetViewGrids(void) {
+    plgManager->InitViewGridIterator(plugId, id);
+    int gId = -1;
+    string gName = "";
+    while (plgManager->GetNextViewGrid(gId, gName)) {
+        gridNames.insert(pair<string, int>(gName, gId));
+    }
+}
+
+int cViewPlugin::GridId(const char *name) {
+    map<string, int>::iterator hit = gridNames.find(name);
+    if (hit != gridNames.end())
+        return (int)hit->second;
+    return ATTR_UNKNOWN;    
+}
+
+/***********************************************************
+* cPluginTabView
+***********************************************************/
+cPluginTabView::cPluginTabView(int viewId, int plugId) {
+    sdOsd = NULL;
+    init = true;
+    drawScrollbar = true;
+    scrollbar = NULL;
+    tablabels = NULL;
+    detailView = new cViewDetailAdvancedPlugin(viewId, plugId);
+    firstTab = true;
+}
+
+cPluginTabView::~cPluginTabView(void) {
+    delete scrollbar;
+    delete tablabels;
+    delete detailView;
+}
+
+void cPluginTabView::SetGlobals(cGlobals *globals) {
+    detailView->SetGlobals(globals);
+    if (scrollbar)
+        scrollbar->SetGlobals(globals);
+    if (tablabels)
+        tablabels->SetGlobals(globals);
+}
+
+void cPluginTabView::AddTab(cArea *tab) {
+    if (firstTab) {
+        tab->SetActiveTab(true);
+        firstTab = false;
+    }
+    detailView->AddArea(tab);
+}
+
+void cPluginTabView::AddScrollbar(cVeDmScrollbar *scrollbar) {
+    this->scrollbar = scrollbar;
+}
+
+void cPluginTabView::AddTablabels(cVeDmTablabels *tablabels) {
+    this->tablabels = tablabels;
+}
+
+void cPluginTabView::PreCache(int containerX, int containerY, int containerWidth, int containerHeight) {
+    detailView->SetOsd(sdOsd);
+    detailView->SetTokenContainer();
+    detailView->SetContainer(containerX, containerY, containerWidth, containerHeight);
+    detailView->Cache();
+    if (scrollbar) {
+        scrollbar->SetContainer(containerX, containerY, containerWidth, containerHeight);
+        scrollbar->Cache();
+    }
+    if (tablabels) {
+        tablabels->SetContainer(containerX, containerY, containerWidth, containerHeight);
+        tablabels->Cache();        
+    }
+}
+
+void cPluginTabView::Set(skindesignerapi::cTokenContainer *tk) {
+    detailView->Set(tk);
+}
+
+void cPluginTabView::Render(void) {
+    detailView->Render();
+    if (drawScrollbar) {
+        drawScrollbar = false;
+        DrawScrollbar();
+    }
+    if (!init)
+        return;
+    init = false;
+    vector<const char*> tabs;
+    int activeTab = detailView->GetTabs(tabs);
+    if (tablabels) {        
+        tablabels->SetTabs(tabs);
+        tablabels->SetActiveTab(activeTab);
+        if (tablabels->Parse())
+            tablabels->Render();
+    }
+}
+
+void cPluginTabView::Clear(void) {
+    init = true;
+    drawScrollbar = true;
+    detailView->ResetTabs();
+    detailView->Close();
+    if (tablabels)
+        tablabels->Close();
+    if (scrollbar)
+        scrollbar->Close();
+}
+
+void cPluginTabView::KeyLeft(void) {
+    if (detailView->NumTabs() > 1) {
+        detailView->Clear();
+        detailView->PrevTab();
+        detailView->SetDirty();
+        if (tablabels) {
+            tablabels->Clear();
+            tablabels->SetActiveTab(detailView->ActiveTab());
+            if (tablabels->Parse())
+                tablabels->Render();
+        }
+        sdOsd->Flush();
+        drawScrollbar = true;
+    } else {
+        //scroll page
+        if (detailView->ScrollUp(true)) {
+            drawScrollbar = true;
+        }
+    }
+}
+
+void cPluginTabView::KeyRight(void) {
+    if (detailView->NumTabs() > 1) {
+        detailView->Clear();
+        detailView->NextTab();
+        detailView->SetDirty();
+        if (tablabels) {
+            tablabels->Clear();
+            tablabels->SetActiveTab(detailView->ActiveTab());
+            if (tablabels->Parse())
+                tablabels->Render();
+        }
+        sdOsd->Flush();
+        drawScrollbar = true;
+    } else {
+        //scroll page
+        if (detailView->ScrollDown(true)) {
+            drawScrollbar = true;
+        }
+    }
+}
+
+void cPluginTabView::KeyUp(void) {
+    if (detailView->ScrollUp()) {
+        drawScrollbar = true;
+    }
+}
+
+void cPluginTabView::KeyDown(void) {
+    if (detailView->ScrollDown()) {
+        drawScrollbar = true;
+    }
+}
+
+void cPluginTabView::DrawScrollbar(void) {
+    if (!scrollbar)
+        return;
+    int barheight = 0;
+    int offset = 0;
+    bool end = true;
+    detailView->Scrollbar(barheight, offset, end);
+    scrollbar->SetDetail(barheight, offset, end);
+    scrollbar->Render();    
+}
+

coreengine/viewdisplayplugin.h

@@ -0,0 +1,101 @@
+#ifndef __VIEWDISPLAYPLUGIN_H
+#define __VIEWDISPLAYPLUGIN_H
+
+#include "view.h"
+#include "viewdetail.h"
+#include "viewelementsdisplaymenu.h"
+#include "viewgrid.h"
+#include "../libskindesignerapi/skindesignerapi.h"
+
+class cPluginTabView;
+/***********************************************************
+* cViewPlugin
+***********************************************************/
+class cViewPlugin : public cView, public skindesignerapi::ISkinDisplayPlugin {
+private:
+    int id;
+    int plugId;
+    int numViews;
+    cViewPlugin **views;
+    int numViewGrids;
+    cViewGrid **viewGrids;
+    map<string,int> gridNames;
+    cPluginTabView *tabView;
+    bool viewChanged;
+    int newViewId;
+    void SetViewElements(void);
+    void SetViewGrids(void);
+    int GridId(const char *name);
+public:
+    cViewPlugin(int id, int plugId);
+    ~cViewPlugin(void);
+    //Internal Interface
+    bool ReadFromXML(const char *plugName, const char *tplName, cSdOsd *osd = NULL);
+    bool ReadSubViews(const char *plugName);
+    void AddViewElement(cVePlugin *viewElement);
+    void AddViewGrid(cViewGrid *viewGrid);
+    void AddTab(cArea *tab);
+    void AddScrollbar(cVeDmScrollbar *scrollbar);
+    void AddTablabels(cVeDmTablabels *tablabels);
+    void SetGlobals(cGlobals *globals);
+    void PreCache(void);
+    cVePlugin *GetViewElement(int veId);
+    cViewGrid *GetViewGrid(int gId);
+    cPluginTabView *GetViewTab(void);
+    void Hide(void);
+    void Show(void);
+    //libskindesigner api interface
+    bool InitOsd(void);
+    void CloseOsd(void);
+    void Deactivate(int viewId, bool hide);
+    void Activate(int viewId);
+    void SetViewElementTokens(int veId, int viewId, skindesignerapi::cTokenContainer *tk);
+    void ClearViewElement(int veId, int viewId);
+    void DisplayViewElement(int veId, int viewId);
+    void SetGrid(long gId, int viewId, int viewGridId,  double x, double y, double width, double height, skindesignerapi::cTokenContainer *tk);
+    void SetGridCurrent(long gId, int viewId, int viewGridId, bool current);
+    void DeleteGrid(long gId, int viewId, int viewGridId);
+    void DisplayGrids(int viewId, int viewGridId);
+    void ClearGrids(int viewId, int viewGridId);
+    void SetTabTokens(int viewId, skindesignerapi::cTokenContainer *tk);
+    void TabLeft(int viewId);
+    void TabRight(int viewId);
+    void TabUp(int viewId);
+    void TabDown(int viewId);
+    void DisplayTabs(int viewId);
+    void ClearTab(int viewId);
+    void Flush(void);
+    bool ChannelLogoExists(string channelId);
+    string GetEpgImagePath(void);
+};
+/***********************************************************
+* cPluginTabView
+***********************************************************/
+class cPluginTabView {
+private:
+    cSdOsd *sdOsd;
+    bool init;
+    bool drawScrollbar;
+    bool firstTab;
+    cVeDmScrollbar *scrollbar;
+    cVeDmTablabels *tablabels;
+    cViewDetailAdvancedPlugin *detailView;
+    void DrawScrollbar(void);
+public:
+    cPluginTabView(int viewId, int plugId);
+    ~cPluginTabView(void);
+    void SetGlobals(cGlobals *globals);
+    void SetOsd(cSdOsd *osd) { sdOsd = osd; };
+    void AddTab(cArea *tab);
+    void AddScrollbar(cVeDmScrollbar *scrollbar);
+    void AddTablabels(cVeDmTablabels *tablabels);
+    void PreCache(int containerX, int containerY, int containerWidth, int containerHeight);
+    void Set(skindesignerapi::cTokenContainer *tk);
+    void Render(void);
+    void Clear(void);
+    void KeyLeft(void);
+    void KeyRight(void);
+    void KeyUp(void);
+    void KeyDown(void);
+};
+#endif //__VIEWDISPLAYPLUGIN_H

coreengine/viewdisplayreplay.c

@@ -0,0 +1,314 @@
+#include "viewdisplayreplay.h"
+
+/************************************************************************************
+* cViewReplay
+************************************************************************************/
+
+cViewReplay::cViewReplay(void) {
+    veCustomTokens = NULL;
+    veEndTime = NULL;
+    veMessage = NULL;
+    veScraperContent = NULL;
+    veRecTitle = NULL;
+    veRecInfo = NULL;
+    veCurrentTime = NULL;
+    veTotalTime = NULL;
+    veProgressbar = NULL;
+    veCutMarks = NULL;
+    veProgressModeOnly = NULL;
+    veControlIcons = NULL;
+    veControlIconsModeOnly = NULL;
+    veJump = NULL;
+    veOnPause = NULL;
+    veOnPauseModeOnly = NULL;
+    ClearVariables();
+    viewId = eViewType::DisplayReplay;
+    viewName = strdup("displayreplay");
+    numViewElements = (int)eVeDisplayReplay::count;
+    viewElements = new cViewElement*[numViewElements];
+    for (int i=0; i < numViewElements; i++) {
+        viewElements[i] = NULL;
+    }
+    SetViewElements();
+}
+
+cViewReplay::~cViewReplay() {
+}
+
+void cViewReplay::SetViewElements(void) {
+    viewElementNames.insert(pair<string, int>("background", (int)eVeDisplayReplay::background));
+    viewElementNames.insert(pair<string, int>("backgroundmodeonly", (int)eVeDisplayReplay::backgroundmodeonly));
+    viewElementNames.insert(pair<string, int>("datetime", (int)eVeDisplayReplay::datetime));
+    viewElementNames.insert(pair<string, int>("time", (int)eVeDisplayReplay::time));
+    viewElementNames.insert(pair<string, int>("scrapercontent", (int)eVeDisplayReplay::scrapercontent));
+    viewElementNames.insert(pair<string, int>("rectitle", (int)eVeDisplayReplay::rectitle));
+    viewElementNames.insert(pair<string, int>("recinfo", (int)eVeDisplayReplay::recinfo));
+    viewElementNames.insert(pair<string, int>("currenttime", (int)eVeDisplayReplay::currenttime));
+    viewElementNames.insert(pair<string, int>("endtime", (int)eVeDisplayReplay::endtime));
+    viewElementNames.insert(pair<string, int>("totaltime", (int)eVeDisplayReplay::totaltime));
+    viewElementNames.insert(pair<string, int>("progressbar", (int)eVeDisplayReplay::progressbar));
+    viewElementNames.insert(pair<string, int>("cutmarks", (int)eVeDisplayReplay::cutmarks));
+    viewElementNames.insert(pair<string, int>("cutmarks", (int)eVeDisplayReplay::cutmarks));
+    viewElementNames.insert(pair<string, int>("controlicons", (int)eVeDisplayReplay::controlicons));
+    viewElementNames.insert(pair<string, int>("controliconsmodeonly", (int)eVeDisplayReplay::controliconsmodeonly));
+    viewElementNames.insert(pair<string, int>("progressmodeonly", (int)eVeDisplayReplay::progressmodeonly));
+    viewElementNames.insert(pair<string, int>("jump", (int)eVeDisplayReplay::jump));
+    viewElementNames.insert(pair<string, int>("message", (int)eVeDisplayReplay::message));
+    viewElementNames.insert(pair<string, int>("onpause", (int)eVeDisplayReplay::onpause));
+    viewElementNames.insert(pair<string, int>("onpausemodeonly", (int)eVeDisplayReplay::onpausemodeonly));
+    viewElementNames.insert(pair<string, int>("customtokens", (int)eVeDisplayReplay::customtokens));
+}
+
+void cViewReplay::SetViewElementObjects(void) {
+    for (int i = 0; i < numViewElements; i++) {
+        if (!viewElements[i])
+            continue;
+        if (dynamic_cast<cVeMessage*>(viewElements[i])) 
+        {
+            veMessage = dynamic_cast<cVeMessage*>(viewElements[i]);
+        }
+        else if (dynamic_cast<cVeDrScraperContent*>(viewElements[i])) 
+        {
+            veScraperContent = dynamic_cast<cVeDrScraperContent*>(viewElements[i]);
+        }
+        else if (dynamic_cast<cVeCustomTokens*>(viewElements[i])) 
+        {
+            veCustomTokens = dynamic_cast<cVeCustomTokens*>(viewElements[i]);
+        }
+        else if (dynamic_cast<cVeDrRecTitle*>(viewElements[i])) 
+        {
+            veRecTitle = dynamic_cast<cVeDrRecTitle*>(viewElements[i]);
+        }
+        else if (dynamic_cast<cVeDrRecInfo*>(viewElements[i])) 
+        {
+            veRecInfo = dynamic_cast<cVeDrRecInfo*>(viewElements[i]);
+        }
+        else if (dynamic_cast<cVeDrCurrentTime*>(viewElements[i])) 
+        {
+            veCurrentTime = dynamic_cast<cVeDrCurrentTime*>(viewElements[i]);
+        }
+        else if (dynamic_cast<cVeDrTotalTime*>(viewElements[i])) 
+        {
+            veTotalTime = dynamic_cast<cVeDrTotalTime*>(viewElements[i]);
+        }
+        else if (dynamic_cast<cVeDrEndTime*>(viewElements[i])) 
+        {
+            veEndTime = dynamic_cast<cVeDrEndTime*>(viewElements[i]);
+        }
+        else if (dynamic_cast<cVeDrProgressBar*>(viewElements[i])) 
+        {
+            veProgressbar = dynamic_cast<cVeDrProgressBar*>(viewElements[i]);
+        }
+        else if (dynamic_cast<cVeDrCutMarks*>(viewElements[i])) 
+        {
+            veCutMarks = dynamic_cast<cVeDrCutMarks*>(viewElements[i]);
+        }
+        else if (dynamic_cast<cVeDrProgressModeonly*>(viewElements[i])) 
+        {
+            veProgressModeOnly = dynamic_cast<cVeDrProgressModeonly*>(viewElements[i]);
+        }
+        else if (dynamic_cast<cVeDrControlIcons*>(viewElements[i]) && (i == (int)eVeDisplayReplay::controlicons)) 
+        {
+            veControlIcons = dynamic_cast<cVeDrControlIcons*>(viewElements[i]);
+        }
+        else if (dynamic_cast<cVeDrControlIcons*>(viewElements[i]) && i == (int)eVeDisplayReplay::controliconsmodeonly) 
+        {
+            veControlIconsModeOnly = dynamic_cast<cVeDrControlIcons*>(viewElements[i]);
+        }
+        else if (dynamic_cast<cVeDrJump*>(viewElements[i])) 
+        {
+            veJump = dynamic_cast<cVeDrJump*>(viewElements[i]);
+        }
+        else if (dynamic_cast<cVeDrOnPause*>(viewElements[i]) && i == (int)eVeDisplayReplay::onpause)
+        {
+            veOnPause = dynamic_cast<cVeDrOnPause*>(viewElements[i]);
+            veOnPause->SetDetached();
+            veOnPause->UnsetWaitOnWakeup();
+        }
+        else if (dynamic_cast<cVeDrOnPause*>(viewElements[i])  && i == (int)eVeDisplayReplay::onpausemodeonly) 
+        {
+            veOnPauseModeOnly = dynamic_cast<cVeDrOnPause*>(viewElements[i]);
+            veOnPauseModeOnly->SetDetached();
+            veOnPauseModeOnly->UnsetWaitOnWakeup();
+        }
+    }
+}
+
+void cViewReplay::ClearVariables(void) {
+    cView::ClearVariables();
+    modeOnly = false;
+    lastFlush = 0;
+    message = false;
+    reclength = -1;
+    timeShiftActive = false;
+    timeShiftFramesTotal = -1;
+    timeShiftLength = -1;
+    timeShiftDuration = "";
+    if (veCustomTokens)
+        veCustomTokens->Reset();
+    if (veEndTime)
+        veEndTime->Set(cString(""));
+    if (veCutMarks)
+        veCutMarks->Reset();
+}
+
+void cViewReplay::SetTimeShift(int framesTotal, int timeShiftLength) {
+    timeShiftActive = true;
+    timeShiftFramesTotal = framesTotal;
+    this->timeShiftLength = timeShiftLength;
+    int mins = (timeShiftLength / 60) % 60;
+    int hours = (timeShiftLength / 3600) % 24;
+    timeShiftDuration = cString::sprintf("%d:%02d", hours, mins);
+}
+
+void cViewReplay::SetRecording(const cRecording *recording) {
+    if (veRecTitle) {
+        veRecTitle->Set(recording);
+    }
+    if (veRecInfo) {
+        veRecInfo->Set(recording);
+    }
+    if (veScraperContent) {
+        veScraperContent->Set(recording);
+    }
+}
+
+void cViewReplay::SetTitle(const char *title) {
+    if (veRecTitle) {
+        veRecTitle->Set(title);
+    }    
+}
+
+void cViewReplay::SetCurrent(const char *current) {
+    if (veCurrentTime)
+        veCurrentTime->Set(current);
+    Render((int)eVeDisplayReplay::currenttime);
+    //good place to refresh these viewelements 
+    //since SetCurrent is called every second
+    Render((int)eVeDisplayReplay::datetime);
+    Render((int)eVeDisplayReplay::time);
+    Render((int)eVeDisplayChannel::customtokens);
+}
+
+void cViewReplay::SetTotal(const char *total) {
+    if (veTotalTime)
+        veTotalTime->Set(total, timeShiftActive, *timeShiftDuration);
+    Render((int)eVeDisplayReplay::totaltime);
+}
+
+void cViewReplay::SetEndTime(int current, int total) {
+    if (!veEndTime)
+        return;
+    int totalLength = total;
+    int recordingLength = reclength;
+    if (timeShiftActive && timeShiftFramesTotal > 0) {
+        totalLength = timeShiftFramesTotal;
+        recordingLength = timeShiftLength;
+    }
+    double rest = (double)(totalLength - current) / (double)totalLength;
+    time_t end = time(0) + rest*recordingLength;
+    veEndTime->Set(TimeString(end));
+    Render((int)eVeDisplayReplay::endtime);
+}
+
+void cViewReplay::SetProgressbar(int current, int total) {
+    if (veProgressbar)
+        veProgressbar->Set(current, total, timeShiftActive, timeShiftFramesTotal);
+    Render((int)eVeDisplayReplay::progressbar);
+}
+
+void cViewReplay::SetMarks(const cMarks *marks, int current, int total) {
+    if (veCutMarks)
+        veCutMarks->Set(marks, current, total, timeShiftActive, timeShiftFramesTotal);
+    Render((int)eVeDisplayReplay::cutmarks);
+}
+
+void cViewReplay::SetControlIcons(bool play, bool forward, int speed) {
+    if (!modeOnly) {
+        if (veControlIcons)
+            veControlIcons->Set(play, forward, speed);
+        Render((int)eVeDisplayReplay::controlicons);
+    } else {
+        if (veControlIconsModeOnly)
+            veControlIconsModeOnly->Set(play, forward, speed);
+        Render((int)eVeDisplayReplay::controliconsmodeonly);
+    }
+    
+}
+
+void cViewReplay::SetJump(const char *jump) {
+    if (veJump) {
+        if (!jump)
+            veJump->Clear();
+        else
+            veJump->Set(jump);
+    }
+    Render((int)eVeDisplayReplay::jump);
+}
+
+void cViewReplay::SetMessage(eMessageType type, const char *text) {
+    if (veMessage) {
+        if (text)
+            veMessage->Set(type, text);
+        else
+            veMessage->Clear();
+    }
+    Render((int)eVeDisplayReplay::message);
+}
+
+void cViewReplay::StartOnPause(const char *recfilename) {
+    cVeDrOnPause *onPause = (!modeOnly) ? veOnPause : veOnPauseModeOnly;
+    if (!onPause)
+        return;
+    onPause->Set(recfilename);
+    onPause->Parse(true);
+}
+
+void cViewReplay::ClearOnPause(void) {
+    cVeDrOnPause *onPause = (!modeOnly) ? veOnPause : veOnPauseModeOnly;
+    if (!onPause)
+        return;
+    onPause->Close();
+}
+
+void cViewReplay::Flush(void) {
+    if (init) {
+        sdOsd.LockFlush();
+        if (!modeOnly) {
+            Render((int)eVeDisplayReplay::background);
+            Render((int)eVeDisplayReplay::rectitle);
+            Render((int)eVeDisplayReplay::recinfo);
+            Render((int)eVeDisplayReplay::scrapercontent);
+        } else {
+            Render((int)eVeDisplayReplay::backgroundmodeonly);            
+        } 
+    }
+
+    if (modeOnly) {
+        SetProgressModeOnly();
+    }
+
+    cView::Flush();
+}
+
+void cViewReplay::SetProgressModeOnly(void) {
+    if (!veProgressModeOnly)
+        return;
+    time_t now = time(0);
+    if (now == lastFlush) {
+        return;
+    } 
+    lastFlush = now;
+
+    cControl *control = cControl::Control();
+    if (!control)
+        return;
+    double fps = control->FramesPerSecond();
+    int current = 0;
+    int total = 0;
+    if (!control->GetIndex(current, total))
+        return;
+    veProgressModeOnly->Set(fps, current, total);
+    if (veProgressModeOnly->Parse())
+        veProgressModeOnly->Render();
+}

coreengine/viewdisplayreplay.h

@@ -0,0 +1,57 @@
+#ifndef __VIEWDISPLAYREPLAY_H
+#define __VIEWDISPLAYREPLAY_H
+
+#include "view.h"
+
+class cViewReplay : public cView {
+private:
+    cVeMessage             *veMessage;
+    cVeCustomTokens        *veCustomTokens;
+    cVeDrRecTitle          *veRecTitle;
+    cVeDrRecInfo           *veRecInfo;
+    cVeDrScraperContent    *veScraperContent;
+    cVeDrCurrentTime       *veCurrentTime;
+    cVeDrTotalTime         *veTotalTime;
+    cVeDrEndTime           *veEndTime;
+    cVeDrProgressBar       *veProgressbar;
+    cVeDrCutMarks          *veCutMarks;
+    cVeDrProgressModeonly  *veProgressModeOnly;
+    cVeDrControlIcons      *veControlIcons;
+    cVeDrControlIcons      *veControlIconsModeOnly;
+    cVeDrJump              *veJump;
+    cVeDrOnPause           *veOnPause;
+    cVeDrOnPause           *veOnPauseModeOnly;
+    bool modeOnly;
+    time_t lastFlush;
+    bool message;
+    int reclength;
+    bool timeShiftActive;
+    int timeShiftFramesTotal;
+    int timeShiftLength;
+    cString timeShiftDuration;
+    void SetViewElements(void);
+    void ClearVariables(void);
+    void SetViewElementObjects(void);
+    void SetProgressModeOnly(void);
+public:
+    cViewReplay(void);
+    virtual ~cViewReplay(void);
+    void SetModeOnly(bool modeOnly) { this->modeOnly = modeOnly; };
+    void SetRecordingLength(int length) { reclength = length; };
+    void SetTimeShift(int framesTotal, int timeShiftLength);
+    void SetRecording(const cRecording *recording);
+    void SetTitle(const char *title);
+    void SetCurrent(const char *current);
+    void SetTotal(const char *total);
+    void SetEndTime(int current, int total);
+    void SetProgressbar(int current, int total);
+    void SetMarks(const cMarks *marks, int current, int total);
+    void SetControlIcons(bool play, bool forward, int speed);
+    void SetJump(const char *jump);
+    void SetMessage(eMessageType type, const char *text);
+    void StartOnPause(const char *recfilename);
+    void ClearOnPause(void);
+    void Flush(void);
+};
+
+#endif //__VIEWDISPLAYREPLAY_H1

coreengine/viewdisplaytracks.c

@@ -0,0 +1,122 @@
+#include "viewdisplaytracks.h"
+#include "../config.h"
+
+/************************************************************************************
+* cViewTracks
+************************************************************************************/
+
+cViewTracks::cViewTracks(void) {
+    ClearVariables();
+    viewId = eViewType::DisplayTracks;
+    viewName = strdup("displayaudiotracks");
+    numViewElements = (int)eVeDisplayTracks::count;
+    viewElements = new cViewElement*[numViewElements];
+    for (int i=0; i < numViewElements; i++) {
+        viewElements[i] = NULL;
+    }
+    viewList = NULL;
+    veBackground = NULL;
+    veHeader = NULL;
+    SetViewElements();
+}
+
+cViewTracks::~cViewTracks() {
+}
+
+void cViewTracks::SetViewElements(void) {
+    viewElementNames.insert(pair<string, int>("background", (int)eVeDisplayTracks::background));
+    viewElementNames.insert(pair<string, int>("header", (int)eVeDisplayTracks::header));
+}
+
+void cViewTracks::SetViewElementObjects(void) {
+    if (viewElements[(int)eVeDisplayTracks::background])
+        veBackground = dynamic_cast<cVeDtBackground*>(viewElements[(int)eVeDisplayTracks::background]);
+    if (viewElements[(int)eVeDisplayTracks::header])
+        veHeader = dynamic_cast<cVeDtHeader*>(viewElements[(int)eVeDisplayTracks::header]);
+}
+
+void cViewTracks::ClearVariables(void) {
+    init = true;
+    change = true;
+}
+
+void cViewTracks::Close(void) {
+    delete fader;
+    fader = NULL;
+    if (FadeTime() > 0) {
+        fader = new cAnimation((cFadable*)this, false);
+        fader->Fade();
+        delete fader;
+        fader = NULL;
+    }
+    for (int i=0; i < numViewElements; i++) {
+        if (viewElements[i]) {
+            viewElements[i]->Close();
+        }
+    }
+    if (viewList) {
+        viewList->Close();
+    }
+    ClearVariables();
+    sdOsd.DeleteOsd();
+}
+
+void cViewTracks::AddViewList(cViewList *viewList) {
+    this->viewList = dynamic_cast<cViewListAudioTracks*>(viewList);
+}
+
+void cViewTracks::PreCache(void) {
+    cView::PreCache();
+    if (viewList) {
+        viewList->SetContainer(0, 0, attribs->Width(), attribs->Height());
+        viewList->SetGlobals(globals);
+        viewList->PreCache();
+    }
+}
+
+void cViewTracks::SetTitle(const char *title) {
+    if (veHeader)
+        veHeader->SetTitle(title);
+    change = true;
+}
+
+void cViewTracks::SetNumtracks(int numTracks) {
+    if (veBackground)
+        veBackground->Set(numTracks);
+    if (veHeader)
+        veHeader->SetNumtracks(numTracks);
+    if (viewList)
+        viewList->SetNumtracks(numTracks);
+}
+
+void cViewTracks::SetAudiochannel(int audioChannel) {
+    if (veHeader)
+        veHeader->SetAudiochannel(audioChannel);
+    change = true;
+}
+
+void cViewTracks::SetTracks(const char * const *tracks) {
+    if (viewList)
+        viewList->SetTracks(tracks);
+    change = true;
+}
+
+void cViewTracks::SetCurrentTrack(int index) {
+    if (viewList)
+        viewList->SetCurrentTrack(index);    
+    change = true;
+}
+
+void cViewTracks::Flush(void) {
+    if (init) {
+        sdOsd.LockFlush();
+        Render((int)eVeDisplayTracks::background);
+    }
+    if (change) {
+        Render((int)eVeDisplayTracks::header);
+        if (viewList)
+            viewList->Draw();
+        change = false;
+    }
+    cView::Flush();
+}

coreengine/viewdisplaytracks.h

@@ -0,0 +1,29 @@
+#ifndef __VIEWDISPLAYTRACKS_H
+#define __VIEWDISPLAYTRACKS_H
+
+#include "view.h"
+
+class cViewTracks : public cView {
+private:
+    cViewListAudioTracks *viewList;
+    cVeDtBackground *veBackground;
+    cVeDtHeader *veHeader;
+    bool change;
+    void SetViewElements(void);
+    void SetViewElementObjects(void);
+    void ClearVariables(void);
+public:
+    cViewTracks(void);
+    virtual ~cViewTracks(void);
+    void Close(void);
+    void AddViewList(cViewList *viewList);
+    void PreCache(void);
+    void SetTitle(const char *title);
+    void SetNumtracks(int numTracks);
+    void SetTracks(const char * const *tracks);
+    void SetAudiochannel(int audioChannel);
+    void SetCurrentTrack(int index);
+    void Flush(void);
+};
+
+#endif //__VIEWDISPLAYTRACKS_H

coreengine/viewdisplayvolume.c

@@ -0,0 +1,52 @@
+#include "viewdisplayvolume.h"
+
+/************************************************************************************
+* cViewVolume
+************************************************************************************/
+
+cViewVolume::cViewVolume(void) {
+    viewId = eViewType::DisplayVolume;
+    viewName = strdup("displayvolume");
+    numViewElements = (int)eVeDisplayVolume::count;
+    viewElements = new cViewElement*[numViewElements];
+    for (int i=0; i < numViewElements; i++) {
+        viewElements[i] = NULL;
+    }
+    SetViewElements();
+    ClearVariables();
+    veVolume = NULL;
+}
+
+cViewVolume::~cViewVolume() {
+}
+
+void cViewVolume::SetViewElements(void) {
+    viewElementNames.insert(pair<string, int>("background", (int)eVeDisplayVolume::background));
+    viewElementNames.insert(pair<string, int>("volume", (int)eVeDisplayVolume::volume));
+}
+
+void cViewVolume::SetViewElementObjects(void) {
+    if (!viewElements[(int)eVeDisplayVolume::volume])
+        return;
+    veVolume = dynamic_cast<cVeVolume*>(viewElements[(int)eVeDisplayVolume::volume]);
+}
+
+void cViewVolume::ClearVariables(void) {
+    init = true;
+}
+
+void cViewVolume::SetVolume(int current, int total, bool mute) {
+    if (veVolume)
+        veVolume->Set(current, total, mute);
+}
+
+void cViewVolume::Flush(void) {
+    if (init) {
+        sdOsd.LockFlush();
+        Render((int)eVeDisplayVolume::background);
+    }
+    Render((int)eVeDisplayVolume::volume);
+    cView::Flush();
+}
+
+

coreengine/viewdisplayvolume.h

@@ -0,0 +1,19 @@
+#ifndef __VIEWDISPLAYVOLUME_H
+#define __VIEWDISPLAYVOLUME_H
+
+#include "view.h"
+
+class cViewVolume : public cView {
+private:
+    cVeVolume *veVolume;
+    void SetViewElements(void);
+    void SetViewElementObjects(void);
+    void ClearVariables(void);
+public:
+    cViewVolume(void);
+    virtual ~cViewVolume(void);
+    void SetVolume(int current, int total, bool mute);
+    void Flush(void);
+};
+
+#endif //__VIEWDISPLAYVOLUME_H

coreengine/viewelement.c

@@ -0,0 +1,532 @@
+#include "viewelement.h"
+#include "../config.h"
+
+/******************************************************************
+* cViewElement
+******************************************************************/
+cViewElement::cViewElement(void) {
+    sdOsd = NULL;
+    id = -1;
+    dirty = true;
+    init = true;
+    drawn = false;
+    scrollingStarted = false;
+    blocked = false;
+    detached = false;
+    waitOnWakeup = true;
+    startAnimation = true;
+    globals = NULL;
+    tokenContainer = NULL;
+    attribs = new cViewElementAttribs((int)eViewElementAttribs::count);
+    detacher = NULL;
+    fader = NULL;
+    shifter = NULL;
+}
+
+cViewElement::cViewElement(const cViewElement &other) {
+    sdOsd = other.sdOsd;
+    id = other.id;
+    dirty = other.dirty; 
+    init = other.init;
+    drawn = false;
+    scrollingStarted = false;
+    blocked = false;
+    detached = false;
+    waitOnWakeup = true;
+    startAnimation = true;
+    globals = other.globals;
+    container.Set(other.container.X(), other.container.Y(), other.container.Width(), other.container.Height());
+    tokenContainer = NULL;
+    attribs = new cViewElementAttribs(*other.attribs);
+
+    for (cAreaNode *node = other.areaNodes.First(); node; node = other.areaNodes.Next(node)) {
+        if (cArea *a = dynamic_cast<cArea*>(node)) {
+            areaNodes.Add(new cArea(*a));
+        } else if (cAreaContainer *ac = dynamic_cast<cAreaContainer*>(node)) {
+            areaNodes.Add(new cAreaContainer(*ac));
+        } 
+    }
+    
+    detacher = NULL;
+    fader = NULL;
+    shifter = NULL;
+}
+
+cViewElement::~cViewElement(void) {
+    delete attribs;
+    delete detacher;
+    delete fader;
+    delete shifter;
+    delete tokenContainer;
+}
+
+/******************************************************************
+* Public Functions
+******************************************************************/
+cViewElement *cViewElement::CreateViewElement(const char *name, const char *viewname) {
+    cViewElement *e = NULL;
+    
+    //common view elements
+    if (!strcmp(name, "background") && strcmp(viewname, "displayaudiotracks"))
+        e = new cViewElement();
+    else if (!strcmp(name, "datetime"))
+        e = new cVeDateTime();
+    else if (!strcmp(name, "time"))
+        e = new cVeTime();
+    else if (!strcmp(name, "message"))
+        e = new cVeMessage();
+    else if (!strcmp(name, "devices"))
+        e = new cVeDevices();
+    else if (!strcmp(name, "currentweather"))
+        e = new cVeCurrentWeather();
+    else if (!strcmp(name, "customtokens"))
+        e = new cVeCustomTokens();
+    
+    //displaychannel viewelements
+    else if (!strcmp(name, "channelinfo"))
+        e = new cVeDcChannelInfo();
+    else if (!strcmp(name, "channelgroup"))
+        e = new cVeDcChannelGroup();
+    else if (!strcmp(name, "epginfo"))
+        e = new cVeDcEpgInfo();
+    else if (!strcmp(name, "progressbar") && !strcmp(viewname, "displaychannel"))
+        e = new cVeDcProgressBar();
+    else if (!strcmp(name, "statusinfo"))
+        e = new cVeDcStatusInfo();
+    else if (!strcmp(name, "audioinfo"))
+        e = new cVeDcAudioInfo();
+    else if (!strcmp(name, "screenresolution"))
+        e = new cVeDcScreenResolution();
+    else if (!strcmp(name, "signalquality"))
+        e = new cVeDcSignalQuality();
+    else if (!strcmp(name, "scrapercontent") && !strcmp(viewname, "displaychannel"))
+        e = new cVeDcScraperContent();
+    else if (!strcmp(name, "ecminfo"))
+        e = new cVeDcEcmInfo();
+    
+    //displaymenu viewelements
+    else if (!strcmp(name, "header") && strcmp(viewname, "displayaudiotracks"))
+        e = new cVeDmHeader();
+    else if (!strcmp(name, "sortmode"))
+        e = new cVeDmSortmode();
+    else if (!strcmp(name, "colorbuttons"))
+        e = new cVeDmColorbuttons();
+    else if (!strcmp(name, "scrollbar"))
+        e = new cVeDmScrollbar();
+    else if (!strcmp(name, "timers"))
+        e = new cVeDmTimers();
+    else if (!strcmp(name, "currentschedule"))
+        e = new cVeDmCurrentschedule();
+    else if (!strcmp(name, "discusage"))
+        e = new cVeDmDiscusage();
+    else if (!strcmp(name, "systemload"))
+        e = new cVeDmSystemload();
+    else if (!strcmp(name, "systemmemory"))
+        e = new cVeDmSystemmemory();
+    else if (!strcmp(name, "temperatures"))
+        e = new cVeDmTemperatures();
+    else if (!strcmp(name, "vdrstatistics"))
+        e = new cVeDmVdrstatistics();
+    else if (!strcmp(name, "lastrecordings"))
+        e = new cVeDmLastrecordings();
+    else if (!strcmp(name, "detailheaderepg"))
+        e = new cVeDmDetailheaderEpg();
+    else if (!strcmp(name, "detailheaderrec"))
+        e = new cVeDmDetailheaderRec();
+    else if (!strcmp(name, "detailheaderplugin"))
+        e = new cVeDmDetailheaderPlugin();
+    else if (!strcmp(name, "tablabels"))
+        e = new cVeDmTablabels();
+
+    //displayreplay viewelements
+    else if (!strcmp(name, "backgroundmodeonly"))
+        e = new cViewElement();
+    else if (!strcmp(name, "rectitle"))
+        e = new cVeDrRecTitle();
+    else if (!strcmp(name, "recinfo"))
+        e = new cVeDrRecInfo();
+    else if (!strcmp(name, "currenttime"))
+        e = new cVeDrCurrentTime();
+    else if (!strcmp(name, "totaltime"))
+        e = new cVeDrTotalTime();
+    else if (!strcmp(name, "endtime"))
+        e = new cVeDrEndTime();
+    else if (!strcmp(name, "progressbar") && !strcmp(viewname, "displayreplay"))
+        e = new cVeDrProgressBar();
+    else if (!strcmp(name, "cutmarks"))
+        e = new cVeDrCutMarks();
+    else if (!strcmp(name, "controlicons"))
+        e = new cVeDrControlIcons();
+    else if (!strcmp(name, "controliconsmodeonly"))
+        e = new cVeDrControlIcons();
+    else if (!strcmp(name, "progressmodeonly"))
+        e = new cVeDrProgressModeonly();
+    else if (!strcmp(name, "jump"))
+        e = new cVeDrJump();
+    else if (!strcmp(name, "onpause"))
+        e = new cVeDrOnPause();
+    else if (!strcmp(name, "onpausemodeonly"))
+        e = new cVeDrOnPause();
+    else if (!strcmp(name, "scrapercontent") && !strcmp(viewname, "displayreplay"))
+        e = new cVeDrScraperContent();
+
+    //displayvolume viewelements
+    else if (!strcmp(name, "volume"))
+        e = new cVeVolume();
+
+    //displayvolume viewelements
+    else if (!strcmp(name, "background") && !strcmp(viewname, "displayaudiotracks"))
+        e = new cVeDtBackground();
+    else if (!strcmp(name, "header") && !strcmp(viewname, "displayaudiotracks"))
+        e = new cVeDtHeader();
+
+    //default
+    else {
+        dsyslog("skindesigner: unknown view element %s", name);
+        e = new cViewElement();
+    }
+
+    return e;
+}
+
+void cViewElement::SetGlobals(cGlobals *globals) {
+    this->globals = globals;
+    attribs->SetGlobals(globals);
+    for (cAreaNode *node = areaNodes.First(); node; node = areaNodes.Next(node)) {
+        node->SetGlobals(globals);
+    }
+}
+
+void cViewElement::SetTokenContainer(void) {
+    tokenContainer = new skindesignerapi::cTokenContainer();
+    InheritTokenContainer();
+}
+
+bool cViewElement::Detached(void) {
+    return detached;
+}
+
+void cViewElement::SetContainer(int x, int y, int width, int height) {
+    container.SetX(x);
+    container.SetY(y);
+    container.SetWidth(width);
+    container.SetHeight(height);
+}
+
+void cViewElement::SetAttributes(vector<stringpair> &attributes) { 
+    attribs->Set(attributes); 
+}
+
+void cViewElement::AddArea(cAreaNode *area) {
+    areaNodes.Add(area);
+}
+
+void cViewElement::SetAreaX(int x) {
+    for (cAreaNode *node = areaNodes.First(); node; node = areaNodes.Next(node)) {
+        node->SetX(x);
+    }
+}
+
+void cViewElement::SetAreaY(int y) {
+    for (cAreaNode *node = areaNodes.First(); node; node = areaNodes.Next(node)) {
+        node->SetY(y);
+    }
+}
+
+void cViewElement::SetAreaWidth(int width) {
+    for (cAreaNode *node = areaNodes.First(); node; node = areaNodes.Next(node)) {
+        node->SetWidth(width);
+    }
+}
+
+void cViewElement::SetAreaHeight(int height) {
+    for (cAreaNode *node = areaNodes.First(); node; node = areaNodes.Next(node)) {
+        node->SetHeight(height);
+    }
+}
+
+void cViewElement::SetPosition(int newX, int newY, int newWidth, int newHeight) {
+    cRect newPos(newX, newY, newWidth, newHeight);
+    for (cAreaNode *node = areaNodes.First(); node; node = areaNodes.Next(node)) {
+        node->SetViewPort(newPos);
+    }    
+}
+
+void cViewElement::Cache(void) {
+    attribs->SetContainer(container.X(), container.Y(), container.Width(), container.Height());
+    attribs->Cache();
+    for (cAreaNode *node = areaNodes.First(); node; node = areaNodes.Next(node)) {
+        node->SetContainer(container.X(), container.Y(), container.Width(), container.Height());
+        node->Cache();
+    }
+}
+
+bool cViewElement::Execute(void) {
+    return attribs->DoExecute();
+}
+
+void cViewElement::Clear(void) {
+    tokenContainer->Clear();
+    for (cAreaNode *node = areaNodes.First(); node; node = areaNodes.Next(node)) {
+        sdOsd->Lock();
+        node->Clear();
+        sdOsd->Unlock();
+    }
+    dirty = false;
+    drawn = false;
+    scrollingStarted = false;
+}
+
+void cViewElement::Hide(void) {
+    for (cAreaNode *node = areaNodes.First(); node; node = areaNodes.Next(node)) {
+        sdOsd->Lock();
+        node->Hide();
+        sdOsd->Unlock();
+    }
+    init = true;
+    StopScrolling();
+}
+
+void cViewElement::Show(void) {
+    for (cAreaNode *node = areaNodes.First(); node; node = areaNodes.Next(node)) {
+        sdOsd->Lock();
+        node->Show();
+        sdOsd->Unlock();
+    }
+}
+
+void cViewElement::WakeUp(void) {
+    if (!detacher || !waitOnWakeup) {
+        return;
+    }
+    detacher->WakeUp();
+}
+
+void cViewElement::Close(void) {
+    delete detacher;
+    detacher = NULL;
+    for (cAreaNode *node = areaNodes.First(); node; node = areaNodes.Next(node)) {
+        sdOsd->Lock();
+        node->Close();
+        sdOsd->Unlock();
+    }
+    StopScrolling();
+    dirty = true;
+    init = true;
+    startAnimation = true;
+    drawn = false;
+    scrollingStarted = false;
+    blocked = false;
+}
+
+void cViewElement::Render(void) {
+    if (!dirty || blocked)
+        return;
+
+    if (attribs->DoDebug())
+        Debug();
+    
+    for (cAreaNode *node = areaNodes.First(); node; node = areaNodes.Next(node)) {
+        //Check redraw of already scrolling list element
+        if (drawn && scrollingStarted && node->Scrolling()) {
+            if (DoScroll()) {
+                //current list element
+                continue;
+            } else {
+                //not current list element anymore
+                scrollingStarted = false;
+            }
+        }
+        sdOsd->Lock();
+        node->Clear();
+        sdOsd->Unlock();
+        if (!node->Execute())
+            continue;
+        if (node->BackgroundArea() && drawn)
+            continue;
+        sdOsd->Lock();
+        node->Render();
+        sdOsd->Unlock();
+        
+        if (DoScroll() && node->Scrolling()) {
+            cArea *scrollArea = node->ScrollingArea();
+            if (scrollArea) {
+                scrollingStarted = true;
+                cAnimation *scroller = new cAnimation(scrollArea); 
+                scrollers.Add(scroller);
+                scroller->Start();                
+            }
+        }     
+    }
+    dirty = false;
+    drawn = true;
+    if (startAnimation) {
+        startAnimation = false;
+        StartAnimation();
+    }
+}
+
+void cViewElement::StopScrolling(bool deletePixmaps) {
+    for (cAnimation *scroller = scrollers.First(); scroller; scroller = scrollers.Next(scroller)) {
+        scroller->Stop(deletePixmaps);
+    }
+    scrollers.Clear();
+}
+
+void cViewElement::ParseDetached(void) {
+    Parse(true);
+}
+
+void cViewElement::RenderDetached(void) {
+    blocked = false;
+    Render();
+}
+
+bool cViewElement::Shifting(void) {
+    if (attribs->ShiftTime() >= 0) {
+        return true;
+    }
+    return false;
+}
+
+bool cViewElement::Fading(void) {
+    if (attribs->FadeTime() >= 0) {
+        return true;
+    }
+    return false;
+}
+
+int cViewElement::FadeTime(void) {
+    return attribs->FadeTime();
+}
+
+int cViewElement::ShiftTime(void) {
+    return attribs->ShiftTime();
+}
+
+int cViewElement::ShiftMode(void) {
+    return attribs->ShiftMode();
+}
+
+void cViewElement::StartAnimation(void) {
+    if (ShiftTime() > 0) {
+        cRect shiftbox = CoveredArea();
+        cPoint ref = cPoint(shiftbox.X(), shiftbox.Y());
+        cPoint start = ShiftStart(shiftbox);
+        SetPosition(start, ref);
+        sdOsd->Flush();
+        delete shifter;
+        shifter = new cAnimation((cShiftable*)this, start, ref, true);
+        shifter->Start();
+    } else if (FadeTime() > 0) {
+        SetTransparency(100);
+        sdOsd->Flush();
+        delete fader;
+        fader = new cAnimation((cFadable*)this, true);
+        fader->Start();
+    }
+}
+
+void cViewElement::SetTransparency(int transparency, bool force) {
+    for (cAreaNode *node = areaNodes.First(); node; node = areaNodes.Next(node)) {
+        sdOsd->Lock();
+        node->SetTransparency(transparency);
+        sdOsd->Unlock();
+    }
+}
+
+void cViewElement::SetPosition(cPoint &position, cPoint &reference, bool force) {
+    for (cAreaNode *node = areaNodes.First(); node; node = areaNodes.Next(node)) {
+        sdOsd->Lock();
+        node->SetPosition(position, reference);
+        sdOsd->Unlock();
+    }
+}
+
+cRect cViewElement::CoveredArea(void) {
+    cRect unionArea;
+    for (cAreaNode *node = areaNodes.First(); node; node = areaNodes.Next(node)) {
+        unionArea.Combine(node->CoveringArea());
+    }
+    return unionArea;
+}
+
+void cViewElement::Flush(void) {
+    sdOsd->Flush();
+}
+
+bool cViewElement::Parse(bool forced) { 
+    if (blocked && !forced) {
+        return false;
+    }
+    if (!Detached() || !init) {
+        return true;
+    }
+    delete detacher;
+    detacher = new cAnimation((cDetachable*)this, waitOnWakeup, startAnimation);
+    detacher->Start();
+    startAnimation = false;
+    init = false;
+    blocked = true;
+    return false;
+}
+
+cFunction *cViewElement::GetFunction(const char *name) {
+    for (cAreaNode *node = areaNodes.First(); node; node = areaNodes.Next(node)) {
+        if (cFunction *f = node->GetFunction(name))
+            return f;
+    }
+    return NULL;
+}
+
+void cViewElement::Debug(bool full) {
+    esyslog("skindesigner: ---> viewElement %d", id);
+    tokenContainer->Debug();
+    esyslog("skindesigner: container %d %d %dx%d", container.X(), container.Y(), container.Width(), container.Height());
+    attribs->Debug();
+    if (!full)
+        return;
+    for (cAreaNode *node = areaNodes.First(); node; node = areaNodes.Next(node)) {
+        node->Debug(full);
+    }    
+}
+
+/******************************************************************
+* protected Functions
+******************************************************************/
+void cViewElement::InheritTokenContainer(void) {
+    tokenContainer->CreateContainers();
+    attribs->SetTokenContainer(tokenContainer);
+    for (cAreaNode *node = areaNodes.First(); node; node = areaNodes.Next(node)) {
+        node->SetTokenContainer(tokenContainer);
+    }
+}
+
+void cViewElement::InheritTokenContainerDeep(void) {
+    tokenContainer->CreateContainers();
+    attribs->SetTokenContainerDeep(tokenContainer);
+    for (cAreaNode *node = areaNodes.First(); node; node = areaNodes.Next(node)) {
+        node->SetTokenContainerDeep(tokenContainer);
+    }    
+}
+
+cPoint cViewElement::ShiftStart(cRect &shiftbox) {
+    eShiftType type = (eShiftType)attribs->ShiftType();
+    cPoint start;
+    if (type == eShiftType::none) {
+        start = attribs->ShiftStartpoint();
+    } else if (type == eShiftType::left) {
+        start.SetX(-shiftbox.Width());
+        start.SetY(shiftbox.Y());
+    } else if (type == eShiftType::right) {
+        start.SetX(cOsd::OsdWidth());
+        start.SetY(shiftbox.Y());        
+    } else if (type == eShiftType::top) {
+        start.SetX(shiftbox.X());
+        start.SetY(-shiftbox.Height());        
+    } else if (type == eShiftType::bottom) {
+        start.SetX(shiftbox.X());
+        start.SetY(cOsd::OsdHeight());
+    }
+    return start;
+}

coreengine/viewelement.h

@@ -0,0 +1,93 @@
+#ifndef __VIEWELEMENT_H
+#define __VIEWELEMENT_H
+
+#include <iostream>
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdint.h>
+#include <vdr/tools.h>
+#include "osdwrapper.h"
+#include "globals.h"
+#include "../libskindesignerapi/tokencontainer.h"
+#include "area.h"
+#include "animation.h"
+
+/******************************************************************
+* cViewElement
+******************************************************************/
+class cViewElement : public cDetachable, public cFadable, public cShiftable {
+protected:
+    cSdOsd *sdOsd;
+    int id;
+    bool init;
+    bool drawn;
+    bool dirty;
+    bool blocked;
+    bool detached;
+    bool waitOnWakeup;
+    bool scrollingStarted;
+    bool startAnimation;
+    cGlobals *globals;
+    cRect container;
+    cViewElementAttribs *attribs;
+    cList<cAreaNode> areaNodes;
+    skindesignerapi::cTokenContainer *tokenContainer;
+    cList<cAnimation> scrollers;
+    cAnimation *detacher;
+    cAnimation *fader;
+    cAnimation *shifter;
+    void InheritTokenContainer(void);
+    void InheritTokenContainerDeep(void);
+    virtual bool DoScroll(void) { return true; };
+    cPoint ShiftStart(cRect &shiftbox);
+public:
+    cViewElement(void);
+    cViewElement(const cViewElement &other);
+    virtual ~cViewElement(void);
+    void SetOsd(cSdOsd *osd) { sdOsd = osd; };
+    static cViewElement *CreateViewElement(const char *name, const char *viewname);
+    void SetId(int id) { this->id = id; };
+    void SetGlobals(cGlobals *globals);
+    virtual void SetTokenContainer(void);
+    void SetDetached(void) { detached = true; };
+    void UnsetWaitOnWakeup(void) { waitOnWakeup = false; };
+    bool Detached(void);
+    void SetContainer(int x, int y, int width, int height);
+    void SetAttributes(vector<stringpair> &attributes);
+    void AddArea(cAreaNode *area);
+    void SetAreaX(int x);
+    void SetAreaY(int y);
+    void SetAreaWidth(int width);
+    void SetAreaHeight(int height);
+    void Cache(void);
+    virtual void Close(void);
+    virtual void Clear(void);
+    void Hide(void);
+    void Show(void);
+    void WakeUp(void);
+    bool Execute(void);
+    void SetDirty(void) { dirty = true; };
+    bool Dirty(void) { return dirty; };
+    void SetPosition(int newX, int newY, int newWidth, int newHeight);
+    virtual void Render(void);
+    void StopScrolling(bool deletePixmaps = true);
+    eOrientation Orientation(void) { return attribs->Orientation(); };
+    virtual int Delay(void) { return attribs->Delay(); };
+    void ParseDetached(void);
+    void RenderDetached(void);
+    bool Shifting(void);
+    bool Fading(void);
+    int FadeTime(void);
+    int ShiftTime(void);
+    int ShiftMode(void);
+    void StartAnimation(void);
+    virtual void SetTransparency(int transparency, bool force = false);
+    virtual void SetPosition(cPoint &position, cPoint &reference, bool force = false);
+    cRect CoveredArea(void);
+    void Flush(void);
+    virtual bool Parse(bool forced = false);
+    cFunction *GetFunction(const char *name);
+    virtual void Debug(bool full = false);
+};
+
+#endif //__VIEWELEMENT_H

coreengine/viewelementplugin.c

@@ -0,0 +1,36 @@
+#include "viewelementplugin.h"
+#include "../config.h"
+
+cVePlugin::cVePlugin(void) {
+    plugId = -1;
+    viewId = -1;
+}
+
+cVePlugin::~cVePlugin(void) {
+}
+
+void cVePlugin::Close(void) {
+    cViewElement::Close();
+}
+
+void cVePlugin::SetTokenContainer(void) {
+    skindesignerapi::cTokenContainer *tkVe = plgManager->GetTokenContainerVE(plugId, viewId, id);
+    if (!tkVe)
+        return;
+    tokenContainer = new skindesignerapi::cTokenContainer(*tkVe);
+    InheritTokenContainer();
+}
+
+void cVePlugin::Set(skindesignerapi::cTokenContainer *tk) {
+    tokenContainer->Clear();
+    tokenContainer->SetTokens(tk);
+    SetDirty();
+}
+
+bool cVePlugin::Parse(bool forced) {
+    if (!cViewElement::Parse(forced))
+        return false;
+    if (!dirty)
+        return false;
+    return true;
+}

coreengine/viewelementplugin.h

@@ -0,0 +1,22 @@
+#ifndef __VIEWELEMENTPLUGIN_H
+#define __VIEWELEMENTPLUGIN_H
+
+#include "viewelement.h"
+
+class cVePlugin : public cViewElement {
+private:
+    int plugId;
+    int viewId;
+public:
+    cVePlugin(void);
+    virtual ~cVePlugin(void);
+    void SetPluginId(int plugId) { this->plugId = plugId; };
+    void SetViewId(int viewId) { this->viewId = viewId; };
+    void Close(void);
+    void SetTokenContainer(void);
+    void Set(skindesignerapi::cTokenContainer *tk);
+    bool Parse(bool forced = false);
+    const char *Name(void) { return attribs->Name(); };
+};
+
+#endif //__VIEWELEMENTPLUGIN_H

coreengine/viewelementscommon.c

@@ -0,0 +1,531 @@
+#include "viewelementscommon.h"
+#include "../config.h"
+#include "../services/weatherforecast.h"
+
+/******************************************************************
+* cVeDateTime
+******************************************************************/
+cVeDateTime::cVeDateTime(void) {
+    lastMinute = -1;
+}
+
+cVeDateTime::~cVeDateTime(void) {
+}
+
+void cVeDateTime::Close(void) {
+    lastMinute = -1;
+    cViewElement::Close();
+}
+
+void cVeDateTime::SetTokenContainer(void) {
+    tokenContainer = new skindesignerapi::cTokenContainer();
+    tokenContainer->DefineStringToken("{time}", (int)eDateTimeST::time);
+    tokenContainer->DefineStringToken("{dayleadingzero}", (int)eDateTimeST::dayleadingzero);
+    tokenContainer->DefineStringToken("{dayname}", (int)eDateTimeST::dayname);
+    tokenContainer->DefineStringToken("{daynameshort}", (int)eDateTimeST::daynameshort);
+    tokenContainer->DefineStringToken("{month}", (int)eDateTimeST::month);
+    tokenContainer->DefineStringToken("{monthname}", (int)eDateTimeST::monthname);
+    tokenContainer->DefineStringToken("{monthnameshort}", (int)eDateTimeST::monthnameshort);
+    tokenContainer->DefineIntToken("{day}", (int)eDateTimeIT::day);
+    tokenContainer->DefineIntToken("{year}", (int)eDateTimeIT::year);
+    InheritTokenContainer();
+}
+
+bool cVeDateTime::Parse(bool forced) {
+    if (!cViewElement::Parse(forced))
+        return false;
+    time_t t = time(0);   // get time now
+    struct tm * now = localtime(&t);
+    int min = now->tm_min;
+    if (!forced && min == lastMinute) {
+        return false;
+    }
+    lastMinute = min;
+    SetDirty();
+
+    tokenContainer->Clear();
+    tokenContainer->AddIntToken((int)eDateTimeIT::year, now->tm_year + 1900);
+    tokenContainer->AddIntToken((int)eDateTimeIT::day, now->tm_mday);
+
+    char monthname[20];
+    char monthshort[10];
+    strftime(monthshort, sizeof(monthshort), "%b", now);
+    strftime(monthname, sizeof(monthname), "%B", now);
+
+    tokenContainer->AddStringToken((int)eDateTimeST::monthname, monthname);
+    tokenContainer->AddStringToken((int)eDateTimeST::monthnameshort, monthshort);
+    tokenContainer->AddStringToken((int)eDateTimeST::month, *cString::sprintf("%02d", now->tm_mon + 1));
+    tokenContainer->AddStringToken((int)eDateTimeST::dayleadingzero, *cString::sprintf("%02d", now->tm_mday));
+    tokenContainer->AddStringToken((int)eDateTimeST::dayname, *WeekDayNameFull(now->tm_wday));
+    tokenContainer->AddStringToken((int)eDateTimeST::daynameshort, *WeekDayName(now->tm_wday));
+    tokenContainer->AddStringToken((int)eDateTimeST::time, *TimeString(t));
+    return true;
+}
+
+/******************************************************************
+* cVeTime
+******************************************************************/
+cVeTime::cVeTime(void) {
+    lastSecond = -1;
+}
+
+cVeTime::~cVeTime(void) {
+}
+
+void cVeTime::Close(void) {
+    lastSecond = -1;
+    cViewElement::Close();
+}
+
+void cVeTime::SetTokenContainer(void) {
+    tokenContainer = new skindesignerapi::cTokenContainer();
+    tokenContainer->DefineIntToken("{sec}", (int)eTimeIT::sec);
+    tokenContainer->DefineIntToken("{min}", (int)eTimeIT::min);
+    tokenContainer->DefineIntToken("{hour}", (int)eTimeIT::hour);
+    tokenContainer->DefineIntToken("{hmins}", (int)eTimeIT::hmins);
+    InheritTokenContainer();
+}
+
+bool cVeTime::Parse(bool forced) {
+    if (!cViewElement::Parse(forced))
+        return false;
+    time_t t = time(0);   // get time now
+    struct tm * now = localtime(&t);
+    int sec = now->tm_sec;
+    if (!forced && sec == lastSecond) {
+        return false;
+    }
+    lastSecond = sec;
+    SetDirty();
+
+    int min = now->tm_min;
+    int hour = now->tm_hour;
+    int hourMinutes = hour%12 * 5 + min / 12;
+
+    tokenContainer->Clear();
+    tokenContainer->AddIntToken((int)eTimeIT::sec, sec);
+    tokenContainer->AddIntToken((int)eTimeIT::min, min);
+    tokenContainer->AddIntToken((int)eTimeIT::hour, hour);
+    tokenContainer->AddIntToken((int)eTimeIT::hmins, hourMinutes);
+    return true;
+}
+/******************************************************************
+* cVeMessage
+******************************************************************/
+cVeMessage::cVeMessage(void) {
+    changed = false;
+    text = NULL;
+    type = mtStatus;
+}
+
+cVeMessage::~cVeMessage(void) {
+    free(text);
+}
+
+void cVeMessage::SetTokenContainer(void) {
+    tokenContainer = new skindesignerapi::cTokenContainer();
+    tokenContainer->DefineStringToken("{text}", (int)eMessageST::text);
+    tokenContainer->DefineIntToken("{status}", (int)eMessageIT::status);
+    tokenContainer->DefineIntToken("{info}", (int)eMessageIT::info);
+    tokenContainer->DefineIntToken("{warning}", (int)eMessageIT::warning);
+    tokenContainer->DefineIntToken("{error}", (int)eMessageIT::error);
+    InheritTokenContainer();
+}
+
+void cVeMessage::Set(eMessageType type, const char *text) {
+    if (!text)
+        return;
+    free(this->text);
+    this->text = strdup(text);
+    this->type = type; 
+    changed = true;
+}
+
+bool cVeMessage::Parse(bool forced) {
+    if (!cViewElement::Parse(forced) || !changed)
+        return false;
+
+    tokenContainer->Clear();
+    tokenContainer->AddIntToken((int)eMessageIT::status, (type == mtStatus)  ? true : false);
+    tokenContainer->AddIntToken((int)eMessageIT::info, (type == mtInfo)  ? true : false);
+    tokenContainer->AddIntToken((int)eMessageIT::warning, (type == mtWarning)  ? true : false);
+    tokenContainer->AddIntToken((int)eMessageIT::error, (type == mtError)  ? true : false);
+    tokenContainer->AddStringToken((int)eMessageST::text, text);
+    SetDirty();
+    changed = false;
+    return true;
+}
+
+/******************************************************************
+* cVeDevices
+******************************************************************/
+cVeDevices::cVeDevices(void) {
+    lastRefresh = 0;
+    initial = true;
+    devicesIndex = -1;
+    lastSignalStrength = NULL;
+    lastSignalQuality = NULL;
+    recDevices = NULL;
+}
+
+cVeDevices::~cVeDevices(void) {
+    mutexDevices.Lock();
+    delete[] lastSignalStrength;
+    lastSignalStrength = NULL;
+    delete[] lastSignalQuality;
+    lastSignalQuality = NULL;
+    delete[] recDevices;
+    recDevices = NULL;
+    mutexDevices.Unlock();
+}
+
+void cVeDevices::Init(void) {
+    light = (attribs->Mode() == (int)eViewElementMode::light) ? true : false;  
+    int totalDevices = cDevice::NumDevices();
+    for (int i = 0; i < totalDevices; i++) {
+        const cDevice *device = cDevice::GetDevice(i);
+        if (!device || !device->NumProvidedSystems()) {
+            continue;
+        }
+        devices.push_back(i);
+    }
+    numDevices = devices.size();    
+    lastSignalStrength = new int[numDevices];
+    lastSignalQuality = new int[numDevices];
+    recDevices = new bool[numDevices];
+    mutexDevices.Lock();
+    for (int i=0; i<numDevices; i++) {
+        lastSignalStrength[i] = 0;
+        lastSignalQuality[i] = 0;
+        recDevices[i] = false;
+    }
+    mutexDevices.Unlock();
+}
+
+void cVeDevices::Close(void) {
+    devices.clear();
+    initial = true;
+    numDevices = 0;
+    mutexDevices.Lock();
+    delete[] lastSignalStrength;
+    lastSignalStrength = NULL;
+    delete[] lastSignalQuality;
+    lastSignalQuality = NULL;
+    delete[] recDevices;
+    recDevices = NULL;
+    mutexDevices.Unlock();
+    cViewElement::Close();
+}
+
+void cVeDevices::SetTokenContainer(void) {
+    tokenContainer = new skindesignerapi::cTokenContainer();
+    tokenContainer->DefineIntToken("{numdevices}", (int)eDevicesIT::numdevices);
+    tokenContainer->DefineLoopToken("{devices[num]}", (int)eDevicesLT::num);
+    tokenContainer->DefineLoopToken("{devices[type]}", (int)eDevicesLT::type);
+    tokenContainer->DefineLoopToken("{devices[istuned]}", (int)eDevicesLT::istuned);
+    tokenContainer->DefineLoopToken("{devices[livetv]}", (int)eDevicesLT::livetv);
+    tokenContainer->DefineLoopToken("{devices[recording]}", (int)eDevicesLT::recording);
+    tokenContainer->DefineLoopToken("{devices[hascam]}", (int)eDevicesLT::hascam);
+    tokenContainer->DefineLoopToken("{devices[cam]}", (int)eDevicesLT::cam);
+    tokenContainer->DefineLoopToken("{devices[signalstrength]}", (int)eDevicesLT::signalstrength);
+    tokenContainer->DefineLoopToken("{devices[signalquality]}", (int)eDevicesLT::signalquality);
+    tokenContainer->DefineLoopToken("{devices[channelnumber]}", (int)eDevicesLT::channelnumber);
+    tokenContainer->DefineLoopToken("{devices[channelname]}", (int)eDevicesLT::channelname);
+    tokenContainer->DefineLoopToken("{devices[channellogoexists]}", (int)eDevicesLT::channellogoexists);
+    tokenContainer->DefineLoopToken("{devices[channelid]}", (int)eDevicesLT::channelid);
+    tokenContainer->DefineLoopToken("{devices[source]}", (int)eDevicesLT::source);
+
+    devicesIndex = tokenContainer->LoopIndex("devices");
+    InheritTokenContainer();
+}
+
+bool cVeDevices::Parse(bool forced) {
+    if (!cViewElement::Parse(forced))
+        return false;
+    if (initial) {
+        Init();
+        initial = false;
+    } else {
+        //in light modus content is static
+        if (light)
+            return false;
+        //check if drawing is necessary
+        if (lastRefresh - cTimeMs::Now() < 500)
+            return false;
+        bool changed = false;
+        for (int i = 0; i < numDevices; i++) {
+            const cDevice *device = cDevice::GetDevice(devices[i]);
+            if (!device || !device->NumProvidedSystems()) {
+                continue;
+            }
+            int signalStrength = device->SignalStrength();
+            int signalQuality = device->SignalQuality();
+            int lastSigStr = 0;
+            int lastSigQual = 0;
+            mutexDevices.Lock();
+            if (lastSignalStrength && lastSignalQuality) {
+                lastSigStr = lastSignalStrength[i];
+                lastSigQual = lastSignalQuality[i];
+            }
+            mutexDevices.Unlock();
+            if ((signalStrength != lastSigStr) || (signalQuality != lastSigQual)) {
+                changed = true;
+                break;
+            }            
+        }
+        if (!changed) {
+            return false;
+        }
+    }
+
+    //check device which currently displays live tv
+    int deviceLiveTV = -1;
+    cDevice *primaryDevice = cDevice::PrimaryDevice();
+    if (primaryDevice) {
+        if (!primaryDevice->Replaying() || primaryDevice->Transferring())
+            deviceLiveTV = cDevice::ActualDevice()->DeviceNumber();
+        else
+            deviceLiveTV = primaryDevice->DeviceNumber();
+    }
+    //check currently recording devices
+    for (cTimer *timer = Timers.First(); timer; timer = Timers.Next(timer)) {
+        if (!timer->Recording()) {
+            continue;
+        }
+        if (cRecordControl *RecordControl = cRecordControls::GetRecordControl(timer)) {
+            const cDevice *recDevice = RecordControl->Device();
+            if (recDevice) {
+                mutexDevices.Lock();
+                if (recDevices)
+                    recDevices[recDevice->DeviceNumber()] = true;
+                mutexDevices.Unlock();
+            }
+        }
+    }
+
+    //create loop container
+    tokenContainer->Clear();
+    
+    vector<int> loopInfo;
+    loopInfo.push_back(numDevices);
+    tokenContainer->CreateLoopTokenContainer(&loopInfo);
+    tokenContainer->AddIntToken((int)eDevicesIT::numdevices, numDevices);
+
+    for (int i = 0; i < numDevices; i++) {
+        const cDevice *device = cDevice::GetDevice(devices[i]);
+        if (!device || !device->NumProvidedSystems()) {
+            continue;
+        }
+        tokenContainer->AddLoopToken(devicesIndex, i, (int)eDevicesLT::num, *cString::sprintf("%d", i));
+        tokenContainer->AddLoopToken(devicesIndex, i, (int)eDevicesLT::type, *(device->DeviceType()));
+
+        cCamSlot *camSlot = device->CamSlot();
+        int camNumber = -1;
+        if (camSlot) {
+            camNumber = camSlot->SlotNumber();
+            tokenContainer->AddLoopToken(devicesIndex, i, (int)eDevicesLT::hascam, "1");
+        } else {
+            tokenContainer->AddLoopToken(devicesIndex, i, (int)eDevicesLT::hascam, "0");
+        }
+        tokenContainer->AddLoopToken(devicesIndex, i, (int)eDevicesLT::cam, *cString::sprintf("%d", camNumber));
+
+        int signalStrength = 0;
+        int signalQuality = 0;
+        if (!light) {
+            signalStrength = device->SignalStrength();
+            signalQuality = device->SignalQuality();
+        }
+        tokenContainer->AddLoopToken(devicesIndex, i, (int)eDevicesLT::signalstrength, *cString::sprintf("%d", signalStrength));
+        tokenContainer->AddLoopToken(devicesIndex, i, (int)eDevicesLT::signalstrength, *cString::sprintf("%d", signalQuality));
+        tokenContainer->AddLoopToken(devicesIndex, i, (int)eDevicesLT::livetv, i == deviceLiveTV ? "1" : "0");
+
+        bool isRecording = false;
+        mutexDevices.Lock();
+        if (recDevices && recDevices[i])
+            isRecording = true;
+        mutexDevices.Unlock();
+        tokenContainer->AddLoopToken(devicesIndex, i, (int)eDevicesLT::recording, isRecording ? "1" : "0");
+
+        const cChannel *channel = device->GetCurrentlyTunedTransponder();
+        const cSource *source = (channel) ? Sources.Get(channel->Source()) : NULL;
+        if (channel && channel->Number() > 0) {
+            tokenContainer->AddLoopToken(devicesIndex, i, (int)eDevicesLT::channelnumber, *cString::sprintf("%d", channel->Number()));
+            tokenContainer->AddLoopToken(devicesIndex, i, (int)eDevicesLT::channelname, channel->Name());
+            string channelID = *(channel->GetChannelID().ToString());
+            tokenContainer->AddLoopToken(devicesIndex, i, (int)eDevicesLT::channelid, channelID.c_str());
+            tokenContainer->AddLoopToken(devicesIndex, i, (int)eDevicesLT::channellogoexists, imgCache->LogoExists(channelID) ? "1" : "0");
+            tokenContainer->AddLoopToken(devicesIndex, i, (int)eDevicesLT::istuned, "1");
+        } else {
+            tokenContainer->AddLoopToken(devicesIndex, i, (int)eDevicesLT::istuned, "0");
+        }
+    
+        tokenContainer->AddLoopToken(devicesIndex, i, (int)eDevicesLT::source, source ? source->Description() : "");
+
+        mutexDevices.Lock();
+        if (lastSignalStrength)
+            lastSignalStrength[i] = signalStrength;
+        if (lastSignalQuality)
+            lastSignalQuality[i] = signalQuality;
+        mutexDevices.Unlock();
+    }
+
+    SetDirty();
+    lastRefresh = cTimeMs::Now();
+    return true;
+}
+/******************************************************************
+* cVeCurrentWeather
+******************************************************************/
+cVeCurrentWeather::cVeCurrentWeather(void) {
+}
+
+cVeCurrentWeather::~cVeCurrentWeather(void) {
+}
+
+void cVeCurrentWeather::SetTokenContainer(void) {
+    tokenContainer = new skindesignerapi::cTokenContainer();
+    tokenContainer->DefineStringToken("{timestamp}", (int)eCurrentWeatherST::timestamp);
+    tokenContainer->DefineStringToken("{summary}", (int)eCurrentWeatherST::summary);
+    tokenContainer->DefineStringToken("{icon}", (int)eCurrentWeatherST::icon);
+    tokenContainer->DefineStringToken("{precipitationtype}", (int)eCurrentWeatherST::precipitationtype);
+    tokenContainer->DefineStringToken("{windbearingstring}", (int)eCurrentWeatherST::windbearingstring);
+    tokenContainer->DefineStringToken("{temperature}", (int)eCurrentWeatherST::temperature);
+    tokenContainer->DefineStringToken("{apparenttemperature}", (int)eCurrentWeatherST::apparenttemperature);
+    tokenContainer->DefineStringToken("{mintemperature}", (int)eCurrentWeatherST::mintemperature);
+    tokenContainer->DefineStringToken("{maxtemperature}", (int)eCurrentWeatherST::maxtemperature);
+    tokenContainer->DefineStringToken("{precipitationintensity}", (int)eCurrentWeatherST::precipitationintensity);
+    tokenContainer->DefineStringToken("{windspeed}", (int)eCurrentWeatherST::windspeed);
+    tokenContainer->DefineStringToken("{visibility}", (int)eCurrentWeatherST::visibility);
+    tokenContainer->DefineStringToken("{pressure}", (int)eCurrentWeatherST::pressure);
+    tokenContainer->DefineStringToken("{ozone}", (int)eCurrentWeatherST::ozone);
+    tokenContainer->DefineIntToken("{precipitationprobability}", (int)eCurrentWeatherIT::precipitationprobability);
+    tokenContainer->DefineIntToken("{humidity}", (int)eCurrentWeatherIT::humidity);
+    tokenContainer->DefineIntToken("{windbearing}", (int)eCurrentWeatherIT::windbearing);
+    tokenContainer->DefineIntToken("{cloudcover}", (int)eCurrentWeatherIT::cloudcover);
+    InheritTokenContainer();
+}
+
+bool cVeCurrentWeather::Parse(bool forced) {
+    if (!cViewElement::Parse(forced))
+        return false;
+    static cPlugin *pWeatherForecast = cPluginManager::GetPlugin("weatherforecast");
+    if (!pWeatherForecast)
+        return false;
+    cServiceCurrentWeather currentWeather;
+    if (!pWeatherForecast->Service("GetCurrentWeather", &currentWeather)) {
+        return false;
+    }
+    SetDirty();
+    tokenContainer->Clear();
+    tokenContainer->AddStringToken((int)eCurrentWeatherST::timestamp, currentWeather.timeStamp.c_str());
+    tokenContainer->AddStringToken((int)eCurrentWeatherST::temperature, currentWeather.temperature.c_str());
+    tokenContainer->AddStringToken((int)eCurrentWeatherST::apparenttemperature, currentWeather.apparentTemperature.c_str());
+    tokenContainer->AddStringToken((int)eCurrentWeatherST::mintemperature, currentWeather.minTemperature.c_str());
+    tokenContainer->AddStringToken((int)eCurrentWeatherST::maxtemperature, currentWeather.maxTemperature.c_str());
+    tokenContainer->AddStringToken((int)eCurrentWeatherST::summary, currentWeather.summary.c_str());
+    tokenContainer->AddStringToken((int)eCurrentWeatherST::icon, currentWeather.icon.c_str());
+    tokenContainer->AddStringToken((int)eCurrentWeatherST::precipitationintensity, currentWeather.precipitationIntensity.c_str());
+    tokenContainer->AddStringToken((int)eCurrentWeatherST::precipitationtype, currentWeather.precipitationType.c_str());
+    tokenContainer->AddStringToken((int)eCurrentWeatherST::windspeed, currentWeather.windSpeed.c_str());
+    tokenContainer->AddStringToken((int)eCurrentWeatherST::windbearingstring, currentWeather.windBearingString.c_str());
+    tokenContainer->AddStringToken((int)eCurrentWeatherST::visibility, currentWeather.visibility.c_str());
+    tokenContainer->AddStringToken((int)eCurrentWeatherST::pressure, currentWeather.pressure.c_str());
+    tokenContainer->AddStringToken((int)eCurrentWeatherST::ozone, currentWeather.ozone.c_str());
+    tokenContainer->AddIntToken((int)eCurrentWeatherIT::precipitationprobability, currentWeather.precipitationProbability);
+    tokenContainer->AddIntToken((int)eCurrentWeatherIT::humidity, currentWeather.humidity);
+    tokenContainer->AddIntToken((int)eCurrentWeatherIT::windbearing, currentWeather.windBearing);
+    tokenContainer->AddIntToken((int)eCurrentWeatherIT::cloudcover, currentWeather.cloudCover);
+    return true;
+}
+/******************************************************************
+* cVeCustomTokens
+******************************************************************/
+cVeCustomTokens::cVeCustomTokens(void) {
+}
+
+cVeCustomTokens::~cVeCustomTokens(void) {
+}
+
+void cVeCustomTokens::Reset(void) {
+    globals->ResetCustomTokenChange();
+}
+
+void cVeCustomTokens::SetTokenContainer(void) {
+    tokenContainer = new skindesignerapi::cTokenContainer();
+    int numTokens = config.numCustomTokens;
+    for (int i=0; i < numTokens; i++) {
+        cString nameIntToken = cString::sprintf("{customint%d}", i+1);
+        cString nameStringToken = cString::sprintf("{customstring%d}", i+1);
+        tokenContainer->DefineStringToken(*nameStringToken, i);
+        tokenContainer->DefineIntToken(*nameIntToken, i);
+    }
+    InheritTokenContainer();
+}
+
+bool cVeCustomTokens::Parse(bool forced) {
+    if (!cViewElement::Parse(forced))
+        return false;
+
+    if (!globals->CustomTokenChange())
+        return false;
+
+    tokenContainer->Clear();
+    map <int, string> customStringTokens = globals->GetCustomStringTokens();
+    for (map<int, string>::iterator it = customStringTokens.begin(); it != customStringTokens.end(); it++) {
+        int index = it->first;
+        if (index > 0 && index <= config.numCustomTokens) {
+            tokenContainer->AddStringToken(index-1, it->second.c_str());
+        }
+    }
+    map <int, int> customIntTokkens = globals-> GetCustomIntTokens();
+    for (map<int, int>::iterator it = customIntTokkens.begin(); it != customIntTokkens.end(); it++) {
+        int index = it->first;
+        if (index > 0 && index <= config.numCustomTokens) {
+            tokenContainer->AddIntToken(index-1, it->second);
+        }
+    }
+    SetDirty();
+    return true;
+}
+
+/******************************************************************
+* cVeVolume
+******************************************************************/
+cVeVolume::cVeVolume(void) {
+    current = 0;
+    total = 0;
+    mute = false;
+    changed = true;
+}
+
+cVeVolume::~cVeVolume(void) {
+}
+
+void cVeVolume::SetTokenContainer(void) {
+    tokenContainer = new skindesignerapi::cTokenContainer();
+    tokenContainer->DefineIntToken("{volume}", (int)eDVVolumeIT::volume);
+    tokenContainer->DefineIntToken("{volpercent}", (int)eDVVolumeIT::volpercent);
+    tokenContainer->DefineIntToken("{maxvolume}", (int)eDVVolumeIT::maxvolume);
+    tokenContainer->DefineIntToken("{mute}", (int)eDVVolumeIT::mute);
+    InheritTokenContainer();
+}
+
+void cVeVolume::Set(int current, int total, bool mute) {
+    this->current = current;
+    this->total = total;
+    this->mute = mute;
+    changed = true;
+}
+
+bool cVeVolume::Parse(bool forced) {
+    if (!cViewElement::Parse(forced) || !changed)
+        return false;
+    tokenContainer->Clear();
+    tokenContainer->AddIntToken((int)eDVVolumeIT::volume, current);
+    tokenContainer->AddIntToken((int)eDVVolumeIT::maxvolume, total);
+    tokenContainer->AddIntToken((int)eDVVolumeIT::volpercent, (double)current *100 / (double)total);
+    tokenContainer->AddIntToken((int)eDVVolumeIT::mute, mute);
+    changed = false;
+    SetDirty();
+    return true;
+}

coreengine/viewelementscommon.h

@@ -0,0 +1,110 @@
+#ifndef __VIEWELEMENTSCOMMON_H
+#define __VIEWELEMENTSCOMMON_H
+
+#include <vdr/menu.h>
+#include "viewelement.h"
+
+/******************************************************************
+* cVeDateTime
+******************************************************************/
+class cVeDateTime : public cViewElement {
+private:
+    int lastMinute;
+public:
+    cVeDateTime(void);
+    virtual ~cVeDateTime(void);
+    void Close(void);
+    void SetTokenContainer(void);
+    bool Parse(bool forced = false);
+};
+/******************************************************************
+* cVeTime
+******************************************************************/
+class cVeTime : public cViewElement {
+private:
+    int lastSecond;
+public:
+    cVeTime(void);
+    virtual ~cVeTime(void);
+    void Close(void);
+    void SetTokenContainer(void);
+    bool Parse(bool forced = false);
+};
+/******************************************************************
+* cVeMessage
+******************************************************************/
+class cVeMessage : public cViewElement {
+private:
+    bool changed;
+    eMessageType type;
+    char *text;
+public:
+    cVeMessage(void);
+    virtual ~cVeMessage(void);
+    void SetTokenContainer(void);
+    void Set(eMessageType type, const char *text);
+    bool Parse(bool forced = false);
+};
+/******************************************************************
+* cVeDevices
+******************************************************************/
+class cVeDevices : public cViewElement {
+private:
+    bool light;
+    time_t lastRefresh;
+    vector<int> devices;
+    bool initial;
+    int devicesIndex;
+    cMutex mutexDevices;
+    int numDevices;
+    int* lastSignalStrength;
+    int* lastSignalQuality;
+    bool* recDevices;
+    void Init(void);
+public:
+    cVeDevices(void);
+    virtual ~cVeDevices(void);
+    void Close(void);
+    void SetTokenContainer(void);
+    bool Parse(bool forced = false);
+};
+/******************************************************************
+* cVeCurrentWeather
+******************************************************************/
+class cVeCurrentWeather : public cViewElement {
+private:
+public:
+    cVeCurrentWeather(void);
+    virtual ~cVeCurrentWeather(void);
+    void SetTokenContainer(void);
+    bool Parse(bool forced = false);
+};
+/******************************************************************
+* cVeCustomTokens
+******************************************************************/
+class cVeCustomTokens : public cViewElement {
+private:
+public:
+    cVeCustomTokens(void);
+    virtual ~cVeCustomTokens(void);
+    void Reset(void);
+    void SetTokenContainer(void);
+    bool Parse(bool forced = false);
+};
+/******************************************************************
+* cVeVolume
+******************************************************************/
+class cVeVolume : public cViewElement {
+private:
+    int current;
+    int total;
+    bool mute;
+    bool changed;
+public:
+    cVeVolume(void);
+    virtual ~cVeVolume(void);
+    void SetTokenContainer(void);
+    void Set(int current, int total, bool mute);
+    bool Parse(bool forced = false);
+};
+#endif //__VIEWELEMENTSCOMMON_H

coreengine/viewelementsdisplaychannel.c

@@ -0,0 +1,650 @@
+#include "viewelementsdisplaychannel.h"
+#include "../config.h"
+#include "../extensions/helpers.h"
+#include "../extensions/timers.h"
+#include "../services/scraper2vdr.h"
+
+/******************************************************************
+* cVeDcChannelInfo
+******************************************************************/
+cVeDcChannelInfo::cVeDcChannelInfo(void) {
+}
+
+cVeDcChannelInfo::~cVeDcChannelInfo(void) {
+}
+
+void cVeDcChannelInfo::SetTokenContainer(void) {
+    tokenContainer = new skindesignerapi::cTokenContainer();
+    tokenContainer->DefineStringToken("{channelnumber}", (int)eDCChannelInfoST::channelnumber);
+    tokenContainer->DefineStringToken("{channelname}", (int)eDCChannelInfoST::channelname);
+    tokenContainer->DefineStringToken("{channelid}", (int)eDCChannelInfoST::channelid);
+    tokenContainer->DefineIntToken("{channellogoexists}", (int)eDCChannelInfoIT::channellogoexists);
+    tokenContainer->DefineIntToken("{switching}", (int)eDCChannelInfoIT::switching);
+    InheritTokenContainer();
+}
+
+void cVeDcChannelInfo::Set(const cChannel *c, int number) {
+    cString channelNumber("");
+    cString channelName("");
+    cString channelId("");
+    if (c) {
+        channelName = c->Name() ? c->Name() : "";
+        channelId = c->GetChannelID().ToString();
+        if (!c->GroupSep()) {
+            channelNumber = cString::sprintf("%d%s", c->Number(), number ? "-" : "");
+        }
+    } else if (number) {
+        channelNumber = cString::sprintf("%d-", number);
+    } else {
+        channelName = ChannelString(NULL, 0);
+    }
+
+    tokenContainer->Clear();
+    tokenContainer->AddStringToken((int)eDCChannelInfoST::channelnumber, *channelNumber);
+    tokenContainer->AddStringToken((int)eDCChannelInfoST::channelname, *channelName);
+    tokenContainer->AddStringToken((int)eDCChannelInfoST::channelid, *channelId);
+    bool logoExists = imgCache->LogoExists(*channelId);
+    tokenContainer->AddIntToken((int)eDCChannelInfoIT::channellogoexists, logoExists);
+    tokenContainer->AddIntToken((int)eDCChannelInfoIT::switching, (number > 0)?true:false);
+
+    SetDirty();
+}
+
+/******************************************************************
+* cVeDcChannelGroup
+******************************************************************/
+cVeDcChannelGroup::cVeDcChannelGroup(void) {
+}
+
+cVeDcChannelGroup::~cVeDcChannelGroup(void) {
+}
+
+void cVeDcChannelGroup::SetTokenContainer(void) {
+    tokenContainer = new skindesignerapi::cTokenContainer();
+    tokenContainer->DefineStringToken("{group}", (int)eDCChannelGroupST::group);
+    tokenContainer->DefineStringToken("{nextgroup}", (int)eDCChannelGroupST::nextgroup);
+    tokenContainer->DefineStringToken("{prevgroup}", (int)eDCChannelGroupST::prevgroup);
+    tokenContainer->DefineStringToken("{seppath}", (int)eDCChannelGroupST::seppath);
+    tokenContainer->DefineIntToken("{prevAvailable}", (int)eDCChannelGroupIT::prevAvailable);
+    tokenContainer->DefineIntToken("{nextAvailable}", (int)eDCChannelGroupIT::nextAvailable);
+    tokenContainer->DefineIntToken("{sepexists}", (int)eDCChannelGroupIT::sepexists);
+    InheritTokenContainer();
+}
+
+void cVeDcChannelGroup::Set(const cChannel *c) {
+    const char *sep = c->Name(); 
+    bool sepExists = imgCache->SeparatorLogoExists(sep);
+
+    const char *prevChannelSep = GetChannelSep(c, true);
+    const char *nextChannelSep = GetChannelSep(c, false);
+
+    tokenContainer->Clear();
+    tokenContainer->AddStringToken((int)eDCChannelGroupST::group, sep);
+    tokenContainer->AddStringToken((int)eDCChannelGroupST::nextgroup, nextChannelSep ? nextChannelSep : "");
+    tokenContainer->AddStringToken((int)eDCChannelGroupST::prevgroup, prevChannelSep ? prevChannelSep : "");
+    tokenContainer->AddStringToken((int)eDCChannelGroupST::seppath, sepExists ? sep : "");
+    tokenContainer->AddIntToken((int)eDCChannelGroupIT::prevAvailable, (prevChannelSep)?true:false);
+    tokenContainer->AddIntToken((int)eDCChannelGroupIT::nextAvailable, (nextChannelSep)?true:false);
+    tokenContainer->AddIntToken((int)eDCChannelGroupIT::sepexists, sepExists);
+
+    SetDirty();
+}
+
+const char *cVeDcChannelGroup::GetChannelSep(const cChannel *c, bool prev) {
+    const cChannel *sep = prev ? Channels.Prev(c) :
+                                 Channels.Next(c);
+    for (; sep; (prev)?(sep = Channels.Prev(sep)):(sep = Channels.Next(sep))) {
+        if (sep->GroupSep()) {
+            return sep->Name();
+        }
+    }
+    return NULL;
+}
+/******************************************************************
+* cVeDcEpgInfo
+******************************************************************/
+cVeDcEpgInfo::cVeDcEpgInfo(void) {
+}
+
+cVeDcEpgInfo::~cVeDcEpgInfo(void) {
+}
+
+void cVeDcEpgInfo::SetTokenContainer(void) {
+    tokenContainer = new skindesignerapi::cTokenContainer();
+    tokenContainer->DefineStringToken("{currenttitle}", (int)eDCEpgInfoST::currenttitle);
+    tokenContainer->DefineStringToken("{currentsubtitle}", (int)eDCEpgInfoST::currentsubtitle);
+    tokenContainer->DefineStringToken("{currentstart}", (int)eDCEpgInfoST::currentstart);
+    tokenContainer->DefineStringToken("{currentstop}", (int)eDCEpgInfoST::currentstop);
+    tokenContainer->DefineStringToken("{nexttitle}", (int)eDCEpgInfoST::nexttitle);
+    tokenContainer->DefineStringToken("{nextsubtitle}", (int)eDCEpgInfoST::nextsubtitle);
+    tokenContainer->DefineStringToken("{nextstart}", (int)eDCEpgInfoST::nextstart);
+    tokenContainer->DefineStringToken("{nextstop}", (int)eDCEpgInfoST::nextstop);
+    tokenContainer->DefineIntToken("{currentduration}", (int)eDCEpgInfoIT::currentduration);
+    tokenContainer->DefineIntToken("{currentdurationhours}", (int)eDCEpgInfoIT::currentdurationhours);
+    tokenContainer->DefineIntToken("{currentdurationminutes}", (int)eDCEpgInfoIT::currentdurationminutes);
+    tokenContainer->DefineIntToken("{currentelapsed}", (int)eDCEpgInfoIT::currentelapsed);
+    tokenContainer->DefineIntToken("{currentremaining}", (int)eDCEpgInfoIT::currentremaining);
+    tokenContainer->DefineIntToken("{nextduration}", (int)eDCEpgInfoIT::nextduration);
+    tokenContainer->DefineIntToken("{nextdurationhours}", (int)eDCEpgInfoIT::nextdurationhours);
+    tokenContainer->DefineIntToken("{nextdurationminutes}", (int)eDCEpgInfoIT::nextdurationminutes);
+    tokenContainer->DefineIntToken("{nextrecording}", (int)eDCEpgInfoIT::nextrecording);
+    tokenContainer->DefineIntToken("{currentrecording}", (int)eDCEpgInfoIT::currentrecording);
+    tokenContainer->DefineIntToken("{hasVPS}", (int)eDCEpgInfoIT::hasVPS);
+    InheritTokenContainer();
+}
+
+void cVeDcEpgInfo::Set(const cEvent *p, const cEvent *f) {
+    tokenContainer->Clear();
+    if (p) {
+        tokenContainer->AddStringToken((int)eDCEpgInfoST::currenttitle, p->Title());
+        tokenContainer->AddStringToken((int)eDCEpgInfoST::currentsubtitle, p->ShortText());
+        tokenContainer->AddStringToken((int)eDCEpgInfoST::currentstart, *p->GetTimeString());
+        tokenContainer->AddStringToken((int)eDCEpgInfoST::currentstop, *p->GetEndTimeString());
+        tokenContainer->AddIntToken((int)eDCEpgInfoIT::currentduration, p->Duration() / 60);
+        tokenContainer->AddIntToken((int)eDCEpgInfoIT::currentdurationhours, p->Duration() / 3600);
+        tokenContainer->AddIntToken((int)eDCEpgInfoIT::currentdurationminutes, (p->Duration() / 60) % 60);
+        tokenContainer->AddIntToken((int)eDCEpgInfoIT::currentelapsed, (int)round((time(NULL) - p->StartTime())/60));
+        tokenContainer->AddIntToken((int)eDCEpgInfoIT::currentremaining, (int)round((p->EndTime() - time(NULL))/60));
+        tokenContainer->AddIntToken((int)eDCEpgInfoIT::currentrecording, EventHasTimer(p));
+        tokenContainer->AddIntToken((int)eDCEpgInfoIT::hasVPS, (bool)p->Vps());
+    }
+    if (f) {
+        tokenContainer->AddStringToken((int)eDCEpgInfoST::nexttitle, f->Title());
+        tokenContainer->AddStringToken((int)eDCEpgInfoST::nextsubtitle, f->ShortText());
+        tokenContainer->AddStringToken((int)eDCEpgInfoST::nextstart, *f->GetTimeString());
+        tokenContainer->AddStringToken((int)eDCEpgInfoST::nextstop, *f->GetEndTimeString());
+        tokenContainer->AddIntToken((int)eDCEpgInfoIT::nextduration, f->Duration() / 60);
+        tokenContainer->AddIntToken((int)eDCEpgInfoIT::nextdurationhours, f->Duration() / 3600);
+        tokenContainer->AddIntToken((int)eDCEpgInfoIT::nextdurationminutes, (f->Duration() / 60) % 60);
+        tokenContainer->AddIntToken((int)eDCEpgInfoIT::hasVPS, (bool)f->Vps());
+    }
+    SetDirty();
+}
+
+bool cVeDcEpgInfo::EventHasTimer(const cEvent *e) {
+    if (!e) return false;
+    cGlobalSortedTimers SortedTimers;// local and remote timers
+    bool hasTimer = e->HasTimer();
+    for (int i = 0; i < SortedTimers.Size() && !hasTimer; i++) 
+        if (const cTimer *Timer = SortedTimers[i]) 
+            if (Timer->Channel()->GetChannelID() == e->ChannelID()) 
+                if (const cEvent *timerEvent = Timer->Event())
+                    if (e->EventID() == timerEvent->EventID())
+                        hasTimer = true;
+    return hasTimer;
+}
+
+/******************************************************************
+* cVeDcProgressBar
+******************************************************************/
+cVeDcProgressBar::cVeDcProgressBar(void) {
+    currentLast = -1;
+    startTime = -1;
+    duration = -1;
+}
+
+cVeDcProgressBar::~cVeDcProgressBar(void) {
+}
+
+void cVeDcProgressBar::Close(void) {
+    currentLast = -1;
+    startTime = -1;
+    duration = -1;
+    cViewElement::Close();
+}
+
+void cVeDcProgressBar::SetTokenContainer(void) {
+    tokenContainer = new skindesignerapi::cTokenContainer();
+    tokenContainer->DefineStringToken("{start}", (int)eDCProgressBarST::start);
+    tokenContainer->DefineStringToken("{stop}", (int)eDCProgressBarST::stop);
+    tokenContainer->DefineIntToken("{duration}", (int)eDCProgressBarIT::duration);
+    tokenContainer->DefineIntToken("{elapsed}", (int)eDCProgressBarIT::elapsed);
+    tokenContainer->DefineIntToken("{remaining}", (int)eDCProgressBarIT::remaining);
+    tokenContainer->DefineIntToken("{permashift}", (int)eDCProgressBarIT::permashift);
+    tokenContainer->DefineIntToken("{livebuffer}", (int)eDCProgressBarIT::livebuffer);
+    InheritTokenContainer();
+}
+
+void cVeDcProgressBar::Set(const cEvent *p) {
+    if (!p) {
+        startTime = -1;
+        duration = -1;
+        return;
+    }
+    startTime = p->StartTime();
+    duration = p->Duration();
+
+    int current = 0;
+    time_t t = time(NULL);
+    if (t > startTime)
+        current = t - startTime;
+
+    currentLast = current;
+    SetDirty();
+
+    tokenContainer->Clear();
+    tokenContainer->AddStringToken((int)eDCProgressBarST::start, *p->GetTimeString());
+    tokenContainer->AddStringToken((int)eDCProgressBarST::stop, *p->GetEndTimeString());
+    tokenContainer->AddIntToken((int)eDCProgressBarIT::duration, duration);
+    tokenContainer->AddIntToken((int)eDCProgressBarIT::elapsed, current);
+    tokenContainer->AddIntToken((int)eDCProgressBarIT::remaining, duration - current);
+    int liveBuffer = GetLiveBuffer();
+    if (liveBuffer >= 0) {
+        tokenContainer->AddIntToken((int)eDCProgressBarIT::permashift, 1);
+        tokenContainer->AddIntToken((int)eDCProgressBarIT::livebuffer, liveBuffer);
+    } else {
+        tokenContainer->AddIntToken((int)eDCProgressBarIT::permashift, 0);
+    }
+}
+
+bool cVeDcProgressBar::Parse(bool force) {
+    if (!cViewElement::Parse(force))
+        return false;
+    int current = 0;
+    time_t t = time(NULL);
+    if (t > startTime)
+        current = t - startTime;
+    if (!(current > currentLast + 3) && !force && !Dirty())
+        return false;
+    SetDirty();
+    if (duration <= 0) {
+        tokenContainer->AddIntToken((int)eDCProgressBarIT::duration, 0);
+        tokenContainer->AddIntToken((int)eDCProgressBarIT::elapsed, 0);
+        tokenContainer->AddIntToken((int)eDCProgressBarIT::remaining, 0);        
+    } else {    
+        tokenContainer->AddIntToken((int)eDCProgressBarIT::duration, duration);
+        tokenContainer->AddIntToken((int)eDCProgressBarIT::elapsed, current);
+        tokenContainer->AddIntToken((int)eDCProgressBarIT::remaining, duration - current);
+        int liveBuffer = GetLiveBuffer();
+        if (liveBuffer >= 0) {
+            tokenContainer->AddIntToken((int)eDCProgressBarIT::permashift, 1);
+            tokenContainer->AddIntToken((int)eDCProgressBarIT::livebuffer, liveBuffer);
+        } else {
+            tokenContainer->AddIntToken((int)eDCProgressBarIT::permashift, 0);
+        }
+    }
+    return true;
+}
+
+int cVeDcProgressBar::GetLiveBuffer(void) {
+    static cPlugin *pPermashift = cPluginManager::GetPlugin("permashift");
+    if (!pPermashift) {
+        return -1;
+    }
+    int buffer = 0;
+    if (pPermashift->Service("Permashift-GetUsedBufferSecs-v1", &buffer)) {
+        return buffer;
+    }
+    return -1;
+}
+/******************************************************************
+* cVeDcStatusInfo
+******************************************************************/
+cVeDcStatusInfo::cVeDcStatusInfo(void) {
+}
+
+cVeDcStatusInfo::~cVeDcStatusInfo(void) {
+}
+
+void cVeDcStatusInfo::SetTokenContainer(void) {
+    tokenContainer = new skindesignerapi::cTokenContainer();
+    tokenContainer->DefineIntToken("{isRadio}", (int)eDCStatusInfoIT::isRadio);
+    tokenContainer->DefineIntToken("{hasVT}", (int)eDCStatusInfoIT::hasVT);
+    tokenContainer->DefineIntToken("{isStereo}", (int)eDCStatusInfoIT::isStereo);
+    tokenContainer->DefineIntToken("{isDolby}", (int)eDCStatusInfoIT::isDolby);
+    tokenContainer->DefineIntToken("{isEncrypted}", (int)eDCStatusInfoIT::isEncrypted);
+    tokenContainer->DefineIntToken("{isRecording}", (int)eDCStatusInfoIT::isRecording);
+    tokenContainer->DefineIntToken("{newmails}", (int)eDCStatusInfoIT::newmails);
+    InheritTokenContainer();
+}
+
+void cVeDcStatusInfo::Set(const cChannel *c) {
+    bool isRadio = !c->Vpid() && c->Apid(0);
+    bool hasVT = c->Vpid() && c->Tpid();
+    bool isStereo = c->Apid(0);
+    bool isDolby = c->Dpid(0);
+    bool isEncrypted = c->Ca();
+    bool isRecording = cRecordControls::Active();
+    cGlobalSortedTimers SortedTimers;// local and remote timers
+    for (int i = 0; i < SortedTimers.Size() && !isRecording; i++)
+        if (const cTimer *Timer = SortedTimers[i])
+            if (Timer->Recording()) 
+                isRecording = true;
+
+    tokenContainer->AddIntToken((int)eDCStatusInfoIT::isRadio, isRadio);
+    tokenContainer->AddIntToken((int)eDCStatusInfoIT::hasVT, hasVT);
+    tokenContainer->AddIntToken((int)eDCStatusInfoIT::isStereo, isStereo);
+    tokenContainer->AddIntToken((int)eDCStatusInfoIT::isDolby, isDolby);
+    tokenContainer->AddIntToken((int)eDCStatusInfoIT::isEncrypted, isEncrypted);
+    tokenContainer->AddIntToken((int)eDCStatusInfoIT::isRecording, isRecording);
+    tokenContainer->AddIntToken((int)eDCStatusInfoIT::newmails, CheckMails());
+    SetDirty();
+}
+
+bool cVeDcStatusInfo::CheckMails(void) {
+    static cPlugin *pMailbox = cPluginManager::GetPlugin("mailbox");
+    if (!pMailbox) {
+        return false;
+    }
+    bool newMail = false;
+    if (pMailbox->Service("MailBox-HasNewMail-1.0", &newMail)) {
+        return newMail;
+    }
+    return false;
+}
+
+/******************************************************************
+* cVeDcAudioInfo
+******************************************************************/
+cVeDcAudioInfo::cVeDcAudioInfo(void) {
+    lastNumAudioTracks = -1;
+    lastAudioChannel = -1;
+    lastTracDesc = NULL;
+    lastTrackLang = NULL;
+}
+
+cVeDcAudioInfo::~cVeDcAudioInfo(void) {
+}
+
+void cVeDcAudioInfo::Close(void) {
+    lastNumAudioTracks = -1;
+    lastAudioChannel = -1;
+    free(lastTracDesc);
+    lastTracDesc = NULL;
+    free(lastTrackLang);
+    lastTrackLang = NULL;
+    cViewElement::Close();
+}
+
+void cVeDcAudioInfo::SetTokenContainer(void) {
+    tokenContainer = new skindesignerapi::cTokenContainer();
+    tokenContainer->DefineStringToken("{trackdesc}", (int)eDCAudioInfoST::trackdesc);
+    tokenContainer->DefineStringToken("{tracklang}", (int)eDCAudioInfoST::tracklang);
+    tokenContainer->DefineIntToken("{numaudiotracks}", (int)eDCAudioInfoIT::numaudiotracks);
+    tokenContainer->DefineIntToken("{audiochannel}", (int)eDCAudioInfoIT::audiochannel);
+    InheritTokenContainer();
+}
+
+bool cVeDcAudioInfo::Parse(bool forced) {
+    if (!cViewElement::Parse(forced))
+        return false;
+    int numAudioTracks = 0;
+    int audioChannel = -1;
+    const char *trackDescription = "";
+    const char *trackLanguage = "";
+
+    cDevice *device = cDevice::PrimaryDevice();
+    if (device) {
+        numAudioTracks = device->NumAudioTracks();
+        audioChannel = device->GetAudioChannel();
+        if (numAudioTracks > 0) {
+            const tTrackId *track = device->GetTrack(device->GetCurrentAudioTrack());
+            if (track) {
+                trackDescription = track->description ? track->description : "";
+                trackLanguage = track->language ? track->language : "";
+            }
+        }
+    }
+    if (   !Dirty() && !forced && lastNumAudioTracks == numAudioTracks 
+           && lastAudioChannel == audioChannel 
+           && lastTracDesc && !strcmp(trackDescription, lastTracDesc)
+           && lastTrackLang && !strcmp(trackLanguage, lastTrackLang)) {
+        return false;
+    }
+
+    lastNumAudioTracks = numAudioTracks;
+    lastAudioChannel = audioChannel;
+    free(lastTracDesc);
+    lastTracDesc = strdup(trackDescription);
+    free(lastTrackLang);
+    lastTrackLang = strdup(trackLanguage);
+    SetDirty();
+
+    tokenContainer->Clear();
+    tokenContainer->AddIntToken((int)eDCAudioInfoIT::numaudiotracks, numAudioTracks);
+    tokenContainer->AddIntToken((int)eDCAudioInfoIT::audiochannel, audioChannel);
+    tokenContainer->AddStringToken((int)eDCAudioInfoST::trackdesc, trackDescription);
+    tokenContainer->AddStringToken((int)eDCAudioInfoST::tracklang, trackLanguage);
+    return true;
+}
+/******************************************************************
+* cVeDcScreenResolution
+******************************************************************/
+cVeDcScreenResolution::cVeDcScreenResolution(void) {
+    lastScreenWidth = -1;
+    lastScreenHeight = -1;
+}
+
+cVeDcScreenResolution::~cVeDcScreenResolution(void) {
+}
+
+void cVeDcScreenResolution::Close(void) {
+    lastScreenWidth = -1;
+    lastScreenHeight = -1;
+    cViewElement::Close();
+}
+
+void cVeDcScreenResolution::SetTokenContainer(void) {
+    tokenContainer = new skindesignerapi::cTokenContainer();
+    tokenContainer->DefineStringToken("{resolution}", (int)eDCScreenResolutionST::resolution);
+    tokenContainer->DefineStringToken("{aspect}", (int)eDCScreenResolutionST::aspect);
+    tokenContainer->DefineIntToken("{screenwidth}", (int)eDCScreenResolutionIT::screenwidth);
+    tokenContainer->DefineIntToken("{screenheight}", (int)eDCScreenResolutionIT::screenheight);
+    tokenContainer->DefineIntToken("{isHD}", (int)eDCScreenResolutionIT::isHD);
+    tokenContainer->DefineIntToken("{isWideScreen}", (int)eDCScreenResolutionIT::isWideScreen);
+    InheritTokenContainer();
+}
+
+bool cVeDcScreenResolution::Parse(bool forced) {
+    if (!cViewElement::Parse(forced))
+        return false;
+    int screenWidth = 0;
+    int screenHeight = 0;
+    double aspect = 0;
+
+    cDevice::PrimaryDevice()->GetVideoSize(screenWidth, screenHeight, aspect);
+
+    if ((lastScreenWidth == screenWidth) && (lastScreenHeight == screenHeight))
+        return false;
+
+    if ((screenWidth == 0) && (screenHeight == 0))
+        return false;
+
+    lastScreenWidth = screenWidth;
+    lastScreenHeight = screenHeight;
+    SetDirty();
+
+    bool isHD = false;
+    string resName = GetScreenResolutionString(screenWidth, screenHeight, &isHD);
+
+    bool isWideScreen = false;
+    string aspectName = GetScreenAspectString(aspect, &isWideScreen);
+
+    tokenContainer->Clear();
+    tokenContainer->AddIntToken((int)eDCScreenResolutionIT::screenwidth, screenWidth);
+    tokenContainer->AddIntToken((int)eDCScreenResolutionIT::screenheight, screenHeight);
+    tokenContainer->AddIntToken((int)eDCScreenResolutionIT::isHD, isHD);
+    tokenContainer->AddIntToken((int)eDCScreenResolutionIT::isWideScreen, isWideScreen);
+    tokenContainer->AddStringToken((int)eDCScreenResolutionST::resolution, resName.c_str());
+    tokenContainer->AddStringToken((int)eDCScreenResolutionST::aspect, aspectName.c_str());
+    return true;
+}
+/******************************************************************
+* cVeDcSignalQuality
+******************************************************************/
+cVeDcSignalQuality::cVeDcSignalQuality(void) {
+    lastSignalDisplay = -1;
+    lastSignalStrength = -1;
+    lastSignalQuality = -1;
+}
+
+cVeDcSignalQuality::~cVeDcSignalQuality(void) {
+}
+
+void cVeDcSignalQuality::Close(void) {
+    lastSignalDisplay = -1;
+    lastSignalStrength = -1;
+    lastSignalQuality = -1;
+    cViewElement::Close();
+}
+
+void cVeDcSignalQuality::SetTokenContainer(void) {
+    tokenContainer = new skindesignerapi::cTokenContainer();
+    tokenContainer->DefineIntToken("{signalstrength}", (int)eDCSignalQualityIT::signalstrength);
+    tokenContainer->DefineIntToken("{signalquality}", (int)eDCSignalQualityIT::signalquality);
+    InheritTokenContainer();
+}
+
+bool cVeDcSignalQuality::Parse(bool forced) {
+    if (!cViewElement::Parse(forced))
+        return false;
+    time_t now = time(NULL);
+    if (now == lastSignalDisplay)
+        return false;
+    lastSignalDisplay = now;
+
+    int signalStrength = cDevice::ActualDevice()->SignalStrength();
+    int signalQuality = cDevice::ActualDevice()->SignalQuality();
+
+    if (signalStrength < 0) signalStrength = 0;
+    if (signalQuality < 0) signalQuality = 0;
+
+    if (signalStrength == 0 && signalQuality==0)
+        return false;
+
+    if ((lastSignalStrength == signalStrength) && (lastSignalQuality == signalQuality))
+        return false;
+    SetDirty();
+    lastSignalStrength = signalStrength;
+    lastSignalQuality = signalQuality;
+
+    tokenContainer->Clear();
+    tokenContainer->AddIntToken((int)eDCSignalQualityIT::signalstrength, signalStrength);
+    tokenContainer->AddIntToken((int)eDCSignalQualityIT::signalquality, signalQuality);
+    return true;
+}
+
+/******************************************************************
+* cVeDcScraperContent
+******************************************************************/
+cVeDcScraperContent::cVeDcScraperContent(void) {
+}
+
+cVeDcScraperContent::~cVeDcScraperContent(void) {
+}
+
+void cVeDcScraperContent::SetTokenContainer(void) {
+    tokenContainer = new skindesignerapi::cTokenContainer();
+    tokenContainer->DefineStringToken("{posterpath}", (int)eScraperPosterBannerST::posterpath);
+    tokenContainer->DefineStringToken("{bannerpath}", (int)eScraperPosterBannerST::bannerpath);
+    tokenContainer->DefineStringToken("{mediapath}", (int)eScraperPosterBannerST::mediapath);
+    tokenContainer->DefineIntToken("{posterwidth}", (int)eScraperPosterBannerIT::posterwidth);
+    tokenContainer->DefineIntToken("{posterheight}", (int)eScraperPosterBannerIT::posterheight);
+    tokenContainer->DefineIntToken("{hasPoster}", (int)eScraperPosterBannerIT::hasposter);
+    tokenContainer->DefineIntToken("{bannerwidth}", (int)eScraperPosterBannerIT::bannerwidth);
+    tokenContainer->DefineIntToken("{bannerheight}", (int)eScraperPosterBannerIT::bannerheight);
+    tokenContainer->DefineIntToken("{hasBanner}", (int)eScraperPosterBannerIT::hasbanner);
+    tokenContainer->DefineIntToken("{mediawidth}", (int)eScraperPosterBannerIT::mediawidth);
+    tokenContainer->DefineIntToken("{mediaheight}", (int)eScraperPosterBannerIT::mediaheight);
+    tokenContainer->DefineIntToken("{isbanner}", (int)eScraperPosterBannerIT::isbanner);
+    InheritTokenContainer();
+}
+
+void cVeDcScraperContent::Set(const cEvent *e) {
+    tokenContainer->Clear();
+    SetPosterBanner(tokenContainer, e, NULL);
+    SetDirty();
+}
+
+/******************************************************************
+* cVeDcScreenResolution
+******************************************************************/
+cVeDcEcmInfo::cVeDcEcmInfo(void) {
+    channelSid = -1;
+    lastEcmInfo.hops = -1;
+    lastEcmInfo.ecmtime = -1;
+    lastEcmInfo.caid = -1;
+    lastEcmInfo.pid = -1;
+    lastEcmInfo.prid = -1;
+}
+
+cVeDcEcmInfo::~cVeDcEcmInfo(void) {
+}
+
+void cVeDcEcmInfo::Close(void) {
+    channelSid = -1;
+    lastEcmInfo.hops = -1;
+    lastEcmInfo.ecmtime = -1;
+    lastEcmInfo.caid = -1;
+    lastEcmInfo.pid = -1;
+    lastEcmInfo.prid = -1;
+    cViewElement::Close();
+}
+
+void cVeDcEcmInfo::SetTokenContainer(void) {
+    tokenContainer = new skindesignerapi::cTokenContainer();
+    tokenContainer->DefineStringToken("{cardsystem}", (int)eDCEcmInfoST::cardsystem);
+    tokenContainer->DefineStringToken("{reader}", (int)eDCEcmInfoST::reader);
+    tokenContainer->DefineStringToken("{from}", (int)eDCEcmInfoST::from);
+    tokenContainer->DefineStringToken("{protocol}", (int)eDCEcmInfoST::protocol);
+    tokenContainer->DefineIntToken("{caid}", (int)eDCEcmInfoIT::caid);
+    tokenContainer->DefineIntToken("{pid}", (int)eDCEcmInfoIT::pid);
+    tokenContainer->DefineIntToken("{prid}", (int)eDCEcmInfoIT::prid);
+    tokenContainer->DefineIntToken("{ecmtime}", (int)eDCEcmInfoIT::ecmtime);
+    tokenContainer->DefineIntToken("{hops}", (int)eDCEcmInfoIT::hops);
+    InheritTokenContainer();
+}
+
+void cVeDcEcmInfo::Set(const cChannel *c) {
+    channelSid = c->Sid();
+}
+
+bool cVeDcEcmInfo::Parse(bool forced) {
+    if (!cViewElement::Parse(forced))
+        return false;
+    static cPlugin *pDVBApi = cPluginManager::GetPlugin("dvbapi");
+    if (!pDVBApi)
+        return false;
+    if (channelSid < 0)
+        return false;
+
+    sDVBAPIEcmInfo ecmInfo;
+    ecmInfo.sid = channelSid;
+
+    if (!pDVBApi->Service("GetEcmInfo", &ecmInfo)) {
+        return false;
+    }
+
+    if (ecmInfo.hops < 0 || ecmInfo.ecmtime <= 0 || ecmInfo.ecmtime > 100000)
+        return false;
+    if (CompareECMInfos(&ecmInfo))
+        return false;
+    lastEcmInfo = ecmInfo;
+    SetDirty();
+
+    tokenContainer->Clear();
+    tokenContainer->AddIntToken((int)eDCEcmInfoIT::caid, ecmInfo.caid);
+    tokenContainer->AddIntToken((int)eDCEcmInfoIT::pid, ecmInfo.pid);
+    tokenContainer->AddIntToken((int)eDCEcmInfoIT::prid, ecmInfo.prid);
+    tokenContainer->AddIntToken((int)eDCEcmInfoIT::ecmtime, ecmInfo.ecmtime);
+    tokenContainer->AddIntToken((int)eDCEcmInfoIT::hops, ecmInfo.hops);
+    tokenContainer->AddStringToken((int)eDCEcmInfoST::cardsystem, *ecmInfo.cardsystem);
+    tokenContainer->AddStringToken((int)eDCEcmInfoST::reader, *ecmInfo.reader);
+    tokenContainer->AddStringToken((int)eDCEcmInfoST::from, *ecmInfo.from);
+    tokenContainer->AddStringToken((int)eDCEcmInfoST::protocol, *ecmInfo.protocol);
+    return true;
+}
+
+bool cVeDcEcmInfo::CompareECMInfos(sDVBAPIEcmInfo *ecmInfo) {
+    if (ecmInfo->caid != lastEcmInfo.caid)
+        return false;
+    if (ecmInfo->pid != lastEcmInfo.pid)
+        return false;
+    if (ecmInfo->prid != lastEcmInfo.prid)
+        return false;
+    if (ecmInfo->ecmtime != lastEcmInfo.ecmtime)
+        return false;
+    if (ecmInfo->hops != lastEcmInfo.hops)
+        return false;
+    return true;
+}

coreengine/viewelementsdisplaychannel.h

@@ -0,0 +1,145 @@
+#ifndef __VIEWELEMENTSDC_H
+#define __VIEWELEMENTSDC_H
+
+#include "viewelement.h"
+#include "../extensions/scrapmanager.h"
+#include "../services/dvbapi.h"
+
+/******************************************************************
+* cVeDcChannelInfo
+******************************************************************/
+class cVeDcChannelInfo : public cViewElement {
+private:
+public:
+    cVeDcChannelInfo(void);
+    virtual ~cVeDcChannelInfo(void);
+    void SetTokenContainer(void);
+    void Set(const cChannel *c, int number);
+};
+/******************************************************************
+* cVeDcChannelGroup
+******************************************************************/
+class cVeDcChannelGroup : public cViewElement {
+private:
+    const char *GetChannelSep(const cChannel *c, bool prev);
+public:
+    cVeDcChannelGroup(void);
+    virtual ~cVeDcChannelGroup(void);
+    void SetTokenContainer(void);
+    void Set(const cChannel *c);
+};
+/******************************************************************
+* cVeDcEpgInfo
+******************************************************************/
+class cVeDcEpgInfo : public cViewElement {
+private:
+    bool EventHasTimer(const cEvent *e);
+public:
+    cVeDcEpgInfo(void);
+    virtual ~cVeDcEpgInfo(void);
+    void SetTokenContainer(void);
+    void Set(const cEvent *p, const cEvent *f);
+};
+/******************************************************************
+* cVeDcProgressBar
+******************************************************************/
+class cVeDcProgressBar : public cViewElement {
+private:
+    int currentLast;
+    int startTime;
+    int duration;
+    int GetLiveBuffer(void);
+public:
+    cVeDcProgressBar(void);
+    virtual ~cVeDcProgressBar(void);
+    void Close(void);
+    void SetTokenContainer(void);
+    void Set(const cEvent *p);
+    bool Parse(bool forced = false);
+};
+/******************************************************************
+* cVeDcStatusInfo
+******************************************************************/
+class cVeDcStatusInfo : public cViewElement {
+private:
+    bool CheckMails(void);
+public:
+    cVeDcStatusInfo(void);
+    virtual ~cVeDcStatusInfo(void);
+    void SetTokenContainer(void);
+    void Set(const cChannel *c);
+};
+/******************************************************************
+* cVeDcAudioInfo
+******************************************************************/
+class cVeDcAudioInfo : public cViewElement {
+private:
+    int lastNumAudioTracks;
+    int lastAudioChannel;
+    char *lastTracDesc;
+    char *lastTrackLang;
+public:
+    cVeDcAudioInfo(void);
+    virtual ~cVeDcAudioInfo(void);
+    void Close(void);
+    void SetTokenContainer(void);
+    bool Parse(bool forced = false);
+};
+/******************************************************************
+* cVeDcScreenResolution
+******************************************************************/
+class cVeDcScreenResolution : public cViewElement {
+private:
+    int lastScreenWidth;
+    int lastScreenHeight;
+public:
+    cVeDcScreenResolution(void);
+    virtual ~cVeDcScreenResolution(void);
+    void Close(void);
+    void SetTokenContainer(void);
+    bool Parse(bool forced = false);
+};
+/******************************************************************
+* cVeDcSignalQuality
+******************************************************************/
+class cVeDcSignalQuality : public cViewElement {
+private:
+    int lastSignalDisplay;
+    int lastSignalStrength;
+    int lastSignalQuality;
+public:
+    cVeDcSignalQuality(void);
+    virtual ~cVeDcSignalQuality(void);
+    void Close(void);
+    void SetTokenContainer(void);
+    bool Parse(bool forced = false);
+};
+/******************************************************************
+* cVeDcScraperContent
+******************************************************************/
+class cVeDcScraperContent : public cViewElement, public cScrapManager {
+private:
+public:
+    cVeDcScraperContent(void);
+    virtual ~cVeDcScraperContent(void);
+    void SetTokenContainer(void);
+    void Set(const cEvent *e);
+};
+/******************************************************************
+* cVeDcEcmInfo
+******************************************************************/
+class cVeDcEcmInfo : public cViewElement {
+private:
+    int channelSid;
+    sDVBAPIEcmInfo lastEcmInfo;
+    bool CompareECMInfos(sDVBAPIEcmInfo *ecmInfo);
+public:
+    cVeDcEcmInfo(void);
+    virtual ~cVeDcEcmInfo(void);
+    void Close(void);
+    void SetTokenContainer(void);
+    void Set(const cChannel *c);
+    bool Parse(bool forced = false);
+};
+
+#endif //__VIEWELEMENTSDC_H

coreengine/viewelementsdisplaymenu.h

@@ -0,0 +1,250 @@
+#ifndef __VIEWELEMENTSDM_H
+#define __VIEWELEMENTSDM_H
+
+#include "viewelement.h"
+#include "../extensions/scrapmanager.h"
+
+/******************************************************************
+* cVeDmHeader
+******************************************************************/
+class cVeDmHeader : public cViewElement {
+private:
+    char *title;
+    char *channelName;
+    int channelNumber;
+    char *channelId;
+    bool epgSearchFav;
+public:
+    cVeDmHeader(void);
+    virtual ~cVeDmHeader(void);
+    void SetTokenContainer(void);
+    void SetTitle(const char *title);
+    void SetChannel(const cChannel *channel);
+    void Set(eMenuCategory menuCat);
+    void IsEpgSearchFav(bool isFav) { epgSearchFav = isFav;} ;
+};
+
+/******************************************************************
+* cVeDmSortmode
+******************************************************************/
+class cVeDmSortmode : public cViewElement {
+private:
+    eMenuSortMode sortMode;
+    eMenuSortMode lastSortMode;
+public:
+    cVeDmSortmode(void);
+    virtual ~cVeDmSortmode(void);
+    void Reset(void) { lastSortMode = msmUnknown; }
+    void SetTokenContainer(void);
+    void Set(eMenuSortMode sortMode);
+    bool Parse(bool forced = false);
+};
+
+/******************************************************************
+* cVeDmColorbuttons
+******************************************************************/
+class cVeDmColorbuttons : public cViewElement {
+private:
+    bool changed;
+    char *red;
+    char *green;
+    char *yellow;
+    char *blue;
+public:
+    cVeDmColorbuttons(void);
+    virtual ~cVeDmColorbuttons(void);
+    void SetTokenContainer(void);
+    void SetButtons(const char *red, const char *green, const char *yellow, const char *blue);
+    bool Parse(bool forced = false);
+};
+
+/******************************************************************
+* cVeDmScrollbar
+******************************************************************/
+class cVeDmScrollbar : public cViewElement {
+private:
+public:
+    cVeDmScrollbar(void);
+    virtual ~cVeDmScrollbar(void);
+    void SetTokenContainer(void);
+    void SetList(int numDisplayed, int offset, int numMax);
+    void SetDetail(int height, int offset, bool end);
+};
+
+
+/******************************************************************
+* cVeDmTimers
+******************************************************************/
+class cVeDmTimers : public cViewElement {
+private:
+    int timerIndex;
+public:
+    cVeDmTimers(void);
+    virtual ~cVeDmTimers(void);
+    void SetTokenContainer(void);
+    bool Parse(bool forced = false);
+};
+
+/******************************************************************
+* cVeDmCurrentschedule
+******************************************************************/
+class cVeDmCurrentschedule : public cViewElement, public cScrapManager {
+private:
+    const char *rec;
+    void ParseFromChannel(const cChannel *channel);
+    void ParseFromRecording(const cRecording *recording);
+    void RecName(string &path, string &name, string &folder);
+public:
+    cVeDmCurrentschedule(void);
+    virtual ~cVeDmCurrentschedule(void);
+    void SetTokenContainer(void);
+    void SetRecording(const char *currentRec);
+    bool Parse(bool forced = false);    
+};
+
+/******************************************************************
+* cVeDmDiscusage
+******************************************************************/
+class cVeDmDiscusage : public cViewElement {
+private:
+public:
+    cVeDmDiscusage(void);
+    virtual ~cVeDmDiscusage(void);
+    void SetTokenContainer(void);
+    bool Parse(bool forced = false);
+};
+
+/******************************************************************
+* cVeDmSystemload
+******************************************************************/
+class cVeDmSystemload : public cViewElement {
+private:
+    double lastSystemLoad;
+public:
+    cVeDmSystemload(void);
+    virtual ~cVeDmSystemload(void);
+    void Reset(void) { lastSystemLoad = -1.0f; }
+    void SetTokenContainer(void);
+    bool Parse(bool forced = false);
+};
+
+/******************************************************************
+* cVeDmSystemmemory
+******************************************************************/
+class cVeDmSystemmemory : public cViewElement {
+private:
+    int lastMemUsage;
+public:
+    cVeDmSystemmemory(void);
+    virtual ~cVeDmSystemmemory(void);
+    void Reset(void) { lastMemUsage = -1; }
+    void SetTokenContainer(void);
+    bool Parse(bool forced = false);
+};
+
+/******************************************************************
+* cVeDmTemperatures
+******************************************************************/
+class cVeDmTemperatures : public cViewElement {
+private:
+    int lastCpuTemp;
+    int lastGpuTemp;
+public:
+    cVeDmTemperatures(void);
+    virtual ~cVeDmTemperatures(void);
+    void Reset(void) { lastCpuTemp = -1; lastGpuTemp = -1; }
+    void SetTokenContainer(void);
+    bool Parse(bool forced = false);
+};
+
+/******************************************************************
+* cVeDmVdrstatistics
+******************************************************************/
+class cVeDmVdrstatistics : public cViewElement {
+private:
+    string lastVdrCPU;
+    string lastVdrMEM;
+public:
+    cVeDmVdrstatistics(void);
+    virtual ~cVeDmVdrstatistics(void);
+    void Reset(void) { lastVdrCPU = "undefined"; lastVdrMEM = "undefined"; }
+    void SetTokenContainer(void);
+    bool Parse(bool forced = false);
+};
+
+/******************************************************************
+* cVeDmLastrecordings
+******************************************************************/
+class cVeDmLastrecordings : public cViewElement, public cScrapManager {
+private:
+    int recIndex;
+    void RecName(string &path, string &name, string &folder);
+public:
+    cVeDmLastrecordings(void);
+    virtual ~cVeDmLastrecordings(void);
+    void SetTokenContainer(void);
+    bool Parse(bool forced = false);
+};
+
+/******************************************************************
+* cVeDmDetailheaderEpg
+******************************************************************/
+class cVeDmDetailheaderEpg : public cViewElement, public cScrapManager {
+private:
+    const cEvent *event;
+public:
+    cVeDmDetailheaderEpg(void);
+    virtual ~cVeDmDetailheaderEpg(void);
+    void SetTokenContainer(void);
+    void SetEvent(const cEvent *event);
+    bool Parse(bool forced = false);
+};
+
+/******************************************************************
+* cVeDmDetailheaderRec
+******************************************************************/
+class cVeDmDetailheaderRec : public cViewElement, public cScrapManager {
+private:
+    const cRecording *recording;
+public:
+    cVeDmDetailheaderRec(void);
+    virtual ~cVeDmDetailheaderRec(void);
+    void SetTokenContainer(void);
+    void SetRecording(const cRecording *rec);
+    bool Parse(bool forced = false);
+};
+
+/******************************************************************
+* cVeDmDetailheaderPlugin
+******************************************************************/
+class cVeDmDetailheaderPlugin : public cViewElement {
+private:
+    int plugId;
+    int plugMenuId;
+public:
+    cVeDmDetailheaderPlugin(void);
+    virtual ~cVeDmDetailheaderPlugin(void);
+    void SetPlugId(int id) { plugId = id; };
+    void SetPlugMenuId(int id) { plugMenuId = id; };
+    void SetTokenContainer(void);
+    void Set(skindesignerapi::cTokenContainer *tk);
+    bool Parse(bool forced = false);
+};
+
+/******************************************************************
+* cVeDmTablabels
+******************************************************************/
+class cVeDmTablabels : public cViewElement {
+private:
+    int tabIndex;
+    int activeTab;
+    vector<const char*> tabs;
+public:
+    cVeDmTablabels(void);
+    virtual ~cVeDmTablabels(void);
+    void SetTokenContainer(void);
+    void SetTabs(vector<const char*> &newTabs);
+    void SetActiveTab(int activeTab) { SetDirty(); this->activeTab = activeTab; };
+    bool Parse(bool forced = false);
+};
+#endif //__VIEWELEMENTSDM_H

coreengine/viewelementsdisplayreplay.c

@@ -0,0 +1,816 @@
+#include "viewelementsdisplayreplay.h"
+#include "../config.h"
+#include "../extensions/helpers.h"
+#include "../services/scraper2vdr.h"
+
+/******************************************************************
+* cVeDrRecTitle
+******************************************************************/
+cVeDrRecTitle::cVeDrRecTitle(void) {
+    recording = NULL;
+    title = NULL;
+}
+
+cVeDrRecTitle::~cVeDrRecTitle(void) {
+    free(title);
+}
+
+void cVeDrRecTitle::SetTokenContainer(void) {
+    tokenContainer = new skindesignerapi::cTokenContainer();
+    tokenContainer->DefineStringToken("{rectitle}", (int)eDRRecTitleST::rectitle);
+    tokenContainer->DefineStringToken("{recsubtitle}", (int)eDRRecTitleST::recsubtitle);
+    tokenContainer->DefineStringToken("{recdate}", (int)eDRRecTitleST::recdate);
+    tokenContainer->DefineStringToken("{rectime}", (int)eDRRecTitleST::rectime);
+    InheritTokenContainer();
+}
+
+void cVeDrRecTitle::Set(const cRecording *recording) {
+    this->recording = recording;
+}
+
+void cVeDrRecTitle::Set(const char *title) {
+    if (!title)
+        return;
+    free(this->title);
+    this->title = strdup(title);
+}
+
+bool cVeDrRecTitle::Parse(bool force) {
+    if (!cViewElement::Parse(force))
+        return false;
+    if (!recording && !title)
+        return false;
+
+    tokenContainer->Clear();
+    if (recording) {
+        const char *recName = NULL;
+        const cRecordingInfo *recInfo = recording->Info();
+        if (recInfo)
+            recName = recInfo->Title();
+        if (!recName)
+            recName = recording->Name();
+        tokenContainer->AddStringToken((int)eDRRecTitleST::rectitle, recName);
+        tokenContainer->AddStringToken((int)eDRRecTitleST::recsubtitle, recInfo ? recInfo->ShortText() : "");
+        tokenContainer->AddStringToken((int)eDRRecTitleST::recdate, *ShortDateString(recording->Start()));
+        tokenContainer->AddStringToken((int)eDRRecTitleST::rectime, *TimeString(recording->Start()));        
+    } else if (title) {
+        tokenContainer->AddStringToken((int)eDRRecTitleST::rectitle, title);        
+    }
+
+    SetDirty();
+    return true;
+}
+
+/******************************************************************
+* cVeDrRecInfo
+******************************************************************/
+cVeDrRecInfo::cVeDrRecInfo(void) {
+    recording = NULL;
+}
+
+cVeDrRecInfo::~cVeDrRecInfo(void) {
+}
+
+void cVeDrRecInfo::SetTokenContainer(void) {
+    tokenContainer = new skindesignerapi::cTokenContainer();
+    tokenContainer->DefineStringToken("{resolution}", (int)eDRRecInfoST::resolution);
+    tokenContainer->DefineStringToken("{aspect}", (int)eDRRecInfoST::aspect);
+    tokenContainer->DefineIntToken("{screenwidth}", (int)eDRRecInfoIT::screenwidth);
+    tokenContainer->DefineIntToken("{screenheight}", (int)eDRRecInfoIT::screenheight);
+    tokenContainer->DefineIntToken("{isHD}", (int)eDRRecInfoIT::isHD);
+    tokenContainer->DefineIntToken("{isWideScreen}", (int)eDRRecInfoIT::isWideScreen);
+    InheritTokenContainer();
+}
+
+void cVeDrRecInfo::Set(const cRecording *recording) {
+    this->recording = recording;
+}
+
+bool cVeDrRecInfo::Parse(bool force) {
+    if (!cViewElement::Parse(force))
+        return false;
+    if (!recording)
+        return false;
+    
+    int screenWidth = 0;
+    int screenHeight = 0;
+    double aspect = 0;
+    cDevice::PrimaryDevice()->GetVideoSize(screenWidth, screenHeight, aspect);
+    bool isHD = false;
+    string resName = GetScreenResolutionString(screenWidth, screenHeight, &isHD);
+    bool isWideScreen = false;
+    string aspectName = GetScreenAspectString(aspect, &isWideScreen);
+
+    tokenContainer->Clear();
+    tokenContainer->AddIntToken((int)eDRRecInfoIT::screenwidth, screenWidth);
+    tokenContainer->AddIntToken((int)eDRRecInfoIT::screenheight, screenHeight);
+    tokenContainer->AddIntToken((int)eDRRecInfoIT::isHD, isHD);
+    tokenContainer->AddIntToken((int)eDRRecInfoIT::isWideScreen, isWideScreen);
+    tokenContainer->AddStringToken((int)eDRRecInfoST::resolution, resName.c_str());
+    tokenContainer->AddStringToken((int)eDRRecInfoST::aspect, aspectName.c_str());
+
+    SetDirty();
+    return true;
+}
+
+/******************************************************************
+* cVeDrCurrentTime
+******************************************************************/
+cVeDrCurrentTime::cVeDrCurrentTime(void) {
+    changed = true;
+    current = NULL;
+}
+
+cVeDrCurrentTime::~cVeDrCurrentTime(void) {
+    free(current);
+}
+
+void cVeDrCurrentTime::SetTokenContainer(void) {
+    tokenContainer = new skindesignerapi::cTokenContainer();
+    tokenContainer->DefineStringToken("{reccurrent}", (int)eDRCurrentTimeST::reccurrent);
+    InheritTokenContainer();
+}
+
+void cVeDrCurrentTime::Set(const char *current) {
+    if (!current)
+        return;
+    free(this->current);
+    this->current = strdup(current);
+    changed = true;
+}
+
+bool cVeDrCurrentTime::Parse(bool force) {
+    if (!cViewElement::Parse(force) || !changed)
+        return false;
+    tokenContainer->Clear();
+    tokenContainer->AddStringToken((int)eDRCurrentTimeST::reccurrent, current);
+    SetDirty();
+    changed = false;
+    return true;
+}
+
+/******************************************************************
+* cVeDrTotalTime
+******************************************************************/
+cVeDrTotalTime::cVeDrTotalTime(void) {
+    changed = true;
+    total = NULL;
+    timeshiftActive = false;
+    timeshiftDuration = NULL;
+}
+
+cVeDrTotalTime::~cVeDrTotalTime(void) {
+    free(total);
+    free(timeshiftDuration);
+}
+
+void cVeDrTotalTime::SetTokenContainer(void) {
+    tokenContainer = new skindesignerapi::cTokenContainer();
+    tokenContainer->DefineStringToken("{rectotal}", (int)eDRTotalTimeST::rectotal);
+    tokenContainer->DefineStringToken("{timeshifttotal}", (int)eDRTotalTimeST::timeshifttotal);
+    tokenContainer->DefineIntToken("{timeshift}", (int)eDRTotalTimeIT::timeshift);
+    InheritTokenContainer();
+}
+
+void cVeDrTotalTime::Set(const char *total, bool timeshiftActive, const char *timeshiftDuration) {
+    if (!total)
+        return;
+    free(this->total);
+    this->total = strdup(total);
+    this->timeshiftActive = timeshiftActive;
+    free(this->timeshiftDuration);
+    this->timeshiftDuration = NULL;
+    if (timeshiftDuration)
+        this->timeshiftDuration = strdup(timeshiftDuration);
+    changed = true;
+}
+
+bool cVeDrTotalTime::Parse(bool force) {
+    if (!cViewElement::Parse(force) || !changed)
+        return false;
+    tokenContainer->Clear();
+    tokenContainer->AddStringToken((int)eDRTotalTimeST::rectotal, total);
+    tokenContainer->AddStringToken((int)eDRTotalTimeST::timeshifttotal, timeshiftDuration);
+    tokenContainer->AddIntToken((int)eDRTotalTimeIT::timeshift, timeshiftActive);
+    SetDirty();
+    changed = false;
+    return true;
+}
+
+/******************************************************************
+* cVeDrEndTime
+******************************************************************/
+cVeDrEndTime::cVeDrEndTime(void) {
+    end = "";
+}
+
+cVeDrEndTime::~cVeDrEndTime(void) {
+}
+
+void cVeDrEndTime::SetTokenContainer(void) {
+    tokenContainer = new skindesignerapi::cTokenContainer();
+    tokenContainer->DefineStringToken("{recend}", (int)eDREndTimeST::recend);
+    InheritTokenContainer();
+}
+
+void cVeDrEndTime::Set(cString end) {
+    if (strcmp(*this->end, *end)) {
+        this->end = end;
+        changed = true;
+    }
+}
+
+bool cVeDrEndTime::Parse(bool force) {
+    if (!cViewElement::Parse(force) || !changed)
+        return false;
+    tokenContainer->Clear();
+    tokenContainer->AddStringToken((int)eDREndTimeST::recend, *end);
+    SetDirty();
+    changed = false;
+    return true;
+}
+
+/******************************************************************
+* cVeDrProgressBar
+******************************************************************/
+cVeDrProgressBar::cVeDrProgressBar(void) {
+    current = -1;
+    total = -1;
+    timeshiftActive = false;
+    timeshiftTotal = -1;
+    changed = true;
+}
+
+cVeDrProgressBar::~cVeDrProgressBar(void) {
+}
+
+void cVeDrProgressBar::SetTokenContainer(void) {
+    tokenContainer = new skindesignerapi::cTokenContainer();
+    tokenContainer->DefineIntToken("{current}", (int)eDRProgressbarIT::current);
+    tokenContainer->DefineIntToken("{total}", (int)eDRProgressbarIT::total);
+    tokenContainer->DefineIntToken("{timeshift}", (int)eDRProgressbarIT::timeshift);
+    tokenContainer->DefineIntToken("{timeshifttotal}", (int)eDRProgressbarIT::timeshifttotal);
+    InheritTokenContainer();
+}
+
+void cVeDrProgressBar::Set(int current, int total, bool timeshiftActive, int timeshiftTotal) {
+    if (this->current == current)
+        return;
+    this->current = current;
+    this->total = total;
+    this->timeshiftActive = timeshiftActive;
+    this->timeshiftTotal = timeshiftTotal;
+    changed = true;
+}
+
+bool cVeDrProgressBar::Parse(bool force) {
+    if (!cViewElement::Parse(force) || !changed)
+        return false;
+
+    tokenContainer->Clear();
+    tokenContainer->AddIntToken((int)eDRProgressbarIT::current, current);
+    tokenContainer->AddIntToken((int)eDRProgressbarIT::total, total);
+    tokenContainer->AddIntToken((int)eDRProgressbarIT::timeshift, timeshiftActive);
+    tokenContainer->AddIntToken((int)eDRProgressbarIT::timeshifttotal, timeshiftTotal);
+
+    SetDirty();
+    return true;
+}
+
+/******************************************************************
+* cVeDrCutMarks
+******************************************************************/
+cVeDrCutMarks::cVeDrCutMarks(void) {
+    cutmarksIndex = -1;
+    lastMarks = NULL;
+    Reset();
+}
+
+cVeDrCutMarks::~cVeDrCutMarks(void) {
+    delete[] lastMarks;
+}
+
+void cVeDrCutMarks::SetTokenContainer(void) {
+    tokenContainer = new skindesignerapi::cTokenContainer();
+    tokenContainer->DefineIntToken("{timeshift}", (int)eDRCutmarksIT::timeshift);
+    tokenContainer->DefineLoopToken("{marks[position]}", (int)eDRCutmarksLT::position);
+    tokenContainer->DefineLoopToken("{marks[endposition]}", (int)eDRCutmarksLT::endposition);
+    tokenContainer->DefineLoopToken("{marks[total]}", (int)eDRCutmarksLT::total);
+    tokenContainer->DefineLoopToken("{marks[timeshifttotal]}", (int)eDRCutmarksLT::timeshifttotal);
+    tokenContainer->DefineLoopToken("{marks[active]}", (int)eDRCutmarksLT::active);
+    tokenContainer->DefineLoopToken("{marks[startmark]}", (int)eDRCutmarksLT::startmark);
+    cutmarksIndex = tokenContainer->LoopIndex("marks");
+    InheritTokenContainer();
+}
+
+void cVeDrCutMarks::Set(const cMarks *marks, int current, int total, bool timeshiftActive, int timeshiftTotal) {
+    this->marks = marks;
+    this->current = current;
+    this->total = total;
+    this->timeshiftActive = timeshiftActive;
+    this->timeshiftTotal = timeshiftTotal;
+}
+
+void cVeDrCutMarks::Reset(void) {
+    marks = NULL;
+    current = -1;
+    total = -1;
+    numMarksLast = 0;
+    delete[] lastMarks;
+    lastMarks = NULL;
+    markActive = -1;
+    timeshiftActive = false;
+    timeshiftTotal = -1;
+}
+
+bool cVeDrCutMarks::Parse(bool force) {
+    if (!cViewElement::Parse(force))
+        return false;
+    if (!marks || !MarksChanged()) {
+        return false;
+    }
+    tokenContainer->Clear();
+    tokenContainer->AddIntToken((int)eDRCutmarksIT::timeshift, timeshiftActive);
+    int numMarks = marks->Count();
+    vector<int> cutmarksInfo;
+    cutmarksInfo.push_back(numMarks);
+    tokenContainer->CreateLoopTokenContainer(&cutmarksInfo);
+    cString tot = cString::sprintf("%d", total);
+    cString timeshifttot = cString::sprintf("%d",timeshiftTotal);
+    int i = 0;
+    bool isStartMark = true;
+    for (const cMark *m = marks->First(); m; m = marks->Next(m)) {
+        tokenContainer->AddLoopToken(cutmarksIndex, i, (int)eDRCutmarksLT::position, *cString::sprintf("%d", m->Position()));
+        tokenContainer->AddLoopToken(cutmarksIndex, i, (int)eDRCutmarksLT::total, *tot);
+        if (timeshiftActive) {
+            tokenContainer->AddLoopToken(cutmarksIndex, i, (int)eDRCutmarksLT::timeshifttotal, *timeshifttot);
+        }
+        tokenContainer->AddLoopToken(cutmarksIndex, i, (int)eDRCutmarksLT::startmark, isStartMark ? "1" : "0");
+        tokenContainer->AddLoopToken(cutmarksIndex, i, (int)eDRCutmarksLT::active, (m->Position() == current) ? "1" : "0");
+        const cMark *m2 = marks->Next(m);
+        if (m2) { 
+            tokenContainer->AddLoopToken(cutmarksIndex, i, (int)eDRCutmarksLT::endposition, *cString::sprintf("%d", m2->Position()));
+        } else {
+            tokenContainer->AddLoopToken(cutmarksIndex, i, (int)eDRCutmarksLT::endposition, *tot);
+        }
+        i++;
+        isStartMark = !isStartMark;
+    }
+    SetDirty();
+    return true;
+}
+
+bool cVeDrCutMarks::MarksChanged(void) {
+    bool redraw = false;
+    //if mark was active, we redraw always
+    if (markActive >= 0) {
+        markActive = -1;
+        redraw = true;
+    }
+    //check if current position in recording hits mark exactly
+    for (const cMark *m = marks->First(); m; m = marks->Next(m)) {
+        if (m->Position() == current) {
+            markActive = current;
+            redraw = true;
+            break;
+        }
+    }
+    if (redraw)
+        return true;
+    //if number of marks has changed, redraw
+    int numMarks = marks->Count();
+    if (numMarks != numMarksLast) {
+        RememberMarks();
+        return true;
+    }
+    if (!lastMarks)
+        return false;
+    //if position has changed, redraw
+    int i=0;
+    for (const cMark *m = marks->First(); m; m = marks->Next(m)) {
+        if (m->Position() != lastMarks[i]) {
+            RememberMarks();
+            return true;
+        }
+        i++;
+    }
+    return false;
+}
+
+void cVeDrCutMarks::RememberMarks(void) {
+    if (!marks)
+        return;
+    numMarksLast = marks->Count();
+    if (numMarksLast < 1)
+        return;
+    delete[] lastMarks;
+    lastMarks = new int[numMarksLast];
+    int i=0;
+    for (const cMark *m = marks->First(); m; m = marks->Next(m)) {
+        lastMarks[i] = m->Position();
+        i++;
+    }
+}
+
+/******************************************************************
+* cVeDrControlIcons
+******************************************************************/
+cVeDrControlIcons::cVeDrControlIcons(void) {
+    play = false;
+    forward = false;
+    speed = 0;
+    changed = true;
+}
+
+cVeDrControlIcons::~cVeDrControlIcons(void) {
+}
+
+void cVeDrControlIcons::SetTokenContainer(void) {
+    tokenContainer = new skindesignerapi::cTokenContainer();
+    tokenContainer->DefineIntToken("{play}", (int)eDRControlIconsIT::play);
+    tokenContainer->DefineIntToken("{pause}", (int)eDRControlIconsIT::pause);
+    tokenContainer->DefineIntToken("{forward}", (int)eDRControlIconsIT::forward);
+    tokenContainer->DefineIntToken("{forward1x}", (int)eDRControlIconsIT::forward1x);
+    tokenContainer->DefineIntToken("{forward2x}", (int)eDRControlIconsIT::forward2x);
+    tokenContainer->DefineIntToken("{forward3x}", (int)eDRControlIconsIT::forward3x);
+    tokenContainer->DefineIntToken("{rewind}", (int)eDRControlIconsIT::rewind);
+    tokenContainer->DefineIntToken("{rewind1x}", (int)eDRControlIconsIT::rewind1x);
+    tokenContainer->DefineIntToken("{rewind2x}", (int)eDRControlIconsIT::rewind2x);
+    tokenContainer->DefineIntToken("{rewind3x}", (int)eDRControlIconsIT::rewind3x);
+    InheritTokenContainer();
+}
+
+void cVeDrControlIcons::Set(bool play, bool forward, int speed) {
+    this->play = play;
+    this->forward = forward;
+    this->speed = speed;
+    changed = true;
+}
+
+bool cVeDrControlIcons::Parse(bool force) {
+    if (!cViewElement::Parse(force) || !changed)
+        return false;
+
+    bool isPlay = false;
+    bool isPause = false;
+    bool isFF = false;
+    bool isFF1x = false;
+    bool isFF2x = false;
+    bool isFF3x = false;
+    bool isRew = false;
+    bool isRew1x = false;
+    bool isRew2x = false;
+    bool isRew3x = false;
+
+    if (speed == -1) {
+        if (play) {
+            isPlay = true;
+        } else {
+            isPause = true;
+        }
+    } else if (forward) {
+        if (!play) {
+            isPause = true;
+        }
+        if (speed == 1) {
+            isFF1x = true;
+        } else if (speed == 2) {
+            isFF2x = true;
+        } else if (speed == 3) {
+            isFF3x = true;
+        } else {
+            isFF = true;
+        }
+    } else {
+        if (!play) {
+            isPause = true;
+        }
+        if (speed == 1) {
+            isRew1x = true;
+        } else if (speed == 2) {
+            isRew2x = true;
+        } else if (speed == 3) {
+            isRew3x = true;
+        } else {
+            isRew = true;
+        }
+    }
+    tokenContainer->Clear();
+    tokenContainer->AddIntToken((int)eDRControlIconsIT::play, isPlay);
+    tokenContainer->AddIntToken((int)eDRControlIconsIT::pause, isPause);
+    tokenContainer->AddIntToken((int)eDRControlIconsIT::forward, isFF);
+    tokenContainer->AddIntToken((int)eDRControlIconsIT::forward1x, isFF1x);
+    tokenContainer->AddIntToken((int)eDRControlIconsIT::forward2x, isFF2x);
+    tokenContainer->AddIntToken((int)eDRControlIconsIT::forward3x, isFF3x);
+    tokenContainer->AddIntToken((int)eDRControlIconsIT::rewind, isRew);
+    tokenContainer->AddIntToken((int)eDRControlIconsIT::rewind1x, isRew1x);
+    tokenContainer->AddIntToken((int)eDRControlIconsIT::rewind2x, isRew2x);
+    tokenContainer->AddIntToken((int)eDRControlIconsIT::rewind3x, isRew3x);
+    SetDirty();
+    changed = false;
+    return true;
+}
+
+/******************************************************************
+* cVeDrProgressModeonly
+******************************************************************/
+cVeDrProgressModeonly::cVeDrProgressModeonly(void) {
+    fps = 0.0f;
+    current = 0;
+    total = 0;
+    changed = true;
+}
+
+cVeDrProgressModeonly::~cVeDrProgressModeonly(void) {
+}
+
+void cVeDrProgressModeonly::SetTokenContainer(void) {
+    tokenContainer = new skindesignerapi::cTokenContainer();
+    tokenContainer->DefineIntToken("{current}", (int)eDRProgressModeonlyIT::current);
+    tokenContainer->DefineIntToken("{total}", (int)eDRProgressModeonlyIT::total);
+    tokenContainer->DefineStringToken("{timecurrent}", (int)eDRProgressModeonlyST::timecurrent);
+    tokenContainer->DefineStringToken("{timetotal}", (int)eDRProgressModeonlyST::timetotal);
+    InheritTokenContainer();
+}
+
+void cVeDrProgressModeonly::Set(double fps, int current, int total) {
+    if (this->current == current)
+        return;
+    this->fps = fps;
+    this->current = current;
+    this->total = total;    
+    changed = true;
+}
+
+bool cVeDrProgressModeonly::Parse(bool force) {
+    if (!cViewElement::Parse(force) || !changed)
+        return false;
+
+    string cur = GetTimeString((double)current / fps);
+    string tot = GetTimeString((double)total / fps);
+
+    tokenContainer->Clear();
+    tokenContainer->AddIntToken((int)eDRProgressModeonlyIT::current, current);
+    tokenContainer->AddIntToken((int)eDRProgressModeonlyIT::total, total);
+    tokenContainer->AddStringToken((int)eDRProgressModeonlyST::timecurrent, cur.c_str());
+    tokenContainer->AddStringToken((int)eDRProgressModeonlyST::timetotal, tot.c_str());
+
+    SetDirty();
+    changed = false;
+    return true;
+}
+
+/******************************************************************
+* cVeDrJump
+******************************************************************/
+cVeDrJump::cVeDrJump(void) {
+    jump = NULL;
+    changed = false;
+}
+
+cVeDrJump::~cVeDrJump(void) {
+    free(jump);
+}
+
+void cVeDrJump::SetTokenContainer(void) {
+    tokenContainer = new skindesignerapi::cTokenContainer();
+    tokenContainer->DefineStringToken("{jump}", (int)eDRJumpST::jump);
+    InheritTokenContainer();
+}
+
+void cVeDrJump::Set(const char *jump) {
+    if (!jump)
+        return;
+    free(this->jump);
+    this->jump = strdup(jump);
+    changed = true;
+}
+
+bool cVeDrJump::Parse(bool force) {
+    if (!cViewElement::Parse(force) || !changed)
+        return false;
+
+    tokenContainer->Clear();
+    tokenContainer->AddStringToken((int)eDRJumpST::jump, jump);
+    changed = false;
+    SetDirty();
+    return true;
+}
+
+/******************************************************************
+* cVeDrOnPause
+******************************************************************/
+cVeDrOnPause::cVeDrOnPause(void) {
+    actorsIndex = -1;
+    recfilename = NULL;
+}
+
+cVeDrOnPause::~cVeDrOnPause(void) {
+    free(recfilename);
+}
+
+void cVeDrOnPause::SetTokenContainer(void) {
+    tokenContainer = new skindesignerapi::cTokenContainer();
+    tokenContainer->DefineStringToken("{name}", (int)eDROnpauseST::name);
+    tokenContainer->DefineStringToken("{shorttext}", (int)eDROnpauseST::shorttext);
+    tokenContainer->DefineStringToken("{description}", (int)eDROnpauseST::description);
+    tokenContainer->DefineStringToken("{date}", (int)eDROnpauseST::date);
+    tokenContainer->DefineStringToken("{time}", (int)eDROnpauseST::time);
+    tokenContainer->DefineStringToken("{durationminutes}", (int)eDROnpauseST::durationminutes);
+    tokenContainer->DefineStringToken("{durationeventminutes}", (int)eDROnpauseST::durationeventminutes);
+    tokenContainer->DefineIntToken("{daynumeric}", (int)eDROnpauseIT::daynumeric);
+    tokenContainer->DefineIntToken("{month}", (int)eDROnpauseIT::month);
+    tokenContainer->DefineIntToken("{year}", (int)eDROnpauseIT::year);
+    tokenContainer->DefineIntToken("{duration}", (int)eDROnpauseIT::duration);
+    tokenContainer->DefineIntToken("{durationhours}", (int)eDROnpauseIT::durationhours);
+    tokenContainer->DefineIntToken("{durationevent}", (int)eDROnpauseIT::durationevent);
+    tokenContainer->DefineIntToken("{durationeventhours}", (int)eDROnpauseIT::durationeventhours);
+    tokenContainer->DefineStringToken("{movietitle}", (int)eScraperST::movietitle);
+    tokenContainer->DefineStringToken("{movieoriginalTitle}", (int)eScraperST::movieoriginalTitle);
+    tokenContainer->DefineStringToken("{movietagline}", (int)eScraperST::movietagline);
+    tokenContainer->DefineStringToken("{movieoverview}", (int)eScraperST::movieoverview);
+    tokenContainer->DefineStringToken("{moviegenres}", (int)eScraperST::moviegenres);
+    tokenContainer->DefineStringToken("{moviehomepage}", (int)eScraperST::moviehomepage);
+    tokenContainer->DefineStringToken("{moviereleasedate}", (int)eScraperST::moviereleasedate);
+    tokenContainer->DefineStringToken("{moviepopularity}", (int)eScraperST::moviepopularity);
+    tokenContainer->DefineStringToken("{movievoteaverage}", (int)eScraperST::movievoteaverage);
+    tokenContainer->DefineStringToken("{posterpath}", (int)eScraperST::posterpath);
+    tokenContainer->DefineStringToken("{fanartpath}", (int)eScraperST::fanartpath);
+    tokenContainer->DefineStringToken("{moviecollectionName}", (int)eScraperST::moviecollectionName);
+    tokenContainer->DefineStringToken("{collectionposterpath}", (int)eScraperST::collectionposterpath);
+    tokenContainer->DefineStringToken("{collectionfanartpath}", (int)eScraperST::collectionfanartpath);
+    tokenContainer->DefineStringToken("{seriesname}", (int)eScraperST::seriesname);
+    tokenContainer->DefineStringToken("{seriesoverview}", (int)eScraperST::seriesoverview);
+    tokenContainer->DefineStringToken("{seriesfirstaired}", (int)eScraperST::seriesfirstaired);
+    tokenContainer->DefineStringToken("{seriesnetwork}", (int)eScraperST::seriesnetwork);
+    tokenContainer->DefineStringToken("{seriesgenre}", (int)eScraperST::seriesgenre);
+    tokenContainer->DefineStringToken("{seriesrating}", (int)eScraperST::seriesrating);
+    tokenContainer->DefineStringToken("{seriesstatus}", (int)eScraperST::seriesstatus);
+    tokenContainer->DefineStringToken("{episodetitle}", (int)eScraperST::episodetitle);
+    tokenContainer->DefineStringToken("{episodefirstaired}", (int)eScraperST::episodefirstaired);
+    tokenContainer->DefineStringToken("{episodegueststars}", (int)eScraperST::episodegueststars);
+    tokenContainer->DefineStringToken("{episodeoverview}", (int)eScraperST::episodeoverview);
+    tokenContainer->DefineStringToken("{episoderating}", (int)eScraperST::episoderating);
+    tokenContainer->DefineStringToken("{episodeimagepath}", (int)eScraperST::episodeimagepath);
+    tokenContainer->DefineStringToken("{seasonposterpath}", (int)eScraperST::seasonposterpath);
+    tokenContainer->DefineStringToken("{seriesposter1path}", (int)eScraperST::seriesposter1path);
+    tokenContainer->DefineStringToken("{seriesposter2path}", (int)eScraperST::seriesposter2path);
+    tokenContainer->DefineStringToken("{seriesposter3path}", (int)eScraperST::seriesposter3path);
+    tokenContainer->DefineStringToken("{seriesfanart1path}", (int)eScraperST::seriesfanart1path);
+    tokenContainer->DefineStringToken("{seriesfanart2path}", (int)eScraperST::seriesfanart2path);
+    tokenContainer->DefineStringToken("{seriesfanart3path}", (int)eScraperST::seriesfanart3path);
+    tokenContainer->DefineStringToken("{seriesbanner1path}", (int)eScraperST::seriesbanner1path);
+    tokenContainer->DefineStringToken("{seriesbanner2path}", (int)eScraperST::seriesbanner2path);
+    tokenContainer->DefineStringToken("{seriesbanner3path}", (int)eScraperST::seriesbanner3path);
+    tokenContainer->DefineIntToken("{ismovie}", (int)eScraperIT::ismovie);
+    tokenContainer->DefineIntToken("{moviebudget}", (int)eScraperIT::moviebudget);
+    tokenContainer->DefineIntToken("{movierevenue}", (int)eScraperIT::movierevenue);
+    tokenContainer->DefineIntToken("{movieadult}", (int)eScraperIT::movieadult);
+    tokenContainer->DefineIntToken("{movieruntime}", (int)eScraperIT::movieruntime);
+    tokenContainer->DefineIntToken("{isseries}", (int)eScraperIT::isseries);
+    tokenContainer->DefineIntToken("{posterwidth}", (int)eScraperIT::posterwidth);
+    tokenContainer->DefineIntToken("{posterheight}", (int)eScraperIT::posterheight);
+    tokenContainer->DefineIntToken("{fanartwidth}", (int)eScraperIT::fanartwidth);
+    tokenContainer->DefineIntToken("{fanartheight}", (int)eScraperIT::fanartheight);
+    tokenContainer->DefineIntToken("{movieiscollection}", (int)eScraperIT::movieiscollection);
+    tokenContainer->DefineIntToken("{collectionposterwidth}", (int)eScraperIT::collectionposterwidth);
+    tokenContainer->DefineIntToken("{collectionposterheight}", (int)eScraperIT::collectionposterheight);
+    tokenContainer->DefineIntToken("{collectionfanartwidth}", (int)eScraperIT::collectionfanartwidth);
+    tokenContainer->DefineIntToken("{collectionfanartheight}", (int)eScraperIT::collectionfanartheight);
+    tokenContainer->DefineIntToken("{epgpicavailable}", (int)eScraperIT::epgpicavailable);
+    tokenContainer->DefineIntToken("{episodenumber}", (int)eScraperIT::episodenumber);
+    tokenContainer->DefineIntToken("{episodeseason}", (int)eScraperIT::episodeseason);
+    tokenContainer->DefineIntToken("{episodeimagewidth}", (int)eScraperIT::episodeimagewidth);
+    tokenContainer->DefineIntToken("{episodeimageheight}", (int)eScraperIT::episodeimageheight);
+    tokenContainer->DefineIntToken("{seasonposterwidth}", (int)eScraperIT::seasonposterwidth);
+    tokenContainer->DefineIntToken("{seasonposterheight}", (int)eScraperIT::seasonposterheight);
+    tokenContainer->DefineIntToken("{seriesposter1width}", (int)eScraperIT::seriesposter1width);
+    tokenContainer->DefineIntToken("{seriesposter1height}", (int)eScraperIT::seriesposter1height);
+    tokenContainer->DefineIntToken("{seriesposter2width}", (int)eScraperIT::seriesposter2width);
+    tokenContainer->DefineIntToken("{seriesposter2height}", (int)eScraperIT::seriesposter2height);
+    tokenContainer->DefineIntToken("{seriesposter3width}", (int)eScraperIT::seriesposter3width);
+    tokenContainer->DefineIntToken("{seriesposter3height}", (int)eScraperIT::seriesposter3height);
+    tokenContainer->DefineIntToken("{seriesfanart1width}", (int)eScraperIT::seriesfanart1width);
+    tokenContainer->DefineIntToken("{seriesfanart1height}", (int)eScraperIT::seriesfanart1height);
+    tokenContainer->DefineIntToken("{seriesfanart2width}", (int)eScraperIT::seriesfanart2width);
+    tokenContainer->DefineIntToken("{seriesfanart2height}", (int)eScraperIT::seriesfanart2height);
+    tokenContainer->DefineIntToken("{seriesfanart3width}", (int)eScraperIT::seriesfanart3width);
+    tokenContainer->DefineIntToken("{seriesfanart3height}", (int)eScraperIT::seriesfanart3height);
+    tokenContainer->DefineIntToken("{seriesbanner1width}", (int)eScraperIT::seriesbanner1width);
+    tokenContainer->DefineIntToken("{seriesbanner1height}", (int)eScraperIT::seriesbanner1height);
+    tokenContainer->DefineIntToken("{seriesbanner2width}", (int)eScraperIT::seriesbanner2width);
+    tokenContainer->DefineIntToken("{seriesbanner2height}", (int)eScraperIT::seriesbanner2height);
+    tokenContainer->DefineIntToken("{seriesbanner3width}", (int)eScraperIT::seriesbanner3width);
+    tokenContainer->DefineIntToken("{seriesbanner3height}", (int)eScraperIT::seriesbanner3height);
+    tokenContainer->DefineLoopToken("{actors[name]}", (int)eScraperLT::name);
+    tokenContainer->DefineLoopToken("{actors[role]}", (int)eScraperLT::role);
+    tokenContainer->DefineLoopToken("{actors[thumb]}", (int)eScraperLT::thumb);
+    tokenContainer->DefineLoopToken("{actors[thumbwidth]}", (int)eScraperLT::thumbwidth);
+    tokenContainer->DefineLoopToken("{actors[thumbheight]}", (int)eScraperLT::thumbheight);
+    actorsIndex = tokenContainer->LoopIndex("actors");
+    InheritTokenContainer();
+}
+
+void cVeDrOnPause::Set(const char *recfilename) {
+    if (!recfilename)
+        return;
+    free(this->recfilename);
+    this->recfilename = strdup(recfilename);
+}
+
+bool cVeDrOnPause::Parse(bool force) {
+    if (!cViewElement::Parse(force))
+        return false;
+    if (!recfilename)
+        return false;
+    const cRecording *recording = new cRecording(recfilename);
+    if (!recording)
+        return false;
+    tokenContainer->Clear();
+    tokenContainer->AddStringToken((int)eDROnpauseST::name, recording->Name());
+    const cRecordingInfo *info = recording->Info();
+    if (info) {
+        tokenContainer->AddStringToken((int)eDROnpauseST::shorttext, info->ShortText());
+        tokenContainer->AddStringToken((int)eDROnpauseST::description, info->Description());
+        const cEvent *event = info->GetEvent();
+        if (event) {
+            string recDate = *(event->GetDateString());
+            string recTime = *(event->GetTimeString());
+            if (recDate.find("1970") != string::npos) {
+                time_t start = recording->Start();
+                recDate = *DateString(start);
+                recTime = *TimeString(start);
+            }
+            tokenContainer->AddStringToken((int)eDROnpauseST::date, recDate.c_str());
+            tokenContainer->AddStringToken((int)eDROnpauseST::time, recTime.c_str());
+            time_t startTime = event->StartTime();
+            struct tm * sStartTime = localtime(&startTime);
+            tokenContainer->AddIntToken((int)eDROnpauseIT::year, sStartTime->tm_year + 1900);
+            tokenContainer->AddIntToken((int)eDROnpauseIT::daynumeric, sStartTime->tm_mday);
+            tokenContainer->AddIntToken((int)eDROnpauseIT::month, sStartTime->tm_mon+1);
+            int duration = event->Duration() / 60;
+            int recDuration = recording->LengthInSeconds();
+            recDuration = (recDuration>0)?(recDuration / 60):0;
+            tokenContainer->AddIntToken((int)eDROnpauseIT::duration, recDuration);
+            tokenContainer->AddIntToken((int)eDROnpauseIT::durationhours, recDuration / 60);
+            tokenContainer->AddStringToken((int)eDROnpauseST::durationminutes, *cString::sprintf("%.2d", recDuration%60));
+            tokenContainer->AddIntToken((int)eDROnpauseIT::durationevent, duration);
+            tokenContainer->AddIntToken((int)eDROnpauseIT::durationeventhours, duration / 60);
+            tokenContainer->AddStringToken((int)eDROnpauseST::durationeventminutes, *cString::sprintf("%.2d", duration%60));
+        }
+    }
+    
+    vector<int> loopInfo;
+    bool scrapInfoAvailable = LoadFullScrapInfo(NULL, recording);
+    int numActors = NumActors();
+    loopInfo.push_back(numActors);
+    tokenContainer->CreateLoopTokenContainer(&loopInfo);
+    if (scrapInfoAvailable) {
+        SetFullScrapInfo(tokenContainer, actorsIndex);
+    }
+
+    SetDirty();
+    delete recording;
+    return true;
+}
+
+/******************************************************************
+* cVeDrScraperContent
+******************************************************************/
+cVeDrScraperContent::cVeDrScraperContent(void) {
+    recording = NULL;
+}
+
+cVeDrScraperContent::~cVeDrScraperContent(void) {
+}
+
+void cVeDrScraperContent::SetTokenContainer(void) {
+    tokenContainer = new skindesignerapi::cTokenContainer();
+    tokenContainer->DefineStringToken("{posterpath}", (int)eScraperPosterBannerST::posterpath);
+    tokenContainer->DefineStringToken("{bannerpath}", (int)eScraperPosterBannerST::bannerpath);
+    tokenContainer->DefineStringToken("{mediapath}", (int)eScraperPosterBannerST::mediapath);
+    tokenContainer->DefineIntToken("{posterwidth}", (int)eScraperPosterBannerIT::posterwidth);
+    tokenContainer->DefineIntToken("{posterheight}", (int)eScraperPosterBannerIT::posterheight);
+    tokenContainer->DefineIntToken("{hasPoster}", (int)eScraperPosterBannerIT::hasposter);
+    tokenContainer->DefineIntToken("{bannerwidth}", (int)eScraperPosterBannerIT::bannerwidth);
+    tokenContainer->DefineIntToken("{bannerheight}", (int)eScraperPosterBannerIT::bannerheight);
+    tokenContainer->DefineIntToken("{hasBanner}", (int)eScraperPosterBannerIT::hasbanner);
+    tokenContainer->DefineIntToken("{mediawidth}", (int)eScraperPosterBannerIT::mediawidth);
+    tokenContainer->DefineIntToken("{mediaheight}", (int)eScraperPosterBannerIT::mediaheight);
+    tokenContainer->DefineIntToken("{isbanner}", (int)eScraperPosterBannerIT::isbanner);
+    InheritTokenContainer();
+}
+
+void cVeDrScraperContent::Set(const cRecording *recording) {
+    this->recording = recording;
+}
+
+bool cVeDrScraperContent::Parse(bool force) {
+    if (!cViewElement::Parse(force))
+        return false;
+    if (!recording)
+        return false;
+    SetPosterBanner(tokenContainer, NULL, recording);
+    SetDirty();
+    return true;
+}

coreengine/viewelementsdisplayreplay.h

@@ -0,0 +1,206 @@
+#ifndef __VIEWELEMENTSDR_H
+#define __VIEWELEMENTSDR_H
+
+#include "viewelement.h"
+#include "../extensions/scrapmanager.h"
+
+/******************************************************************
+* cVeDrRecTitle
+******************************************************************/
+class cVeDrRecTitle : public cViewElement {
+private:
+    const cRecording *recording;
+    char *title;
+public:
+    cVeDrRecTitle(void);
+    virtual ~cVeDrRecTitle(void);
+    void SetTokenContainer(void);
+    void Set(const cRecording *recording);
+    void Set(const char *title);
+    bool Parse(bool forced = false);
+};
+
+/******************************************************************
+* cVeDrRecInfo
+******************************************************************/
+class cVeDrRecInfo : public cViewElement {
+private:
+    const cRecording *recording;
+public:
+    cVeDrRecInfo(void);
+    virtual ~cVeDrRecInfo(void);
+    void SetTokenContainer(void);
+    void Set(const cRecording *recording);
+    bool Parse(bool forced = false);
+};
+
+/******************************************************************
+* cVeDrCurrentTime
+******************************************************************/
+class cVeDrCurrentTime : public cViewElement {
+private:
+    bool changed;
+    char *current;
+public:
+    cVeDrCurrentTime(void);
+    virtual ~cVeDrCurrentTime(void);
+    void SetTokenContainer(void);
+    void Set(const char *current);
+    bool Parse(bool forced = false);
+};
+
+/******************************************************************
+* cVeDrTotalTime
+******************************************************************/
+class cVeDrTotalTime : public cViewElement {
+private:
+    bool changed;
+    char *total;
+    bool timeshiftActive;
+    char *timeshiftDuration;
+public:
+    cVeDrTotalTime(void);
+    virtual ~cVeDrTotalTime(void);
+    void SetTokenContainer(void);
+    void Set(const char *total, bool timeshiftActive, const char *timeshiftDuration);
+    bool Parse(bool forced = false);
+};
+
+/******************************************************************
+* cVeDrEndTime
+******************************************************************/
+class cVeDrEndTime : public cViewElement {
+private:
+    cString end;
+    bool changed;
+public:
+    cVeDrEndTime(void);
+    virtual ~cVeDrEndTime(void);
+    void SetTokenContainer(void);
+    void Set(cString end);
+    bool Parse(bool forced = false);
+};
+
+/******************************************************************
+* cVeDrProgressBar
+******************************************************************/
+class cVeDrProgressBar : public cViewElement {
+private:
+    int current;
+    int total;
+    bool timeshiftActive;
+    int timeshiftTotal;
+    bool changed;
+public:
+    cVeDrProgressBar(void);
+    virtual ~cVeDrProgressBar(void);
+    void SetTokenContainer(void);
+    void Set(int current, int total, bool timeshiftActive, int timeshiftTotal);
+    bool Parse(bool forced = false);
+};
+
+/******************************************************************
+* cVeDrCutMarks
+******************************************************************/
+class cVeDrCutMarks : public cViewElement {
+private:
+    int cutmarksIndex;
+    const cMarks *marks;
+    int current;
+    int total;
+    bool timeshiftActive;
+    int timeshiftTotal;
+    int numMarksLast;
+    int *lastMarks;
+    int markActive;
+    bool MarksChanged(void);
+    void RememberMarks(void);
+public:
+    cVeDrCutMarks(void);
+    virtual ~cVeDrCutMarks(void);
+    void SetTokenContainer(void);
+    void Set(const cMarks *marks, int current, int total, bool timeshiftActive, int timeshiftTotal);
+    void Reset(void);
+    bool Parse(bool forced = false);
+};
+
+/******************************************************************
+* cVeDrControlIcons
+******************************************************************/
+class cVeDrControlIcons : public cViewElement {
+private:
+    bool play;
+    bool forward;
+    int speed;
+    bool changed;
+public:
+    cVeDrControlIcons(void);
+    virtual ~cVeDrControlIcons(void);
+    void SetTokenContainer(void);
+    void Set(bool play, bool forward, int speed);
+    bool Parse(bool forced = false);
+};
+
+/******************************************************************
+* cVeDrProgressModeonly
+******************************************************************/
+class cVeDrProgressModeonly : public cViewElement {
+private:
+    double fps;
+    int current;
+    int total;
+    bool changed;
+public:
+    cVeDrProgressModeonly(void);
+    virtual ~cVeDrProgressModeonly(void);
+    void SetTokenContainer(void);
+    void Set(double fps, int current, int total);
+    bool Parse(bool forced = false);
+};
+
+/******************************************************************
+* cVeDrJump
+******************************************************************/
+class cVeDrJump : public cViewElement {
+private:
+    char *jump;
+    bool changed;
+public:
+    cVeDrJump(void);
+    virtual ~cVeDrJump(void);
+    void SetTokenContainer(void);
+    void Set(const char *jump);
+    bool Parse(bool forced = false);
+};
+
+/******************************************************************
+* cVeDrOnPause
+******************************************************************/
+class cVeDrOnPause : public cViewElement, public cScrapManager {
+private:
+    int actorsIndex;
+    char *recfilename;
+public:
+    cVeDrOnPause(void);
+    virtual ~cVeDrOnPause(void);
+    int Delay(void) { return attribs->Delay() * 1000; };
+    void SetTokenContainer(void);
+    void Set(const char *recfilename);
+    bool Parse(bool forced = false);
+};
+
+/******************************************************************
+* cVeDrScraperContent
+******************************************************************/
+class cVeDrScraperContent : public cViewElement, public cScrapManager {
+private:
+    const cRecording *recording;
+public:
+    cVeDrScraperContent(void);
+    virtual ~cVeDrScraperContent(void);
+    void SetTokenContainer(void);
+    void Set(const cRecording *recording);
+    bool Parse(bool forced = false);
+};
+
+#endif //__VIEWELEMENTSDR_H

coreengine/viewelementsdisplaytracks.c

@@ -0,0 +1,84 @@
+#include "viewelementsdisplaytracks.h"
+
+/******************************************************************
+* cVeDtBackground
+******************************************************************/
+cVeDtBackground::cVeDtBackground(void) {
+    numTracks = 0;
+}
+
+cVeDtBackground::~cVeDtBackground(void) {
+}
+
+void cVeDtBackground::SetTokenContainer(void) {
+    tokenContainer = new skindesignerapi::cTokenContainer();
+    tokenContainer->DefineIntToken("{numtracks}", (int)eDTBackgroundIT::numtracks);
+    InheritTokenContainer();
+}
+
+void cVeDtBackground::Set(int numTracks) {
+    this->numTracks = numTracks;
+}
+
+bool cVeDtBackground::Parse(bool forced) {
+    if (!cViewElement::Parse(forced))
+        return false;
+    tokenContainer->Clear();
+    tokenContainer->AddIntToken((int)eDTBackgroundIT::numtracks, numTracks);
+    SetDirty();
+    return true;
+}
+
+/******************************************************************
+* cVeDtHeader
+******************************************************************/
+cVeDtHeader::cVeDtHeader(void) {
+    title = NULL;
+    audioChannel = 0;
+    numTracks = 0;
+    changed = true;
+}
+
+cVeDtHeader::~cVeDtHeader(void) {
+    free(title);
+}
+
+void cVeDtHeader::SetTokenContainer(void) {
+    tokenContainer = new skindesignerapi::cTokenContainer();
+    tokenContainer->DefineIntToken("{numtracks}", (int)eDTHeaderIT::numtracks);
+    tokenContainer->DefineIntToken("{isstereo}", (int)eDTHeaderIT::isstereo);
+    tokenContainer->DefineIntToken("{isac3}", (int)eDTHeaderIT::isac3);
+    tokenContainer->DefineStringToken("{title}", (int)eDTHeaderST::title);
+    InheritTokenContainer();
+}
+
+void cVeDtHeader::SetTitle(const char *title) {
+    if (!title)
+        return;
+    free(this->title);
+    this->title = strdup(title);
+    changed = true;
+}
+
+void cVeDtHeader::SetNumtracks(int numTracks) {    
+    this->numTracks = numTracks;
+    changed = true;
+}
+
+void cVeDtHeader::SetAudiochannel(int audioChannel) {
+    this->audioChannel = audioChannel;
+    changed = true;
+}
+
+bool cVeDtHeader::Parse(bool forced) {
+    if (!cViewElement::Parse(forced) || !changed)
+        return false;
+
+    tokenContainer->Clear();
+    tokenContainer->AddIntToken((int)eDTHeaderIT::numtracks, numTracks);
+    tokenContainer->AddIntToken((int)eDTHeaderIT::isstereo, (audioChannel < 0) ? false : true);
+    tokenContainer->AddIntToken((int)eDTHeaderIT::isac3, (audioChannel < 0) ? true : false);
+    tokenContainer->AddStringToken((int)eDTHeaderST::title, title);
+    SetDirty();
+    return true;
+}

coreengine/viewelementsdisplaytracks.h

@@ -0,0 +1,40 @@
+#ifndef __VIEWELEMENTSDT_H
+#define __VIEWELEMENTSDT_H
+
+#include <vdr/menu.h>
+#include "viewelement.h"
+
+/******************************************************************
+* cVeDtBackground
+******************************************************************/
+class cVeDtBackground : public cViewElement {
+private:
+    int numTracks;
+public:
+    cVeDtBackground(void);
+    virtual ~cVeDtBackground(void);
+    void SetTokenContainer(void);
+    void Set(int numTracks);
+    bool Parse(bool forced = false);
+};
+
+/******************************************************************
+* cVeDtHeader
+******************************************************************/
+class cVeDtHeader : public cViewElement {
+private:
+    char *title;
+    int audioChannel;
+    int numTracks;
+    bool changed;
+public:
+    cVeDtHeader(void);
+    virtual ~cVeDtHeader(void);
+    void SetTokenContainer(void);
+    void SetTitle(const char *title);
+    void SetNumtracks(int numTracks);
+    void SetAudiochannel(int audioChannel);
+    bool Parse(bool forced = false);
+};
+
+#endif //__VIEWELEMENTSDT_H

coreengine/viewgrid.c

@@ -0,0 +1,188 @@
+#include "viewgrid.h"
+#include "../extensions/helpers.h"
+
+cViewGrid::cViewGrid(void) {
+    id = -1;
+    plugId = -1;
+    viewId = -1;
+    globals = NULL;
+    attribs = new cViewElementAttribs((int)eViewElementAttribs::count);
+    gridTpl = NULL;
+    gridsize = GRIDSIZE;
+    grid = new cGridElement*[gridsize];
+    for (int i=0; i < gridsize; i++) {
+        grid[i] = NULL;
+    }
+    gridMin = 0;
+    gridMax = -1;
+}
+
+cViewGrid::~cViewGrid(void) {
+    delete attribs;
+    delete gridTpl;
+}
+
+void cViewGrid::SetGlobals(cGlobals *globals) {
+    this->globals = globals;
+}
+
+void cViewGrid::SetContainer(int x, int y, int width, int height) {
+    container.SetX(x);
+    container.SetY(y);
+    container.SetWidth(width);
+    container.SetHeight(height);
+}
+
+void cViewGrid::SetAttributes(vector<stringpair> &attributes) {
+    attribs->Set(attributes);
+}
+
+void cViewGrid::AddGridElement(cGridElement *gridElement) {
+    gridTpl = gridElement;
+}
+
+const char *cViewGrid::Name(void) {
+    return attribs->Name();
+}
+
+void cViewGrid::SetTokenContainer(void) {
+    if (!gridTpl)
+        return;
+    gridTpl->SetId(id);
+    gridTpl->SetPluginId(plugId);
+    gridTpl->SetViewId(viewId);
+    gridTpl->SetTokenContainer();
+}
+
+void cViewGrid::PreCache(void) {
+    attribs->SetContainer(container.X(), container.Y(), container.Width(), container.Height());
+    attribs->SetGlobals(globals);
+    attribs->Cache();
+    gridTpl->SetGlobals(globals);
+    gridTpl->SetContainer(attribs->X(), attribs->Y(), attribs->Width(), attribs->Height());
+    gridTpl->Cache();
+    
+}
+
+void cViewGrid::CheckSize(int id) {
+    if (id < gridsize)
+        return;
+    int newgridsize = gridsize + GRIDSIZE;
+    while (newgridsize < id)
+        newgridsize += gridsize;
+    cGridElement **gridNew = new cGridElement*[newgridsize];
+    int i=0;
+    bool foundFirst = false;
+    for (; i < gridsize; i++) {
+        if (!foundFirst && grid[i]) {
+            foundFirst = true;
+            gridMin = i;
+        }
+        gridNew[i] = grid[i];
+    }
+    gridsize = newgridsize;
+    for (; i < gridsize; i++) {
+        gridNew[i] = NULL;
+    }
+    delete[] grid;
+    grid = gridNew;
+}
+
+void cViewGrid::SetTokens(int gId, skindesignerapi::cTokenContainer *tk) {
+    if (!grid[gId]) {
+        return;
+    }
+    grid[gId]->Set(tk);
+}
+
+void cViewGrid::PositionGrid(int gId, double x, double y, double width, double height) {
+    int gridX = attribs->X() + x * attribs->Width();
+    int gridY = attribs->Y() + y * attribs->Height();
+    int gridWidth = width * attribs->Width();
+    int gridHeight = height * attribs->Height();
+    if (!grid[gId]) {
+        if (gId >= gridMax)
+            gridMax = gId+1;
+        grid[gId] = CreateGrid(gridX, gridY, gridWidth, gridHeight);
+    } else {
+        if (grid[gId]->Width() == gridWidth && grid[gId]->Height() == gridHeight) {
+            grid[gId]->SetPosition(gridX, gridY, gridWidth, gridHeight);
+        } else {
+            cGridElement *ge = CreateGrid(gridX, gridY, gridWidth, gridHeight);
+            ge->Set(grid[gId]->GetTokenContainer());
+            grid[gId]->Close();
+            delete grid[gId];
+            grid[gId] = ge;
+        }
+        grid[gId]->SetDirty();
+    }
+}
+
+void cViewGrid::SetCurrentGrid(int gId, bool current) {
+    if (gId >= 0 && grid[gId]) {
+        grid[gId]->SetCurrent(current);
+    }
+}
+
+void cViewGrid::DeleteGrid(int gId) {
+    if (!grid[gId])
+        return;
+    grid[gId]->Close();
+    delete grid[gId];
+    grid[gId] = NULL;
+}
+
+void cViewGrid::ClearGrids(void) {
+    for (int i = 0; i < gridsize; i++) {
+        if (!grid[i])
+            continue;
+        grid[i]->Close();
+        delete grid[i];
+        grid[i] = NULL;
+    }
+}
+
+void cViewGrid::Render(void) {
+    for (int i = gridMin; i < gridMax; i++) {
+        if (grid[i] && grid[i]->Parse()) {
+            grid[i]->Render();
+        }
+    }
+}
+
+cGridElement *cViewGrid::CreateGrid(int x, int y, int width, int height) {
+    cGridElement *ge = new cGridElement(*gridTpl);
+    ge->SetAreaX(x);
+    ge->SetAreaY(y);
+    ge->SetAreaWidth(width);
+    ge->SetAreaHeight(height);
+    return ge;
+}
+
+void cViewGrid::Close(void) {
+    ClearGrids();
+    gridsize = GRIDSIZE;
+    delete[] grid;
+    grid = new cGridElement*[gridsize];
+    for (int i=0; i < gridsize; i++) {
+        grid[i] = NULL;
+    }
+    gridMin = 0;
+    gridMax = -1;
+}
+
+void cViewGrid::Hide(void) {
+    for (int i = 0; i < gridsize; i++) {
+        if (grid[i]) {
+            grid[i]->Hide();
+        }
+    }
+}
+
+void cViewGrid::Show(void) {
+    for (int i = 0; i < gridsize; i++) {
+        if (grid[i]) {
+            grid[i]->Show();
+        }
+    }
+}

coreengine/viewgrid.h

@@ -0,0 +1,47 @@
+#ifndef __VIEWGRID_H
+#define __VIEWGRID_H
+
+#define GRIDSIZE 500
+
+#include "gridelement.h"
+
+class cViewGrid {
+protected:
+    cRect container;
+    cGlobals *globals;
+    cViewElementAttribs *attribs;
+    cGridElement *gridTpl;
+    int gridsize;
+    cGridElement **grid;
+    int gridMin;
+    int gridMax;
+    int id;
+    int viewId;
+    int plugId;
+    cGridElement *CreateGrid(int x, int y, int width, int height);
+public:
+    cViewGrid(void);
+    virtual ~cViewGrid(void);
+    void SetGlobals(cGlobals *globals);
+    void SetContainer(int x, int y, int width, int height);
+    void SetAttributes(vector<stringpair> &attributes);
+    void SetId(int id) { this->id = id; };
+    void SetPluginId(int plugId) { this->plugId = plugId; };
+    void SetViewId(int viewId) { this->viewId = viewId; };
+    void AddGridElement(cGridElement *gridElement);
+    const char *Name(void);
+    void SetTokenContainer(void);
+    void PreCache(void);
+    void CheckSize(int id);
+    void SetTokens(int gId, skindesignerapi::cTokenContainer *tk);
+    void PositionGrid(int gId, double x, double y, double width, double height);
+    void SetCurrentGrid(int gId, bool current);
+    void DeleteGrid(int gId);
+    void ClearGrids(void);
+    void Render(void);
+    void Close(void);
+    void Hide(void);
+    void Show(void);
+};
+
+#endif //__VIEWGRID_H

coreengine/viewlist.c

@@ -0,0 +1,899 @@
+#include "viewlist.h"
+
+cViewList::cViewList(void) {
+    globals = NULL;
+    attribs = new cViewListAttribs((int)eViewListAttribs::count);
+    numElements = 0;
+    listElement = NULL;
+    currentElement = NULL;
+    listElements = NULL;
+    plugId = -1;
+    plugMenuId = -1;
+}
+
+cViewList::~cViewList(void) {
+    delete attribs;
+    delete listElement;
+    delete currentElement;
+    if (listElements) {
+        for (int i=0; i < numElements; ++i) {
+            if (listElements[i]) {
+                delete listElements[i];
+                listElements[i] = NULL;
+            }
+        }
+    }
+    delete[] listElements;
+}
+    
+void cViewList::SetGlobals(cGlobals *globals) {
+    this->globals = globals;
+    if (listElement)
+        listElement->SetGlobals(globals);
+    if (currentElement)
+        currentElement->SetGlobals(globals);
+}   
+
+void cViewList::SetContainer(int x, int y, int width, int height) {
+    container.SetX(x);
+    container.SetY(y);
+    container.SetWidth(width);
+    container.SetHeight(height);
+}
+
+void cViewList::SetAttributes(vector<stringpair> &attributes) {
+    attribs->Set(attributes);
+}
+
+cViewList *cViewList::CreateViewList(const char *name) {
+    cViewList *l = NULL;
+    if (!strcmp(name, "menudefault"))
+        l = new cViewListDefault();
+    else if (!strcmp(name, "menumain"))
+        l = new cViewListMain();
+    else if (!strcmp(name, "menusetup"))
+        l = new cViewListMain();
+    else if (!strcmp(name, "menuschedules"))
+        l = new cViewListSchedules();
+    else if (!strcmp(name, "menutimers"))
+        l = new cViewListTimers();
+    else if (!strcmp(name, "menuchannels"))
+        l = new cViewListChannels();
+    else if (!strcmp(name, "menurecordings"))
+        l = new cViewListRecordings();
+    else if (!strcmp(name, "displayaudiotracks"))
+        l = new cViewListAudioTracks();
+    else if (startswith(name, "menuplugin"))
+        l = new cViewListPlugin();
+    else
+        esyslog("skindesigner: unknown viewlist %s", name);
+    return l;
+}
+
+cViewElement *cViewList::CreateListElement(const char *name) {
+    cViewElement *le = NULL;
+    if (!strcmp(name, "menudefault"))
+        le = new cLeMenuDefault();
+    else if (!strcmp(name, "menumain"))
+        le = new cLeMenuMain();
+    else if (!strcmp(name, "menusetup"))
+        le = new cLeMenuMain();
+    else if (!strcmp(name, "menuschedules"))
+        le = new cLeMenuSchedules();
+    else if (!strcmp(name, "menutimers"))
+        le = new cLeMenuTimers();
+    else if (!strcmp(name, "menuchannels"))
+        le = new cLeMenuChannels();
+    else if (!strcmp(name, "menurecordings"))
+        le = new cLeMenuRecordings();
+    else if (!strcmp(name, "displayaudiotracks"))
+        le = new cLeAudioTracks();
+    else if (startswith(name, "menuplugin"))
+        le = new cLeMenuPlugin();
+    else
+        esyslog("skindesigner: unknown viewlist %s", name);
+    return le;
+}
+
+cViewElement *cViewList::CreateCurrentElement(const char *name) {
+    cViewElement *ce = NULL;
+    if (!strcmp(name, "menumain"))
+        ce = new cCeMenuMain();
+    else if (!strcmp(name, "menusetup"))
+        ce = new cCeMenuMain();
+    else if (!strcmp(name, "menuschedules"))
+        ce = new cCeMenuSchedules();
+    else if (!strcmp(name, "menutimers"))
+        ce = new cCeMenuTimers();
+    else if (!strcmp(name, "menuchannels"))
+        ce = new cCeMenuChannels();
+    else if (!strcmp(name, "menurecordings"))
+        ce = new cCeMenuRecordings();
+    else if (startswith(name, "menuplugin"))
+        ce = new cCeMenuPlugin();
+    else
+        esyslog("skindesigner: unknown viewlist %s", name);
+    return ce;
+}
+
+void cViewList::AddListElement(cViewElement *listElement) {
+    this->listElement = listElement;
+    listElement->SetTokenContainer();
+}
+
+void cViewList::AddCurrentElement(cViewElement *currentElement) {
+    this->currentElement = currentElement;
+    currentElement->SetTokenContainer();
+}
+
+void cViewList::PreCache(void) {
+    attribs->SetContainer(container.X(), container.Y(), container.Width(), container.Height());
+    attribs->SetGlobals(globals);
+    attribs->Cache();
+    numElements = attribs->NumListElements();
+    orientation = attribs->Orientation();
+    eAlign align = attribs->Align();
+    int x = attribs->X();
+    int y = attribs->Y();
+    int width = attribs->Width();
+    int height = attribs->Height();
+    
+    int step = 0;
+    if (orientation == eOrientation::vertical) {
+        step = height / numElements;
+    } else {
+        step = width / numElements;
+    }
+
+    int start = 0;
+    if (align == eAlign::center) {
+        if (orientation == eOrientation::vertical) {
+            start = y + (height - numElements * step) / 2;
+        } else {
+            start = x + (width - numElements * step) / 2;            
+        }
+    } else if (align == eAlign::bottom) {
+        start = y + height - numElements * step;         
+    } else if (align == eAlign::right) {
+        start = x + width - numElements * step;                 
+    }
+    Prepare(start, step);
+}
+
+int cViewList::NumItems(void) {
+    return numElements;
+}
+
+eOrientation cViewList::Orientation(void) {
+    return attribs->Orientation();
+}
+
+void cViewList::Draw(eMenuCategory menuCat) {
+    int current = -1;
+    for (int i = 0; i < numElements; i++) {
+        listElements[i]->SetMenuCategory(menuCat);
+        if (listElements[i]->Parse()) {
+            listElements[i]->Render();
+            if (listElements[i]->Current()) {
+                listElements[i]->RenderCurrent();
+                current = i;
+            }
+        }
+    }
+    if (current >= 0 && listElements[current]) {
+        listElements[current]->WakeCurrent();
+    }
+
+}
+
+void cViewList::Clear(void) {
+    if (!listElements)
+        return;
+    for (int i = 0; i < numElements; i++) {
+        listElements[i]->StopScrolling();
+        listElements[i]->Clear();
+    }    
+}
+
+void cViewList::Close(void) {
+    if (!listElements)
+        return;
+    for (int i = 0; i < numElements; i++) {
+        listElements[i]->StopScrolling();
+        listElements[i]->Close();
+    }
+}
+
+void cViewList::SetTransparency(int transparency) {
+    for (int i = 0; i < numElements; i++) {
+        if (listElements[i]) {
+            listElements[i]->SetTransparency(transparency);
+        }
+    }
+}
+
+void cViewList::Debug(void) {   
+}
+
+/******************************************************************
+* cViewListDefault
+******************************************************************/
+cViewListDefault::cViewListDefault(void) {
+    listDefault = NULL;
+    colX = NULL;
+    colWidths = NULL;
+    avrgFontWidth = 0;
+    listFont = NULL;
+    plugName = NULL;
+}
+
+cViewListDefault::~cViewListDefault(void) {
+    delete[] listDefault;
+    delete[] colX;
+    delete[] colWidths;
+}
+
+void cViewListDefault::Prepare(int start, int step) {
+    if (!listElement)
+        return;
+
+    cLeMenuDefault *tpl = dynamic_cast<cLeMenuDefault*>(listElement);
+    if (!tpl) return;
+    listDefault = new cLeMenuDefault*[numElements];
+    listElements = new cListElement*[numElements];
+    int pos = start;
+    
+    for (int i = 0; i < numElements; i++) {
+        listDefault[i] = new cLeMenuDefault(*tpl);
+        listElements[i] = listDefault[i];
+        listDefault[i]->SetNumber(i);
+        listDefault[i]->SetTokenContainer();
+        int x, y, width, height;
+        if (orientation == eOrientation::vertical) {
+            x = attribs->X();
+            y = pos;
+            width = attribs->Width();
+            height = step;
+            listDefault[i]->SetAreaHeight(height);
+        } else {
+            x = pos;
+            y = attribs->Y();
+            width = step;
+            height = attribs->Height();
+            listDefault[i]->SetAreaWidth(width);
+        }
+        listDefault[i]->SetContainer(x, y, width, height);
+        listDefault[i]->Cache();
+        pos += step;
+    }
+
+    //Setting average font width
+    avrgFontWidth = 20;
+    const char *determinateFont = attribs->DeterminateFont();
+    if (!determinateFont) {
+        return;
+    }
+    cFunction *f = listDefault[0]->GetFunction(determinateFont);
+    if (!f)
+        return;
+    cFuncDrawText *fdt = dynamic_cast<cFuncDrawText*>(f);
+    if (!fdt) {
+        return;
+    }
+    avrgFontWidth = fdt->AvrgFontWidth();
+    listFont = fdt->GetFont();
+    colX = new int[MAX_TABS];
+    colWidths = new int[MAX_TABS];
+    for (int i=0; i < MAX_TABS; i++) {
+        colX[i] = 0;
+        colWidths[i] = 0;
+    }
+    for (int i = 0; i < numElements; i++) {
+        listDefault[i]->SetListInfo(colX, colWidths);
+    }
+}
+
+void cViewListDefault::SetTabs(int tab1, int tab2, int tab3, int tab4, int tab5) {
+    int itemWidth = attribs->MenuItemWidth();
+    if (!tab1) {
+        colX[0] = 0;
+        colWidths[0] = itemWidth;
+        for (int i = 1; i < MAX_TABS; i++) {
+                colX[i] = 0;            
+                colWidths[i] = 0;
+        }
+    } else {
+        colX[0] = 0;
+        colX[1] = tab1 ? colX[0] + tab1 : 0;
+        colX[2] = tab2 ? colX[1] + tab2 : 0;
+        colX[3] = tab3 ? colX[2] + tab3 : 0;
+        colX[4] = tab4 ? colX[3] + tab4 : 0;
+        colX[5] = tab5 ? colX[4] + tab5 : 0;
+        for (int i = 1; i < MAX_TABS; i++)
+            colX[i] *= avrgFontWidth;
+
+        bool end = false;
+        for (int i = 0; i < MAX_TABS; i++) {
+            if ( i < MAX_TABS -1 && colX[i+1] > 0) {
+                colWidths[i] = colX[i+1] - colX[i];
+            } else if (!end) {
+                end = true;
+                colWidths[i] = itemWidth - colX[i];
+            } else {
+                colWidths[i] = 0;                
+            }
+        }
+    }
+}
+
+void cViewListDefault::Set(const char *text, int index, bool current, bool selectable) {
+    if (!current)
+        listDefault[index]->StopScrolling();
+    listDefault[index]->SetCurrent(current);
+    listDefault[index]->SetSelectable(selectable);
+    listDefault[index]->SetPlugin(plugName);
+    listDefault[index]->SetText(text);
+}
+
+const cFont *cViewListDefault::GetListFont(void) {
+    return listFont; 
+};
+
+int cViewListDefault::GetListWidth(void) {
+    return attribs->MenuItemWidth();
+}
+
+/******************************************************************
+* cViewListMain
+******************************************************************/
+cViewListMain::cViewListMain(void) {
+    listMain = NULL;
+    currentMain = NULL;
+}
+
+cViewListMain::~cViewListMain(void) {
+    delete[] listMain;
+}
+
+void cViewListMain::Prepare(int start, int step) {
+    if (!listElement)
+        return;
+
+    cLeMenuMain *tpl = dynamic_cast<cLeMenuMain*>(listElement);
+    if (!tpl) return;
+
+    listMain = new cLeMenuMain*[numElements];
+    listElements = new cListElement*[numElements];
+    int pos = start;
+    
+    for (int i = 0; i < numElements; i++) {
+        listMain[i] = new cLeMenuMain(*tpl);
+        listElements[i] = listMain[i];
+        listMain[i]->SetNumber(i);
+        listMain[i]->SetTokenContainer();
+        int x, y, width, height;
+        if (orientation == eOrientation::vertical) {
+            x = attribs->X();
+            y = pos;
+            width = attribs->Width();
+            height = step;
+            listMain[i]->SetAreaHeight(height);
+        } else {
+            x = pos;
+            y = attribs->Y();
+            width = step;
+            height = attribs->Height();
+            listMain[i]->SetAreaWidth(width);
+        }
+        listMain[i]->SetContainer(x, y, width, height);
+        listMain[i]->Cache();
+        pos += step;
+    }
+
+    if (!currentElement) return;
+    currentMain = dynamic_cast<cCeMenuMain*>(currentElement);
+    if (!currentMain) return;
+
+    currentMain->SetContainer(attribs->X(), attribs->Y(), attribs->Width(), attribs->Height());
+    currentMain->SetDetached();
+    currentMain->Cache();
+    for (int i = 0; i < numElements; i++) {
+        listMain[i]->SetCurrentElement(currentMain);
+    }
+}
+
+void cViewListMain::Set(const char *text, int index, bool current, bool selectable) {
+    if (!current)
+        listMain[index]->StopScrolling();
+    listMain[index]->SetCurrent(current);
+    listMain[index]->ClearCurrentElement();
+    listMain[index]->SetSelectable(selectable);
+    listMain[index]->SetText(text);
+}
+
+const char *cViewListMain::GetPlugin(void) {
+    for (int i = 0; i < numElements; i++) {
+        if (listMain[i] && listMain[i]->Current()) {
+            return listMain[i]->PluginName();
+        }
+    }
+    return NULL;
+}
+/******************************************************************
+* cViewListSchedules
+******************************************************************/
+cViewListSchedules::cViewListSchedules(void) {
+    listSchedules = NULL;
+    currentSchedules = NULL;
+    epgSearchFav = false;
+}
+
+cViewListSchedules::~cViewListSchedules(void) {
+    delete[] listSchedules;
+}
+
+void cViewListSchedules::Prepare(int start, int step) {
+    if (!listElement)
+        return;
+
+    cLeMenuSchedules *tpl = dynamic_cast<cLeMenuSchedules*>(listElement);
+    if (!tpl) return;
+
+    listSchedules = new cLeMenuSchedules*[numElements];
+    listElements = new cListElement*[numElements];
+    int pos = start;
+    
+    for (int i = 0; i < numElements; i++) {
+        listSchedules[i] = new cLeMenuSchedules(*tpl);
+        listElements[i] = listSchedules[i];
+        listSchedules[i]->SetNumber(i);
+        listSchedules[i]->SetTokenContainer();
+        int x, y, width, height;
+        if (orientation == eOrientation::vertical) {
+            x = attribs->X();
+            y = pos;
+            width = attribs->Width();
+            height = step;
+            listSchedules[i]->SetAreaHeight(height);
+        } else {
+            x = pos;
+            y = attribs->Y();
+            width = step;
+            height = attribs->Height();
+            listSchedules[i]->SetAreaWidth(width);
+        }
+        listSchedules[i]->SetContainer(x, y, width, height);
+        listSchedules[i]->Cache();
+        pos += step;
+    }
+
+    if (!currentElement) return;
+    currentSchedules = dynamic_cast<cCeMenuSchedules*>(currentElement);
+    if (!currentSchedules) return;
+
+    currentSchedules->SetContainer(attribs->X(), attribs->Y(), attribs->Width(), attribs->Height());
+    currentSchedules->SetDetached();
+    currentSchedules->Cache();
+    for (int i = 0; i < numElements; i++) {
+        listSchedules[i]->SetCurrentElement(currentSchedules);
+    }
+}
+
+void cViewListSchedules::Set(const cEvent *event, int index, bool current, bool selectable, 
+                             const cChannel *channel, bool withDate, eTimerMatch timerMatch) {
+    if (!current)
+        listSchedules[index]->StopScrolling();
+    listSchedules[index]->SetCurrent(current);
+    listSchedules[index]->ClearCurrentElement();
+    listSchedules[index]->SetSelectable(selectable);
+    listSchedules[index]->SetEpgSearchFav(epgSearchFav);
+    listSchedules[index]->Set(event, channel, withDate, timerMatch);
+}
+
+/******************************************************************
+* cViewListTimers
+******************************************************************/
+cViewListTimers::cViewListTimers(void) {    
+    listTimers = NULL;
+    currentTimer = NULL;
+}
+
+cViewListTimers::~cViewListTimers(void) {
+    delete[] listTimers;
+}
+
+void cViewListTimers::Prepare(int start, int step) {
+    if (!listElement)
+        return;
+
+    cLeMenuTimers *tpl = dynamic_cast<cLeMenuTimers*>(listElement);
+    if (!tpl) return;
+
+    listTimers = new cLeMenuTimers*[numElements];
+    listElements = new cListElement*[numElements];
+    int pos = start;
+    
+    for (int i = 0; i < numElements; i++) {
+        listTimers[i] = new cLeMenuTimers(*tpl);
+        listElements[i] = listTimers[i];
+        listTimers[i]->SetNumber(i);
+        listTimers[i]->SetTokenContainer();
+        int x, y, width, height;
+        if (orientation == eOrientation::vertical) {
+            x = attribs->X();
+            y = pos;
+            width = attribs->Width();
+            height = step;
+            listTimers[i]->SetAreaHeight(height);
+        } else {
+            x = pos;
+            y = attribs->Y();
+            width = step;
+            height = attribs->Height();
+            listTimers[i]->SetAreaWidth(width);
+        }
+        listTimers[i]->SetContainer(x, y, width, height);
+        listTimers[i]->Cache();
+        pos += step;
+    }
+
+    if (!currentElement) return;
+    currentTimer = dynamic_cast<cCeMenuTimers*>(currentElement);
+    if (!currentTimer) return;
+
+    currentTimer->SetContainer(attribs->X(), attribs->Y(), attribs->Width(), attribs->Height());
+    currentTimer->SetDetached();
+    currentTimer->Cache();
+    for (int i = 0; i < numElements; i++) {
+        listTimers[i]->SetCurrentElement(currentTimer);
+    }
+}
+
+void cViewListTimers::Set(const cTimer *timer, int index, bool current, bool selectable) {
+    if (!current)
+        listTimers[index]->StopScrolling();
+    listTimers[index]->SetCurrent(current);
+    listTimers[index]->ClearCurrentElement();
+    listTimers[index]->SetSelectable(selectable);
+    listTimers[index]->Set(timer);
+}
+
+/******************************************************************
+* cViewListChannels
+******************************************************************/
+cViewListChannels::cViewListChannels(void) {
+    listChannels = NULL;
+    currentChannel = NULL;
+}
+
+cViewListChannels::~cViewListChannels(void) {
+    delete[] listChannels;
+}
+
+void cViewListChannels::Prepare(int start, int step) {
+    if (!listElement)
+        return;
+
+    cLeMenuChannels *tpl = dynamic_cast<cLeMenuChannels*>(listElement);
+    if (!tpl) return;
+
+    listChannels = new cLeMenuChannels*[numElements];
+    listElements = new cListElement*[numElements];
+    int pos = start;
+    
+    for (int i = 0; i < numElements; i++) {
+        listChannels[i] = new cLeMenuChannels(*tpl);
+        listElements[i] = listChannels[i];
+        listChannels[i]->SetNumber(i);
+        listChannels[i]->SetTokenContainer();
+        int x, y, width, height;
+        if (orientation == eOrientation::vertical) {
+            x = attribs->X();
+            y = pos;
+            width = attribs->Width();
+            height = step;
+            listChannels[i]->SetAreaHeight(height);
+        } else {
+            x = pos;
+            y = attribs->Y();
+            width = step;
+            height = attribs->Height();
+            listChannels[i]->SetAreaWidth(width);
+        }
+        listChannels[i]->SetContainer(x, y, width, height);
+        listChannels[i]->Cache();
+        pos += step;
+    }
+
+    if (!currentElement) return;
+    currentChannel = dynamic_cast<cCeMenuChannels*>(currentElement);
+    if (!currentChannel) return;
+
+    currentChannel->SetContainer(attribs->X(), attribs->Y(), attribs->Width(), attribs->Height());
+    currentChannel->SetDetached();
+    currentChannel->Cache();
+    for (int i = 0; i < numElements; i++) {
+        listChannels[i]->SetCurrentElement(currentChannel);
+    }
+}
+
+void cViewListChannels::Set(const cChannel *channel, int index, bool current, bool selectable, bool withProvider) {
+    if (!current)
+        listChannels[index]->StopScrolling();
+    listChannels[index]->SetCurrent(current);
+    listChannels[index]->ClearCurrentElement();
+    listChannels[index]->SetSelectable(selectable);
+    listChannels[index]->Set(channel, withProvider);
+}
+
+/******************************************************************
+* cViewListRecordings
+******************************************************************/
+cViewListRecordings::cViewListRecordings(void) {
+    listRecordings = NULL;
+    currentRecording = NULL;
+}
+
+cViewListRecordings::~cViewListRecordings(void) {
+    delete[] listRecordings;
+}
+
+void cViewListRecordings::Prepare(int start, int step) {
+    if (!listElement)
+        return;
+
+    cLeMenuRecordings *tpl = dynamic_cast<cLeMenuRecordings*>(listElement);
+    if (!tpl) return;
+
+    listRecordings = new cLeMenuRecordings*[numElements];
+    listElements = new cListElement*[numElements];
+    int pos = start;
+    
+    for (int i = 0; i < numElements; i++) {
+        listRecordings[i] = new cLeMenuRecordings(*tpl);
+        listElements[i] = listRecordings[i];
+        listRecordings[i]->SetNumber(i);
+        listRecordings[i]->SetTokenContainer();
+        int x, y, width, height;
+        if (orientation == eOrientation::vertical) {
+            x = attribs->X();
+            y = pos;
+            width = attribs->Width();
+            height = step;
+            listRecordings[i]->SetAreaHeight(height);
+        } else {
+            x = pos;
+            y = attribs->Y();
+            width = step;
+            height = attribs->Height();
+            listRecordings[i]->SetAreaWidth(width);
+        }
+        listRecordings[i]->SetContainer(x, y, width, height);
+        listRecordings[i]->Cache();
+        pos += step;
+    }
+
+    if (!currentElement) return;
+    currentRecording = dynamic_cast<cCeMenuRecordings*>(currentElement);
+    if (!currentRecording) return;
+
+    currentRecording->SetContainer(attribs->X(), attribs->Y(), attribs->Width(), attribs->Height());
+    currentRecording->SetDetached();
+    currentRecording->Cache();
+    for (int i = 0; i < numElements; i++) {
+        listRecordings[i]->SetCurrentElement(currentRecording);
+    }
+}
+
+void cViewListRecordings::Set(const cRecording *recording, int index, bool current, bool selectable, int level, int total, int New) {
+    if (!current)
+        listRecordings[index]->StopScrolling();
+    listRecordings[index]->SetCurrent(current);
+    listRecordings[index]->ClearCurrentElement();
+    listRecordings[index]->SetSelectable(selectable);
+    listRecordings[index]->Set(recording, level, total, New);
+}
+
+/******************************************************************
+* cViewListPlugin
+******************************************************************/
+cViewListPlugin::cViewListPlugin(void) {
+    listPlugin = NULL;
+    currentPlugin = NULL;
+}
+
+cViewListPlugin::~cViewListPlugin(void) {
+    delete[] listPlugin;
+}
+
+void cViewListPlugin::Prepare(int start, int step) {
+    if (!listElement)
+        return;
+
+    if (!listElement)
+        return;
+
+    cLeMenuPlugin *tpl = dynamic_cast<cLeMenuPlugin*>(listElement);
+    if (!tpl) return;
+
+    listPlugin = new cLeMenuPlugin*[numElements];
+    listElements = new cListElement*[numElements];
+    int pos = start;
+    
+    for (int i = 0; i < numElements; i++) {
+        listPlugin[i] = new cLeMenuPlugin(*tpl);
+        listElements[i] = listPlugin[i];
+        listPlugin[i]->SetNumber(i);
+        listPlugin[i]->SetPlugId(plugId);
+        listPlugin[i]->SetPlugMenuId(plugMenuId);
+        listPlugin[i]->SetTokenContainer();
+        int x, y, width, height;
+        if (orientation == eOrientation::vertical) {
+            x = attribs->X();
+            y = pos;
+            width = attribs->Width();
+            height = step;
+            listPlugin[i]->SetAreaHeight(height);
+        } else {
+            x = pos;
+            y = attribs->Y();
+            width = step;
+            height = attribs->Height();
+            listPlugin[i]->SetAreaWidth(width);
+        }
+        listPlugin[i]->SetContainer(x, y, width, height);
+        listPlugin[i]->Cache();
+        pos += step;
+    }
+
+    if (!currentElement) return;
+    currentPlugin = dynamic_cast<cCeMenuPlugin*>(currentElement);
+    if (!currentPlugin) return;
+
+    currentPlugin->SetContainer(attribs->X(), attribs->Y(), attribs->Width(), attribs->Height());
+    currentPlugin->SetPlugId(plugId);
+    currentPlugin->SetPlugMenuId(plugMenuId);
+    currentPlugin->SetTokenContainer();
+    currentPlugin->SetDetached();
+    currentPlugin->Cache();
+    for (int i = 0; i < numElements; i++) {
+        listPlugin[i]->SetCurrentElement(currentPlugin);
+    }
+}
+
+void cViewListPlugin::Set(skindesignerapi::cTokenContainer *tk, int index, bool current, bool selectable) {
+   if (!current)
+        listPlugin[index]->StopScrolling();
+    listPlugin[index]->SetCurrent(current);
+    listPlugin[index]->ClearCurrentElement();
+    listPlugin[index]->SetSelectable(selectable);
+    listPlugin[index]->Set(tk);
+}
+
+/******************************************************************
+* cViewListAudioTracks
+******************************************************************/
+cViewListAudioTracks::cViewListAudioTracks(void) {
+    listAudioTracks = NULL;
+    numTracks = 0;
+    tokenContainer = NULL;
+}
+
+cViewListAudioTracks::~cViewListAudioTracks(void) {
+    delete[] listAudioTracks;
+    delete tokenContainer;
+}
+
+void cViewListAudioTracks::Close(void) {
+    if (!listElements)
+        return;
+    for (int i = 0; i < numElements; i++) {
+        delete listAudioTracks[i];
+    }
+    delete[] listAudioTracks;
+    listAudioTracks = NULL;
+ }
+
+void cViewListAudioTracks::PreCache(void) {
+    tokenContainer = new skindesignerapi::cTokenContainer();
+    tokenContainer->DefineIntToken("{numelements}", 0);
+    tokenContainer->CreateContainers();
+    attribs->SetTokenContainer(tokenContainer);
+    attribs->SetContainer(container.X(), container.Y(), container.Width(), container.Height());
+    attribs->SetGlobals(globals);
+    attribs->Cache();
+}
+
+void cViewListAudioTracks::SetNumtracks(int numTracks) {
+    this->numTracks = numTracks;
+    tokenContainer->Clear();
+    tokenContainer->AddIntToken(0, numTracks);
+}
+
+void cViewListAudioTracks::SetTracks(const char * const *tracks) {
+    if (numTracks <= 0)
+        return;
+    orientation = attribs->Orientation();
+    eAlign align = attribs->Align();
+    int x = attribs->X();
+    int y = attribs->Y();
+    int width = attribs->Width();
+    int height = attribs->Height();
+
+    int step = 0;
+    if (orientation == eOrientation::vertical) {
+        step = height / numTracks;
+    } else {
+        step = width / numTracks;
+    }
+
+    int start = 0;
+    if (align == eAlign::center) {
+        if (orientation == eOrientation::vertical) {
+            start = y + (height - numTracks * step) / 2;
+        } else {
+            start = x + (width - numTracks * step) / 2;            
+        }
+    } else if (align == eAlign::bottom) {
+        start = y + height - numTracks * step;         
+    } else if (align == eAlign::right) {
+        start = x + width - numTracks * step;                 
+    } else if (align == eAlign::top) {
+        start = y;                 
+    }
+
+    cLeAudioTracks *tpl = dynamic_cast<cLeAudioTracks*>(listElement);
+    if (!tpl) return;
+
+    listAudioTracks = new cLeAudioTracks*[numTracks];
+    listElements = new cListElement*[numTracks];
+    int pos = start;
+    
+    for (int i = 0; i < numTracks; i++) {
+        listAudioTracks[i] = new cLeAudioTracks(*tpl);
+        listElements[i] = listAudioTracks[i];
+        listAudioTracks[i]->SetNumber(i);
+        listAudioTracks[i]->SetTokenContainer();
+        int x, y, width, height;
+        if (orientation == eOrientation::vertical) {
+            x = attribs->X();
+            y = pos;
+            width = attribs->Width();
+            height = step;
+            listAudioTracks[i]->SetAreaHeight(height);
+        } else {
+            x = pos;
+            y = attribs->Y();
+            width = step;
+            height = attribs->Height();
+            listAudioTracks[i]->SetAreaWidth(width);
+        }
+        listAudioTracks[i]->SetContainer(x, y, width, height);
+        listAudioTracks[i]->Cache();
+        pos += step;
+    }
+    for (int i=0; i < numTracks; i++) {
+        listAudioTracks[i]->Set(tracks[i]);
+        listAudioTracks[i]->SetSelectable(true);
+    }
+}
+
+void cViewListAudioTracks::SetCurrentTrack(int index) {
+    for (int i = 0; i < numTracks; i++) {
+        if (i != index) {
+            listAudioTracks[i]->SetCurrent(false);
+            listAudioTracks[i]->SetDirty();
+            listAudioTracks[i]->StopScrolling();
+        }
+    }
+    listAudioTracks[index]->SetCurrent(true);
+    listAudioTracks[index]->SetDirty();
+}
+
+void cViewListAudioTracks::Draw(void) {
+    for (int i = 0; i < numTracks; i++) {
+        if (listAudioTracks[i]->Parse()) {
+            listAudioTracks[i]->Render();
+        }
+    }
+}

coreengine/viewlist.h

@@ -0,0 +1,155 @@
+#ifndef __VIEWLIST_H
+#define __VIEWLIST_H
+
+#include "globals.h"
+#include "../libskindesignerapi/tokencontainer.h"
+#include "listelements.h"
+#include "area.h"
+
+class cViewList {
+protected:
+    int plugId;
+    int plugMenuId;
+    cViewListAttribs *attribs;
+    cRect container;
+    cGlobals *globals;
+    int numElements;
+    eOrientation orientation;
+    cViewElement *listElement;
+    cViewElement *currentElement;
+    cListElement **listElements;
+    virtual void Prepare(int start, int step) {};
+public:
+    cViewList(void);
+    virtual ~cViewList(void);
+    void SetGlobals(cGlobals *globals);    
+    void SetContainer(int x, int y, int width, int height);
+    void SetAttributes(vector<stringpair> &attributes);
+    void SetPlugId(int id) { plugId = id; };
+    void SetPlugMenuId(int id) { plugMenuId = id; };
+    static cViewList *CreateViewList(const char *name);
+    static cViewElement *CreateListElement(const char *name);
+    static cViewElement *CreateCurrentElement(const char *name);
+    void AddListElement(cViewElement *listElement);
+    void AddCurrentElement(cViewElement *currentElement);
+    virtual void PreCache(void);
+    int NumItems(void);
+    eOrientation Orientation(void);
+    void Draw(eMenuCategory menuCat);
+    void Clear(void);
+    virtual void Close(void);
+    void SetTransparency(int transparency);
+    void Debug(void);
+};
+
+class cViewListDefault : public cViewList {
+private:
+    cLeMenuDefault **listDefault;
+    int avrgFontWidth;
+    const cFont *listFont;
+    int *colX;
+    int *colWidths;
+    const char *plugName;
+protected:
+    void Prepare(int start, int step);
+public:
+    cViewListDefault(void);
+    virtual ~cViewListDefault(void);
+    void SetTabs(int tab1, int tab2, int tab3, int tab4, int tab5);
+    void SetPlugin(const char *plugName) { this->plugName = plugName; };
+    void Set(const char *text, int index, bool current, bool selectable);
+    const cFont *GetListFont(void);
+    int GetListWidth(void);
+};
+
+class cViewListMain : public cViewList {
+private:
+    cLeMenuMain **listMain;
+    cCeMenuMain *currentMain;
+protected:
+    void Prepare(int start, int step);
+public:
+    cViewListMain(void);
+    virtual ~cViewListMain(void);
+    void Set(const char *text, int index, bool current, bool selectable);
+    const char *GetPlugin(void);
+};
+
+class cViewListSchedules : public cViewList {
+private:
+    cLeMenuSchedules **listSchedules;
+    cCeMenuSchedules *currentSchedules;
+    bool epgSearchFav;
+protected:
+    void Prepare(int start, int step);
+public:
+    cViewListSchedules(void);
+    virtual ~cViewListSchedules(void);
+    void IsEpgSearchFav(bool isFav) { epgSearchFav = isFav; };
+    void Set(const cEvent *event, int index, bool current, bool selectable, const cChannel *channel, bool withDate, eTimerMatch timerMatch);
+};
+
+class cViewListTimers : public cViewList {
+private:
+    cLeMenuTimers **listTimers;
+    cCeMenuTimers *currentTimer;
+protected:
+    void Prepare(int start, int step);
+public:
+    cViewListTimers(void);
+    virtual ~cViewListTimers(void);
+    void Set(const cTimer *timer, int index, bool current, bool selectable);
+};
+
+class cViewListChannels : public cViewList {
+private:
+    cLeMenuChannels **listChannels;
+    cCeMenuChannels *currentChannel;
+protected:
+    void Prepare(int start, int step);
+public:
+    cViewListChannels(void);
+    virtual ~cViewListChannels(void);
+    void Set(const cChannel *channel, int index, bool current, bool selectable, bool withProvider);
+};
+
+class cViewListRecordings : public cViewList {
+private:
+    cLeMenuRecordings **listRecordings;
+    cCeMenuRecordings *currentRecording;
+protected:
+    void Prepare(int start, int step);
+public:
+    cViewListRecordings(void);
+    virtual ~cViewListRecordings(void);
+    void Set(const cRecording *recording, int index, bool current, bool selectable, int level, int total, int New);
+};
+
+class cViewListPlugin : public cViewList {
+private:
+    cLeMenuPlugin **listPlugin;
+    cCeMenuPlugin *currentPlugin;
+protected:
+    void Prepare(int start, int step);
+public:
+    cViewListPlugin(void);
+    virtual ~cViewListPlugin(void);
+    void Set(skindesignerapi::cTokenContainer *tk, int index, bool current, bool selectable);
+};
+
+class cViewListAudioTracks : public cViewList {
+private:
+    skindesignerapi::cTokenContainer *tokenContainer;
+    int numTracks;
+    cLeAudioTracks **listAudioTracks;
+public:
+    cViewListAudioTracks(void);
+    virtual ~cViewListAudioTracks(void);
+    void Close(void);
+    void PreCache(void);
+    void SetNumtracks(int numTracks);
+    void SetTracks(const char * const *tracks);
+    void SetCurrentTrack(int index);
+    void Draw(void);
+};
+#endif //__VIEWLIST_H

coreengine/xmlparser.c

@@ -1,10 +1,11 @@
 #include "xmlparser.h"
 #include "../config.h"
-#include "../libcore/helpers.h"
+#include "../extensions/helpers.h"
 
 using namespace std;
 
 cXmlParser::cXmlParser(void) {
+    sdOsd = NULL;
     view = NULL;
     globals = NULL;
     skinSetup = NULL;
@@ -16,7 +17,7 @@ cXmlParser::~cXmlParser() {
 /*********************************************************************
 * PUBLIC Functions
 *********************************************************************/
-bool cXmlParser::ReadView(cTemplateView *view, string xmlFile) {
+bool cXmlParser::ReadView(cView *view, string xmlFile) {
     if (!view)
         return false;
     this->view = view;
@@ -35,37 +36,72 @@ bool cXmlParser::ReadView(cTemplateView *view, string xmlFile) {
 bool cXmlParser::ParseView(void) {
     if (!view)
         return false;
-
     vector<stringpair> rootAttribs = ParseAttributes();
-    ValidateAttributes(NodeName(), rootAttribs);
-    view->SetParameters(rootAttribs);
+    view->SetAttributes(rootAttribs);
+
+    cViewMenu *menuView = dynamic_cast<cViewMenu*>(view);
+    cViewTracks *tracksView = dynamic_cast<cViewTracks*>(view);
 
     if (!LevelDown())
         return false;
 
     do {
-
-        if (view->ValidSubView(NodeName())) {
-            ParseSubView();
-        } else if (view->ValidViewElement(NodeName())) {
-            ParseViewElement();
+        if (view->ValidViewElement(NodeName())) {
+            ParseViewElement(NodeName());
+        } else if (menuView) {
+            if (menuView->ValidSubView(NodeName())) {
+                ParseSubView(NodeName());
             } else if (view->ValidViewList(NodeName())) {
                 ParseViewList();
-        } else if (view->ValidViewGrid(NodeName())) {
-            ParseGrid();
-        } else if (CheckNodeName("tab")) {
-            ParseViewTab(view);
             } else {
+                esyslog("skindesigner: unknown node %s", NodeName());
+                return false;
+            }
+        } else if (tracksView) {
+            if (view->ValidViewList(NodeName())) {
+                ParseViewList();
+            } else {
+                esyslog("skindesigner: unknown node %s", NodeName());
+                return false;
+            }
+        } else {
+            esyslog("skindesigner: unknown view %s", NodeName());
             return false;
         }
-
     } while (NextNode());
 
     return true;
-    
 }
 
-bool cXmlParser::ReadPluginView(string plugName, int templateNumber, string templateName) {
+bool cXmlParser::ParsePluginView(void) {
+    if (!view)
+        return false;
+    vector<stringpair> rootAttribs = ParseAttributes();
+    view->SetAttributes(rootAttribs);
+
+    if (!LevelDown())
+        return false;
+
+    do {
+        if (CheckNodeName("viewelement")) {
+            ParsePluginViewElement();
+        } else if (CheckNodeName("grid")) {
+            ParseGrid();
+        } else if (CheckNodeName("tab")) {
+            ParseViewTabPlugin();
+        } else if (CheckNodeName("scrollbar")) {
+            ParsePluginViewElement(true, false);
+        } else if (CheckNodeName("tablabels")) {
+            ParsePluginViewElement(false, true);
+        } else {
+            esyslog("skindesigner: unknown node %s in plugin view", NodeName());
+        }
+    } while (NextNode());
+
+    return true;
+}
+
+bool cXmlParser::ReadPluginView(string templateName) {
     string xmlPath = GetPath(templateName);
     DeleteDocument();
     if (! ReadXMLFile(xmlPath.c_str()) )
@@ -77,30 +113,34 @@ bool cXmlParser::ReadPluginView(string plugName, int templateNumber, string temp
     return true;
 }
 
-bool cXmlParser::ParsePluginView(string plugName, int templateNumber) {
-    cTemplateView *plugView = new cTemplateViewMenu();
-    view->AddPluginView(plugName, templateNumber, plugView);
-
-    vector<stringpair> attribs = ParseAttributes();
-    ValidateAttributes(NodeName(), attribs);
-    plugView->SetParameters(attribs);
+bool cXmlParser::ParsePluginView(string plugName, int plugId, int menuNumber, int menuType) {
+    if (!view)
+        return false;
+    cViewMenu *menuView = dynamic_cast<cViewMenu*>(view);
+    if (!menuView) {
+        return false;
+    }
+    vector<pair<string, string> > attribs = ParseAttributes();
 
     if (!LevelDown())
         return false;
-    do {
 
+    cSubView *plugView = cViewMenu::CreatePluginview(plugName.c_str(), plugId, menuNumber, menuType);
+    plugView->SetAttributes(attribs);
+    menuView->AddPluginview(plugView);
+    do {
         if (plugView->ValidViewElement(NodeName())) {
-            ParseViewElement(plugView);
+            ParseViewElement(NodeName(), plugView);
         } else if (plugView->ValidViewList(NodeName())) {
             ParseViewList(plugView);
         } else if (CheckNodeName("tab")) {
             ParseViewTab(plugView);
         } else {
+            esyslog("skindesigner: error - unknown %s", NodeName());
             return false;
         }
-
     } while (NextNode());
-
+    LevelUp();
     return true;
 }
 
@@ -164,24 +204,25 @@ bool cXmlParser::ParseSkinSetup(string skin) {
 /*********************************************************************
 * PRIVATE Functions
 *********************************************************************/
-
-bool cXmlParser::ParseSubView(void) {
+bool cXmlParser::ParseSubView(string name) {
     if (!view)
         return false;
-
-    cTemplateView *subView = new cTemplateViewMenu();
-    view->AddSubView(NodeName(), subView);
-
-    vector<pair<string, string> > subViewAttribs = ParseAttributes();
-    ValidateAttributes(NodeName(), subViewAttribs);
-    subView->SetParameters(subViewAttribs);
+    cViewMenu *menuView = dynamic_cast<cViewMenu*>(view);
+    if (!menuView) {
+        return false;
+    }
+    vector<pair<string, string> > attribs = ParseAttributes();
 
     if (!LevelDown())
         return false;
-    do {
 
+    cSubView *subView = cViewMenu::CreateSubview(name.c_str());
+    subView->SetAttributes(attribs);
+    menuView->AddSubview(name.c_str(), subView);
+
+    do {
         if (subView->ValidViewElement(NodeName())) {
-            ParseViewElement(subView);
+            ParseViewElement(NodeName(), subView);
         } else if (subView->ValidViewList(NodeName())) {
             ParseViewList(subView);
         } else if (CheckNodeName("tab")) {
@@ -189,70 +230,133 @@ bool cXmlParser::ParseSubView(void) {
         } else {
             return false;
         }
-
     } while (NextNode());
     LevelUp();
     return true;
-
 }
-void cXmlParser::ParseViewElement(cTemplateView *subView) {
+
+void cXmlParser::ParseViewElement(string name, cView *subView) {
     if (!view)
         return;
-    
     const char *viewElementName = NodeName();
     vector<stringpair> attributes = ParseAttributes();
-    ValidateAttributes("viewelement", attributes);
 
     if (!LevelDown())
         return;
 
-    cTemplateViewElement *viewElement = new cTemplateViewElement();
-    viewElement->SetParameters(attributes);
+    //correct detailheader name
+    if (subView) {
+        if (!strcmp(subView->GetViewName(), "menudetailedepg") && !name.compare("detailheader")) {
+            name = "detailheaderepg";
+        } else if (!strcmp(subView->GetViewName(), "menudetailedrecording") && !name.compare("detailheader")) {
+            name = "detailheaderrec";
+        } else if (startswith(subView->GetViewName(), "menuplugin") && !name.compare("detailheader")) {
+            name = "detailheaderplugin";
+        }
+    }
 
+    cViewElement *viewElement = cViewElement::CreateViewElement(name.c_str(), view->GetViewName());
+    if (!viewElement) {
+        LevelUp();
+        return;
+    }
+
+    viewElement->SetOsd(sdOsd);
+    viewElement->SetAttributes(attributes);
     do {
         if (!CheckNodeName("areacontainer") && !CheckNodeName("area") && !CheckNodeName("areascroll")) {
             esyslog("skindesigner: invalid tag \"%s\" in viewelement", NodeName());
             continue;
         }
-        cTemplatePixmapNode *pix = NULL;
+        cAreaNode *area = NULL;
         if (CheckNodeName("area") || CheckNodeName("areascroll")) {
-            pix = ParseArea();
+            area = ParseArea();
         } else {
-            pix = ParseAreaContainer();
+            area = ParseAreaContainer();
         }
-        pix->SetGlobals(globals);
-        viewElement->AddPixmap(pix);
+        viewElement->AddArea(area);
     } while (NextNode());
+
     LevelUp();
 
     if (subView)
         subView->AddViewElement(viewElementName, viewElement);
     else
         view->AddViewElement(viewElementName, viewElement);
+
 }
 
-void cXmlParser::ParseViewList(cTemplateView *subView) {
+void cXmlParser::ParsePluginViewElement(bool isScrollbar, bool isTabLabels) {
+    if (!view)
+        return;
+    cViewPlugin *pluginView = dynamic_cast<cViewPlugin*>(view);
+    if (!pluginView)
+        return;
+
+    vector<stringpair> attributes = ParseAttributes();
+
+    if (!LevelDown())
+        return;
+
+    cViewElement *viewElement = NULL;
+    if (isScrollbar) {
+        viewElement = new cVeDmScrollbar();
+    } else if (isTabLabels) {
+        viewElement = new cVeDmTablabels();
+    } else {
+        viewElement = new cVePlugin();        
+    }
+
+    viewElement->SetOsd(sdOsd);
+    viewElement->SetAttributes(attributes);
+    do {
+        if (!CheckNodeName("areacontainer") && !CheckNodeName("area") && !CheckNodeName("areascroll")) {
+            esyslog("skindesigner: invalid tag \"%s\" in viewelement", NodeName());
+            continue;
+        }
+        cAreaNode *area = NULL;
+        if (CheckNodeName("area") || CheckNodeName("areascroll")) {
+            area = ParseArea();
+        } else {
+            area = ParseAreaContainer();
+        }
+        viewElement->AddArea(area);
+    } while (NextNode());
+
+    LevelUp();
+    
+    if (isScrollbar) {
+        pluginView->AddScrollbar(dynamic_cast<cVeDmScrollbar*>(viewElement));
+    } else if (isTabLabels) {
+        pluginView->AddTablabels(dynamic_cast<cVeDmTablabels*>(viewElement));
+    } else {
+        pluginView->AddViewElement(dynamic_cast<cVePlugin*>(viewElement));
+    }
+}
+
+void cXmlParser::ParseViewList(cView *subView) {
     if (!view)
         return;
 
-    vector<stringpair> attribs = ParseAttributes();
-    ValidateAttributes(NodeName(), attribs);
+    const char *name = NULL;
+    if (subView)
+        name = subView->GetViewName();
+    else
+        name = view->GetViewName();
 
-    cTemplateViewList *viewList = new cTemplateViewList();
-    viewList->SetGlobals(globals);
-    viewList->SetParameters(attribs);
+    vector<stringpair> attribs = ParseAttributes();
+    cViewList *viewList = cViewList::CreateViewList(name);
+    viewList->SetAttributes(attribs);
 
     if (!LevelDown())
         return;
 
     do {
         if (CheckNodeName("currentelement")) {
-
-            cTemplateViewElement *currentElement = new cTemplateViewElement();
-            vector<stringpair> attribsCur = ParseAttributes();
-            ValidateAttributes(NodeName(), attribsCur);
-            currentElement->SetGlobals(globals);
-            currentElement->SetParameters(attribsCur);
+            cViewElement *currentElement = cViewList::CreateCurrentElement(name);
+            currentElement->SetOsd(sdOsd);
+            vector<stringpair> attribsList = ParseAttributes();
+            currentElement->SetAttributes(attribsList);
             if (!LevelDown())
                 continue;
             do {
@@ -260,24 +364,21 @@ void cXmlParser::ParseViewList(cTemplateView *subView) {
                     esyslog("skindesigner: invalid tag \"%s\" in viewelement", NodeName());
                     continue;
                 }
-                cTemplatePixmapNode *pix = NULL;
+                cAreaNode *area = NULL;
                 if (CheckNodeName("area") || CheckNodeName("areascroll")) {
-                    pix = ParseArea();
+                    area = ParseArea();
                 } else {
-                    pix = ParseAreaContainer();
+                    area = ParseAreaContainer();
                 }
-                currentElement->AddPixmap(pix);
+                currentElement->AddArea(area);
             } while (NextNode());
             LevelUp();
             viewList->AddCurrentElement(currentElement);
-
         } else if (CheckNodeName("listelement")) {
-            
-            cTemplateViewElement *listElement = new cTemplateViewElement();
+            cViewElement *listElement = cViewList::CreateListElement(name);
+            listElement->SetOsd(sdOsd);
             vector<stringpair> attribsList = ParseAttributes();
-            ValidateAttributes(NodeName(), attribsList);
-            listElement->SetGlobals(globals);
-            listElement->SetParameters(attribsList);            
+            listElement->SetAttributes(attribsList);            
             if (!LevelDown())
                 return;
             do {
@@ -285,110 +386,128 @@ void cXmlParser::ParseViewList(cTemplateView *subView) {
                     esyslog("skindesigner: invalid tag \"%s\" in viewelement", NodeName());
                     continue;
                 }
-                cTemplatePixmapNode *pix = NULL;
+                cAreaNode *area = NULL;
                 if (CheckNodeName("area") || CheckNodeName("areascroll")) {
-                    pix = ParseArea();
+                    area = ParseArea();
                 } else {
-                    pix = ParseAreaContainer();
+                    area = ParseAreaContainer();
                 }
-                listElement->AddPixmap(pix);
+                listElement->AddArea(area);
             } while (NextNode());
             LevelUp();
             viewList->AddListElement(listElement);
         }
-
     } while (NextNode());
     LevelUp();
     
     if (subView)
-        subView->AddViewList(NodeName(), viewList);
+        subView->AddViewList(viewList);
     else
-        view->AddViewList(NodeName(), viewList);
+        view->AddViewList(viewList);
+    
 }
 
-void cXmlParser::ParseViewTab(cTemplateView *subView) {
+void cXmlParser::ParseViewTab(cView *subView) {
     if (!view || !subView)
         return;
-
+    cSubView *menuSubView = dynamic_cast<cSubView*>(subView);
+    if (!menuSubView) {
+        return;
+    }
     vector<stringpair> attribs = ParseAttributes();
-    ValidateAttributes(NodeName(), attribs);
+    cArea *tab = new cArea();
+    tab->SetOsd(sdOsd);
+    tab->SetTab();
+    tab->SetAttributes(attribs);
+    ParseFunctionCalls(tab);
+    menuSubView->AddTab(tab);
+}
 
-    cTemplateViewTab *viewTab = new cTemplateViewTab();
-    viewTab->SetGlobals(globals);
-    viewTab->SetParameters(attribs);
-    viewTab->SetScrolling();
-    ParseFunctionCalls(viewTab);
-    subView->AddViewTab(viewTab);
+void cXmlParser::ParseViewTabPlugin(void) {
+    if (!view)
+        return;
+    cViewPlugin *plugView = dynamic_cast<cViewPlugin*>(view);
+    if (!plugView) {
+        return;
+    }
+    vector<stringpair> attribs = ParseAttributes();
+    cArea *tab = new cArea();
+    tab->SetOsd(sdOsd);
+    tab->SetTab();
+    tab->SetAttributes(attribs);
+    ParseFunctionCalls(tab);
+    plugView->AddTab(tab);
 }
 
 void cXmlParser::ParseGrid(void) {
     if (!view)
         return;
+    cViewPlugin *pluginView = dynamic_cast<cViewPlugin*>(view);
+    if (!pluginView)
+        return;
 
     vector<stringpair> attributes = ParseAttributes();
-    ValidateAttributes(NodeName(), attributes);
 
     if (!LevelDown())
         return;
 
-    cTemplateViewGrid *viewGrid = new cTemplateViewGrid();
-    viewGrid->SetParameters(attributes);
+    cViewGrid *viewGrid = new cViewGrid();
+    viewGrid->SetAttributes(attributes);
+    cGridElement *gridElement = new cGridElement();
+    gridElement->SetOsd(sdOsd);
 
     do {
-
         if (!CheckNodeName("areacontainer") && !CheckNodeName("area") && !CheckNodeName("areascroll")) {
             esyslog("skindesigner: invalid tag \"%s\" in grid", NodeName());
             continue;
         }
-        cTemplatePixmapNode *pix = NULL;
+        cAreaNode *area = NULL;
         if (CheckNodeName("area") || CheckNodeName("areascroll")) {
-            pix = ParseArea();
+            area = ParseArea();
         } else {
-            pix = ParseAreaContainer();
+            area = ParseAreaContainer();
         }
-        pix->SetGlobals(globals);
-        viewGrid->AddPixmap(pix);
+        gridElement->AddArea(area);
     } while (NextNode());
     LevelUp();
     
-    view->AddGrid(viewGrid);
+    viewGrid->AddGridElement(gridElement);
+    pluginView->AddViewGrid(viewGrid);
 }
 
-cTemplatePixmap *cXmlParser::ParseArea(void) {
+cArea *cXmlParser::ParseArea(void) {
     vector<stringpair> attribs = ParseAttributes();
-    ValidateAttributes(NodeName(), attribs);
-
-    cTemplatePixmap *pix = new cTemplatePixmap();
+    cArea *area = new cArea();
+    area->SetOsd(sdOsd);
     if (CheckNodeName("areascroll")) {
-        pix->SetScrolling();
+        area->SetScrolling();
     }
-    pix->SetParameters(attribs);
-    ParseFunctionCalls(pix);
-    return pix;    
+    area->SetAttributes(attribs);
+    ParseFunctionCalls(area);
+    return area;    
 }
 
-cTemplatePixmapContainer *cXmlParser::ParseAreaContainer(void) {
+cAreaContainer *cXmlParser::ParseAreaContainer(void) {
     vector<stringpair> attribs = ParseAttributes();
-    ValidateAttributes(NodeName(), attribs);
 
-    cTemplatePixmapContainer *pixContainer = new cTemplatePixmapContainer();
-    pixContainer->SetParameters(attribs);
+    cAreaContainer *areaContainer = new cAreaContainer();
+    areaContainer->SetAttributes(attribs);
 
     if (!LevelDown())
-        return pixContainer;
+        return areaContainer;
     do {
         if (!CheckNodeName("area") && !CheckNodeName("areascroll")) {
             esyslog("skindesigner: invalid tag \"%s\" in areacontainer", NodeName());
             continue;
         }
-        cTemplatePixmap *pix = ParseArea();
-        pixContainer->AddPixmap(pix);
+        cArea *area = ParseArea();
+        areaContainer->AddArea(area);
     } while (NextNode());
     LevelUp();
-    return pixContainer;
+    return areaContainer;
 }
 
-void cXmlParser::ParseFunctionCalls(cTemplatePixmap *pix) {
+void cXmlParser::ParseFunctionCalls(cArea *area) {
     if (!view)
         return;
     if (!LevelDown())
@@ -396,31 +515,28 @@ void cXmlParser::ParseFunctionCalls(cTemplatePixmap *pix) {
     do {
         if (CheckNodeName("loop")) {
             vector<stringpair> attribs = ParseAttributes();
-            ValidateAttributes(NodeName(), attribs);
-            cTemplateLoopFunction *loopFunc = new cTemplateLoopFunction();
-            loopFunc->SetParameters(attribs);
-            ParseLoopFunctionCalls(loopFunc);
-            pix->AddLoopFunction(loopFunc);
-        } else if (view->ValidFunction(NodeName())) {
+            cFunction *f = area->AddFunction(NodeName(), attribs);
+            cFuncLoop *loopFunc = dynamic_cast<cFuncLoop*>(f);
+            if (!loopFunc)
+                continue;
+            ParseLoopFunctionCalls(area, loopFunc);
+        } else if (area->ValidFunction(NodeName())) {
             vector<stringpair> attribs = ParseAttributes();
-            ValidateAttributes(NodeName(), attribs);
-            pix->AddFunction(NodeName(), attribs);
+            area->AddFunction(NodeName(), attribs);
         }
-
     } while (NextNode());
     LevelUp();
 }
 
-void cXmlParser::ParseLoopFunctionCalls(cTemplateLoopFunction *loopFunc) {
+void cXmlParser::ParseLoopFunctionCalls(cArea *area, cFuncLoop *loopFunc) {
     if (!view)
         return;
     if (!LevelDown())
         return;
     do {
-        if (view->ValidFunction(NodeName())) {
+        if (area->ValidFunction(NodeName())) {
             vector<stringpair> attribs = ParseAttributes();
-            ValidateAttributes(NodeName(), attribs);
-            loopFunc->AddFunction(NodeName(), attribs);
+            area->AddFunction(NodeName(), attribs, loopFunc);
         }
     } while (NextNode());
     LevelUp();
@@ -610,21 +726,6 @@ void cXmlParser::ParseSetupParameter(void) {
     skinSetup->SetParameter(paramType, paramName, paramDisplayText, paramHelpText, paramMin, paramMax, paramValue, paramOptions);
 }
 
-void cXmlParser::ValidateAttributes(const char *nodeName, vector<stringpair> &attributes) {
-    bool repeat = true;
-    while (repeat) {
-        repeat  = false;
-        for (vector<stringpair>::iterator it = attributes.begin(); it != attributes.end(); it++) {
-            string attributeName = (*it).first;
-            if (!view->ValidAttribute(nodeName, attributeName.c_str())) {
-                attributes.erase(it);
-                repeat = true;
-                break;
-            }
-        }
-    }
-}
-
 string cXmlParser::GetPath(string xmlFile) {
     string activeSkin = Setup.OSDSkin;
     string activeTheme = Setup.OSDTheme;

coreengine/xmlparser.h

@@ -9,12 +9,11 @@
 #include <map>
 #include <set>
 #include <vdr/plugin.h>
-#include "../libcore/libxmlwrapper.h"
-#include "templateview.h"
-#include "templateviewlist.h"
-#include "templateviewgrid.h"
-#include "templateviewtab.h"
-#include "../libcore/skinsetup.h"
+#include "../extensions/libxmlwrapper.h"
+#include "osdwrapper.h"
+#include "view.h"
+#include "viewlist.h"
+#include "../extensions/skinsetup.h"
 
 using namespace std;
 
@@ -22,19 +21,22 @@ using namespace std;
 
 class cXmlParser : public cLibXMLWrapper {
 private:
-    cTemplateView *view;
+    cSdOsd *sdOsd;
+    cView *view;
     cGlobals *globals;
     cSkinSetup *skinSetup;
     //parsing views
-    bool ParseSubView(void);
-    void ParseViewElement(cTemplateView *subView = NULL);
-    void ParseViewList(cTemplateView *subView = NULL);
-    void ParseViewTab(cTemplateView *subView);
+    bool ParseSubView(string name);
+    void ParseViewElement(string name, cView *subView = NULL);
+    void ParsePluginViewElement(bool isScrollbar = false, bool isTabLabels = false);
+    void ParseViewList(cView *subView = NULL);
+    void ParseViewTab(cView *subView);
+    void ParseViewTabPlugin(void);
     void ParseGrid(void);
-    cTemplatePixmap *ParseArea(void);
-    cTemplatePixmapContainer *ParseAreaContainer(void);
-    void ParseFunctionCalls(cTemplatePixmap *pix);
-    void ParseLoopFunctionCalls(cTemplateLoopFunction *loopFunc);
+    cArea *ParseArea(void);
+    cAreaContainer *ParseAreaContainer(void);
+    void ParseFunctionCalls(cArea *area);
+    void ParseLoopFunctionCalls(cArea *area, cFuncLoop *loopFunc);
     //parsing globals
     void ParseGlobalColors(void);
     void InsertColor(string name, string value);
@@ -46,17 +48,19 @@ private:
     void ParseSetupMenu(void);
     void ParseSetupParameter(void);
     //helpers
-    void ValidateAttributes(const char *nodeName, vector<stringpair> &attributes);
     string GetPath(string xmlFile);
 public:
     cXmlParser(void);
     virtual ~cXmlParser(void);
+    void SetOsd(cSdOsd *osd) { sdOsd = osd; };
     //reading views
-    bool ReadView(cTemplateView *view, string xmlFile);
+    bool ReadView(cView *view, string xmlFile);
     bool ParseView(void);
-    //reading plugin views
-    bool ReadPluginView(string plugName, int templateNumber, string templateName);
-    bool ParsePluginView(string plugName, int templateNumber);
+    //Parse advanced plugin view
+    bool ParsePluginView(void);
+    //reading basic plugin menu views
+    bool ReadPluginView(string templateName);
+    bool ParsePluginView(string plugName, int plugId, int menuNumber, int menuType);
     //reading globals
     bool ReadGlobals(cGlobals *globals, string xmlFile);
     bool ParseGlobals(void);

designer.c

@@ -1,5 +1,5 @@
 #include "designer.h"
-#include "libcore/helpers.h"
+#include "extensions/helpers.h"
 
 cSkinDesigner::cSkinDesigner(string skin) : cSkin(skin.c_str(), &::Theme) {
     init = true;
@@ -9,13 +9,12 @@ cSkinDesigner::cSkinDesigner(string skin) : cSkin(skin.c_str(), &::Theme) {
     useBackupSkin = false;
     
     globals = NULL;
-    channelTemplate = NULL;
-    menuTemplate = NULL;
-    messageTemplate = NULL;
-    replayTemplate = NULL;
-    volumeTemplate = NULL;
-    audiotracksTemplate = NULL;
-
+    channelView = NULL;
+    menuView = NULL;
+    messageView = NULL;
+    replayView = NULL;
+    volumeView = NULL;
+    tracksView = NULL;
     currentMenu = NULL;
 
     dsyslog("skindesigner: skin %s started", skin.c_str());
@@ -24,7 +23,7 @@ cSkinDesigner::cSkinDesigner(string skin) : cSkin(skin.c_str(), &::Theme) {
 cSkinDesigner::~cSkinDesigner(void) {
     if (globals)
         delete globals;
-    DeleteTemplates();
+    DeleteViews();
     if (backupSkin)
         delete backupSkin;
 }
@@ -36,9 +35,9 @@ const char *cSkinDesigner::Description(void) {
 cSkinDisplayChannel *cSkinDesigner::DisplayChannel(bool WithInfo) {
     currentMenu = NULL;
     cSkinDisplayChannel *displayChannel = NULL;
-    if (!useBackupSkin) {
     Init();
-        displayChannel = new cSDDisplayChannel(channelTemplate, WithInfo);
+    if (!useBackupSkin) {
+        displayChannel = new cSDDisplayChannel(channelView, WithInfo);
     } else {
         displayChannel = backupSkin->DisplayChannel(WithInfo);
     }
@@ -49,7 +48,7 @@ cSkinDisplayMenu *cSkinDesigner::DisplayMenu(void) {
     if (!useBackupSkin) {
         cSDDisplayMenu *displayMenu = NULL;
         Init();
-        displayMenu = new cSDDisplayMenu(menuTemplate);
+        displayMenu = new cSDDisplayMenu(menuView);
         currentMenu = displayMenu;
         return displayMenu;
     } else {
@@ -64,7 +63,7 @@ cSkinDisplayReplay *cSkinDesigner::DisplayReplay(bool ModeOnly) {
     cSkinDisplayReplay *displayReplay = NULL;
     if (!useBackupSkin) {
         Init();
-        displayReplay = new cSDDisplayReplay(replayTemplate, ModeOnly);
+        displayReplay = new cSDDisplayReplay(replayView, ModeOnly);
     } else {
         displayReplay = backupSkin->DisplayReplay(ModeOnly);
     }
@@ -76,7 +75,7 @@ cSkinDisplayVolume *cSkinDesigner::DisplayVolume(void) {
     cSkinDisplayVolume *displayVolume = NULL;
     if (!useBackupSkin) {
         Init();
-        displayVolume = new cSDDisplayVolume(volumeTemplate);
+        displayVolume = new cSDDisplayVolume(volumeView);
     } else {
         displayVolume = backupSkin->DisplayVolume();
     }
@@ -88,7 +87,7 @@ cSkinDisplayTracks *cSkinDesigner::DisplayTracks(const char *Title, int NumTrack
     cSkinDisplayTracks *displayTracks = NULL;
     if (!useBackupSkin) {
         Init();
-        displayTracks = new cSDDisplayTracks(audiotracksTemplate, Title, NumTracks, Tracks);
+        displayTracks = new cSDDisplayTracks(tracksView, Title, NumTracks, Tracks);
     } else {
         displayTracks = backupSkin->DisplayTracks(Title, NumTracks, Tracks);
     }
@@ -100,28 +99,13 @@ cSkinDisplayMessage *cSkinDesigner::DisplayMessage(void) {
     cSkinDisplayMessage *displayMessage = NULL;
     if (!useBackupSkin) {
         Init();
-        displayMessage = new cSDDisplayMessage(messageTemplate);
+        displayMessage = new cSDDisplayMessage(messageView);
     } else {
         displayMessage = backupSkin->DisplayMessage();
     }
     return displayMessage;
 }
 
-cSkinDisplayPlugin *cSkinDesigner::DisplayPlugin(string pluginName, int viewID, int subViewID) {
-    currentMenu = NULL;
-    if (useBackupSkin) 
-        return NULL;
-    Init();
-    map< string, map <int, cTemplate*> >::iterator hit = pluginTemplates.find(pluginName);
-    if (hit == pluginTemplates.end())
-        return NULL;
-    map <int, cTemplate*>::iterator hit2 = (hit->second).find(viewID);
-    if (hit2 == (hit->second).end())
-        return NULL;
-    return new cSkinDisplayPlugin(hit2->second, subViewID);
-}
-
-
 void cSkinDesigner::Reload(void) {
     dsyslog("skindesigner: forcing full reload of templates");
     if (cOsd::IsOpen()) {
@@ -130,14 +114,14 @@ void cSkinDesigner::Reload(void) {
     }
 
     cStopWatch watch;
-    bool ok = LoadTemplates();
+    bool ok = LoadViews();
     if (!ok) {
         esyslog("skindesigner: error during loading of templates - using LCARS as backup");
         if (!backupSkin)
             backupSkin = new cSkinLCARS();
         useBackupSkin = true;
     } else {
-        CacheTemplates();
+        CacheViews();
         useBackupSkin = false;        
         watch.Stop("templates reloaded and cache created");
     }
@@ -147,38 +131,62 @@ void cSkinDesigner::ListAvailableFonts(void) {
     fontManager->ListAvailableFonts();
 }
 
-bool cSkinDesigner::SetCustomToken(string option) {
+bool cSkinDesigner::SetCustomIntToken(string option) {
     splitstring s(option.c_str());
     vector<string> flds = s.split('=', 0);
-
     if (flds.size() != 2)
         return false;
-
-    string key = trim(flds[0]);
+    int key = atoi(trim(flds[0]).c_str());
     string val = trim(flds[1]);
-
     if (!globals)
         return true;
-
-    if (isNumber(val)) {
+    if (key > 0 && isNumber(val)) {
         globals->AddCustomInt(key, atoi(val.c_str()));
     } else {
-        globals->AddCustomString(key, val);
+        return false;
     }
     return true;
 }
 
+bool cSkinDesigner::SetCustomStringToken(string option) {
+    splitstring s(option.c_str());
+    vector<string> flds = s.split('=', 0);
+    if (flds.size() != 2)
+        return false;
+    int key = atoi(trim(flds[0]).c_str());
+    string val = trim(flds[1]);
+    if (!globals)
+        return true;
+    if (key > 0)
+        globals->AddCustomString(key, val);
+    else
+        return false;
+    return true;
+}
+
 void cSkinDesigner::ListCustomTokens(void) {
     if (!globals)
         return;
     globals->ListCustomTokens();
 }
 
+skindesignerapi::ISkinDisplayPlugin *cSkinDesigner::GetDisplayPlugin(int plugId) {
+    map<int, cViewPlugin*>::iterator hit = pluginViews.find(plugId);
+    if (hit == pluginViews.end())
+        return NULL;
+    return hit->second;
+}
+
 /*********************************************************************************
 * PRIVATE FUNCTIONS
 *********************************************************************************/    
 void cSkinDesigner::Init(void) {
-    if (init || config.OsdSizeChanged() || config.SkinChanged() || config.OsdLanguageChanged() || config.setupCloseDoReload) {
+    if (   init 
+        || config.OsdSizeChanged() 
+        || config.SkinChanged() 
+        || config.OsdLanguageChanged() || 
+        config.setupCloseDoReload ) 
+    {
         config.setupCloseDoReload = false;
         if (init) {
             config.SetSkin();
@@ -188,6 +196,7 @@ void cSkinDesigner::Init(void) {
         dsyslog("skindesigner: initializing skin %s", skin.c_str());
         
         config.CheckDecimalPoint();
+        plgManager->Reset();
 
         if (fontManager)
             delete fontManager;
@@ -198,69 +207,63 @@ void cSkinDesigner::Init(void) {
         imgCache->SetPathes();
 
         cStopWatch watch;
-        bool ok = LoadTemplates();
+        bool ok = LoadViews();
         if (!ok) {
             esyslog("skindesigner: error during loading of templates - using LCARS as backup");
             backupSkin = new cSkinLCARS();
             useBackupSkin = true;
         } else {
-            CacheTemplates();
-            watch.Stop("templates loaded and cache created");
+            CacheViews();
+            watch.Stop("templates loaded and caches created");
         }
         init = false;
-    } else if (config.OsdFontsChanged()) {
+    } 
+    else if (config.OsdFontsChanged()) 
+    {
         dsyslog("skindesigner: reloading fonts");
         if (fontManager)
             delete fontManager;
         fontManager = new cFontManager();
         cStopWatch watch;
-        bool ok = LoadTemplates();
+        bool ok = LoadViews();
         if (!ok) {
             esyslog("skindesigner: error during loading of templates - using LCARS as backup");
             backupSkin = new cSkinLCARS();
             useBackupSkin = true;
         } else {
-            CacheTemplates();
-            watch.Stop("templates loaded and cache created");
+            CacheViews();
+            watch.Stop("templates loaded and caches created");
         }
     }
 }
 
-void cSkinDesigner::DeleteTemplates(void) {
-    if (channelTemplate) {
-        delete channelTemplate;
-        channelTemplate = NULL;
+void cSkinDesigner::DeleteViews(void) {
+    delete channelView;
+    channelView = NULL;
+
+    delete menuView;
+    menuView = NULL;
+
+    delete messageView;
+    messageView = NULL;
+
+    delete replayView;
+    replayView = NULL;
+
+    delete volumeView;
+    volumeView = NULL;
+
+    delete tracksView;
+    tracksView = NULL;
+
+    for (map<int,cViewPlugin*>::iterator it = pluginViews.begin(); it != pluginViews.end(); it++) {
+        cViewPlugin *plugView = it->second;
+        delete plugView;
     }
-    if (menuTemplate) {
-        delete menuTemplate;
-        menuTemplate = NULL;
-    }
-    if (messageTemplate) {
-        delete messageTemplate;
-        messageTemplate = NULL;
-    }
-    if (replayTemplate) {
-        delete replayTemplate;
-        replayTemplate = NULL;
-    }
-    if (volumeTemplate) {
-        delete volumeTemplate;
-        volumeTemplate = NULL;
-    }
-    if (audiotracksTemplate) {
-        delete audiotracksTemplate;
-        audiotracksTemplate = NULL;
-    }
-    for (map< string, map <int, cTemplate*> >::iterator plugs = pluginTemplates.begin(); plugs !=pluginTemplates.end(); plugs++) {
-        map <int, cTemplate*> plugTpls = plugs->second;
-        for (map <int, cTemplate*>::iterator tpl = plugTpls.begin(); tpl != plugTpls.end(); tpl++) {
-            delete tpl->second;
-        }
-    }
-    pluginTemplates.clear();
+    pluginViews.clear();
 }
 
-bool cSkinDesigner::LoadTemplates(void) {
+bool cSkinDesigner::LoadViews(void) {
     if (globals)
         delete globals;
     globals = new cGlobals();
@@ -276,142 +279,102 @@ bool cSkinDesigner::LoadTemplates(void) {
         skinSetup->AddToGlobals(globals);
     }
 
-    DeleteTemplates();
+    DeleteViews();
 
-    channelTemplate = new cTemplate(vtDisplayChannel);
-    channelTemplate->SetGlobals(globals);
-    ok = channelTemplate->ReadFromXML();
+    channelView = new cViewChannel();
+    ok = channelView->ReadFromXML();
     if (!ok) {
         esyslog("skindesigner: error reading displaychannel template, aborting");
-        DeleteTemplates();
+        DeleteViews();
         return false;
     }
-    channelTemplate->Translate();
+    channelView->SetGlobals(globals);
 
-    menuTemplate = new cTemplate(vtDisplayMenu);
-    menuTemplate->SetGlobals(globals);
-    ok = menuTemplate->ReadFromXML();
+    menuView = new cViewMenu();
+    ok = menuView->ReadFromXML();
     if (!ok) {
         esyslog("skindesigner: error reading displaymenu template, aborting");
-        DeleteTemplates();
+        DeleteViews();
         return false;
     }
-    menuTemplate->Translate();
+    menuView->SetGlobals(globals);
 
-    messageTemplate = new cTemplate(vtDisplayMessage);
-    messageTemplate->SetGlobals(globals);
-    ok = messageTemplate->ReadFromXML();
+    messageView = new cViewMessage();
+    ok = messageView->ReadFromXML();
     if (!ok) {
         esyslog("skindesigner: error reading displaymessage template, aborting");
-        DeleteTemplates();
+        DeleteViews();
         return false;
     }
-    messageTemplate->Translate();
+    messageView->SetGlobals(globals);
 
-    replayTemplate = new cTemplate(vtDisplayReplay);
-    replayTemplate->SetGlobals(globals);
-    ok = replayTemplate->ReadFromXML();
+    replayView = new cViewReplay();
+    ok = replayView->ReadFromXML();
     if (!ok) {
         esyslog("skindesigner: error reading displayreplay template, aborting");
-        DeleteTemplates();
+        DeleteViews();
         return false;
     }
-    replayTemplate->Translate();
+    replayView->SetGlobals(globals);
 
-    volumeTemplate = new cTemplate(vtDisplayVolume);
-    volumeTemplate->SetGlobals(globals);
-    ok = volumeTemplate->ReadFromXML();
+    volumeView = new cViewVolume();
+    ok = volumeView->ReadFromXML();
     if (!ok) {
         esyslog("skindesigner: error reading displayvolume template, aborting");
-        DeleteTemplates();
+        DeleteViews();
         return false;
     }
-    volumeTemplate->Translate();
+    volumeView->SetGlobals(globals);
 
-    audiotracksTemplate = new cTemplate(vtDisplayAudioTracks);
-    audiotracksTemplate->SetGlobals(globals);
-    ok = audiotracksTemplate->ReadFromXML();
+    tracksView = new cViewTracks();
+    ok = tracksView->ReadFromXML();
     if (!ok) {
         esyslog("skindesigner: error reading displayaudiotracks template, aborting");
-        DeleteTemplates();
+        DeleteViews();
         return false;
     }
-    audiotracksTemplate->Translate();
+    tracksView->SetGlobals(globals);
 
-    config.InitPluginViewIterator();
-    map <int,string> *plugViews = NULL;
-    string plugName;
-    while ( plugViews = config.GetPluginViews(plugName) ) {
-        for (map <int,string>::iterator v = plugViews->begin(); v != plugViews->end(); v++) {
-            int viewID = v->first;
-            stringstream templateName;
-            templateName << "plug-" << plugName << "-" << v->second.c_str();
-            cTemplate *plgTemplate = new cTemplate(vtDisplayPlugin, plugName, viewID);
-            plgTemplate->SetGlobals(globals);
-            ok = plgTemplate->ReadFromXML(templateName.str());
-            if (!ok) {
-                esyslog("skindesigner: error reading plugin %s template", plugName.c_str());
-                delete plgTemplate;
-                pluginTemplates.erase(plugName);
-                break;
-            }
-            ok = plgTemplate->SetSubViews(plugName, viewID);
-            if (!ok) {
-                delete plgTemplate;
-                pluginTemplates.erase(plugName);
-                break;
-            }
-            plgTemplate->Translate();
-            map< string, map <int, cTemplate*> >::iterator hit = pluginTemplates.find(plugName);
-            if (hit == pluginTemplates.end()) {
-                map <int, cTemplate*> plugTemplates;
-                plugTemplates.insert(pair<int, cTemplate*>(v->first, plgTemplate));
-                pluginTemplates.insert(pair<string, map <int, cTemplate*> >(plugName, plugTemplates));
-            } else {
-                (hit->second).insert(pair<int, cTemplate*>(v->first, plgTemplate));
-            }
-        }
-    }
+    LoadPluginViews();
 
     dsyslog("skindesigner: templates successfully validated and parsed");        
     return true;
 }
 
-void cSkinDesigner::CacheTemplates(void) {
-    channelTemplate->PreCache();
-    menuTemplate->PreCache();
-    messageTemplate->PreCache();
-    replayTemplate->PreCache();
-    volumeTemplate->PreCache();
-    audiotracksTemplate->PreCache();
-    for (map< string, map <int, cTemplate*> >::iterator plugs = pluginTemplates.begin(); plugs != pluginTemplates.end(); plugs++) {
-        for (map <int, cTemplate*>::iterator plugTplts = plugs->second.begin(); plugTplts != plugs->second.end(); plugTplts++) {
-            (plugTplts->second)->PreCache();
+void cSkinDesigner::LoadPluginViews(void) {
+    plgManager->InitPluginViewIterator();
+    string plugName = "";
+    string viewTpl = "";
+    int plugId = -1;
+    while ( plgManager->GetNextPluginView(plugName, plugId, viewTpl) ) {
+        cViewPlugin *plugView = new cViewPlugin(0, plugId);
+        bool ok = plugView->ReadFromXML(plugName.c_str(), viewTpl.c_str());
+        if (!ok) {
+            esyslog("skindesigner: error during loading templates for plugin %s", plugName.c_str());
+            continue;
+        }
+        ok = plugView->ReadSubViews(plugName.c_str());
+        if (!ok) {
+            esyslog("skindesigner: error during loading templates for plugin %s", plugName.c_str());
+            continue;
+        }
+        plugView->SetGlobals(globals);
+        pluginViews.insert(pair<int, cViewPlugin*>(plugId, plugView));
     }
 }
-    dsyslog("skindesigner: templates cached");
-    fontManager->DeleteFonts();
-    fontManager->CacheFonts(channelTemplate);
-    fontManager->CacheFonts(menuTemplate);
-    fontManager->CacheFonts(messageTemplate);
-    fontManager->CacheFonts(replayTemplate);
-    fontManager->CacheFonts(volumeTemplate);
-    fontManager->CacheFonts(audiotracksTemplate);
-    dsyslog("skindesigner: fonts cached");
-    dsyslog("skindesigner: caching images...");
-    imgCache->Clear();
-    imgCache->SetPathes();
-    channelTemplate->CacheImages();
-    menuTemplate->CacheImages();
-    messageTemplate->CacheImages();
-    replayTemplate->CacheImages();
-    volumeTemplate->CacheImages();
-    audiotracksTemplate->CacheImages();
-    for (map< string, map <int, cTemplate*> >::iterator plugs = pluginTemplates.begin(); plugs != pluginTemplates.end(); plugs++) {
-        for (map <int, cTemplate*>::iterator plugTplts = plugs->second.begin(); plugTplts != plugs->second.end(); plugTplts++) {
-            (plugTplts->second)->CacheImages();
-        }
+
+void cSkinDesigner::CacheViews(void) {
+    channelView->PreCache();
+    menuView->PreCache();
+    messageView->PreCache();
+    replayView->PreCache();
+    volumeView->PreCache();
+    tracksView->PreCache();
+    for (map<int,cViewPlugin*>::iterator it = pluginViews.begin(); it != pluginViews.end(); it++) {
+        cViewPlugin *plugView = it->second;
+        plugView->PreCache();
     }
+    dsyslog("skindesigner: templates and images cached");
     imgCache->Debug(false);
 }
 

designer.h

@@ -4,15 +4,19 @@
 class cSkinDesigner;
 
 #include "config.h"
-#include "libtemplate/template.h"
-#include "libtemplate/xmlparser.h"
+#include "coreengine/viewdisplaychannel.h"
+#include "coreengine/viewdisplaymenu.h"
+#include "coreengine/viewdisplayreplay.h"
+#include "coreengine/viewdisplayvolume.h"
+#include "coreengine/viewdisplaytracks.h"
+#include "coreengine/viewdisplaymessage.h"
+#include "coreengine/viewdisplayplugin.h"
 #include "displaychannel.h"
 #include "displaymenu.h"
 #include "displayreplay.h"
 #include "displayvolume.h"
 #include "displaytracks.h"
 #include "displaymessage.h"
-#include "displayplugin.h"
 #include <vdr/skinlcars.h>
 
 class cSkinDesigner : public cSkin {
@@ -22,19 +26,20 @@ private:
     cSkinLCARS *backupSkin;
     bool useBackupSkin;
     cGlobals *globals;
-    cTemplate *channelTemplate;
-    cTemplate *menuTemplate;
-    cTemplate *messageTemplate;
-    cTemplate *replayTemplate;
-    cTemplate *volumeTemplate;
-    cTemplate *audiotracksTemplate;
-    map< string, map <int, cTemplate*> > pluginTemplates;
+    cViewChannel  *channelView;
+    cViewMenu     *menuView;
+    cViewMessage  *messageView;
+    cViewReplay   *replayView;
+    cViewVolume   *volumeView;
+    cViewTracks   *tracksView;
     cSDDisplayMenu *currentMenu;
+    map<int, cViewPlugin* > pluginViews;
     void Init(void);
     void ReloadCaches(void);
-    void DeleteTemplates(void);
-    bool LoadTemplates(void);
-    void CacheTemplates(void);
+    void DeleteViews(void);
+    bool LoadViews(void);
+    void LoadPluginViews(void);
+    void CacheViews(void);
 public:
     cSkinDesigner(string skin);
     virtual ~cSkinDesigner(void);
@@ -45,13 +50,14 @@ public:
     virtual cSkinDisplayVolume *DisplayVolume(void);
     virtual cSkinDisplayTracks *DisplayTracks(const char *Title, int NumTracks, const char * const *Tracks);
     virtual cSkinDisplayMessage *DisplayMessage(void);
-    virtual cSkinDisplayPlugin *DisplayPlugin(string pluginName, int viewID, int subViewID);
     void ActivateBackupSkin(void) { useBackupSkin = true; };
     void Reload(void);
     void ListAvailableFonts(void);
-    bool SetCustomToken(string option);
+    bool SetCustomIntToken(string option);
+    bool SetCustomStringToken(string option);
     void ListCustomTokens(void);
     cSDDisplayMenu *GetDisplayMenu(void) { return currentMenu; };
+    skindesignerapi::ISkinDisplayPlugin *GetDisplayPlugin(int plugId);
 };
 
 #endif //__SKINDESIGNER_H

displaychannel.c

@@ -1,220 +1,36 @@
 #include "displaychannel.h"
-#include "libcore/timers.h"
 
-cSDDisplayChannel::cSDDisplayChannel(cTemplate *channelTemplate, bool WithInfo) {
-    channelView = NULL;
-
-    if (!channelTemplate) {
-        doOutput = false;
-        return;
-    } else {
-        doOutput = true;
-    }
-    groupSep = false;
-    present = NULL;
-    currentLast = 0;
-    channelChange = false;
-    initial = true;
-    devicesLast = cTimeMs::Now();
-    currentChannelSid = -1;
-    isEncrypted = false;
-
-    channelView = new cDisplayChannelView(channelTemplate->GetRootView());
-    if (!channelView->createOsd()) {
-        doOutput = false;
-        return;
-    }
-    channelView->DrawDebugGrid();
+cSDDisplayChannel::cSDDisplayChannel(cViewChannel *channelView, bool WithInfo) {
+    view = channelView;
+    ok = view->Init();
+    if (!ok)
+        esyslog("skindesigner: Error initiating displaychannel view - aborting");
 }
 
 cSDDisplayChannel::~cSDDisplayChannel() {
-    if (channelView)
-        delete channelView;
+    view->Close();
 }
 
 void cSDDisplayChannel::SetChannel(const cChannel *Channel, int Number) {
-    if (!doOutput)
+    if (!ok)
         return;
-    channelChange = true;
-    groupSep = false;
-
-    cString ChannelNumber("");
-    cString ChannelName("");
-    cString ChannelID("");
-    currentChannelSid = -1;
-    isEncrypted = false;
-
-    if (Channel) {
-        ChannelName = Channel->Name() ? Channel->Name() : "";
-        ChannelID = Channel->GetChannelID().ToString();
-        currentChannelSid = Channel->Sid();
-        isEncrypted = Channel->Ca();
-        if (!Channel->GroupSep()) {
-            ChannelNumber = cString::sprintf("%d%s", Channel->Number(), Number ? "-" : "");
-        } else {
-            groupSep = true;
-        }
-    } else if (Number) {
-        ChannelNumber = cString::sprintf("%d-", Number);
-    } else {
-        ChannelName = ChannelString(NULL, 0);
-    }
-
-    channelView->ClearChannel();
-    channelView->ClearEPGInfo();
-    channelView->ClearStatusIcons();
-    channelView->ClearChannelGroups();
-    channelView->ClearScraperContent();
-    channelView->ClearAudioInfo();
-    channelView->ClearEncryptionInfo();
-    if (!groupSep) {
-        channelView->DrawChannel(ChannelNumber, ChannelName, ChannelID, (Number > 0)?true:false);
-        channelView->DrawProgressBarBack();
-        channelView->DrawSignalBackground();
-        if (Channel) {
-            channelView->DrawStatusIcons(Channel);
-            channelView->DrawAudioInfo();
-        }
-    } else {
-        channelView->ClearSignal();
-        channelView->ClearSignalBackground();
-        channelView->ClearProgressBar();
-        channelView->ClearProgressBarBack();
-        if (Channel)
-            channelView->DrawChannelGroups(Channel, ChannelName);
-    }
-
+    view->SetChannel(Channel, Number);
 }
 
 void cSDDisplayChannel::SetEvents(const cEvent *Present, const cEvent *Following) {
-    if (!doOutput)
+    if (!ok)
         return;
-
-    present = Present;
-    channelView->ClearProgressBar();
-    if (!groupSep) {
-        channelView->ClearEPGInfo();
+    view->SetEvents(Present, Following);
 }
 
-    cGlobalSortedTimers SortedTimers;// local and remote timers
-
-    bool recPresent = false;
-    if (Present) {
-        if (!groupSep) {
-            SetProgressBar(Present);
-        }
-        eTimerMatch TimerMatch = tmNone;
-        const cTimer *Timer = Timers.GetMatch(Present, &TimerMatch);
-        if (Timer && Timer->Recording()) {
-            recPresent = true;
-        }
-        for (int i = 0; i < SortedTimers.Size() && !recPresent; i++) 
-            if (const cTimer *Timer = SortedTimers[i]) 
-                if (Timer->Channel()->GetChannelID() == Present->ChannelID()) 
-                    if (const cEvent *timerEvent = Timer->Event())
-                        if (Present->EventID() == timerEvent->EventID())
-                            recPresent = Timer->Recording();
-        
-    }
-    bool recFollowing = false;
-    if (Following) {
-        recFollowing = Following->HasTimer();
-        for (int i = 0; i < SortedTimers.Size() && !recFollowing; i++) 
-            if (const cTimer *Timer = SortedTimers[i]) 
-                if (Timer->Channel()->GetChannelID() == Following->ChannelID()) 
-                    if (const cEvent *timerEvent = Timer->Event())
-                        if (Following->EventID() == timerEvent->EventID())
-                            recFollowing = true;
-    }
-
-    if (Present || Following) {
-        channelView->DrawEPGInfo(Present, Following, recPresent, recFollowing);
-        channelView->DrawScraperContent(Present);
-    }
-}
-
-void cSDDisplayChannel::SetProgressBar(const cEvent *present) {
-    int Current = 0;
-    int Total = 0;
-    time_t t = time(NULL);
-    if (t > present->StartTime())
-        Current = t - present->StartTime();
-    Total = present->Duration();
-    if ((Current > currentLast + 3) || initial || channelChange) {
-        currentLast = Current;
-        cString start = present->GetTimeString();
-        cString stop = present->GetEndTimeString();
-        channelView->DrawProgressBar(start, stop, Current, Total);
-    }
-}
-
-
 void cSDDisplayChannel::SetMessage(eMessageType Type, const char *Text) {
-    if (!doOutput)
+    if (!ok)
         return;
-    channelView->ClearChannel();
-    channelView->ClearEPGInfo();
-    channelView->ClearStatusIcons();
-    channelView->ClearScreenResolution();
-    channelView->ClearProgressBar();
-    channelView->ClearProgressBarBack();
-    channelView->ClearSignal();
-    channelView->ClearSignalBackground();
-    channelView->ClearScraperContent();
-    channelView->ClearAudioInfo();
-    channelView->DisplayMessage(Type, Text);
-    groupSep = true;
+    view->SetMessage(Type, Text);
 }
 
 void cSDDisplayChannel::Flush(void) {
-    if (!doOutput)
+    if (!ok)
         return;
-
-    if (initial) {
-        channelView->DrawBackground();
-        channelView->DrawSignalBackground();
-        channelView->DrawCurrentWeather();
-    }
-
-    if (initial || channelView->CustomTokenChange()) {
-        channelView->DrawCustomTokens();
-    }
-
-    if (initial || channelChange) {
-        channelView->DrawDate();
-    }
-    channelView->DrawTime();
-
-    if (present) {
-        SetProgressBar(present);
-    } else {
-        channelView->ClearProgressBar();
-    }
-
-    if (!groupSep) {
-        channelView->DrawScreenResolution();
-        channelView->DrawSignal();
-        channelView->DrawAudioInfo();
-        if (initial || cTimeMs::Now() - devicesLast  > 500) {
-            channelView->DrawDevices(initial);
-            devicesLast = cTimeMs::Now();
-        }
-        if (isEncrypted) {
-            channelView->DrawEncryptionInfo(currentChannelSid);
-        }
-    } else {
-        channelView->ClearStatusIcons();
-        channelView->ClearScreenResolution();
-        channelView->ClearSignal();
-        channelView->ClearSignalBackground();
-        channelView->ClearDevices();
-    }
-
-    if (initial) {
-        channelView->DoStart();
-    }
-
-    initial = false;
-    channelChange = false;
-    channelView->Flush();
+    view->Flush();
 }

displaychannel.h

@@ -1,30 +1,17 @@
 #ifndef __DISPLAYCHANNEL_H
 #define __DISPLAYCHANNEL_H
 
-#include <vdr/thread.h>
+#include <vdr/skins.h>
 #include "config.h"
-#include "libtemplate/template.h"
-#include "views/displaychannelview.h"
+#include "coreengine/definitions.h"
+#include "coreengine/viewdisplaychannel.h"
 
 class cSDDisplayChannel : public cSkinDisplayChannel {
 private:
-    cDisplayChannelView *channelView;
-    bool doOutput;
-    bool initial;
-    bool groupSep;
-    bool channelChange;
-    time_t lastSignalDisplay;
-    int lastSignalStrength;
-    int lastSignalQuality;
-    int lastScreenWidth;
-    int currentLast;
-    uint64_t devicesLast;
-    const cEvent *present;
-    int currentChannelSid;
-    int isEncrypted;
-    void SetProgressBar(const cEvent *present);
+    cViewChannel *view;
+    bool ok;
 public:
-    cSDDisplayChannel(cTemplate *channelTemplate, bool WithInfo);
+    cSDDisplayChannel(cViewChannel *channelView, bool WithInfo);
     virtual ~cSDDisplayChannel();
     virtual void SetChannel(const cChannel *Channel, int Number);
     virtual void SetEvents(const cEvent *Present, const cEvent *Following);

displaymenu.c

@@ -1,345 +1,174 @@
-#include <vdr/player.h>
 #include "displaymenu.h"
-#include "libcore/helpers.h"
 
-cSDDisplayMenu::cSDDisplayMenu(cTemplate *menuTemplate) {
-    textAreaFont = NULL;
-    rootView = NULL;
-    doOutput = true;
-    state = vsInit;
-    pluginMenu = -1;
-    pluginName = "";
-    pluginMenuType = mtUnknown;
-    if (!menuTemplate) {
-        doOutput = false;
-        dsyslog("skindesigner: displayMenu no valid template - aborting");
-        return;
-    }
-    rootView = new cDisplayMenuRootView(menuTemplate->GetRootView());
-    if (!rootView->createOsd()) {
-        doOutput = false;
-        return;
-    }
+cSDDisplayMenu::cSDDisplayMenu(cViewMenu *menuView) {
+    view = menuView;
+    bool ok = false;
+    if (view)
+        ok = view->Init();
+    if (ok) {
         SetCurrentRecording();
-    rootView->DrawDebugGrid();
+    } else {
+        esyslog("skindesigner: Error initiating displaymenu view - aborting");
+    }
 }
 
 cSDDisplayMenu::~cSDDisplayMenu() {
-    if (rootView)
-        delete rootView;
-    if (textAreaFont)
-        delete textAreaFont;
+    if (view)
+        view->Close();
 }
 
 void cSDDisplayMenu::Scroll(bool Up, bool Page) {
-    if (!doOutput)
-        return;
-    rootView->KeyInput(Up, Page);
+    if (view)
+        view->KeyDetailView(Up, Page);
 }
 
 int cSDDisplayMenu::MaxItems(void) {
-    if (!doOutput)
+    if (view)
+        return view->NumListItems();
     return 0;
-    int maxItems = rootView->GetMaxItems();
-    return maxItems;
 }
 
 void cSDDisplayMenu::Clear(void) {
-    if (!doOutput)
-        return;
-    rootView->Clear();
+    if (view)
+        view->Clear();
 }
 
 void cSDDisplayMenu::SetMenuCategory(eMenuCategory MenuCat) {
-    if (!doOutput)
-        return;
-    rootView->SetMenu(MenuCat, (state == vsInit) ? true : false);
-    cSkinDisplayMenu::SetMenuCategory(MenuCat);
-    if (state != vsInit)
-        state = vsMenuInit;
+    if (view)
+        view->SetSubView(MenuCat);
 }
 
 void cSDDisplayMenu::SetMenuSortMode(eMenuSortMode MenuSortMode) {
-    if (!doOutput)
-        return;
-    rootView->SetSortMode(MenuSortMode);
+    if (view)
+        view->SetSortMode(MenuSortMode);
 }
 
 eMenuOrientation cSDDisplayMenu::MenuOrientation(void) {
-    if (!doOutput)
+    if (view)
+        return view->MenuOrientation();
     return moVertical;
-    return rootView->MenuOrientation();
 }
 
-void cSDDisplayMenu::SetPluginMenu(string name, int menu, int type, bool init) {
-    pluginName = name;
-    pluginMenu = menu;
-    pluginMenuType = (ePluginMenuType)type;
-    rootView->SetPluginMenu(pluginName, pluginMenu, pluginMenuType);
-    if (!init) {
-        rootView->SetMenu(mcPlugin, false);        
-    }
+void cSDDisplayMenu::SetPluginMenu(int plugId, int menuId, int type, bool init) {
+    if (view)
+        view->SetPluginMenu(plugId, menuId);
 }
 
 void cSDDisplayMenu::SetTitle(const char *Title) {
-    if (!doOutput)
-        return;
-    rootView->SetTitle(Title);
+    if (view)
+        view->SetTitleHeader(Title);
 }
 
 void cSDDisplayMenu::SetButtons(const char *Red, const char *Green, const char *Yellow, const char *Blue) {
-    if (!doOutput)
-        return;
-    rootView->SetButtonTexts(Red, Green, Yellow, Blue);
-    if (state != vsInit && MenuCategory() != mcMain)
-        state = vsMenuInit;
+    if (view)
+        view->SetMenuButtons(Red, Green, Yellow, Blue);
 }
 
 void cSDDisplayMenu::SetMessage(eMessageType Type, const char *Text) {
-    if (!doOutput)
-        return;
-    rootView->SetMessage(Type, Text);
-    rootView->DoFlush();
+    if (view)
+        view->SetMessage(Type, Text);
 }
 
 bool cSDDisplayMenu::SetItemEvent(const cEvent *Event, int Index, bool Current, bool Selectable, const cChannel *Channel, bool WithDate, eTimerMatch TimerMatch) {
-    if (!doOutput)
-        return true;
-    if (!rootView->SubViewAvailable())
+    if (!view)
         return false;
-    if (config.blockFlush)
-        rootView->LockFlush();
-    bool isFav = false;
-    if (MenuCategory() == mcSchedule && Channel) {
-        isFav = true;
-        rootView->SetEpgSearchFavorite();
+    if (Index == 0) {
+        view->SetChannelHeader(Event);
     }
-    const cChannel *channel = Channel;
-    if (MenuCategory() == mcSchedule) {
-        if (!channel) {
-            channel = rootView->GetChannel();
-        } 
-        if (!channel && Event) {
-            channel = Channels.GetByChannelID(Event->ChannelID());
-        }
-        rootView->SetChannel(channel);
-    }
-
-    cDisplayMenuListView *list = rootView->GetListView();
-    if (!list)
-        return false;
-    list->AddSchedulesMenuItem(Index, Event, channel, TimerMatch, MenuCategory(), isFav, Current, Selectable, "");
-    if (state == vsIdle)
-        state = vsMenuUpdate;
-    return true;
+    return view->SetItemEvent(Event, Index, Current, Selectable, Channel, WithDate, TimerMatch);
 }
 
 bool cSDDisplayMenu::SetItemTimer(const cTimer *Timer, int Index, bool Current, bool Selectable) {
-    if (!doOutput)
-        return true;
-    if (!rootView->SubViewAvailable())
+    if (!view)
         return false;
-    if (config.blockFlush)
-        rootView->LockFlush();
-    cDisplayMenuListView *list = rootView->GetListView();
-    if (!list)
-        return false;
-    list->AddTimersMenuItem(Index, Timer, Current, Selectable);
-    if (state == vsIdle)
-        state = vsMenuUpdate;
-    return true;
+    return view->SetItemTimer(Timer, Index, Current, Selectable);
 }
 
 bool cSDDisplayMenu::SetItemChannel(const cChannel *Channel, int Index, bool Current, bool Selectable, bool WithProvider) {
-    if (!doOutput)
-        return true;
-    if (!rootView->SubViewAvailable())
+    if (!view)
         return false;
-    if (config.blockFlush)
-        rootView->LockFlush();
-    cDisplayMenuListView *list = rootView->GetListView();
-    if (!list)
-        return false;
-    list->AddChannelsMenuItem(Index, Channel, WithProvider, Current, Selectable);
-    if (state == vsIdle)
-        state = vsMenuUpdate;
-    return true;
+    return view->SetItemChannel(Channel, Index, Current, Selectable, WithProvider);
 }
 
 bool cSDDisplayMenu::SetItemRecording(const cRecording *Recording, int Index, bool Current, bool Selectable, int Level, int Total, int New) {
-    if (!doOutput)
-        return true;
-    if (!rootView->SubViewAvailable())
+    if (!view)
         return false;
-    if (config.blockFlush)
-        rootView->LockFlush();
-    cDisplayMenuListView *list = rootView->GetListView();
-    if (!list)
-        return false;
-
-    list->AddRecordingMenuItem(Index, Recording, Level, Total, New, Current, Selectable);
-    if (state == vsIdle)
-        state = vsMenuUpdate;
-    return true;
-}
-
-bool cSDDisplayMenu::SetItemPlugin(map<string,string> *stringTokens, map<string,int> *intTokens, map<string,vector<map<string,string> > > *loopTokens, int Index, bool Current, bool Selectable) {
-    if (!doOutput)
-        return true;
-    if (!rootView->SubViewAvailable())
-        return false;
-    if (config.blockFlush)
-        rootView->LockFlush();
-    cDisplayMenuListView *list = rootView->GetListView();
-    if (!list)
-        return false;
-    list->AddPluginMenuItem(stringTokens, intTokens, loopTokens, Index, Current, Selectable);
-    if (state == vsIdle)
-        state = vsMenuUpdate;
-    return true;
+    return view->SetItemRecording(Recording, Index, Current, Selectable, Level, Total, New);
 }
 
 void cSDDisplayMenu::SetItem(const char *Text, int Index, bool Current, bool Selectable) {
-    if (!doOutput)
-        return;
-    //esyslog("skindesigner: %s %d - %s", Current ? "----->" : "", Index, Text);
-    cDisplayMenuListView *list = rootView->GetListView();
-    if (!list) {
+    if (!view)
         return;
+    view->SetItem(Text, Index, Current, Selectable);
+    SetEditableWidth(view->GetListWidth() / 2);
 }
-    if (config.blockFlush)
-        rootView->LockFlush();
-    eMenuCategory cat = MenuCategory();
-    if (cat == mcMain && rootView->SubViewAvailable()) {
-        string plugName = list->AddMainMenuItem(Index, Text, Current, Selectable);
-        if (Current) {
-            rootView->SetSelectedPluginMainMenu(plugName);
-        }
-    } else if (cat == mcSetup && rootView->SubViewAvailable()) {
-        list->AddSetupMenuItem(Index, Text, Current, Selectable);        
-    } else if ((cat == mcSchedule || cat == mcScheduleNow || cat == mcScheduleNext) && rootView->SubViewAvailable()) {
-        list->AddSchedulesMenuItem(Index, NULL, NULL, tmNone, MenuCategory(), false, Current, Selectable, Text ? Text : "");
-    } else {
-        rootView->CorrectDefaultMenu();
-        string *tabTexts = new string[MaxTabs];
-        for (int i=0; i<MaxTabs; i++) {
-            const char *s = GetTabbedText(Text, i);
-            if (s) {
-                if (strlen(s) == 0)
-                    tabTexts[i] = " ";
-                else
-                    tabTexts[i] = s;
-            } else {
-                tabTexts[i] = "";
-            }
-        }
-        list->AddDefaultMenuItem(Index, tabTexts, Current, Selectable);
-        SetEditableWidth( rootView->GetListViewWidth() / 2);
-    }
-    if (state == vsIdle)
-        state = vsMenuUpdate;
+
+bool cSDDisplayMenu::SetItemPlugin(skindesignerapi::cTokenContainer *tk, int Index, bool Current, bool Selectable) {
+    if (!view)
+        return false;
+    bool ok = view->SetItemPlugin(tk, Index, Current, Selectable);
+    return ok;
 }
 
 void cSDDisplayMenu::SetTabs(int Tab1, int Tab2, int Tab3, int Tab4, int Tab5) {
-    if (!doOutput)
-        return;
-    rootView->SetTabs(Tab1, Tab2, Tab3, Tab4, Tab5);
+    if (view)
+        view->SetTabs(Tab1, Tab2, Tab3, Tab4, Tab5);
 }
 
 int cSDDisplayMenu::GetTextAreaWidth(void) const {
-    int areaWidth = rootView->GetTextAreaWidth();
-    return areaWidth;
+    if (view)
+        return view->GetTextAreaWidth();
+    return 0;
 }
 
 const cFont *cSDDisplayMenu::GetTextAreaFont(bool FixedFont) const {
-    if (textAreaFont)
-        return textAreaFont;
-    textAreaFont = rootView->GetTextAreaFont();
-    return textAreaFont;
+    if (view)
+        return view->GetTextAreaFont();
+    return NULL;
 }
 
 void cSDDisplayMenu::SetScrollbar(int Total, int Offset) {
-    if (!doOutput)
-        return;
-    rootView->RenderMenuScrollBar(Total, Offset);
+    if (view)
+        view->SetScrollbar(Total, Offset);
 }
 
 void cSDDisplayMenu::SetEvent(const cEvent *Event) {
-    if (!doOutput)
-        return;
-    rootView->SetDetailedViewEvent(Event);
-    state = vsMenuDetail;
+    if (view)
+        view->SetEvent(Event);
 }
 
 void cSDDisplayMenu::SetRecording(const cRecording *Recording) {
-    if (!doOutput)
-        return;
-    rootView->SetDetailedViewRecording(Recording);
-    state = vsMenuDetail;
+    if (view)
+        view->SetRecording(Recording);
 }
 
 void cSDDisplayMenu::SetText(const char *Text, bool FixedFont) {
-    if (!doOutput)
-        return;
-    rootView->SetDetailedViewText(Text);
-    state = vsMenuDetail;
+    if (view)
+        view->SetText(Text);
 }
 
-bool cSDDisplayMenu::SetPluginText(map<string,string> *stringTokens, map<string,int> *intTokens, map<string,vector<map<string,string> > > *loopTokens) {
-    if (!doOutput)
-        return true;
-    bool tmplOk = rootView->SetDetailedViewPlugin(stringTokens, intTokens, loopTokens);
-    state = vsMenuDetail;
-    return tmplOk;
+bool cSDDisplayMenu::SetPluginText(skindesignerapi::cTokenContainer *tk) {
+    bool ok = false;
+    if (view)
+        ok = view->SetPluginText(tk);
+    return ok;
 }
 
 void cSDDisplayMenu::Flush(void) {
-    if (!doOutput)
-        return;
-    bool doFlush = false;
-    if (state == vsInit) {
-        rootView->Start();
-        rootView->RenderMenuItems();
-        doFlush = true;
-    } else if (state == vsMenuInit) {
-        rootView->Render();
-        rootView->RenderMenuItems();
-        doFlush = true;
-    } else if (state == vsMenuUpdate) {
-        rootView->RenderMenuItems();
-        doFlush = true;
-    } else if (state == vsMenuDetail) {
-        rootView->OpenFlush();
-        rootView->Render();
-        rootView->DoFlush();
-        rootView->RenderDetailView();
-        rootView->DoFlush();
-    }
-
-    if (rootView->RenderDynamicElements()) {
-        doFlush = true;
-    }
-
-    if (doFlush) {
-        if (config.blockFlush)
-            rootView->OpenFlush();
-        rootView->DoFlush();
-    }
-    state = vsIdle;
+    if (view)
+        view->Flush();
 }
 
 void cSDDisplayMenu::SetCurrentRecording(void) {
     cControl *control = cControl::Control();
     if (!control) {
+        view->SetCurrentRecording(NULL);
         return;
     }
     const cRecording *recording = control->GetRecording();
     if (!recording) {
+        view->SetCurrentRecording(NULL);
         return;
     }
-    string recFileName = "";
-    if (recording->FileName()) {
-        recFileName = recording->FileName();
-    }
-    rootView->SetCurrentRecording(recFileName);
+    view->SetCurrentRecording(recording->FileName());
 }

displaymenu.h

@@ -11,31 +11,16 @@ enum eMenuOrientation {
 #endif
 
 #include "libskindesignerapi/skindesignerapi.h"
-#include "libtemplate/template.h"
-#include "views/displaymenurootview.h"
-
-enum eViewState {
-    vsInit,
-    vsMenuInit,
-    vsMenuUpdate,
-    vsMenuDetail,
-    vsIdle
-};
+#include <vdr/skins.h>
+#include "coreengine/viewdisplaymenu.h"
 
 class cSDDisplayMenu : public skindesignerapi::ISDDisplayMenu {
 private:
-    cDisplayMenuRootView *rootView;
-    eViewState state;
-    bool doOutput;
-    string pluginName;
-    int pluginMenu;
-    ePluginMenuType pluginMenuType;
-    mutable cFont *textAreaFont;
+    cViewMenu *view;
+    bool ok;
     void SetCurrentRecording(void);
-protected:
-    int Tab(int n);
 public:
-    cSDDisplayMenu(cTemplate *menuTemplate);
+    cSDDisplayMenu(cViewMenu *menuView);
     virtual ~cSDDisplayMenu();
     virtual void Scroll(bool Up, bool Page);
     virtual int MaxItems(void);
@@ -43,21 +28,21 @@ public:
     virtual void SetMenuCategory(eMenuCategory MenuCat);
     virtual void SetMenuSortMode(eMenuSortMode MenuSortMode);
     virtual eMenuOrientation MenuOrientation(void);
-    virtual void SetPluginMenu(string name, int menu, int type, bool init);
+    virtual void SetPluginMenu(int plugId, int menuId, int type, bool init);
     virtual void SetTitle(const char *Title);
     virtual void SetButtons(const char *Red, const char *Green = NULL, const char *Yellow = NULL, const char *Blue = NULL);
     virtual void SetMessage(eMessageType Type, const char *Text);
-    virtual void SetItem(const char *Text, int Index, bool Current, bool Selectable);
     virtual bool SetItemEvent(const cEvent *Event, int Index, bool Current, bool Selectable, const cChannel *Channel, bool WithDate, eTimerMatch TimerMatch);
     virtual bool SetItemTimer(const cTimer *Timer, int Index, bool Current, bool Selectable);
     virtual bool SetItemChannel(const cChannel *Channel, int Index, bool Current, bool Selectable, bool WithProvider);
     virtual bool SetItemRecording(const cRecording *Recording, int Index, bool Current, bool Selectable, int Level, int Total, int New);
-    virtual bool SetItemPlugin(map<string,string> *stringTokens, map<string,int> *intTokens, map<string,vector<map<string,string> > > *loopTokens, int Index, bool Current, bool Selectable);
+    virtual void SetItem(const char *Text, int Index, bool Current, bool Selectable);
+    virtual bool SetItemPlugin(skindesignerapi::cTokenContainer *tk, int Index, bool Current, bool Selectable);
     virtual void SetScrollbar(int Total, int Offset);
     virtual void SetEvent(const cEvent *Event);
     virtual void SetRecording(const cRecording *Recording);
     virtual void SetText(const char *Text, bool FixedFont);
-    virtual bool SetPluginText(map<string,string> *stringTokens, map<string,int> *intTokens, map<string,vector<map<string,string> > > *loopTokens);
+    virtual bool SetPluginText(skindesignerapi::cTokenContainer *tk);
     virtual void Flush(void);
     virtual void SetTabs(int Tab1, int Tab2 = 0, int Tab3 = 0, int Tab4 = 0, int Tab5 = 0);
     virtual int GetTextAreaWidth(void) const;

displaymessage.c

@@ -1,46 +1,25 @@
 #include "displaymessage.h"
 
-cSDDisplayMessage::cSDDisplayMessage(cTemplate *messageTemplate) {
-    messageView = NULL;
-    doOutput = true;
-    initial = true;
-    if (!messageTemplate) {
-        doOutput = false;
-        esyslog("skindesigner: displayMessage no valid template - aborting");
-        return;
-    }
-    messageView = new cDisplayMessageView(messageTemplate->GetRootView());
-    if (!messageView->createOsd()) {
-        doOutput = false;
-        return;
-    }
-    messageView->DrawDebugGrid();
-    messageView->DrawBackground();
+cSDDisplayMessage::cSDDisplayMessage(cViewMessage *messageView) {
+    view = messageView;
+    ok = view->Init();
+    if (!ok)
+        esyslog("skindesigner: Error initiating displaymessage view - aborting");
 }
 
 cSDDisplayMessage::~cSDDisplayMessage() {
-    if (messageView)
-        delete messageView;
+    view->Close();
 }
 
 void cSDDisplayMessage::SetMessage(eMessageType Type, const char *Text) {
-    if (!doOutput)
+    if (!ok)
         return;
-    messageView->ClearMessage();
-    if (!Text) {
-        return;
-    }
-    messageView->DrawMessage(Type, Text);
+    view->SetMessage(Type, Text);
 }
 
 
 void cSDDisplayMessage::Flush(void) {
-    if (!doOutput)
+    if (!ok)
         return;
-    if (initial) {
-        messageView->DoFadeIn();
-        initial = false;
-    } else {
-        messageView->Flush();
-    }
+    view->Flush();
 }

displaymessage.h

@@ -1,19 +1,15 @@
 #ifndef __DISPLAYMESSAGE_H
 #define __DISPLAYMESSAGE_H
 
-#include <vdr/thread.h>
-#include <vdr/skins.h>
 #include "config.h"
-#include "libtemplate/template.h"
-#include "views/displaymessageview.h"
+#include "coreengine/viewdisplaymessage.h"
 
 class cSDDisplayMessage : public cSkinDisplayMessage {
 private:
-    cDisplayMessageView *messageView;
-    bool doOutput;
-    bool initial;
+    cViewMessage *view;
+    bool ok;
 public:
-    cSDDisplayMessage(cTemplate *messageTemplate);
+    cSDDisplayMessage(cViewMessage *messageView);
     virtual ~cSDDisplayMessage();
     virtual void SetMessage(eMessageType Type, const char *Text);
     virtual void Flush(void);

displayplugin.c

@@ -1,201 +0,0 @@
-#include "config.h"
-#include "displayplugin.h"
-
-cSkinDisplayPlugin::cSkinDisplayPlugin(cTemplate *pluginTemplate, int subViewID) {
-    if (!pluginTemplate) {
-        doOutput = false;
-        return;
-    } else {
-        doOutput = true;
-    }
-    initial = true;
-    if (subViewID > -1) {
-        cTemplateView *subView = pluginTemplate->GetRootView()->GetSubView((eSubView)subViewID);
-        if (!subView) {
-            doOutput = false;
-            return;            
-        }
-        pluginView = new cDisplayPluginView(subView, false);
-    } else {
-        pluginView = new cDisplayPluginView(pluginTemplate->GetRootView(), true);
-    }
-    if (!pluginView->createOsd() && subViewID < 0) {
-        doOutput = false;
-        return;
-    }
-    pluginView->DrawDebugGrid();
-}
-
-cSkinDisplayPlugin::~cSkinDisplayPlugin(void) {
-    if (pluginView) {
-        delete pluginView;
-        pluginView = NULL;
-    }
-}
-
-void cSkinDisplayPlugin::Deactivate(bool hide) {
-    if (!doOutput) {
-        return;
-    }
-    pluginView->Deactivate(hide);
-}
-
-void cSkinDisplayPlugin::Activate(void) {
-    if (!doOutput) {
-        return;
-    }
-    pluginView->Activate();
-}
-
-
-void cSkinDisplayPlugin::ClearViewElement(int id) {
-    if (!doOutput) {
-        return;
-    }
-    pluginView->CleanViewElement(id);
-}
-
-void cSkinDisplayPlugin::DisplayViewElement(int id) {
-    if (!doOutput) {
-        return;
-    }
-    pluginView->DisplayViewElement(id);
-}
-
-void cSkinDisplayPlugin::SetViewElementIntTokens(map<string,int> *intTokens) { 
-    if (pluginView)
-        pluginView->SetIntTokens(intTokens);
-}
-
-void cSkinDisplayPlugin::SetViewElementStringTokens(map<string,string> *stringTokens) { 
-    if (pluginView)
-        pluginView->SetStringTokens(stringTokens);
-}
-
-void cSkinDisplayPlugin::SetViewElementLoopTokens(map<string,vector<map<string,string> > > *loopTokens) { 
-    if (pluginView)
-        pluginView->SetLoopTokens(loopTokens);
-}
-
-void cSkinDisplayPlugin::InitGrids(int viewGridID) {
-    if (!doOutput) {
-        return;
-    }
-    pluginView->InitGrids(viewGridID);
-}
-
-void cSkinDisplayPlugin::SetGrid(int viewGridID, long gridID, 
-                                 double x, double y, double width, double height, 
-                                 map<string,int> *intTokens, map<string,string> *stringTokens) {
-    if (!doOutput) {
-        return;
-    }
-    pluginView->SetGrid(viewGridID, gridID, x, y, width, height, intTokens, stringTokens);
-}
-
-void cSkinDisplayPlugin::SetGridCurrent(int viewGridID, long gridID, bool current) {
-    if (!doOutput) {
-        return;
-    }
-    pluginView->SetGridCurrent(viewGridID, gridID, current);
-}
-
-void cSkinDisplayPlugin::DeleteGrid(int viewGridID, long gridID) {
-    if (!doOutput) {
-        return;
-    }
-    pluginView->DeleteGrid(viewGridID, gridID);   
-}
-
-void cSkinDisplayPlugin::DisplayGrids(int viewGridID) {
-    if (!doOutput) {
-        return;
-    }
-    pluginView->DisplayGrids(viewGridID);
-}
-
-void cSkinDisplayPlugin::ClearGrids(int viewGridID) {
-    if (!doOutput) {
-        return;
-    }
-    pluginView->ClearGrids(viewGridID);
-}
-
-void cSkinDisplayPlugin::SetTabIntTokens(map<string,int> *intTokens) {
-    if (!doOutput) {
-        return;
-    }
-    pluginView->SetTabIntTokens(intTokens);
-}
-
-void cSkinDisplayPlugin::SetTabStringTokens(map<string,string> *stringTokens) {
-    if (!doOutput) {
-        return;
-    }
-    pluginView->SetTabStringTokens(stringTokens);
-}
-
-void cSkinDisplayPlugin::SetTabLoopTokens(map<string,vector<map<string,string> > > *loopTokens) {
-    if (!doOutput) {
-        return;
-    }
-    pluginView->SetTabLoopTokens(loopTokens);
-}
-
-void cSkinDisplayPlugin::SetTabs(void) {
-    if (!doOutput) {
-        return;
-    }
-    pluginView->SetTabs();    
-}
-
-void cSkinDisplayPlugin::TabLeft(void) {
-    if (!doOutput) {
-        return;
-    }
-    pluginView->TabLeft();
-}
-
-void cSkinDisplayPlugin::TabRight(void) {
-    if (!doOutput) {
-        return;
-    }
-    pluginView->TabRight();
-}
-
-void cSkinDisplayPlugin::TabUp(void) {
-    if (!doOutput) {
-        return;
-    }
-    pluginView->TabUp();
-}
-
-void cSkinDisplayPlugin::TabDown(void) {
-    if (!doOutput) {
-        return;
-    }
-    pluginView->TabDown();
-}
-
-void cSkinDisplayPlugin::DisplayTabs(void) {
-        if (!doOutput) {
-        return;
-    }
-    pluginView->DisplayTab(); 
-}
-
-void cSkinDisplayPlugin::Flush(void) {
-    if (initial) {
-        pluginView->DoStart();
-        initial = false;
-    }
-    pluginView->Flush();
-}
-
-bool cSkinDisplayPlugin::ChannelLogoExists(string channelId) {
-    return imgCache->LogoExists(channelId);
-}
-
-string cSkinDisplayPlugin::GetEpgImagePath(void) {
-    return *config.epgImagePath;
-}

displayplugin.h

@@ -1,44 +0,0 @@
-#ifndef __DISPLAYPLUGIN_H
-#define __DISPLAYPLUGIN_H
-
-#include "libskindesignerapi/skindesignerapi.h"
-#include "libtemplate/template.h"
-#include "views/displaypluginview.h"
-
-class cSkinDisplayPlugin : public skindesignerapi::ISkinDisplayPlugin {
-private:
-    bool doOutput;
-    bool initial;
-    cDisplayPluginView *pluginView;
-public:
-    cSkinDisplayPlugin(void) {};
-    cSkinDisplayPlugin(cTemplate *pluginTemplate, int subViewID);
-    virtual ~cSkinDisplayPlugin(void);
-    virtual void Deactivate(bool hide);
-    virtual void Activate(void);
-    virtual void ClearViewElement(int id);
-    virtual void DisplayViewElement(int id);
-    virtual void SetViewElementIntTokens(map<string,int> *intTokens);
-    virtual void SetViewElementStringTokens(map<string,string> *stringTokens);
-    virtual void SetViewElementLoopTokens(map<string,vector<map<string,string> > > *loopTokens);
-    virtual void InitGrids(int viewGridID);
-    virtual void SetGrid(int viewGridID, long gridID, double x, double y, double width, double height, map<string,int> *intTokens, map<string,string> *stringTokens);
-    virtual void SetGridCurrent(int viewGridID, long gridID, bool current);
-    virtual void DeleteGrid(int viewGridID, long gridID);
-    virtual void DisplayGrids(int viewGridID);
-    virtual void ClearGrids(int viewGridID);
-    virtual void SetTabIntTokens(map<string,int> *intTokens);
-    virtual void SetTabStringTokens(map<string,string> *stringTokens);
-    virtual void SetTabLoopTokens(map<string,vector<map<string,string> > > *loopTokens);
-    virtual void SetTabs(void);
-    virtual void TabLeft(void);
-    virtual void TabRight(void);
-    virtual void TabUp(void);
-    virtual void TabDown(void);
-    virtual void DisplayTabs(void);
-    virtual void Flush(void);
-    virtual bool ChannelLogoExists(string channelId);
-    virtual string GetEpgImagePath(void);
-};
-
-#endif //__DISPLAYPLUGIN_H

displayreplay.c

@@ -1,129 +1,84 @@
 #define __STL_CONFIG_H
-#include <vdr/player.h>
 #include "displayreplay.h"
 
-cSDDisplayReplay::cSDDisplayReplay(cTemplate *replayTemplate, bool ModeOnly) {
-    doOutput = true;
-    initial = true;
-    initialModeSet = false;
-    modeOnly = ModeOnly;
-    replayView = NULL;
-    if (!replayTemplate) {
-        doOutput = false;
-        esyslog("skindesigner: displayReplay no valid template - aborting");
-        return;
-    }
-    replayView = new cDisplayReplayView(replayTemplate->GetRootView());
-    if (!replayView->createOsd()) {
-        doOutput = false;
-        return;
-    }
-    replayView->DrawDebugGrid();
+cSDDisplayReplay::cSDDisplayReplay(cViewReplay *replayView, bool ModeOnly) {
+    init = true;
+    view = replayView;
+    ok = view->Init();
+    if (!ok)
+        esyslog("skindesigner: Error initiating displayreplay view - aborting");
+    view->SetModeOnly(ModeOnly);
 }
 
 cSDDisplayReplay::~cSDDisplayReplay() {
-    if (replayView)
-        delete replayView;
+    view->Close();
 }
 
 void cSDDisplayReplay::SetRecording(const cRecording *Recording) {
-    if (!doOutput || !Recording)
-        return;
-    if (initial) {
-        replayView->SetRecordingLength(Recording->LengthInSeconds());
+    if (ok) {
+        view->SetRecording(Recording);
+        if (init) {
+            view->SetRecordingLength(Recording->LengthInSeconds());
             SetTimeShiftValues(Recording);
+            init = false;
+        }
     }
-    replayView->DrawTitle(Recording);
-    replayView->DrawRecordingInformation(Recording);
-    replayView->DrawScraperContent(Recording);
 }
 
 void cSDDisplayReplay::SetTitle(const char *Title) {
-    if (!doOutput || !Title)
-        return;
-    replayView->DrawTitle(Title);
+    view->SetTitle(Title);
 }
 
 void cSDDisplayReplay::SetMode(bool Play, bool Forward, int Speed) {
-    if (!doOutput)
+    if (!ok)
         return;
     if (!Play && Speed < 0) {
-        string recFileName = "";
         cControl *control = cControl::Control();
         if (control) {
             const cRecording *recording = control->GetRecording();
-            if (recording && recording->FileName())
-                recFileName = recording->FileName();
+            if (recording && recording->FileName()) {
+                view->StartOnPause(recording->FileName());
+            }
         }
-        replayView->DrawOnPause(recFileName, modeOnly);
     } else {
-        replayView->ClearOnPause();
+        view->ClearOnPause();
     }
 
-    replayView->DrawControlIcons(Play, Forward, Speed, modeOnly);
-    initialModeSet = true;
+    view->SetControlIcons(Play, Forward, Speed);
 }
 
 void cSDDisplayReplay::SetProgress(int Current, int Total) {
-    if (!doOutput)
-        return;
-    replayView->DelayOnPause();
-    replayView->DrawProgressBar(Current, Total);
-    replayView->DrawMarks(marks, Current, Total);
-    replayView->DrawEndTime(Current, Total);
+    if (ok) {
+        view->SetProgressbar(Current, Total);
+        view->SetMarks(marks, Current, Total);
+        view->SetEndTime(Current, Total);
+    }
 }
 
 void cSDDisplayReplay::SetCurrent(const char *Current) {
-    if (!doOutput)
-        return;
-    replayView->DrawCurrent(Current);
+    if (ok)
+        view->SetCurrent(Current);
 }
 
 void cSDDisplayReplay::SetTotal(const char *Total) {
-    if (!doOutput)
-        return;
-    replayView->DrawTotal(Total);
+    if (ok)
+        view->SetTotal(Total);
 }
 
 void cSDDisplayReplay::SetJump(const char *Jump) {
-    if (!doOutput)
-        return;
-    replayView->DrawJump(Jump);    
+    if (ok)
+        view->SetJump(Jump);
 }
 
 void cSDDisplayReplay::SetMessage(eMessageType Type, const char *Text) {
-    if (!doOutput)
-        return;
-    replayView->DrawMessage(Type, Text);
+    if (ok)
+        view->SetMessage(Type, Text);
 }
 
 void cSDDisplayReplay::Flush(void) {
-    if (!doOutput)
+    if (!ok)
         return;
-    if (!modeOnly) {
-        replayView->DrawDate();
-        replayView->DrawTime();
-    }
-    if (modeOnly) {
-        cControl *control = cControl::Control();
-        if (control) {
-            double fps = control->FramesPerSecond();
-            int current = 0;
-            int total = 0;
-            if (control->GetIndex(current, total))
-                replayView->DrawProgressModeOnly(fps, current, total);
-        }
-    }
-    if (initial && initialModeSet) {
-        replayView->DrawBackground(modeOnly);
-        replayView->DrawCustomTokens();
-        replayView->DoFadeIn();
-        initial = false;
-    } else {
-        if (replayView->CustomTokenChange())
-            replayView->DrawCustomTokens();
-        replayView->Flush();
-    }
+    view->Flush();
 }
 
 void cSDDisplayReplay::SetTimeShiftValues(const cRecording *recording) {
@@ -146,5 +101,5 @@ void cSDDisplayReplay::SetTimeShiftValues(const cRecording *recording) {
     time_t recordingStart = time(0) - recording->LengthInSeconds();
     int framesTotal = (liveEventStop - recordingStart)*fps;
     int recLength = liveEventStop - recordingStart;
-    replayView->SetTimeShift(framesTotal, recLength);
+    view->SetTimeShift(framesTotal, recLength);
 }

displayreplay.h

@@ -2,21 +2,17 @@
 #define __DISPLAYREPLAY_H
 
 #include <vdr/skins.h>
-#include <vdr/thread.h>
 #include "config.h"
-#include "libtemplate/template.h"
-#include "views/displayreplayview.h"
+#include "coreengine/viewdisplayreplay.h"
 
 class cSDDisplayReplay : public cSkinDisplayReplay {
 private:
-    cDisplayReplayView *replayView;
-    bool initial;
-    bool initialModeSet;
-    bool doOutput;
-    bool modeOnly;
+    bool ok;
+    bool init;
+    cViewReplay *view;
     void SetTimeShiftValues(const cRecording *recording);
 public:
-    cSDDisplayReplay(cTemplate *replayTemplate, bool ModeOnly);
+    cSDDisplayReplay(cViewReplay *replayView, bool ModeOnly);
     virtual ~cSDDisplayReplay();
     virtual void SetRecording(const cRecording *Recording);
     virtual void SetTitle(const char *Title);

displaytracks.c

@@ -1,59 +1,31 @@
 #include "displaytracks.h"
 
-
-cSDDisplayTracks::cSDDisplayTracks(cTemplate *audiotracksTemplate, const char *Title, int NumTracks, const char * const *Tracks) {
-    initial = true;
-    numTracks = NumTracks;
-    tracksView = NULL;
-    doOutput = true;
-    currentTrack = 0;
-    menuTitle = Title;
-    if (!audiotracksTemplate) {
-        esyslog("skindesigner: displayTracks no valid template - aborting");
-        doOutput = false;
-        return;
-    }
-    tracksView = new cDisplayAudiotracksView(NumTracks, audiotracksTemplate->GetRootView());
-    if (!tracksView->createOsd()) {
-        doOutput = false;
-        return;
-    }
-    tracksView->DrawDebugGrid();
-    tracksView->DrawBackground();
-
-    cDisplayMenuListView *list = tracksView->GetListView();
-    if (list) {
-        for (int i = 0; i < NumTracks; i++) {
-            list->AddTracksMenuItem(i, Tracks[i], (i==currentTrack)?true:false, true);
-        }
-    }    
+cSDDisplayTracks::cSDDisplayTracks(cViewTracks *tracksView, const char *Title, int NumTracks, const char * const *Tracks) {
+    view = tracksView;
+    ok = view->Init();
+    if (!ok)
+        esyslog("skindesigner: Error initiating displaytracks view - aborting");
+    view->SetTitle(Title);
+    view->SetNumtracks(NumTracks);
+    view->SetTracks(Tracks);
 }
 
 cSDDisplayTracks::~cSDDisplayTracks() {
-    if (tracksView)
-        delete tracksView;
+    view->Close();
 }
 
 void cSDDisplayTracks::SetTrack(int Index, const char * const *Tracks) {
-    cDisplayMenuListView *list = tracksView->GetListView();
-    if (list) {
-        list->AddTracksMenuItem(currentTrack, Tracks[currentTrack], false, true);
-        list->AddTracksMenuItem(Index, Tracks[Index], true, true);
-        currentTrack = Index;
-    }
+    if (ok)
+        view->SetCurrentTrack(Index);
 }
 
 void cSDDisplayTracks::SetAudioChannel(int AudioChannel) {
-    tracksView->DrawHeader(menuTitle, AudioChannel);
+    if (ok)
+        view->SetAudiochannel(AudioChannel);
 }
 
 void cSDDisplayTracks::Flush(void) {
-    if (!doOutput)
+    if (!ok)
         return;
-    if (initial) {
-        tracksView->DoFadeIn();
-    }
-    initial = false;
-    tracksView->RenderMenuItems();
-    tracksView->Flush();
+    view->Flush();
 }

displaytracks.h

@@ -2,21 +2,15 @@
 #define __DISPLAYTRACKS_H
 
 #include <vdr/skins.h>
-#include <vdr/thread.h>
 #include "config.h"
-#include "libtemplate/template.h"
-#include "views/displayaudiotracksview.h"
+#include "coreengine/viewdisplaytracks.h"
 
 class cSDDisplayTracks : public cSkinDisplayTracks {
 private:
-    cDisplayAudiotracksView *tracksView;
-    bool initial;
-    int numTracks;
-    bool doOutput;
-    int currentTrack;
-    const char *menuTitle;
+    cViewTracks *view;
+    bool ok;
 public:
-    cSDDisplayTracks(cTemplate *audiotracksTemplate, const char *Title, int NumTracks, const char * const *Tracks);
+    cSDDisplayTracks(cViewTracks *tracksView, const char *Title, int NumTracks, const char * const *Tracks);
     virtual ~cSDDisplayTracks();
     virtual void SetTrack(int Index, const char * const *Tracks);
     virtual void SetAudioChannel(int AudioChannel);

displayvolume.c

@@ -1,44 +1,26 @@
 #include "displayvolume.h"
 
 #include "config.h"
-#include "libcore/helpers.h"
 
-cSDDisplayVolume::cSDDisplayVolume(cTemplate *volumeTemplate) {
-    volumeView = NULL;
-    doOutput = true;
-    initial = true;
-    if (!volumeTemplate) {
-        doOutput = false;
-        esyslog("skindesigner: displayVolume no valid template - aborting");
-        return;
-    }
-    volumeView = new cDisplayVolumeView(volumeTemplate->GetRootView());
-    if (!volumeView->createOsd()) {
-        doOutput = false;
-    } else {
-        volumeView->DrawDebugGrid();
-        volumeView->DrawBackground();
-    }
+cSDDisplayVolume::cSDDisplayVolume(cViewVolume *volumeView) {
+    view = volumeView;
+    ok = view->Init();
+    if (!ok)
+        esyslog("skindesigner: Error initiating displayvolume view - aborting");
 }
 
 cSDDisplayVolume::~cSDDisplayVolume() {
-    if (volumeView)
-        delete volumeView;
+    view->Close();
 }
 
 void cSDDisplayVolume::SetVolume(int Current, int Total, bool Mute) {
-    if (!doOutput)
+    if (!ok)
         return;
-    volumeView->DrawVolume(Current, Total, Mute);
+    view->SetVolume(Current, Total, Mute);
 }
 
 void cSDDisplayVolume::Flush(void) {
-    if (!doOutput)
+    if (!ok)
         return;
-    if (initial) {
-        volumeView->DoFadeIn();
-        initial = false;
-    } else {
-        volumeView->Flush();
-    }
+    view->Flush();
 }

displayvolume.h

@@ -1,18 +1,15 @@
 #ifndef __DISPLAYVOLUME_H
 #define __DISPLAYVOLUME_H
 
-#include <vdr/skins.h>
 #include "config.h"
-#include "libtemplate/template.h"
-#include "views/displayvolumeview.h"
+#include "coreengine/viewdisplayvolume.h"
 
 class cSDDisplayVolume : public cSkinDisplayVolume {
 private:
-    cDisplayVolumeView *volumeView;
-    bool doOutput;
-    bool initial;
+    cViewVolume *view;
+    bool ok;
 public:
-    cSDDisplayVolume(cTemplate *volumeTemplate);
+    cSDDisplayVolume(cViewVolume *volumeView);
     virtual ~cSDDisplayVolume();
     virtual void SetVolume(int Current, int Total, bool Mute);
     virtual void Flush(void);

dtd/displaychannel.dtd

@@ -26,79 +26,162 @@
 
 <!ELEMENT background (areacontainer|area|areascroll)*>
 <!ATTLIST background
+  delay CDATA #IMPLIED
+  fadetime CDATA #IMPLIED
+  shifttime CDATA #IMPLIED
+  shifttype CDATA #IMPLIED
+  shiftmode CDATA #IMPLIED
+  startx CDATA #IMPLIED
+  starty CDATA #IMPLIED
   debug CDATA #IMPLIED
   condition CDATA #IMPLIED
 >
 
 <!ELEMENT channelinfo (areacontainer|area|areascroll)*>
 <!ATTLIST channelinfo
+  delay CDATA #IMPLIED
+  fadetime CDATA #IMPLIED
+  shifttime CDATA #IMPLIED
+  shifttype CDATA #IMPLIED
+  shiftmode CDATA #IMPLIED
+  startx CDATA #IMPLIED
+  starty CDATA #IMPLIED
   debug CDATA #IMPLIED
   condition CDATA #IMPLIED
 >
 
 <!ELEMENT epginfo (areacontainer|area|areascroll)*>
 <!ATTLIST epginfo
+  delay CDATA #IMPLIED
+  fadetime CDATA #IMPLIED
+  shifttime CDATA #IMPLIED
+  shifttype CDATA #IMPLIED
+  shiftmode CDATA #IMPLIED
+  startx CDATA #IMPLIED
+  starty CDATA #IMPLIED
   debug CDATA #IMPLIED
   condition CDATA #IMPLIED
 >
 
 <!ELEMENT progressbar (areacontainer|area|areascroll)*>
 <!ATTLIST progressbar
+  delay CDATA #IMPLIED
+  fadetime CDATA #IMPLIED
+  shifttime CDATA #IMPLIED
+  shifttype CDATA #IMPLIED
+  shiftmode CDATA #IMPLIED
+  startx CDATA #IMPLIED
+  starty CDATA #IMPLIED
   debug CDATA #IMPLIED
   condition CDATA #IMPLIED
 >
 
 <!ELEMENT progressbarback (areacontainer|area|areascroll)*>
 <!ATTLIST progressbarback
+  delay CDATA #IMPLIED
+  fadetime CDATA #IMPLIED
+  shifttime CDATA #IMPLIED
+  shifttype CDATA #IMPLIED
+  shiftmode CDATA #IMPLIED
+  startx CDATA #IMPLIED
+  starty CDATA #IMPLIED
   debug CDATA #IMPLIED
   condition CDATA #IMPLIED
 >
 
 <!ELEMENT statusinfo (areacontainer|area|areascroll)*>
 <!ATTLIST statusinfo
+  delay CDATA #IMPLIED
+  fadetime CDATA #IMPLIED
+  shifttime CDATA #IMPLIED
+  shifttype CDATA #IMPLIED
+  shiftmode CDATA #IMPLIED
+  startx CDATA #IMPLIED
+  starty CDATA #IMPLIED
   debug CDATA #IMPLIED
   condition CDATA #IMPLIED
 >
 
 <!ELEMENT audioinfo (areacontainer|area|areascroll)*>
 <!ATTLIST audioinfo
+  delay CDATA #IMPLIED
+  fadetime CDATA #IMPLIED
+  shifttime CDATA #IMPLIED
+  shifttype CDATA #IMPLIED
+  shiftmode CDATA #IMPLIED
+  startx CDATA #IMPLIED
+  starty CDATA #IMPLIED
   debug CDATA #IMPLIED
   condition CDATA #IMPLIED
 >
 
 <!ELEMENT ecminfo (areacontainer|area|areascroll)*>
 <!ATTLIST ecminfo
+  delay CDATA #IMPLIED
+  fadetime CDATA #IMPLIED
+  shifttime CDATA #IMPLIED
+  shifttype CDATA #IMPLIED
+  shiftmode CDATA #IMPLIED
+  startx CDATA #IMPLIED
+  starty CDATA #IMPLIED
   debug CDATA #IMPLIED
   condition CDATA #IMPLIED
 >
 
 <!ELEMENT screenresolution (areacontainer|area|areascroll)*>
 <!ATTLIST screenresolution
+  delay CDATA #IMPLIED
+  fadetime CDATA #IMPLIED
+  shifttime CDATA #IMPLIED
+  shifttype CDATA #IMPLIED
+  shiftmode CDATA #IMPLIED
+  startx CDATA #IMPLIED
+  starty CDATA #IMPLIED
   debug CDATA #IMPLIED
   condition CDATA #IMPLIED
 >
 
 <!ELEMENT channelgroup (areacontainer|area|areascroll)*>
 <!ATTLIST channelgroup
+  delay CDATA #IMPLIED
+  fadetime CDATA #IMPLIED
+  shifttime CDATA #IMPLIED
+  shifttype CDATA #IMPLIED
+  shiftmode CDATA #IMPLIED
+  startx CDATA #IMPLIED
+  starty CDATA #IMPLIED
   debug CDATA #IMPLIED
   condition CDATA #IMPLIED
 >
 
 <!ELEMENT signalquality (areacontainer|area|areascroll)*>
 <!ATTLIST signalquality
+  delay CDATA #IMPLIED
+  fadetime CDATA #IMPLIED
+  shifttime CDATA #IMPLIED
+  shifttype CDATA #IMPLIED
+  shiftmode CDATA #IMPLIED
+  startx CDATA #IMPLIED
+  starty CDATA #IMPLIED
   debug CDATA #IMPLIED
   condition CDATA #IMPLIED
 >
 
 <!ELEMENT signalqualityback (areacontainer|area|areascroll)*>
 <!ATTLIST signalqualityback
+  delay CDATA #IMPLIED
+  fadetime CDATA #IMPLIED
+  shifttime CDATA #IMPLIED
+  shifttype CDATA #IMPLIED
+  shiftmode CDATA #IMPLIED
+  startx CDATA #IMPLIED
+  starty CDATA #IMPLIED
   debug CDATA #IMPLIED
   condition CDATA #IMPLIED
 >
 
 <!ELEMENT devices (areacontainer|area|areascroll)*>
 <!ATTLIST devices
-  detached CDATA #IMPLIED
   delay CDATA #IMPLIED
   fadetime CDATA #IMPLIED
   shifttime CDATA #IMPLIED
@@ -113,7 +196,6 @@
 
 <!ELEMENT currentweather (areacontainer|area|areascroll)*>
 <!ATTLIST currentweather
-  detached CDATA #IMPLIED
   delay CDATA #IMPLIED
   fadetime CDATA #IMPLIED
   shifttime CDATA #IMPLIED
@@ -127,7 +209,6 @@
 
 <!ELEMENT scrapercontent (areacontainer|area|areascroll)*>
 <!ATTLIST scrapercontent
-  detached CDATA #IMPLIED
   delay CDATA #IMPLIED
   fadetime CDATA #IMPLIED
   shifttime CDATA #IMPLIED
@@ -141,7 +222,6 @@
 
 <!ELEMENT datetime (areacontainer|area|areascroll)*>
 <!ATTLIST datetime
-  detached CDATA #IMPLIED
   delay CDATA #IMPLIED
   fadetime CDATA #IMPLIED
   shifttime CDATA #IMPLIED
@@ -155,7 +235,6 @@
 
 <!ELEMENT time (areacontainer|area|areascroll)*>
 <!ATTLIST time
-  detached CDATA #IMPLIED
   delay CDATA #IMPLIED
   fadetime CDATA #IMPLIED
   shifttime CDATA #IMPLIED
@@ -175,8 +254,6 @@
 
 <!ELEMENT customtokens (areacontainer|area|areascroll)*>
 <!ATTLIST customtokens
-  detached CDATA #IMPLIED
-  delay CDATA #IMPLIED
   fadetime CDATA #IMPLIED
   shifttime CDATA #IMPLIED
   shiftmode CDATA #IMPLIED

dtd/displaymenu.dtd

@@ -2,7 +2,7 @@
 
 <!ENTITY % functions SYSTEM "functions.dtd">
 
-<!ELEMENT displaymenu (background,header,datetime,time*,message,sortmode*,colorbuttons,
+<!ELEMENT displaymenu (background,header,datetime,time*,message,sortmode*,colorbuttons,scrollbar*,
                        menudefault,menumain*,menusetup*,menuschedules*,
                        menutimers*,menuchannels*,menurecordings*,
                        menudetailedepg,menudetailedrecording,
@@ -13,18 +13,31 @@
   width CDATA #REQUIRED
   height CDATA #REQUIRED
   fadetime CDATA #IMPLIED
+  shifttime CDATA #IMPLIED
+  shifttype CDATA #IMPLIED
+  shiftmode CDATA #IMPLIED
+  startx CDATA #IMPLIED
+  starty CDATA #IMPLIED
   debuggrid CDATA #IMPLIED
 >
 
 <!ELEMENT background (areacontainer|area|areascroll)*>
 <!ATTLIST background
+  orientation CDATA #IMPLIED
+  delay CDATA #IMPLIED
+  fadetime CDATA #IMPLIED
+  shifttime CDATA #IMPLIED
+  shifttype CDATA #IMPLIED
+  shiftmode CDATA #IMPLIED
+  startx CDATA #IMPLIED
+  starty CDATA #IMPLIED
   debug CDATA #IMPLIED
   condition CDATA #IMPLIED
 >
 
 <!ELEMENT header (areacontainer|area|areascroll)*>
 <!ATTLIST header
-  detached CDATA #IMPLIED
+  orientation CDATA #IMPLIED
   delay CDATA #IMPLIED
   fadetime CDATA #IMPLIED
   shifttime CDATA #IMPLIED
@@ -38,7 +51,7 @@
 
 <!ELEMENT datetime (areacontainer|area|areascroll)*>
 <!ATTLIST datetime
-  detached CDATA #IMPLIED
+  orientation CDATA #IMPLIED
   delay CDATA #IMPLIED
   fadetime CDATA #IMPLIED
   shifttime CDATA #IMPLIED
@@ -52,7 +65,7 @@
 
 <!ELEMENT time (areacontainer|area|areascroll)*>
 <!ATTLIST time
-  detached CDATA #IMPLIED
+  orientation CDATA #IMPLIED
   delay CDATA #IMPLIED
   fadetime CDATA #IMPLIED
   shifttime CDATA #IMPLIED
@@ -66,7 +79,7 @@
 
 <!ELEMENT message (areacontainer|area|areascroll)*>
 <!ATTLIST message
-  detached CDATA #IMPLIED
+  orientation CDATA #IMPLIED
   delay CDATA #IMPLIED
   fadetime CDATA #IMPLIED
   shifttime CDATA #IMPLIED
@@ -80,20 +93,36 @@
 
 <!ELEMENT sortmode (areacontainer|area|areascroll)*>
 <!ATTLIST sortmode
+  orientation CDATA #IMPLIED
+  delay CDATA #IMPLIED
+  fadetime CDATA #IMPLIED
+  shifttime CDATA #IMPLIED
+  shifttype CDATA #IMPLIED
+  shiftmode CDATA #IMPLIED
+  startx CDATA #IMPLIED
+  starty CDATA #IMPLIED
   debug CDATA #IMPLIED
   condition CDATA #IMPLIED
 >
 
 <!ELEMENT colorbuttons (areacontainer|area|areascroll)*>
 <!ATTLIST colorbuttons
+  orientation CDATA #IMPLIED
+  delay CDATA #IMPLIED
+  fadetime CDATA #IMPLIED
+  shifttime CDATA #IMPLIED
+  shifttype CDATA #IMPLIED
+  shiftmode CDATA #IMPLIED
+  startx CDATA #IMPLIED
+  starty CDATA #IMPLIED
   debug CDATA #IMPLIED
   condition CDATA #IMPLIED
 >
 
 <!ELEMENT timers (areacontainer|area|areascroll)*>
 <!ATTLIST timers
-  detached CDATA #IMPLIED
   delay CDATA #IMPLIED
+  orientation CDATA #IMPLIED
   fadetime CDATA #IMPLIED
   shifttime CDATA #IMPLIED
   shifttype CDATA #IMPLIED
@@ -106,8 +135,8 @@
 
 <!ELEMENT discusage (areacontainer|area|areascroll)*>
 <!ATTLIST discusage
-  detached CDATA #IMPLIED
   delay CDATA #IMPLIED
+  orientation CDATA #IMPLIED
   fadetime CDATA #IMPLIED
   shifttime CDATA #IMPLIED
   shifttype CDATA #IMPLIED
@@ -120,8 +149,8 @@
 
 <!ELEMENT devices (areacontainer|area|areascroll)*>
 <!ATTLIST devices
-  detached CDATA #IMPLIED
   delay CDATA #IMPLIED
+  orientation CDATA #IMPLIED
   fadetime CDATA #IMPLIED
   shifttime CDATA #IMPLIED
   shifttype CDATA #IMPLIED
@@ -135,8 +164,8 @@
 
 <!ELEMENT systemload (areacontainer|area|areascroll)*>
 <!ATTLIST systemload
-  detached CDATA #IMPLIED
   delay CDATA #IMPLIED
+  orientation CDATA #IMPLIED
   fadetime CDATA #IMPLIED
   shifttime CDATA #IMPLIED
   shifttype CDATA #IMPLIED
@@ -149,8 +178,8 @@
 
 <!ELEMENT systemmemory (areacontainer|area|areascroll)*>
 <!ATTLIST systemmemory
-  detached CDATA #IMPLIED
   delay CDATA #IMPLIED
+  orientation CDATA #IMPLIED
   fadetime CDATA #IMPLIED
   shifttime CDATA #IMPLIED
   shifttype CDATA #IMPLIED
@@ -163,8 +192,8 @@
 
 <!ELEMENT temperatures (areacontainer|area|areascroll)*>
 <!ATTLIST temperatures
-  detached CDATA #IMPLIED
   delay CDATA #IMPLIED
+  orientation CDATA #IMPLIED
   fadetime CDATA #IMPLIED
   shifttime CDATA #IMPLIED
   shifttype CDATA #IMPLIED
@@ -177,8 +206,8 @@
 
 <!ELEMENT vdrstatistics (areacontainer|area|areascroll)*>
 <!ATTLIST vdrstatistics
-  detached CDATA #IMPLIED
   delay CDATA #IMPLIED
+  orientation CDATA #IMPLIED
   fadetime CDATA #IMPLIED
   shifttime CDATA #IMPLIED
   shifttype CDATA #IMPLIED
@@ -191,8 +220,8 @@
 
 <!ELEMENT currentschedule (areacontainer|area|areascroll)*>
 <!ATTLIST currentschedule
-  detached CDATA #IMPLIED
   delay CDATA #IMPLIED
+  orientation CDATA #IMPLIED
   fadetime CDATA #IMPLIED
   shifttime CDATA #IMPLIED
   shifttype CDATA #IMPLIED
@@ -205,8 +234,8 @@
 
 <!ELEMENT currentweather (areacontainer|area|areascroll)*>
 <!ATTLIST currentweather
-  detached CDATA #IMPLIED
   delay CDATA #IMPLIED
+  orientation CDATA #IMPLIED
   fadetime CDATA #IMPLIED
   shifttime CDATA #IMPLIED
   shifttype CDATA #IMPLIED
@@ -219,8 +248,8 @@
 
 <!ELEMENT lastrecordings (areacontainer|area|areascroll)*>
 <!ATTLIST lastrecordings
-  detached CDATA #IMPLIED
   delay CDATA #IMPLIED
+  orientation CDATA #IMPLIED
   fadetime CDATA #IMPLIED
   shifttime CDATA #IMPLIED
   shifttype CDATA #IMPLIED
@@ -233,8 +262,8 @@
 
 <!ELEMENT customtokens (areacontainer|area|areascroll)*>
 <!ATTLIST customtokens
-  detached CDATA #IMPLIED
   delay CDATA #IMPLIED
+  orientation CDATA #IMPLIED
   fadetime CDATA #IMPLIED
   shifttime CDATA #IMPLIED
   shifttype CDATA #IMPLIED
@@ -247,6 +276,14 @@
 
 <!ELEMENT scrollbar (areacontainer|area|areascroll)*>
 <!ATTLIST scrollbar
+  delay CDATA #IMPLIED
+  orientation CDATA #IMPLIED
+  fadetime CDATA #IMPLIED
+  shifttime CDATA #IMPLIED
+  shifttype CDATA #IMPLIED
+  shiftmode CDATA #IMPLIED
+  startx CDATA #IMPLIED
+  starty CDATA #IMPLIED
   debug CDATA #IMPLIED
   condition CDATA #IMPLIED
 >
@@ -269,6 +306,7 @@
   y CDATA #REQUIRED
   width CDATA #REQUIRED
   height CDATA #REQUIRED
+  orientation CDATA #IMPLIED
   fadetime CDATA #IMPLIED
   scaletvx CDATA #IMPLIED
   scaletvy CDATA #IMPLIED
@@ -285,6 +323,7 @@
   y CDATA #REQUIRED
   width CDATA #REQUIRED
   height CDATA #REQUIRED
+  orientation CDATA #IMPLIED
   fadetime CDATA #IMPLIED
   scaletvx CDATA #IMPLIED
   scaletvy CDATA #IMPLIED
@@ -299,6 +338,7 @@
   y CDATA #REQUIRED
   width CDATA #REQUIRED
   height CDATA #REQUIRED
+  orientation CDATA #IMPLIED
   fadetime CDATA #IMPLIED
   scaletvx CDATA #IMPLIED
   scaletvy CDATA #IMPLIED
@@ -313,6 +353,7 @@
   y CDATA #REQUIRED
   width CDATA #REQUIRED
   height CDATA #REQUIRED
+  orientation CDATA #IMPLIED
   fadetime CDATA #IMPLIED
   scaletvx CDATA #IMPLIED
   scaletvy CDATA #IMPLIED
@@ -327,6 +368,7 @@
   y CDATA #REQUIRED
   width CDATA #REQUIRED
   height CDATA #REQUIRED
+  orientation CDATA #IMPLIED
   fadetime CDATA #IMPLIED
   scaletvx CDATA #IMPLIED
   scaletvy CDATA #IMPLIED
@@ -341,6 +383,7 @@
   y CDATA #REQUIRED
   width CDATA #REQUIRED
   height CDATA #REQUIRED
+  orientation CDATA #IMPLIED
   fadetime CDATA #IMPLIED
   scaletvx CDATA #IMPLIED
   scaletvy CDATA #IMPLIED
@@ -355,6 +398,7 @@
   y CDATA #REQUIRED
   width CDATA #REQUIRED
   height CDATA #REQUIRED
+  orientation CDATA #IMPLIED
   fadetime CDATA #IMPLIED
   scaletvx CDATA #IMPLIED
   scaletvy CDATA #IMPLIED
@@ -429,10 +473,16 @@
 
 <!ELEMENT currentelement (areacontainer|area|areascroll)*>
 <!ATTLIST currentelement
-  delay CDATA #REQUIRED
+  delay CDATA #IMPLIED
+  orientation CDATA #IMPLIED
   fadetime CDATA #IMPLIED
-  condition CDATA #IMPLIED
+  shifttime CDATA #IMPLIED
+  shifttype CDATA #IMPLIED
+  shiftmode CDATA #IMPLIED
+  startx CDATA #IMPLIED
+  starty CDATA #IMPLIED
   debug CDATA #IMPLIED
+  condition CDATA #IMPLIED
 >
 
 <!ELEMENT tab (loop|fill|drawtext|drawtextbox|drawimage|drawrectangle|drawellipse)*>

dtd/displaymenuplugin.dtd

@@ -13,49 +13,87 @@
   scaletvy CDATA #IMPLIED
   scaletvwidth CDATA #IMPLIED
   scaletvheight CDATA #IMPLIED
+  orientation CDATA #IMPLIED
   debuggrid CDATA #IMPLIED
 >
 
 <!ELEMENT background (areacontainer|area|areascroll)*>
 <!ATTLIST background
-  condition CDATA #IMPLIED
+  orientation CDATA #IMPLIED
+  fadetime CDATA #IMPLIED
+  shifttime CDATA #IMPLIED
+  shifttype CDATA #IMPLIED
+  shiftmode CDATA #IMPLIED
+  startx CDATA #IMPLIED
+  starty CDATA #IMPLIED
   debug CDATA #IMPLIED
+  condition CDATA #IMPLIED
 >
 
 <!ELEMENT header (areacontainer|area|areascroll)*>
 <!ATTLIST header
-  condition CDATA #IMPLIED
+  orientation CDATA #IMPLIED
+  fadetime CDATA #IMPLIED
+  shifttime CDATA #IMPLIED
+  shifttype CDATA #IMPLIED
+  shiftmode CDATA #IMPLIED
+  startx CDATA #IMPLIED
+  starty CDATA #IMPLIED
   debug CDATA #IMPLIED
+  condition CDATA #IMPLIED
 >
 
 <!ELEMENT datetime (areacontainer|area|areascroll)*>
 <!ATTLIST datetime
-  condition CDATA #IMPLIED
+  orientation CDATA #IMPLIED
+  fadetime CDATA #IMPLIED
+  shifttime CDATA #IMPLIED
+  shifttype CDATA #IMPLIED
+  shiftmode CDATA #IMPLIED
+  startx CDATA #IMPLIED
+  starty CDATA #IMPLIED
   debug CDATA #IMPLIED
+  condition CDATA #IMPLIED
 >
 
 <!ELEMENT message (areacontainer|area|areascroll)*>
 <!ATTLIST message
-  condition CDATA #IMPLIED
+  orientation CDATA #IMPLIED
+  fadetime CDATA #IMPLIED
+  shifttime CDATA #IMPLIED
+  shifttype CDATA #IMPLIED
+  shiftmode CDATA #IMPLIED
+  startx CDATA #IMPLIED
+  starty CDATA #IMPLIED
   debug CDATA #IMPLIED
+  condition CDATA #IMPLIED
 >
 
 <!ELEMENT colorbuttons (areacontainer|area|areascroll)*>
 <!ATTLIST colorbuttons
-  condition CDATA #IMPLIED
+  orientation CDATA #IMPLIED
+  fadetime CDATA #IMPLIED
+  shifttime CDATA #IMPLIED
+  shifttype CDATA #IMPLIED
+  shiftmode CDATA #IMPLIED
+  startx CDATA #IMPLIED
+  starty CDATA #IMPLIED
   debug CDATA #IMPLIED
+  condition CDATA #IMPLIED
 >
 
 <!ELEMENT scrollbar (areacontainer|area|areascroll)*>
 <!ATTLIST scrollbar
-  condition CDATA #IMPLIED
+  orientation CDATA #IMPLIED
   debug CDATA #IMPLIED
+  condition CDATA #IMPLIED
 >
 
 <!ELEMENT detailheader (areacontainer|area|areascroll)*>
 <!ATTLIST detailheader
-  condition CDATA #IMPLIED
+  orientation CDATA #IMPLIED
   debug CDATA #IMPLIED
+  condition CDATA #IMPLIED
 >
 
 <!ELEMENT tablabels (areacontainer|area|areascroll)*>
@@ -85,7 +123,7 @@
 <!ELEMENT currentelement (areacontainer|area|areascroll)*>
 <!ATTLIST currentelement
   condition CDATA #IMPLIED
-  delay CDATA #REQUIRED
+  delay CDATA #IMPLIED
   fadetime CDATA #IMPLIED
   debug CDATA #IMPLIED
 >

dtd/displayreplay.dtd

@@ -27,29 +27,56 @@
 
 <!ELEMENT background (areacontainer|area|areascroll)*>
 <!ATTLIST background
+  delay CDATA #IMPLIED
+  fadetime CDATA #IMPLIED
+  shifttime CDATA #IMPLIED
+  shifttype CDATA #IMPLIED
+  shiftmode CDATA #IMPLIED
+  startx CDATA #IMPLIED
+  starty CDATA #IMPLIED
   debug CDATA #IMPLIED
 >
 
 <!ELEMENT backgroundmodeonly (areacontainer|area|areascroll)*>
 <!ATTLIST backgroundmodeonly
+  delay CDATA #IMPLIED
+  fadetime CDATA #IMPLIED
+  shifttime CDATA #IMPLIED
+  shifttype CDATA #IMPLIED
+  shiftmode CDATA #IMPLIED
+  startx CDATA #IMPLIED
+  starty CDATA #IMPLIED
   debug CDATA #IMPLIED
 >
 
 <!ELEMENT datetime (areacontainer|area|areascroll)*>
 <!ATTLIST datetime
+  delay CDATA #IMPLIED
+  fadetime CDATA #IMPLIED
+  shifttime CDATA #IMPLIED
+  shifttype CDATA #IMPLIED
+  shiftmode CDATA #IMPLIED
+  startx CDATA #IMPLIED
+  starty CDATA #IMPLIED
   debug CDATA #IMPLIED
   condition CDATA #IMPLIED
 >
 
 <!ELEMENT time (areacontainer|area|areascroll)*>
 <!ATTLIST time
+  delay CDATA #IMPLIED
+  fadetime CDATA #IMPLIED
+  shifttime CDATA #IMPLIED
+  shifttype CDATA #IMPLIED
+  shiftmode CDATA #IMPLIED
+  startx CDATA #IMPLIED
+  starty CDATA #IMPLIED
   debug CDATA #IMPLIED
   condition CDATA #IMPLIED
 >
 
 <!ELEMENT scrapercontent (areacontainer|area|areascroll)*>
 <!ATTLIST scrapercontent
-  detached CDATA #IMPLIED
   delay CDATA #IMPLIED
   fadetime CDATA #IMPLIED
   shifttime CDATA #IMPLIED
@@ -63,66 +90,143 @@
 
 <!ELEMENT rectitle (areacontainer|area|areascroll)*>
 <!ATTLIST rectitle
+  delay CDATA #IMPLIED
+  fadetime CDATA #IMPLIED
+  shifttime CDATA #IMPLIED
+  shifttype CDATA #IMPLIED
+  shiftmode CDATA #IMPLIED
+  startx CDATA #IMPLIED
+  starty CDATA #IMPLIED
   debug CDATA #IMPLIED
   condition CDATA #IMPLIED
 >
 
 <!ELEMENT recinfo (areacontainer|area|areascroll)*>
 <!ATTLIST recinfo
+  delay CDATA #IMPLIED
+  fadetime CDATA #IMPLIED
+  shifttime CDATA #IMPLIED
+  shifttype CDATA #IMPLIED
+  shiftmode CDATA #IMPLIED
+  startx CDATA #IMPLIED
+  starty CDATA #IMPLIED
   debug CDATA #IMPLIED
   condition CDATA #IMPLIED
 >
 
 <!ELEMENT currenttime (areacontainer|area|areascroll)*>
 <!ATTLIST currenttime
+  delay CDATA #IMPLIED
+  fadetime CDATA #IMPLIED
+  shifttime CDATA #IMPLIED
+  shifttype CDATA #IMPLIED
+  shiftmode CDATA #IMPLIED
+  startx CDATA #IMPLIED
+  starty CDATA #IMPLIED
   debug CDATA #IMPLIED
   condition CDATA #IMPLIED
 >
 
 <!ELEMENT totaltime (areacontainer|area|areascroll)*>
 <!ATTLIST totaltime
+  delay CDATA #IMPLIED
+  fadetime CDATA #IMPLIED
+  shifttime CDATA #IMPLIED
+  shifttype CDATA #IMPLIED
+  shiftmode CDATA #IMPLIED
+  startx CDATA #IMPLIED
+  starty CDATA #IMPLIED
   debug CDATA #IMPLIED
   condition CDATA #IMPLIED
 >
 
 <!ELEMENT endtime (areacontainer|area|areascroll)*>
 <!ATTLIST endtime
+  delay CDATA #IMPLIED
+  fadetime CDATA #IMPLIED
+  shifttime CDATA #IMPLIED
+  shifttype CDATA #IMPLIED
+  shiftmode CDATA #IMPLIED
+  startx CDATA #IMPLIED
+  starty CDATA #IMPLIED
   debug CDATA #IMPLIED
   condition CDATA #IMPLIED
 >
 
 <!ELEMENT progressbar (areacontainer|area|areascroll)*>
 <!ATTLIST progressbar
+  delay CDATA #IMPLIED
+  fadetime CDATA #IMPLIED
+  shifttime CDATA #IMPLIED
+  shifttype CDATA #IMPLIED
+  shiftmode CDATA #IMPLIED
+  startx CDATA #IMPLIED
+  starty CDATA #IMPLIED
   debug CDATA #IMPLIED
   condition CDATA #IMPLIED
 >
 
 <!ELEMENT cutmarks (areacontainer|area|areascroll)*>
 <!ATTLIST cutmarks
+  delay CDATA #IMPLIED
+  fadetime CDATA #IMPLIED
+  shifttime CDATA #IMPLIED
+  shifttype CDATA #IMPLIED
+  shiftmode CDATA #IMPLIED
+  startx CDATA #IMPLIED
+  starty CDATA #IMPLIED
   debug CDATA #IMPLIED
   condition CDATA #IMPLIED
 >
 
 <!ELEMENT controlicons (areacontainer|area|areascroll)*>
 <!ATTLIST controlicons
+  delay CDATA #IMPLIED
+  fadetime CDATA #IMPLIED
+  shifttime CDATA #IMPLIED
+  shifttype CDATA #IMPLIED
+  shiftmode CDATA #IMPLIED
+  startx CDATA #IMPLIED
+  starty CDATA #IMPLIED
   debug CDATA #IMPLIED
   condition CDATA #IMPLIED
 >
 
 <!ELEMENT controliconsmodeonly (areacontainer|area|areascroll)*>
 <!ATTLIST controliconsmodeonly
+  delay CDATA #IMPLIED
+  fadetime CDATA #IMPLIED
+  shifttime CDATA #IMPLIED
+  shifttype CDATA #IMPLIED
+  shiftmode CDATA #IMPLIED
+  startx CDATA #IMPLIED
+  starty CDATA #IMPLIED
   debug CDATA #IMPLIED
   condition CDATA #IMPLIED
 >
 
 <!ELEMENT progressmodeonly (areacontainer|area|areascroll)*>
 <!ATTLIST progressmodeonly
+  delay CDATA #IMPLIED
+  fadetime CDATA #IMPLIED
+  shifttime CDATA #IMPLIED
+  shifttype CDATA #IMPLIED
+  shiftmode CDATA #IMPLIED
+  startx CDATA #IMPLIED
+  starty CDATA #IMPLIED
   debug CDATA #IMPLIED
   condition CDATA #IMPLIED
 >
 
 <!ELEMENT jump (areacontainer|area|areascroll)*>
 <!ATTLIST jump
+  delay CDATA #IMPLIED
+  fadetime CDATA #IMPLIED
+  shifttime CDATA #IMPLIED
+  shifttype CDATA #IMPLIED
+  shiftmode CDATA #IMPLIED
+  startx CDATA #IMPLIED
+  starty CDATA #IMPLIED
   debug CDATA #IMPLIED
   condition CDATA #IMPLIED
 >
@@ -138,6 +242,11 @@
   debug CDATA #IMPLIED
   delay CDATA #REQUIRED
   fadetime CDATA #IMPLIED
+  shifttime CDATA #IMPLIED
+  shifttype CDATA #IMPLIED
+  shiftmode CDATA #IMPLIED
+  startx CDATA #IMPLIED
+  starty CDATA #IMPLIED
   condition CDATA #IMPLIED
 >
 
@@ -146,11 +255,23 @@
   debug CDATA #IMPLIED
   delay CDATA #REQUIRED
   fadetime CDATA #IMPLIED
+  shifttime CDATA #IMPLIED
+  shifttype CDATA #IMPLIED
+  shiftmode CDATA #IMPLIED
+  startx CDATA #IMPLIED
+  starty CDATA #IMPLIED
   condition CDATA #IMPLIED
 >
 
 <!ELEMENT customtokens (areacontainer|area|areascroll)*>
 <!ATTLIST customtokens
+  delay CDATA #IMPLIED
+  fadetime CDATA #IMPLIED
+  shifttime CDATA #IMPLIED
+  shifttype CDATA #IMPLIED
+  shiftmode CDATA #IMPLIED
+  startx CDATA #IMPLIED
+  starty CDATA #IMPLIED
   debug CDATA #IMPLIED
   condition CDATA #IMPLIED
 >

dtd/functions.dtd

@@ -90,8 +90,8 @@
 
 <!ELEMENT drawtextbox EMPTY>
 <!ATTLIST drawtextbox
-  x CDATA #REQUIRED
-  y CDATA #REQUIRED
+  x CDATA #IMPLIED
+  y CDATA #IMPLIED
   width CDATA #REQUIRED
   height CDATA #IMPLIED
   align (left|center|right) #IMPLIED
@@ -130,8 +130,8 @@
 
 <!ELEMENT drawrectangle EMPTY>
 <!ATTLIST drawrectangle
-  x CDATA #REQUIRED
-  y CDATA #REQUIRED
+  x CDATA #IMPLIED
+  y CDATA #IMPLIED
   width CDATA #IMPLIED
   height CDATA #IMPLIED
   align (left|center|right) #IMPLIED

extensions/cairoimage.c

@@ -1,5 +1,4 @@
 #include "cairoimage.h"
-#include "../libtemplate/templatefunction.h"
 
 cCairoImage::cCairoImage(void) {
     surface = NULL;
@@ -35,7 +34,7 @@ void cCairoImage::DrawTextVertical(string text, tColor color, string font, int s
     int x = size;
     int y = imgHeight;
     double rotate = 3*M_PI/2;
-    if (direction == diTopDown) {
+    if (direction == (int)eDirection::topdown) {
         rotate = M_PI/2;
         x = size*0.3;
         y = 0;

extensions/cairoimage.h

@@ -5,6 +5,7 @@
 #include <vdr/osd.h>
 #include <string>
 #include <sstream>
+#include "../coreengine/definitions.h"
 
 using namespace std;
 

extensions/fontmanager.c

@@ -7,38 +7,13 @@ using namespace std;
 
 cMutex cFontManager::mutex;
 
-cFontManager::cFontManager() {
+cFontManager::cFontManager(void) {
 }
 
-cFontManager::~cFontManager() {
+cFontManager::~cFontManager(void) {
     DeleteFonts();
 }
 
-void cFontManager::CacheFonts(cTemplate *tpl) {
-    cMutexLock MutexLock(&mutex);
-
-    vector< pair<string, int> > usedFonts = tpl->GetUsedFonts();
-
-    cStringList availableFonts;
-    cFont::GetAvailableFontNames(&availableFonts);
-
-    for (vector< pair<string, int> >::iterator ft = usedFonts.begin(); ft != usedFonts.end(); ft++) {
-        string fontName = ft->first;
-        int fontSize = ft->second;
-        if (fontSize < 1) {
-            continue;
-        }
-
-        int fontAvailable = availableFonts.Find(fontName.c_str());
-        if (fontAvailable == -1) {
-            esyslog("skindesigner: font %s not available, skipping", fontName.c_str());
-            continue;
-        }
-
-        InsertFont(fontName, fontSize);
-    }
-}
-
 void cFontManager::Debug(void) {
     dsyslog("skindesigner: fontmanager fonts available:");
     for (map < string, map< int, cFont* > >::iterator fts = fonts.begin(); fts != fonts.end(); fts++) {

extensions/fontmanager.h

@@ -6,8 +6,6 @@
 #include <vector>
 #include <vdr/skins.h>
 
-#include "../libtemplate/template.h"
-
 using namespace std;
 
 class cFontManager {
@@ -20,11 +18,10 @@ private:
     cFont *GetFont(string name, int size);
     int GetFontHeight(const char *name, int height, int charWidth = 0);
 public:
-    cFontManager();
-    ~cFontManager();
+    cFontManager(void);
+    ~cFontManager(void);
     void Lock(void) { mutex.Lock(); };
     void Unlock(void) { mutex.Unlock(); };
-    void CacheFonts(cTemplate *tpl);
     void DeleteFonts(void);
     int Width(string fontName, int fontSize, const char *text);
     int Height(string fontName, int fontSize);

extensions/helpers.c

@@ -51,35 +51,6 @@ int Minimum(int a, int b, int c, int d, int e, int f) {
     return min;
 }
 
-string CutText(string &text, int width, string fontName, int fontSize) {
-    if (width <= fontManager->Font(fontName, fontSize)->Size())
-        return text.c_str();
-    fontManager->Lock();
-    cTextWrapper twText;
-    twText.Set(text.c_str(), fontManager->Font(fontName, fontSize), width);
-    fontManager->Unlock();
-    string cuttedTextNative = twText.GetLine(0);
-    stringstream sstrText;
-    sstrText << cuttedTextNative << "...";
-    string cuttedText = sstrText.str();
-    int actWidth = fontManager->Width(fontName, fontSize, cuttedText.c_str());
-    if (actWidth > width) {
-        int overlap = actWidth - width;
-        int charWidth = fontManager->Width(fontName, fontSize, ".");
-        if (charWidth == 0)
-            charWidth = 1;
-        int cutChars = overlap / charWidth;
-        if (cutChars > 0) {
-            cuttedTextNative = cuttedTextNative.substr(0, cuttedTextNative.length() - cutChars);
-            stringstream sstrText2;
-            sstrText2 << cuttedTextNative << "...";
-            cuttedText = sstrText2.str();
-        }
-    }
-    return cuttedText;    
-}
-
-
 string StrToLowerCase(string str) {
     string lowerCase = str;
     const int length = lowerCase.length();
@@ -107,7 +78,7 @@ bool FileExists(const string &fullpath) {
         return true;
     }
     if (config.debugImageLoading) {
-        dsyslog("skindesigner: did not found %s", fullpath.c_str());
+        dsyslog("skindesigner: did not find %s", fullpath.c_str());
     }
     return false;
 }
@@ -120,7 +91,7 @@ bool FileExists(const string &path, const string &name, const string &ext) {
         return true;
     }
     if (config.debugImageLoading) {
-        dsyslog("skindesigner: did not found %s", fileName.str().c_str());
+        dsyslog("skindesigner: did not find %s", fileName.str().c_str());
     }
     return false; 
 }

extensions/helpers.h

@@ -1,6 +1,8 @@
 #ifndef __HELPERS_H
 #define __HELPERS_H
 
+#include <string>
+#include <algorithm>
 #include <vdr/osd.h>
 #include <vdr/plugin.h>
 #include "../config.h"
@@ -9,7 +11,6 @@ cPlugin *GetScraperPlugin(void);
 
 cSize ScaleToFit(int widthMax, int heightMax, int widthOriginal, int heightOriginal);
 int Minimum(int a, int b, int c, int d, int e, int f);
-std::string CutText(string &text, int width, string fontName, int fontSize);
 std::string StrToLowerCase(string str);
 bool isNumber(const string& s);
 bool IsToken(const string& token);

extensions/imagecache.c

@@ -59,6 +59,9 @@ void cImageCache::CacheLogo(int width, int height) {
     
     int logosCached = 0;     
 
+    if (config.numLogosMax && config.numLogosMax < (int)channelLogoCache.size())
+        return;
+
     for (const cChannel *channel = Channels.First(); channel; channel = Channels.Next(channel)) {
         if (logosCached >= config.numLogosPerSizeInitial)
             break;
@@ -77,6 +80,8 @@ void cImageCache::CacheLogo(int width, int height) {
             cImage *image = CreateImage(width, height);
             channelLogoCache.insert(pair<string, cImage*>(logoName.str(), image));
         }
+        if (config.numLogosMax && config.numLogosMax < (int)channelLogoCache.size())
+            return;
     }
 }
 
@@ -172,24 +177,34 @@ void cImageCache::CacheIcon(eImageType type, string name, int width, int height)
     GetIcon(type, name, width, height);
 }
 
-cImage *cImageCache::GetIcon(eImageType type, string name, int width, int height) {
+cCachedImage *cImageCache::GetIcon(eImageType type, string name, int width, int height) {
     if (width < 1 || width > 1920 || height < 1 || height > 1080)
         return NULL;
     cMutexLock MutexLock(&mutex);
     stringstream iconName;
     iconName << name << "_" << width << "x" << height;
-    map<string, cImage*>::iterator hit = iconCache.find(iconName.str());
+    map<string, cCachedImage*>::iterator hit = iconCache.find(iconName.str());
     if (hit != iconCache.end()) {
-        return (cImage*)hit->second;
+        return (cCachedImage*)hit->second;
     } else {
         bool success = LoadIcon(type, name);
         if (!success) 
             return NULL;
         cImage *image = CreateImage(width, height, true);
-        iconCache.insert(pair<string, cImage*>(iconName.str(), image));
+        cCachedImage *cachedImg = new cCachedImage();
+        cachedImg->size = image->Width() * image->Height() * sizeof(tColor);
+        int handle = cOsdProvider::StoreImage(*image);
+        if (handle) {
+            cachedImg->handle = handle;
+            delete image;
+        } else {
+            cachedImg->image = image;
+        }
+
+        iconCache.insert(pair<string, cCachedImage*>(iconName.str(), cachedImg));
         hit = iconCache.find(iconName.str());
         if (hit != iconCache.end()) {
-            return (cImage*)hit->second;
+            return (cCachedImage*)hit->second;
         }
     }
     return NULL;    
@@ -321,24 +336,33 @@ void cImageCache::CacheSkinpart(string name, int width, int height) {
     GetSkinpart(name, width, height);
 }
 
-cImage *cImageCache::GetSkinpart(string name, int width, int height) {
+cCachedImage *cImageCache::GetSkinpart(string name, int width, int height) {
     if (width < 1 || width > 1920 || height < 1 || height > 1080)
         return NULL;
     cMutexLock MutexLock(&mutex);
     stringstream iconName;
     iconName << name << "_" << width << "x" << height;
-    map<string, cImage*>::iterator hit = skinPartsCache.find(iconName.str());
+    map<string, cCachedImage*>::iterator hit = skinPartsCache.find(iconName.str());
     if (hit != skinPartsCache.end()) {
-        return (cImage*)hit->second;
+        return (cCachedImage*)hit->second;
     } else {
         bool success = LoadSkinpart(name);
         if (!success) 
             return NULL;
         cImage *image = CreateImage(width, height, false);
-        skinPartsCache.insert(pair<string, cImage*>(iconName.str(), image));
+        cCachedImage *cachedImg = new cCachedImage();
+        cachedImg->size = image->Width() * image->Height() * sizeof(tColor);
+        int handle = cOsdProvider::StoreImage(*image);
+        if (handle) {
+            cachedImg->handle = handle;
+            delete image;
+        } else {
+            cachedImg->image = image;
+        }
+        skinPartsCache.insert(pair<string, cCachedImage*>(iconName.str(), cachedImg));
         hit = skinPartsCache.find(iconName.str());
         if (hit != skinPartsCache.end()) {
-            return (cImage*)hit->second;
+            return (cCachedImage*)hit->second;
         }
     }
     return NULL;    
@@ -368,9 +392,9 @@ cImage *cImageCache::GetVerticalText(string text, tColor color, string font, int
 
 bool cImageCache::LoadIcon(eImageType type, string name) {
     cString subdir("");
-    if (type == itMenuIcon)
+    if (type == eImageType::menuicon)
         subdir = "menuicons";
-    else if (type == itIcon)
+    else if (type == eImageType::icon)
         subdir = "icons";
 
     //first check in theme specific icon path
@@ -452,8 +476,8 @@ bool cImageCache::LoadSkinpart(string name) {
 }
 
 void cImageCache::Clear(void) {
-    for(map<string, cImage*>::const_iterator it = iconCache.begin(); it != iconCache.end(); it++) {
-        cImage *img = (cImage*)it->second;
+    for(map<string, cCachedImage*>::const_iterator it = iconCache.begin(); it != iconCache.end(); it++) {
+        cCachedImage *img = (cCachedImage*)it->second;
         delete img;
     }
     iconCache.clear();
@@ -464,8 +488,8 @@ void cImageCache::Clear(void) {
     }
     channelLogoCache.clear();
 
-    for(map<string, cImage*>::const_iterator it = skinPartsCache.begin(); it != skinPartsCache.end(); it++) {
-        cImage *img = (cImage*)it->second;
+    for(map<string, cCachedImage*>::const_iterator it = skinPartsCache.begin(); it != skinPartsCache.end(); it++) {
+        cCachedImage *img = (cCachedImage*)it->second;
         delete img;
     }
     skinPartsCache.clear();
@@ -478,60 +502,78 @@ void cImageCache::Clear(void) {
 }
 
 void cImageCache::Debug(bool full) {
-    int sizeIconCache = 0;
+    float sizeIconCacheInternal = 0;
+    float sizeIconCacheExternal = 0;
     int numIcons = 0;
-    GetIconCacheSize(numIcons, sizeIconCache);
-    dsyslog("skindesigner: cached %d icons - size %d byte", numIcons, sizeIconCache);
+    GetIconCacheSize(numIcons, sizeIconCacheInternal, sizeIconCacheExternal);
+    dsyslog("skindesigner: cached %d icons - size internal mem %.2fMB, high level mem %.2fMB", numIcons, sizeIconCacheInternal, sizeIconCacheExternal);
     if (full) {
-        for(std::map<std::string, cImage*>::const_iterator it = iconCache.begin(); it != iconCache.end(); it++) {
+        for(std::map<std::string, cCachedImage*>::const_iterator it = iconCache.begin(); it != iconCache.end(); it++) {
             string name = it->first;
-            dsyslog("skindesigner: cached icon %s", name.c_str());
+            cCachedImage *img = (cCachedImage*)it->second;
+            dsyslog("skindesigner: cached icon %s, handle %d", name.c_str(), img->handle);
         }
     }
 
-    int sizeLogoCache = 0;
+    float sizeLogoCache = 0;
     int numLogos = 0;
     GetLogoCacheSize(numLogos, sizeLogoCache);
-    dsyslog("skindesigner: cached %d logos - size %d byte", numLogos, sizeLogoCache);
+    dsyslog("skindesigner: cached %d logos - size %.2fMB internal mem", numLogos, sizeLogoCache);
     if (full) {
         for(std::map<std::string, cImage*>::const_iterator it = channelLogoCache.begin(); it != channelLogoCache.end(); it++) {
             string name = it->first;
             dsyslog("skindesigner: cached logo %s", name.c_str());
         }
     }
-
-    int sizeSkinpartCache = 0;
+    float sizeSkinpartCacheInternal = 0;
+    float sizeSkinpartCacheExternal = 0;
     int numSkinparts = 0;
-    GetSkinpartsCacheSize(numSkinparts, sizeSkinpartCache);
-    dsyslog("skindesigner: cached %d skinparts - size %d byte", numSkinparts, sizeSkinpartCache);
+    GetSkinpartsCacheSize(numSkinparts, sizeSkinpartCacheInternal, sizeSkinpartCacheExternal);
+    dsyslog("skindesigner: cached %d skinparts - size internal mem %.2fMB, high level mem %.2fMB", numSkinparts, sizeSkinpartCacheInternal, sizeSkinpartCacheExternal);
     if (full) {
-        for(std::map<std::string, cImage*>::const_iterator it = skinPartsCache.begin(); it != skinPartsCache.end(); it++) {
+        for(std::map<std::string, cCachedImage*>::const_iterator it = skinPartsCache.begin(); it != skinPartsCache.end(); it++) {
             string name = it->first;
             dsyslog("skindesigner: cached skinpart %s", name.c_str());
         }
     }
 }
 
-void cImageCache::GetIconCacheSize(int &num, int &size) {
+void cImageCache::GetIconCacheSize(int &num, float &sizeInternal, float &sizeExternal) {
     num = iconCache.size();
-    for (map<string, cImage*>::iterator icon = iconCache.begin(); icon != iconCache.end(); icon++) {
-        cImage* img = icon->second;
-        size += img->Width() * img->Height() * sizeof(tColor);
+    int sizeByteInternal = 0;
+    int sizeByteExternal = 0;
+    for (map<string, cCachedImage*>::iterator icon = iconCache.begin(); icon != iconCache.end(); icon++) {
+        cCachedImage* img = icon->second;
+        if (img->image)
+            sizeByteInternal += img->size;
+        else
+            sizeByteExternal += img->size;
     }
+    sizeInternal = sizeByteInternal / 1024.0f / 1024.0f;
+    sizeExternal = sizeByteExternal / 1024.0f / 1024.0f;
 }
 
-void cImageCache::GetLogoCacheSize(int &num, int &size) {
+void cImageCache::GetLogoCacheSize(int &num, float &size) {
     num = channelLogoCache.size();
+    int sizeByte = 0;
     for (map<string, cImage*>::iterator logo = channelLogoCache.begin(); logo != channelLogoCache.end(); logo++) {
         cImage* img = logo->second;
-        size += img->Width() * img->Height() * sizeof(tColor);
+        sizeByte += img->Width() * img->Height() * sizeof(tColor);
     }
+    size = sizeByte / 1024.0f;
 }
 
-void cImageCache::GetSkinpartsCacheSize(int &num, int &size) {
+void cImageCache::GetSkinpartsCacheSize(int &num, float &sizeInternal, float &sizeExternal) {
     num = skinPartsCache.size();
-    for (map<string, cImage*>::iterator skinpart = skinPartsCache.begin(); skinpart != skinPartsCache.end(); skinpart++) {
-        cImage* img = skinpart->second;
-        size += img->Width() * img->Height() * sizeof(tColor);
+    int sizeByteInternal = 0;
+    int sizeByteExternal = 0;
+    for (map<string, cCachedImage*>::iterator skinpart = skinPartsCache.begin(); skinpart != skinPartsCache.end(); skinpart++) {
+        cCachedImage* img = skinpart->second;
+        if (img->image)
+            sizeByteInternal += img->size;
+        else
+            sizeByteExternal += img->size;
     }
+    sizeInternal = sizeByteInternal / 1024.0f / 1024.0f;
+    sizeExternal = sizeByteExternal / 1024.0f / 1024.0f;
 }

extensions/imagecache.h

@@ -7,7 +7,25 @@
 #include <vdr/skins.h>
 #include <vector>
 #include "imageloader.h"
-#include "../libtemplate/templatefunction.h"
+#include "../coreengine/definitions.h"
+
+class cCachedImage {
+public:
+    int handle;
+    cImage *image;
+    int size;
+    cCachedImage(void) {
+        handle = 0;
+        image = NULL;
+        size = 0;
+    };
+    ~cCachedImage(void) {
+        if (handle)
+            cOsdProvider::DropImage(handle);
+        if (image)
+            delete image;
+    };
+};
 
 class cImageCache : public cImageLoader {
 public:
@@ -24,20 +42,20 @@ public:
     bool SeparatorLogoExists(string name);
     //icons
     void CacheIcon(eImageType type, string path, int width, int height);
-    cImage *GetIcon(eImageType type, string name, int width, int height);
+    cCachedImage *GetIcon(eImageType type, string name, int width, int height);
     string GetIconName(string label, eMenuCategory cat = mcUndefined, string plugName = "");
     bool MenuIconExists(string name);
     //skinparts
     void CacheSkinpart(string path, int width, int height);
-    cImage *GetSkinpart(string name, int width, int height);
+    cCachedImage *GetSkinpart(string name, int width, int height);
     //cairo special images
     cImage *GetVerticalText(string text, tColor color, string font, int size, int direction);
     //helpers
     void Clear(void);
     void Debug(bool full);
-    void GetIconCacheSize(int &num, int &size);
-    void GetLogoCacheSize(int &num, int &size);
-    void GetSkinpartsCacheSize(int &num, int &size);
+    void GetIconCacheSize(int &num, float &sizeInternal, float &sizeExternal);
+    void GetLogoCacheSize(int &num, float &size);
+    void GetSkinpartsCacheSize(int &num, float &sizeInternal, float &sizeExternal);
 private:
     static cMutex mutex;
     static string items[16];
@@ -48,9 +66,9 @@ private:
     string iconPathTheme;
     string skinPartsPathTheme;
     string svgTemplatePath;
-    map<string, cImage*> iconCache;
+    map<string, cCachedImage*> iconCache;
     map<string, cImage*> channelLogoCache;
-    map<string, cImage*> skinPartsCache;
+    map<string, cCachedImage*> skinPartsCache;
     map<string, cImage*> cairoImageCache;
     bool LoadIcon(eImageType type, string name);
     bool LoadLogo(const cChannel *channel);

extensions/libxmlwrapper.c

@@ -1,4 +1,4 @@
-#include "../libcore/helpers.h"
+#include "helpers.h"
 #include "libxmlwrapper.h"
 
 void SkinDesignerXMLErrorHandler (void * userData, xmlErrorPtr error) {

extensions/libxmlwrapper.h

@@ -5,6 +5,7 @@
 #include <vector>
 #include <map>
 #include <set>
+#include <utility>
 #include <stack>
 #include <libxml/parser.h>
 #include <libxml/tree.h>
@@ -12,8 +13,8 @@
 #include <vdr/plugin.h>
 
 using namespace std;
-
-#include "../views/viewhelpers.h"
+typedef pair<string,string> stringpair;
+typedef map<string,string> stringmap;
 
 class cLibXMLWrapper {
 private:

extensions/pluginmanager.c

@@ -0,0 +1,301 @@
+#include "pluginmanager.h"
+
+cSDPluginManager::cSDPluginManager(void) {
+    lastId = 0;
+    subviewsfound = false;
+}
+
+cSDPluginManager::~cSDPluginManager(void) {
+}
+
+void cSDPluginManager::Reset(void) {
+    subViewMapping.clear();
+}
+
+void cSDPluginManager::RegisterBasicPlugin(skindesignerapi::cPluginStructure *plugStructure) {
+    dsyslog("skindesigner: plugin %s uses libskindesigner API Version %s", 
+                                                            plugStructure->name.c_str(), 
+                                                            plugStructure->libskindesignerAPIVersion.c_str());
+    plugStructure->id = lastId;
+    registeredPlugins.insert(pair<int,string>(lastId, plugStructure->name));
+    lastId++;
+    map< int, skindesignerapi::sPlugMenu > menusNew;
+    for (map< int, skindesignerapi::sPlugMenu >::iterator it = plugStructure->menus.begin(); it != plugStructure->menus.end(); it++) {
+        int key = it->first;
+        skindesignerapi::sPlugMenu menu = it->second;
+        skindesignerapi::sPlugMenu menuNew;
+        menuNew.type = menu.type;
+        menuNew.tplname = menu.tplname;
+        menuNew.tokenContainer = new skindesignerapi::cTokenContainer(*menu.tokenContainer);
+        menusNew.insert(pair<int, skindesignerapi::sPlugMenu>(key, menuNew));
+    }
+    pluginMenus.insert(pair< int, map < int, skindesignerapi::sPlugMenu > >(plugStructure->id, menusNew));
+
+    if (plugStructure->menus.size() > 0)
+        dsyslog("skindesigner: plugin %s has registered %ld menus", plugStructure->name.c_str(), plugStructure->menus.size());
+
+}
+
+int cSDPluginManager::GetNumPluginMenus(void) {
+    int numMenusTotal = 0;
+    for (map < int, map < int, skindesignerapi::sPlugMenu > >::iterator it = pluginMenus.begin(); it != pluginMenus.end(); it++) {
+        numMenusTotal += (it->second).size();
+    }
+    return numMenusTotal;
+}
+
+void cSDPluginManager::InitPluginMenuIterator(void) {
+    plugMenuIt = pluginMenus.begin();
+}
+
+map <int,skindesignerapi::sPlugMenu> *cSDPluginManager::GetPluginMenus(string &name, int &id) {
+    if (plugMenuIt == pluginMenus.end())
+        return NULL;
+    id = plugMenuIt->first;
+    map<int,string>::iterator hit = registeredPlugins.find(id);
+    if (hit != registeredPlugins.end())
+        name = hit->second; 
+    map <int,skindesignerapi::sPlugMenu> *templates = &plugMenuIt->second;
+    plugMenuIt++;
+    return templates; 
+}
+
+skindesignerapi::cTokenContainer *cSDPluginManager::GetTokenContainer(int plugId, int plugMenuId) {
+    map <int, map<int, skindesignerapi::sPlugMenu> >::iterator hit = pluginMenus.find(plugId);
+    if (hit == pluginMenus.end())
+        return NULL;
+    map<int, skindesignerapi::sPlugMenu>::iterator hit2 = (hit->second).find(plugMenuId);
+    if (hit2 == (hit->second).end())
+        return NULL;
+    skindesignerapi::cTokenContainer *tk = hit2->second.tokenContainer;
+    return tk;    
+}
+
+void cSDPluginManager::AddSubviewMapping(int plugId, int plugMenuId, int subViewId) {
+    map <int, map<int,int> >::iterator hit = subViewMapping.find(plugId);
+    if (hit == subViewMapping.end()) {
+        map<int,int> menus;
+        menus.insert(pair<int,int>(plugMenuId, subViewId));
+        subViewMapping.insert(pair<int, map<int,int> >(plugId, menus));
+    } else {
+        (hit->second).insert(pair<int,int>(plugMenuId, subViewId));
+    }
+}
+
+int cSDPluginManager::GetSubviewId(int plugId, int plugMenuId) {
+    map <int, map<int,int> >::iterator hit = subViewMapping.find(plugId);
+    if (hit == subViewMapping.end())
+        return -1;
+    map<int,int>::iterator hit2 = (hit->second).find(plugMenuId);
+    if (hit2 == (hit->second).end())
+        return -1;
+    return hit2->second;
+}
+
+void cSDPluginManager::RegisterAdvancedPlugin(skindesignerapi::cPluginStructure *plugStructure) {
+    dsyslog("skindesigner: plugin %s uses libskindesigner API Version %s", 
+                                                            plugStructure->name.c_str(), 
+                                                            plugStructure->libskindesignerAPIVersion.c_str());
+    plugStructure->id = lastId;
+    registeredPlugins.insert(pair<int,string>(lastId, plugStructure->name));
+    lastId++;
+
+    rootviews.insert(pair<int,string>(plugStructure->id, plugStructure->rootview));
+    subviews.insert(pair<int,map<int,string> >(plugStructure->id, plugStructure->subviews));
+
+    multimap< int, skindesignerapi::sPlugViewElement > viewelementsNew;
+    for (map< int, skindesignerapi::sPlugViewElement >::iterator it = plugStructure->viewelements.begin(); it != plugStructure->viewelements.end(); it++) {
+        int key = it->first;
+        skindesignerapi::sPlugViewElement ve = it->second;
+        skindesignerapi::sPlugViewElement veNew;
+        veNew.id = ve.id;
+        veNew.viewId = ve.viewId;
+        veNew.name = ve.name;        
+        veNew.tokenContainer = new skindesignerapi::cTokenContainer(*ve.tokenContainer);
+        viewelementsNew.insert(pair<int, skindesignerapi::sPlugViewElement>(key, veNew));
+    }
+    viewelements.insert(pair< int, multimap < int, skindesignerapi::sPlugViewElement > >(plugStructure->id, viewelementsNew));
+
+    multimap< int, skindesignerapi::sPlugViewGrid > viewgridsNew;
+    for (map< int, skindesignerapi::sPlugViewGrid >::iterator it = plugStructure->viewgrids.begin(); it != plugStructure->viewgrids.end(); it++) {
+        int key = it->first;
+        skindesignerapi::sPlugViewGrid vg = it->second;
+        skindesignerapi::sPlugViewGrid vgNew;
+        vgNew.id = vg.id;
+        vgNew.viewId = vg.viewId;
+        vgNew.name = vg.name;        
+        vgNew.tokenContainer = new skindesignerapi::cTokenContainer(*vg.tokenContainer);
+        viewgridsNew.insert(pair<int, skindesignerapi::sPlugViewGrid>(key, vgNew));
+    }
+    viewgrids.insert(pair< int, multimap < int, skindesignerapi::sPlugViewGrid > >(plugStructure->id, viewgridsNew));
+
+    map< int, skindesignerapi::cTokenContainer* > viewtabsNew;
+    for (map<int,skindesignerapi::cTokenContainer*>::iterator it = plugStructure->viewtabs.begin(); it != plugStructure->viewtabs.end(); it++) {
+        int id = it->first;
+        skindesignerapi::cTokenContainer *tk = it->second;
+        viewtabsNew.insert(pair<int,skindesignerapi::cTokenContainer*>(id, new skindesignerapi::cTokenContainer(*tk)));
+    }
+    viewtabs.insert(pair< int, map<int,skindesignerapi::cTokenContainer*> >(plugStructure->id, viewtabsNew));
+
+    if (plugStructure->rootview.size() > 0)
+        dsyslog("skindesigner: plugin %s has registered %ld views with %ld viewelements and %ld viewgrids", 
+                 plugStructure->name.c_str(), 
+                 1 + plugStructure->subviews.size(),
+                 plugStructure->viewelements.size(),
+                 plugStructure->viewgrids.size());
+}
+
+void cSDPluginManager::InitPluginViewIterator(void) {
+    rootViewsIt = rootviews.begin();
+}
+
+bool cSDPluginManager::GetNextPluginView(string &plugName, int &plugId, string &tplName) {
+    if (rootViewsIt == rootviews.end())
+        return false;
+    plugId = rootViewsIt->first;
+    tplName = rootViewsIt->second;
+    map<int,string>::iterator hit = registeredPlugins.find(plugId);
+    if (hit != registeredPlugins.end())
+        plugName = hit->second; 
+    rootViewsIt++;
+    return true; 
+} 
+
+int cSDPluginManager::GetNumSubviews(int plugId) {
+    map< int, map< int, string > >::iterator hit = subviews.find(plugId);
+    if (hit == subviews.end())
+        return 0;
+    return (hit->second).size();
+}
+
+void cSDPluginManager::InitPluginSubviewIterator(int plugId) {
+    map< int, map< int, string > >::iterator hit = subviews.find(plugId);
+    if (hit == subviews.end()) {
+        subviewsfound = false;
+        return;
+    }
+    subviewsCurrent = hit->second;
+    subviewsfound = true;
+    svIt = subviewsCurrent.begin();
+}
+
+bool cSDPluginManager::GetNextSubView(int &id, string &tplname) {
+    if (!subviewsfound)
+        return false;
+    if( svIt == subviewsCurrent.end() ) {
+        return false;    
+    }
+    id = svIt->first;
+    tplname = svIt->second;
+    svIt++;
+    return true;
+}
+
+int cSDPluginManager::GetNumViewElements(int plugId, int viewId) {
+    map< int, multimap< int, skindesignerapi::sPlugViewElement > >::iterator hit = viewelements.find(plugId);
+    if (hit == viewelements.end())
+        return 0;
+    multimap<int, skindesignerapi::sPlugViewElement> *plugVEs = &hit->second;
+    pair<multimap<int, skindesignerapi::sPlugViewElement>::iterator, multimap<int, skindesignerapi::sPlugViewElement>::iterator> range;
+    range = plugVEs->equal_range(viewId);
+    int numVEs = 0;
+    for (multimap<int, skindesignerapi::sPlugViewElement>::iterator it=range.first; it!=range.second; ++it) {
+        numVEs++;
+    }
+    return numVEs;
+}
+
+void cSDPluginManager::InitViewElementIterator(int plugId, int viewId) {
+    map< int, multimap< int, skindesignerapi::sPlugViewElement > >::iterator hit = viewelements.find(plugId);
+    if (hit == viewelements.end())
+        return;
+    multimap<int, skindesignerapi::sPlugViewElement> *plugVEs = &hit->second;
+    veRange = plugVEs->equal_range(viewId);
+    veIt = veRange.first;
+}
+
+bool cSDPluginManager::GetNextViewElement(int &veId, string &veName) {
+    if (veIt == veRange.second)
+        return false;
+    skindesignerapi::sPlugViewElement *ve = &veIt->second;
+    veId = ve->id;
+    veName = ve->name;
+    veIt++;
+    return true;
+}
+
+skindesignerapi::cTokenContainer *cSDPluginManager::GetTokenContainerVE(int plugId, int viewId, int veId) {
+    map< int, multimap< int, skindesignerapi::sPlugViewElement > >::iterator hit = viewelements.find(plugId);
+    if (hit == viewelements.end())
+        return NULL;
+    multimap<int, skindesignerapi::sPlugViewElement> *plugVEs = &hit->second;
+    for (multimap<int, skindesignerapi::sPlugViewElement>::iterator it = plugVEs->begin(); it != plugVEs->end(); it++) {
+        int view = it->first;
+        if (view != viewId)
+            continue;
+        skindesignerapi::sPlugViewElement *ve = &it->second;
+        if (ve->id == veId)
+            return ve->tokenContainer;
+    }
+    return NULL;
+}
+
+int cSDPluginManager::GetNumViewGrids(int plugId, int viewId) {
+    map< int, multimap< int, skindesignerapi::sPlugViewGrid > >::iterator hit = viewgrids.find(plugId);
+    if (hit == viewgrids.end())
+        return 0;
+    multimap<int, skindesignerapi::sPlugViewGrid> *plugVGs = &hit->second;
+    pair<multimap<int, skindesignerapi::sPlugViewGrid>::iterator, multimap<int, skindesignerapi::sPlugViewGrid>::iterator> range;
+    range = plugVGs->equal_range(viewId);
+    int numVGs = 0;
+    for (multimap<int, skindesignerapi::sPlugViewGrid>::iterator it=range.first; it!=range.second; ++it) {
+        numVGs++;
+    }
+    return numVGs;
+}
+
+void cSDPluginManager::InitViewGridIterator(int plugId, int viewId) {
+    map< int, multimap< int, skindesignerapi::sPlugViewGrid > >::iterator hit = viewgrids.find(plugId);
+    if (hit == viewgrids.end())
+        return;
+    multimap<int, skindesignerapi::sPlugViewGrid> *plugGEs = &hit->second;
+    gRange = plugGEs->equal_range(viewId);
+    gIt = gRange.first;
+}
+
+bool cSDPluginManager::GetNextViewGrid(int &gId, string &gName) {
+    if (gIt == gRange.second)
+        return false;
+    skindesignerapi::sPlugViewGrid *ge = &gIt->second;
+    gId = ge->id;
+    gName = ge->name;
+    gIt++;
+    return true;
+}
+
+skindesignerapi::cTokenContainer *cSDPluginManager::GetTokenContainerGE(int plugId, int viewId, int gId) {
+    map< int, multimap< int, skindesignerapi::sPlugViewGrid > >::iterator hit = viewgrids.find(plugId);
+    if (hit == viewgrids.end())
+        return NULL;
+    multimap<int, skindesignerapi::sPlugViewGrid> *plugGEs = &hit->second;
+    for (multimap<int, skindesignerapi::sPlugViewGrid>::iterator it = plugGEs->begin(); it != plugGEs->end(); it++) {
+        int view = it->first;
+        if (view != viewId)
+            continue;
+        skindesignerapi::sPlugViewGrid *g = &it->second;
+        if (g->id == gId)
+            return g->tokenContainer;
+    }
+    return NULL;
+}
+
+skindesignerapi::cTokenContainer *cSDPluginManager::GetTokenContainerTab(int plugId, int viewId) {
+    map< int, map< int, skindesignerapi::cTokenContainer* > >::iterator hit = viewtabs.find(plugId);
+    if (hit == viewtabs.end())
+        return NULL;
+    map< int, skindesignerapi::cTokenContainer* > *tabs = &hit->second;
+    map< int, skindesignerapi::cTokenContainer* >::iterator hit2 = tabs->find(viewId);
+    if (hit2 == tabs->end())
+        return NULL;
+    return (hit2->second);
+}