adaptions skindesigner 0.8.00.2.0

1 files changed, 521 insertions, 376 deletions

diff --git a/detailview.c b/detailview.c
index ad8a7b1..24c2e79 100644
--- a/detailview.c
+++ b/detailview.c
@@ -1,19 +1,19 @@
 #include "helpers.h"

 #include "tvguidengosd.h"

 #include "detailview.h"

-#include "services/scraper2vdr.h"

-#include "services/epgsearch.h"

 

 cDetailView::cDetailView(skindesignerapi::cOsdView *detailView, const cEvent *event) {

     init = true;

     lastSecond = -1;

     this->detailView = detailView;

     this->event = event;

-    back = detailView->GetViewElement(vedBackground);

-    header = detailView->GetViewElement(vedHeader);

-    footer = detailView->GetViewElement(vedFooter);

-    watch = detailView->GetViewElement(vedTime);

+    back = detailView->GetViewElement((int)eViewElementsDetail::background);

+    header = detailView->GetViewElement((int)eViewElementsDetail::header);

+    footer = detailView->GetViewElement((int)eViewElementsDetail::footer);

+    watch = detailView->GetViewElement((int)eViewElementsDetail::time);

     tabs = detailView->GetViewTabs();

+    movie = NULL;

+    series = NULL;

 }

 

 cDetailView::~cDetailView() {

@@ -21,7 +21,10 @@ cDetailView::~cDetailView() {
     delete header;

     delete footer;

     delete watch;

+    delete tabs;

     delete detailView;

+    delete movie;

+    delete series;

 }

 

 void cDetailView::Draw(void) {

@@ -60,6 +63,192 @@ void cDetailView::Down(void) {
     tabs->Display();

 }

 

+void cDetailView::DefineTokens(eViewElementsDetail ve, skindesignerapi::cTokenContainer *tk) {

+    switch (ve) {

+        case eViewElementsDetail::header:

+            tk->DefineIntToken("{ismovie}", (int)eScraperHeaderIT::ismovie);

+            tk->DefineIntToken("{isseries}", (int)eScraperHeaderIT::isseries);

+            tk->DefineIntToken("{posteravailable}", (int)eScraperHeaderIT::posteravailable);

+            tk->DefineIntToken("{posterwidth}", (int)eScraperHeaderIT::posterwidth);

+            tk->DefineIntToken("{posterheight}", (int)eScraperHeaderIT::posterheight);

+            tk->DefineIntToken("{banneravailable}", (int)eScraperHeaderIT::banneravailable);

+            tk->DefineIntToken("{bannerwidth}", (int)eScraperHeaderIT::bannerwidth);

+            tk->DefineIntToken("{bannerheight}", (int)eScraperHeaderIT::bannerheight);

+            tk->DefineIntToken("{daynumeric}", (int)eDetailedHeaderIT::daynumeric);

+            tk->DefineIntToken("{month}", (int)eDetailedHeaderIT::month);

+            tk->DefineIntToken("{year}", (int)eDetailedHeaderIT::year);

+            tk->DefineIntToken("{running}", (int)eDetailedHeaderIT::running);

+            tk->DefineIntToken("{elapsed}", (int)eDetailedHeaderIT::elapsed);

+            tk->DefineIntToken("{duration}", (int)eDetailedHeaderIT::duration);

+            tk->DefineIntToken("{durationhours}", (int)eDetailedHeaderIT::durationhours);

+            tk->DefineIntToken("{channelnumber}", (int)eDetailedHeaderIT::channelnumber);

+            tk->DefineIntToken("{channellogoexists}", (int)eDetailedHeaderIT::channellogoexists);

+            tk->DefineIntToken("{epgpicavailable}", (int)eDetailedHeaderIT::epgpicavailable);

+            tk->DefineStringToken("{posterpath}", (int)eScraperHeaderST::posterpath);

+            tk->DefineStringToken("{bannerpath}", (int)eScraperHeaderST::bannerpath);

+            tk->DefineStringToken("{title}", (int)eDetailedHeaderST::title);

+            tk->DefineStringToken("{shorttext}", (int)eDetailedHeaderST::shorttext);

+            tk->DefineStringToken("{start}", (int)eDetailedHeaderST::start);

+            tk->DefineStringToken("{stop}", (int)eDetailedHeaderST::stop);

+            tk->DefineStringToken("{day}", (int)eDetailedHeaderST::day);

+            tk->DefineStringToken("{date}", (int)eDetailedHeaderST::date);

+            tk->DefineStringToken("{durationminutes}", (int)eDetailedHeaderST::durationminutes);

+            tk->DefineStringToken("{vps}", (int)eDetailedHeaderST::vps);

+            tk->DefineStringToken("{channelname}", (int)eDetailedHeaderST::channelname);

+            tk->DefineStringToken("{channelid}", (int)eDetailedHeaderST::channelid);

+            tk->DefineStringToken("{epgpicpath}", (int)eDetailedHeaderST::epgpicpath);

+            break;

+        case eViewElementsDetail::footer:

+            tk->DefineIntToken("{red1}", (int)eFooterIT::red1);

+            tk->DefineIntToken("{red2}", (int)eFooterIT::red2);

+            tk->DefineIntToken("{red3}", (int)eFooterIT::red3);

+            tk->DefineIntToken("{red4}", (int)eFooterIT::red4);

+            tk->DefineIntToken("{green1}", (int)eFooterIT::green1);

+            tk->DefineIntToken("{green2}", (int)eFooterIT::green2);

+            tk->DefineIntToken("{green3}", (int)eFooterIT::green3);

+            tk->DefineIntToken("{green4}", (int)eFooterIT::green4);

+            tk->DefineIntToken("{yellow1}", (int)eFooterIT::yellow1);

+            tk->DefineIntToken("{yellow2}", (int)eFooterIT::yellow2);

+            tk->DefineIntToken("{yellow3}", (int)eFooterIT::yellow3);

+            tk->DefineIntToken("{yellow4}", (int)eFooterIT::yellow4);

+            tk->DefineIntToken("{blue1}", (int)eFooterIT::blue1);

+            tk->DefineIntToken("{blue2}", (int)eFooterIT::blue2);

+            tk->DefineIntToken("{blue3}", (int)eFooterIT::blue3);

+            tk->DefineIntToken("{blue4}", (int)eFooterIT::blue4);

+            tk->DefineStringToken("{red}", (int)eFooterST::red);

+            tk->DefineStringToken("{green}", (int)eFooterST::green);

+            tk->DefineStringToken("{yellow}", (int)eFooterST::yellow);

+            tk->DefineStringToken("{blue}", (int)eFooterST::blue);

+            break;

+        default:

+            break;

+    }

+}

+

+void cDetailView::DefineTabTokens(skindesignerapi::cTokenContainer *tk) {

+    tk->DefineStringToken("{title}", (int)eDetailedEpgST::title);

+    tk->DefineStringToken("{shorttext}", (int)eDetailedEpgST::shorttext);

+    tk->DefineStringToken("{description}", (int)eDetailedEpgST::description);

+    tk->DefineStringToken("{start}", (int)eDetailedEpgST::start);

+    tk->DefineStringToken("{stop}", (int)eDetailedEpgST::stop);

+    tk->DefineStringToken("{day}", (int)eDetailedEpgST::day);

+    tk->DefineStringToken("{date}", (int)eDetailedEpgST::date);

+    tk->DefineStringToken("{durationminutes}", (int)eDetailedEpgST::durationminutes);

+    tk->DefineStringToken("{vps}", (int)eDetailedEpgST::vps);

+    tk->DefineStringToken("{channelname}", (int)eDetailedEpgST::channelname);

+    tk->DefineStringToken("{channelid}", (int)eDetailedEpgST::channelid);

+    tk->DefineStringToken("{epgpic1path}", (int)eDetailedEpgST::epgpic1path);

+    tk->DefineStringToken("{epgpic2path}", (int)eDetailedEpgST::epgpic2path);

+    tk->DefineStringToken("{epgpic3path}", (int)eDetailedEpgST::epgpic3path);

+    tk->DefineStringToken("{movietitle}", (int)eScraperST::movietitle);

+    tk->DefineStringToken("{movieoriginalTitle}", (int)eScraperST::movieoriginalTitle);

+    tk->DefineStringToken("{movietagline}", (int)eScraperST::movietagline);

+    tk->DefineStringToken("{movieoverview}", (int)eScraperST::movieoverview);

+    tk->DefineStringToken("{moviegenres}", (int)eScraperST::moviegenres);

+    tk->DefineStringToken("{moviehomepage}", (int)eScraperST::moviehomepage);

+    tk->DefineStringToken("{moviereleasedate}", (int)eScraperST::moviereleasedate);

+    tk->DefineStringToken("{moviepopularity}", (int)eScraperST::moviepopularity);

+    tk->DefineStringToken("{movievoteaverage}", (int)eScraperST::movievoteaverage);

+    tk->DefineStringToken("{posterpath}", (int)eScraperST::posterpath);

+    tk->DefineStringToken("{fanartpath}", (int)eScraperST::fanartpath);

+    tk->DefineStringToken("{moviecollectionName}", (int)eScraperST::moviecollectionName);

+    tk->DefineStringToken("{collectionposterpath}", (int)eScraperST::collectionposterpath);

+    tk->DefineStringToken("{collectionfanartpath}", (int)eScraperST::collectionfanartpath);

+    tk->DefineStringToken("{seriesname}", (int)eScraperST::seriesname);

+    tk->DefineStringToken("{seriesoverview}", (int)eScraperST::seriesoverview);

+    tk->DefineStringToken("{seriesfirstaired}", (int)eScraperST::seriesfirstaired);

+    tk->DefineStringToken("{seriesnetwork}", (int)eScraperST::seriesnetwork);

+    tk->DefineStringToken("{seriesgenre}", (int)eScraperST::seriesgenre);

+    tk->DefineStringToken("{seriesrating}", (int)eScraperST::seriesrating);

+    tk->DefineStringToken("{seriesstatus}", (int)eScraperST::seriesstatus);

+    tk->DefineStringToken("{episodetitle}", (int)eScraperST::episodetitle);

+    tk->DefineStringToken("{episodefirstaired}", (int)eScraperST::episodefirstaired);

+    tk->DefineStringToken("{episodegueststars}", (int)eScraperST::episodegueststars);

+    tk->DefineStringToken("{episodeoverview}", (int)eScraperST::episodeoverview);

+    tk->DefineStringToken("{episoderating}", (int)eScraperST::episoderating);

+    tk->DefineStringToken("{episodeimagepath}", (int)eScraperST::episodeimagepath);

+    tk->DefineStringToken("{seasonposterpath}", (int)eScraperST::seasonposterpath);

+    tk->DefineStringToken("{seriesposter1path}", (int)eScraperST::seriesposter1path);

+    tk->DefineStringToken("{seriesposter2path}", (int)eScraperST::seriesposter2path);

+    tk->DefineStringToken("{seriesposter3path}", (int)eScraperST::seriesposter3path);

+    tk->DefineStringToken("{seriesfanart1path}", (int)eScraperST::seriesfanart1path);

+    tk->DefineStringToken("{seriesfanart2path}", (int)eScraperST::seriesfanart2path);

+    tk->DefineStringToken("{seriesfanart3path}", (int)eScraperST::seriesfanart3path);

+    tk->DefineStringToken("{seriesbanner1path}", (int)eScraperST::seriesbanner1path);

+    tk->DefineStringToken("{seriesbanner2path}", (int)eScraperST::seriesbanner2path);

+    tk->DefineStringToken("{seriesbanner3path}", (int)eScraperST::seriesbanner3path);

+    tk->DefineIntToken("{daynumeric}", (int)eDetailedEpgIT::daynumeric);

+    tk->DefineIntToken("{month}", (int)eDetailedEpgIT::month);

+    tk->DefineIntToken("{year}", (int)eDetailedEpgIT::year);

+    tk->DefineIntToken("{running}", (int)eDetailedEpgIT::running);

+    tk->DefineIntToken("{elapsed}", (int)eDetailedEpgIT::elapsed);

+    tk->DefineIntToken("{duration}", (int)eDetailedEpgIT::duration);

+    tk->DefineIntToken("{durationhours}", (int)eDetailedEpgIT::durationhours);

+    tk->DefineIntToken("{channelnumber}", (int)eDetailedEpgIT::channelnumber);

+    tk->DefineIntToken("{channellogoexists}", (int)eDetailedEpgIT::channellogoexists);

+    tk->DefineIntToken("{hasreruns}", (int)eDetailedEpgIT::hasreruns);

+    tk->DefineIntToken("{epgpic1avaialble}", (int)eDetailedEpgIT::epgpic1avaialble);

+    tk->DefineIntToken("{epgpic2avaialble}", (int)eDetailedEpgIT::epgpic2avaialble);

+    tk->DefineIntToken("{epgpic3avaialble}", (int)eDetailedEpgIT::epgpic3avaialble);

+    tk->DefineIntToken("{ismovie}", (int)eScraperIT::ismovie);

+    tk->DefineIntToken("{moviebudget}", (int)eScraperIT::moviebudget);

+    tk->DefineIntToken("{movierevenue}", (int)eScraperIT::movierevenue);

+    tk->DefineIntToken("{movieadult}", (int)eScraperIT::movieadult);

+    tk->DefineIntToken("{movieruntime}", (int)eScraperIT::movieruntime);

+    tk->DefineIntToken("{isseries}", (int)eScraperIT::isseries);

+    tk->DefineIntToken("{posterwidth}", (int)eScraperIT::posterwidth);

+    tk->DefineIntToken("{posterheight}", (int)eScraperIT::posterheight);

+    tk->DefineIntToken("{fanartwidth}", (int)eScraperIT::fanartwidth);

+    tk->DefineIntToken("{fanartheight}", (int)eScraperIT::fanartheight);

+    tk->DefineIntToken("{movieiscollection}", (int)eScraperIT::movieiscollection);

+    tk->DefineIntToken("{collectionposterwidth}", (int)eScraperIT::collectionposterwidth);

+    tk->DefineIntToken("{collectionposterheight}", (int)eScraperIT::collectionposterheight);

+    tk->DefineIntToken("{collectionfanartwidth}", (int)eScraperIT::collectionfanartwidth);

+    tk->DefineIntToken("{collectionfanartheight}", (int)eScraperIT::collectionfanartheight);

+    tk->DefineIntToken("{epgpicavailable}", (int)eScraperIT::epgpicavailable);

+    tk->DefineIntToken("{episodenumber}", (int)eScraperIT::episodenumber);

+    tk->DefineIntToken("{episodeseason}", (int)eScraperIT::episodeseason);

+    tk->DefineIntToken("{episodeimagewidth}", (int)eScraperIT::episodeimagewidth);

+    tk->DefineIntToken("{episodeimageheight}", (int)eScraperIT::episodeimageheight);

+    tk->DefineIntToken("{seasonposterwidth}", (int)eScraperIT::seasonposterwidth);

+    tk->DefineIntToken("{seasonposterheight}", (int)eScraperIT::seasonposterheight);

+    tk->DefineIntToken("{seriesposter1width}", (int)eScraperIT::seriesposter1width);

+    tk->DefineIntToken("{seriesposter1height}", (int)eScraperIT::seriesposter1height);

+    tk->DefineIntToken("{seriesposter2width}", (int)eScraperIT::seriesposter2width);

+    tk->DefineIntToken("{seriesposter2height}", (int)eScraperIT::seriesposter2height);

+    tk->DefineIntToken("{seriesposter3width}", (int)eScraperIT::seriesposter3width);

+    tk->DefineIntToken("{seriesposter3height}", (int)eScraperIT::seriesposter3height);

+    tk->DefineIntToken("{seriesfanart1width}", (int)eScraperIT::seriesfanart1width);

+    tk->DefineIntToken("{seriesfanart1height}", (int)eScraperIT::seriesfanart1height);

+    tk->DefineIntToken("{seriesfanart2width}", (int)eScraperIT::seriesfanart2width);

+    tk->DefineIntToken("{seriesfanart2height}", (int)eScraperIT::seriesfanart2height);

+    tk->DefineIntToken("{seriesfanart3width}", (int)eScraperIT::seriesfanart3width);

+    tk->DefineIntToken("{seriesfanart3height}", (int)eScraperIT::seriesfanart3height);

+    tk->DefineIntToken("{seriesbanner1width}", (int)eScraperIT::seriesbanner1width);

+    tk->DefineIntToken("{seriesbanner1height}", (int)eScraperIT::seriesbanner1height);

+    tk->DefineIntToken("{seriesbanner2width}", (int)eScraperIT::seriesbanner2width);

+    tk->DefineIntToken("{seriesbanner2height}", (int)eScraperIT::seriesbanner2height);

+    tk->DefineIntToken("{seriesbanner3width}", (int)eScraperIT::seriesbanner3width);

+    tk->DefineIntToken("{seriesbanner3height}", (int)eScraperIT::seriesbanner3height);

+    tk->DefineLoopToken("{reruns[title]}", (int)eRerunsLT::title);

+    tk->DefineLoopToken("{reruns[shorttext]}", (int)eRerunsLT::shorttext);

+    tk->DefineLoopToken("{reruns[date]}", (int)eRerunsLT::date);

+    tk->DefineLoopToken("{reruns[day]}", (int)eRerunsLT::day);

+    tk->DefineLoopToken("{reruns[start]}", (int)eRerunsLT::start);

+    tk->DefineLoopToken("{reruns[stop]}", (int)eRerunsLT::stop);

+    tk->DefineLoopToken("{reruns[channelname]}", (int)eRerunsLT::channelname);

+    tk->DefineLoopToken("{reruns[channelnumber]}", (int)eRerunsLT::channelnumber);

+    tk->DefineLoopToken("{reruns[channelid]}", (int)eRerunsLT::channelid);

+    tk->DefineLoopToken("{reruns[channellogoexists]}", (int)eRerunsLT::channellogoexists);

+    tk->DefineLoopToken("{actors[name]}", (int)eScraperLT::name);

+    tk->DefineLoopToken("{actors[role]}", (int)eScraperLT::role);

+    tk->DefineLoopToken("{actors[thumb]}", (int)eScraperLT::thumb);

+    tk->DefineLoopToken("{actors[thumbwidth]}", (int)eScraperLT::thumbwidth);

+    tk->DefineLoopToken("{actors[thumbheight]}", (int)eScraperLT::thumbheight);

+}

+/********************************************************************

+* Private Functions

+********************************************************************/

 void cDetailView::DrawBackground(void) {

     back->Display();

 }

@@ -69,113 +258,85 @@ void cDetailView::DrawHeader(void) {
         return;

     header->ClearTokens();

     static cPlugin *pScraper = GetScraperPlugin();

-    if (!pScraper) {

-        header->AddIntToken("ismovie", false);

-        header->AddIntToken("isseries", false);

-        header->AddIntToken("posteravailable", false);

-        header->AddIntToken("banneravailable", false);

-    } else {

+    if (pScraper) {

         ScraperGetEventType getType;

         getType.event = event;

         if (!pScraper->Service("GetEventType", &getType)) {

-            header->AddIntToken("ismovie", false);

-            header->AddIntToken("isseries", false);

-            header->AddIntToken("posteravailable", false);

-            header->AddIntToken("banneravailable", false);

-        } else {

             if (getType.type == tMovie) {

                 cMovie movie;

                 movie.movieId = getType.movieId;

                 pScraper->Service("GetMovie", &movie);

-                header->AddIntToken("ismovie", true);

-                header->AddIntToken("isseries", false);

-                header->AddIntToken("posteravailable", true);

-                header->AddIntToken("banneravailable", false);

-                header->AddStringToken("posterpath", movie.poster.path);

-                header->AddIntToken("posterwidth", movie.poster.width);

-                header->AddIntToken("posterheight", movie.poster.height);

+                header->AddIntToken((int)eScraperHeaderIT::banneravailable, true);

+                header->AddIntToken((int)eScraperHeaderIT::isseries, false);

+                header->AddIntToken((int)eScraperHeaderIT::posteravailable, true);

+                header->AddIntToken((int)eScraperHeaderIT::banneravailable, false);

+                header->AddStringToken((int)eScraperHeaderST::posterpath, movie.poster.path.c_str());

+                header->AddIntToken((int)eScraperHeaderIT::posterwidth, movie.poster.width);

+                header->AddIntToken((int)eScraperHeaderIT::posterheight, movie.poster.height);

             } else if (getType.type == tSeries) {

                 cSeries series;

                 series.seriesId = getType.seriesId;

                 series.episodeId = getType.episodeId;

                 pScraper->Service("GetSeries", &series);

-                header->AddIntToken("ismovie", false);

-                header->AddIntToken("isseries", true);

+                header->AddIntToken((int)eScraperHeaderIT::ismovie, false);

+                header->AddIntToken((int)eScraperHeaderIT::isseries, true);

                 vector<cTvMedia>::iterator poster = series.posters.begin();

                 if (poster != series.posters.end()) {

-                    header->AddIntToken("posterwidth", (*poster).width);

-                    header->AddIntToken("posterheight", (*poster).height);

-                    header->AddStringToken("posterpath", (*poster).path);

-                    header->AddIntToken("posteravailable", true);

-                } else {

-                    header->AddIntToken("posterwidth", 0);

-                    header->AddIntToken("posterheight", 0);

-                    header->AddStringToken("posterpath", "");                    

-                    header->AddIntToken("posteravailable", false);

+                    header->AddIntToken((int)eScraperHeaderIT::posterwidth, (*poster).width);

+                    header->AddIntToken((int)eScraperHeaderIT::posterheight, (*poster).height);

+                    header->AddStringToken((int)eScraperHeaderST::posterpath, (*poster).path.c_str());

+                    header->AddIntToken((int)eScraperHeaderIT::posteravailable, true);

                 }

                 vector<cTvMedia>::iterator banner = series.banners.begin();

                 if (banner != series.banners.end()) {

-                    header->AddIntToken("bannerwidth", (*banner).width);

-                    header->AddIntToken("bannerheight", (*banner).height);

-                    header->AddStringToken("bannerpath", (*banner).path);

-                    header->AddIntToken("banneravailable", true);

-                } else {

-                    header->AddIntToken("bannerwidth", 0);

-                    header->AddIntToken("bannerheight", 0);

-                    header->AddStringToken("bannerpath", "");                    

-                    header->AddIntToken("banneravailable", false);

+                    header->AddIntToken((int)eScraperHeaderIT::bannerwidth, (*banner).width);

+                    header->AddIntToken((int)eScraperHeaderIT::bannerheight, (*banner).height);

+                    header->AddStringToken((int)eScraperHeaderST::bannerpath, (*banner).path.c_str());

+                    header->AddIntToken((int)eScraperHeaderIT::banneravailable, true);

                 }

-            } else {

-                header->AddIntToken("ismovie", false);

-                header->AddIntToken("isseries", false);        

-                header->AddIntToken("posteravailable", false);

-                header->AddIntToken("banneravailable", false);

             }

         }

     }

 

-    header->AddStringToken("title", event->Title() ? event->Title() : "");

-    header->AddStringToken("shorttext", event->ShortText() ? event->ShortText() : "");

-    header->AddStringToken("start", *(event->GetTimeString()));

-    header->AddStringToken("stop", *(event->GetEndTimeString()));

+    header->AddStringToken((int)eDetailedHeaderST::title, event->Title());

+    header->AddStringToken((int)eDetailedHeaderST::shorttext, event->ShortText());

+    header->AddStringToken((int)eDetailedHeaderST::start, *(event->GetTimeString()));

+    header->AddStringToken((int)eDetailedHeaderST::stop, *(event->GetEndTimeString()));

     

     time_t startTime = event->StartTime();

-    header->AddStringToken("day", *WeekDayName(startTime));

-    header->AddStringToken("date", *ShortDateString(startTime));

+    header->AddStringToken((int)eDetailedHeaderST::day, *WeekDayName(startTime));

+    header->AddStringToken((int)eDetailedHeaderST::date, *ShortDateString(startTime));

     struct tm * sStartTime = localtime(&startTime);

-    header->AddIntToken("year", sStartTime->tm_year + 1900);

-    header->AddIntToken("daynumeric", sStartTime->tm_mday);

-    header->AddIntToken("month", sStartTime->tm_mon+1);

+    header->AddIntToken((int)eDetailedHeaderIT::year, sStartTime->tm_year + 1900);

+    header->AddIntToken((int)eDetailedHeaderIT::daynumeric, sStartTime->tm_mday);

+    header->AddIntToken((int)eDetailedHeaderIT::month, sStartTime->tm_mon+1);

 

     const cChannel *channel = Channels.GetByChannelID(event->ChannelID());

     if (channel) {

-        header->AddStringToken("channelname", channel->Name() ? channel->Name() : "");

-        header->AddIntToken("channelnumber", channel->Number());

+        header->AddStringToken((int)eDetailedHeaderST::channelname, channel->Name());

+        header->AddIntToken((int)eDetailedHeaderIT::channelnumber, channel->Number());

     } else {

-        header->AddStringToken("channelname", "");            

-        header->AddIntToken("channelnumber", 0);

+        header->AddIntToken((int)eDetailedHeaderIT::channelnumber, 0);

     }

-    string channelID = *(channel->GetChannelID().ToString());

-    header->AddStringToken("channelid", channelID);

-    header->AddIntToken("channellogoexists", header->ChannelLogoExists(channelID));

+    cString channelID = channel->GetChannelID().ToString();

+    header->AddStringToken((int)eDetailedHeaderST::channelid, *channelID);

+    header->AddIntToken((int)eDetailedHeaderIT::channellogoexists, header->ChannelLogoExists(*channelID));

 

     bool isRunning = false;

     time_t now = time(NULL);

     if ((now >= event->StartTime()) && (now <= event->EndTime()))

         isRunning = true;

-    header->AddIntToken("running", isRunning);

+    header->AddIntToken((int)eDetailedHeaderIT::running, isRunning);

     if (isRunning) {

-        header->AddIntToken("elapsed", (now - event->StartTime())/60);

+        header->AddIntToken((int)eDetailedHeaderIT::elapsed, (now - event->StartTime())/60);

     } else {

-        header->AddIntToken("elapsed", 0);

+        header->AddIntToken((int)eDetailedHeaderIT::elapsed, 0);

     }

-    header->AddIntToken("duration", event->Duration() / 60);

-    header->AddIntToken("durationhours", event->Duration() / 3600);

-    header->AddStringToken("durationminutes", *cString::sprintf("%.2d", (event->Duration() / 60)%60));

+    header->AddIntToken((int)eDetailedHeaderIT::duration, event->Duration() / 60);

+    header->AddIntToken((int)eDetailedHeaderIT::durationhours, event->Duration() / 3600);

+    header->AddStringToken((int)eDetailedHeaderST::durationminutes, *cString::sprintf("%.2d", (event->Duration() / 60)%60));

     if (event->Vps())

-        header->AddStringToken("vps", *event->GetVpsString());

-    else

-        header->AddStringToken("vps", "");

+        header->AddStringToken((int)eDetailedHeaderST::vps, *event->GetVpsString());

 

     stringstream epgImageName;

     epgImageName << event->EventID();

@@ -183,17 +344,14 @@ void cDetailView::DrawHeader(void) {
 

     bool epgPicAvailable = FileExists(epgImagePath, epgImageName.str(), "jpg");

     if (epgPicAvailable) {

-        header->AddIntToken("epgpicavailable", true);

-        header->AddStringToken("epgpicpath", *cString::sprintf("%s%s.jpg", epgImagePath.c_str(), epgImageName.str().c_str()));

+        header->AddIntToken((int)eDetailedHeaderIT::epgpicavailable, true);

+        header->AddStringToken((int)eDetailedHeaderST::epgpicpath, *cString::sprintf("%s%s.jpg", epgImagePath.c_str(), epgImageName.str().c_str()));

     } else {

         epgImageName << "_0";

         epgPicAvailable = FileExists(epgImagePath, epgImageName.str(), "jpg");

         if (epgPicAvailable) {

-            header->AddIntToken("epgpicavailable", true);

-            header->AddStringToken("epgpicpath", *cString::sprintf("%s%s.jpg", epgImagePath.c_str(), epgImageName.str().c_str()));

-        } else {

-            header->AddIntToken("epgpicavailable", false);

-            header->AddStringToken("epgpicpath", "");                

+            header->AddIntToken((int)eDetailedHeaderIT::epgpicavailable, true);

+            header->AddStringToken((int)eDetailedHeaderST::epgpicpath, *cString::sprintf("%s%s.jpg", epgImagePath.c_str(), epgImageName.str().c_str()));

         }

     }

     

@@ -211,21 +369,17 @@ void cDetailView::DrawFooter(void) {
     footer->Clear();

     footer->ClearTokens();

 

-    footer->AddStringToken("red", textRed);

-    footer->AddStringToken("green", textGreen);

-    footer->AddStringToken("yellow", textYellow);

-    footer->AddStringToken("blue", textBlue);

+    footer->AddStringToken((int)eFooterST::red, textRed.c_str());

+    footer->AddStringToken((int)eFooterST::green, textGreen.c_str());

+    footer->AddStringToken((int)eFooterST::yellow, textYellow.c_str());

+    footer->AddStringToken((int)eFooterST::blue, textBlue.c_str());

 

-    for (int button = 1; button < 5; button++) {

-        string red = *cString::sprintf("red%d", button);

-        string green = *cString::sprintf("green%d", button);

-        string yellow = *cString::sprintf("yellow%d", button);

-        string blue = *cString::sprintf("blue%d", button);

+    for (int button = 0; button < 4; button++) {

         bool isRed = false;

         bool isGreen = false;

         bool isYellow = false;

         bool isBlue = false;

-        switch (colorKeys[button-1]) {

+        switch (colorKeys[button]) {

             case 0:

                 isRed = true;

                 break;

@@ -241,10 +395,10 @@ void cDetailView::DrawFooter(void) {
             default:

                 break;

         }

-        footer->AddIntToken(red, isRed);

-        footer->AddIntToken(green, isGreen);

-        footer->AddIntToken(yellow, isYellow);

-        footer->AddIntToken(blue, isBlue);

+        footer->AddIntToken(0  + button, isRed);

+        footer->AddIntToken(4  + button, isGreen);

+        footer->AddIntToken(8  + button, isYellow);

+        footer->AddIntToken(12 + button, isBlue);

     }

 

     footer->Display();

@@ -268,19 +422,19 @@ bool cDetailView::DrawTime(void) {
     

     watch->Clear();

     watch->ClearTokens();

-    watch->AddIntToken("sec", sec);

-    watch->AddIntToken("min", min);

-    watch->AddIntToken("hour", hour);

-    watch->AddIntToken("hmins", hourMinutes);

-    watch->AddIntToken("year", now->tm_year + 1900);

-    watch->AddIntToken("day", now->tm_mday);

-    watch->AddStringToken("time", *TimeString(t));

-    watch->AddStringToken("monthname", monthname);

-    watch->AddStringToken("monthnameshort", monthshort);

-    watch->AddStringToken("month", *cString::sprintf("%02d", now->tm_mon + 1));

-    watch->AddStringToken("dayleadingzero", *cString::sprintf("%02d", now->tm_mday));

-    watch->AddStringToken("dayname", *WeekDayNameFull(now->tm_wday));

-    watch->AddStringToken("daynameshort", *WeekDayName(now->tm_wday));

+    watch->AddIntToken((int)eTimeIT::sec, sec);

+    watch->AddIntToken((int)eTimeIT::min, min);

+    watch->AddIntToken((int)eTimeIT::hour, hour);

+    watch->AddIntToken((int)eTimeIT::hmins, hourMinutes);

+    watch->AddIntToken((int)eTimeIT::year, now->tm_year + 1900);

+    watch->AddIntToken((int)eTimeIT::day, now->tm_mday);

+    watch->AddStringToken((int)eTimeST::time, *TimeString(t));

+    watch->AddStringToken((int)eTimeST::monthname, monthname);

+    watch->AddStringToken((int)eTimeST::monthnameshort, monthshort);

+    watch->AddStringToken((int)eTimeST::month, *cString::sprintf("%02d", now->tm_mon + 1));

+    watch->AddStringToken((int)eTimeST::dayleadingzero, *cString::sprintf("%02d", now->tm_mday));

+    watch->AddStringToken((int)eTimeST::dayname, *WeekDayNameFull(now->tm_wday));

+    watch->AddStringToken((int)eTimeST::daynameshort, *WeekDayName(now->tm_wday));

     watch->Display();

 

     lastSecond = sec;

@@ -289,328 +443,323 @@ bool cDetailView::DrawTime(void) {
 

 void cDetailView::SetTabTokens(void) {

     tabs->ClearTokens();

-

-    tabs->AddStringToken("title", event->Title() ? event->Title() : "");

-    tabs->AddStringToken("shorttext", event->ShortText() ? event->ShortText() : "");

-    tabs->AddStringToken("description", event->Description() ? event->Description() : "");

-    tabs->AddStringToken("start", *(event->GetTimeString()));

-    tabs->AddStringToken("stop", *(event->GetEndTimeString()));

+    tabs->AddStringToken((int)eDetailedEpgST::title, event->Title());

+    tabs->AddStringToken((int)eDetailedEpgST::shorttext, event->ShortText());

+    tabs->AddStringToken((int)eDetailedEpgST::description, event->Description());

+    tabs->AddStringToken((int)eDetailedEpgST::start, *(event->GetTimeString()));

+    tabs->AddStringToken((int)eDetailedEpgST::stop, *(event->GetEndTimeString()));

     time_t startTime = event->StartTime();

-    tabs->AddStringToken("day", *WeekDayName(startTime));

-    tabs->AddStringToken("date", *ShortDateString(startTime));

+    tabs->AddStringToken((int)eDetailedEpgST::day, *WeekDayName(startTime));

+    tabs->AddStringToken((int)eDetailedEpgST::date, *ShortDateString(startTime));

     struct tm * sStartTime = localtime(&startTime);

-    tabs->AddIntToken("year", sStartTime->tm_year + 1900);

-    tabs->AddIntToken("daynumeric", sStartTime->tm_mday);

-    tabs->AddIntToken("month", sStartTime->tm_mon+1);

+    tabs->AddIntToken((int)eDetailedEpgIT::year, sStartTime->tm_year + 1900);

+    tabs->AddIntToken((int)eDetailedEpgIT::daynumeric, sStartTime->tm_mday);

+    tabs->AddIntToken((int)eDetailedEpgIT::month, sStartTime->tm_mon+1);

 

-    string channelID = *(event->ChannelID().ToString());

-    tabs->AddStringToken("channelid", channelID);

-    tabs->AddIntToken("channellogoexists", tabs->ChannelLogoExists(channelID));

+    cString channelID = event->ChannelID().ToString();

+    tabs->AddStringToken((int)eDetailedEpgST::channelid, *channelID);

+    tabs->AddIntToken((int)eDetailedEpgIT::channellogoexists, tabs->ChannelLogoExists(*channelID));

 

     bool isRunning = false;

     time_t now = time(NULL);

     if ((now >= event->StartTime()) && (now <= event->EndTime()))

         isRunning = true;

-    tabs->AddIntToken("running", isRunning);

+    tabs->AddIntToken((int)eDetailedEpgIT::running, isRunning);

     if (isRunning) {

-        tabs->AddIntToken("elapsed", (now - event->StartTime())/60);

+        tabs->AddIntToken((int)eDetailedEpgIT::elapsed, (now - event->StartTime())/60);

     } else {

-        tabs->AddIntToken("elapsed", 0);

+        tabs->AddIntToken((int)eDetailedEpgIT::elapsed, 0);

     }

-    tabs->AddIntToken("duration", event->Duration() / 60);    

-    tabs->AddIntToken("durationhours", event->Duration() / 3600);

-    tabs->AddStringToken("durationminutes", *cString::sprintf("%.2d", (event->Duration() / 60)%60));

+    tabs->AddIntToken((int)eDetailedEpgIT::duration, event->Duration() / 60);    

+    tabs->AddIntToken((int)eDetailedEpgIT::durationhours, event->Duration() / 3600);

+    tabs->AddStringToken((int)eDetailedEpgST::durationminutes, *cString::sprintf("%.2d", (event->Duration() / 60)%60));

     if (event->Vps())

-        tabs->AddStringToken("vps", *event->GetVpsString());

+        tabs->AddStringToken((int)eDetailedEpgST::vps, *event->GetVpsString());

     else

-        tabs->AddStringToken("vps", "");

+        tabs->AddStringToken((int)eDetailedEpgST::vps, "");

+

 

+    bool scrapInfoAvailable = LoadScrapInfo(event);

+    int numActors = NumActors();

 

-    bool hasReruns = LoadReruns();

-    tabs->AddIntToken("hasreruns", hasReruns);   

+    cList<Epgsearch_searchresults_v1_0::cServiceSearchResult> *reruns = LoadReruns();

+    int numReruns = NumReruns(reruns);

+    

+    vector<int> loopInfo;

+    loopInfo.push_back(numReruns);

+    loopInfo.push_back(numActors);

+    tabs->SetLoop(loopInfo);

+

+    if (numReruns > 0) {

+        tabs->AddIntToken((int)eDetailedEpgIT::hasreruns, 1);

+        SetReruns(reruns);

+    }

+    if (scrapInfoAvailable) {

+        SetScraperTokens();

+    }

 

-    SetScraperTokens();

     SetEpgPictures(event->EventID());

 }

 

-bool cDetailView::LoadReruns(void) {

-    if (!event)

-        return false;

-    

+cList<Epgsearch_searchresults_v1_0::cServiceSearchResult> *cDetailView::LoadReruns(void) {

     cPlugin *epgSearchPlugin = cPluginManager::GetPlugin("epgsearch");

     if (!epgSearchPlugin)

-        return false;

+        return NULL;

 

     if (isempty(event->Title()))

-        return false;

-

-    int maxNumReruns = config.rerunAmount;

-    int rerunDistance = config.rerunDistance * 3600;

-    int rerunNaxChannel = config.rerunMaxChannel;

+        return NULL;

 

     Epgsearch_searchresults_v1_0 data;

-    string strQuery = (event->Title()) ? event->Title() : "";

-    data.query = (char *)strQuery.c_str();

+    data.query = (char*)event->Title();

     data.mode = 0;

     data.channelNr = 0;

     data.useTitle = true;

     data.useSubTitle = true;

     data.useDescription = false;

 

-    bool foundRerun = false;

-    if (epgSearchPlugin->Service("Epgsearch-searchresults-v1.0", &data)) {

-        cList<Epgsearch_searchresults_v1_0::cServiceSearchResult>* list = data.pResultList;

-        if (list && (list->Count() > 1)) {

-            foundRerun = true;

-            int i = 0;

-            for (Epgsearch_searchresults_v1_0::cServiceSearchResult *r = list->First(); r && i < maxNumReruns; r = list->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 (rerunNaxChannel > 0) {

-                    if (channel && channel->Number() > rerunNaxChannel) {

-                        continue;

-                    }

-                }

-                i++;

-                map< string, string > rerun;

-                rerun.insert(pair<string, string>("reruns[title]", r->event->Title() ? r->event->Title() : ""));

-                rerun.insert(pair<string, string>("reruns[shorttext]", r->event->ShortText() ? r->event->ShortText() : ""));

-                rerun.insert(pair<string, string>("reruns[start]", *(r->event->GetTimeString())));

-                rerun.insert(pair<string, string>("reruns[start]", *(r->event->GetTimeString())));

-                rerun.insert(pair<string, string>("reruns[stop]", *(r->event->GetEndTimeString())));

-                rerun.insert(pair<string, string>("reruns[date]", *ShortDateString(r->event->StartTime())));

-                rerun.insert(pair<string, string>("reruns[day]", *WeekDayName(r->event->StartTime())));

-                string channelID = *(r->event->ChannelID().ToString());

-                rerun.insert(pair<string, string>("reruns[channelid]", channelID));

-                bool logoExists = tabs->ChannelLogoExists(channelID);

-                rerun.insert(pair<string, string>("reruns[channellogoexists]", logoExists ? "1" : "0"));

-

-                if (channel) {

-                    stringstream channelNumber;

-                    channelNumber << channel->Number();

-                    rerun.insert(pair<string, string>("reruns[channelname]", channel->ShortName(true)));

-                    rerun.insert(pair<string, string>("reruns[channelnumber]", channelNumber.str()));

-                } else {

-                    rerun.insert(pair<string, string>("reruns[channelname]", ""));

-                    rerun.insert(pair<string, string>("reruns[channelnumber]", ""));                    

-                }

-                tabs->AddLoopToken("reruns", rerun);

-            }

-            delete list;

+    cList<Epgsearch_searchresults_v1_0::cServiceSearchResult> *result = NULL;

+    if (epgSearchPlugin->Service("Epgsearch-searchresults-v1.0", &data))

+        result = data.pResultList;

+    return result;

+}

+

+int cDetailView::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 cDetailView::SetReruns(cList<Epgsearch_searchresults_v1_0::cServiceSearchResult> *reruns) {

+    if (!reruns || reruns->Count() < 2)

+        return;

+    int rerunsIndex = tabs->GetLoopIndex("reruns");

+

+    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;

+        tabs->AddLoopToken(rerunsIndex, i, (int)eRerunsLT::title, r->event->Title());

+        tabs->AddLoopToken(rerunsIndex, i, (int)eRerunsLT::shorttext, r->event->ShortText());

+        tabs->AddLoopToken(rerunsIndex, i, (int)eRerunsLT::start, *(r->event->GetTimeString()));

+        tabs->AddLoopToken(rerunsIndex, i, (int)eRerunsLT::stop, *(r->event->GetEndTimeString()));

+        tabs->AddLoopToken(rerunsIndex, i, (int)eRerunsLT::date, *ShortDateString(r->event->StartTime()));

+        tabs->AddLoopToken(rerunsIndex, i, (int)eRerunsLT::day, *WeekDayName(r->event->StartTime()));

+        cString channelID = r->event->ChannelID().ToString();

+        tabs->AddLoopToken(rerunsIndex, i, (int)eRerunsLT::channelid, *channelID);

+        bool logoExists = tabs->ChannelLogoExists(*channelID);

+        tabs->AddLoopToken(rerunsIndex, i, (int)eRerunsLT::channellogoexists, logoExists ? "1" : "0");

+        if (channel) {

+            cString channelNumber = cString::sprintf("%d", channel->Number());

+            tabs->AddLoopToken(rerunsIndex, i, (int)eRerunsLT::channelname, channel->ShortName(true));

+            tabs->AddLoopToken(rerunsIndex, i, (int)eRerunsLT::channelnumber, *channelNumber);

+        } else {

+            tabs->AddLoopToken(rerunsIndex, i, (int)eRerunsLT::channelname, "");

+            tabs->AddLoopToken(rerunsIndex, i, (int)eRerunsLT::channelnumber, "");

         }

+        i++;

     }

-    return foundRerun;

 }

 

-void cDetailView::SetScraperTokens(void) {

+bool cDetailView::LoadScrapInfo(const cEvent *event) {

     static cPlugin *pScraper = GetScraperPlugin();

     if (!pScraper || !event) {

-        tabs->AddIntToken("ismovie", false);

-        tabs->AddIntToken("isseries", false);

-        return;

+        return false;

     }

-

+    delete movie;

+    movie = NULL;

+    delete series;

+    series = NULL;

+    

     ScraperGetEventType getType;

     getType.event = event;

     getType.recording = NULL;

     if (!pScraper->Service("GetEventType", &getType)) {

-        tabs->AddIntToken("ismovie", false);

-        tabs->AddIntToken("isseries", false);

-        return;

+        return false;

     }

-

     if (getType.type == tMovie) {

-        cMovie movie;

-        movie.movieId = getType.movieId;

-        pScraper->Service("GetMovie", &movie);

-        tabs->AddIntToken("ismovie", true);

-        tabs->AddIntToken("isseries", false);

-

-        tabs->AddStringToken("movietitle", movie.title);

-        tabs->AddStringToken("movieoriginalTitle", movie.originalTitle);

-        tabs->AddStringToken("movietagline", movie.tagline);

-        tabs->AddStringToken("movieoverview", movie.overview);

-        tabs->AddStringToken("moviegenres", movie.genres);

-        tabs->AddStringToken("moviehomepage", movie.homepage);

-        tabs->AddStringToken("moviereleasedate", movie.releaseDate);

+        movie = new cMovie();

+        movie->movieId = getType.movieId;

+        pScraper->Service("GetMovie", movie);

+        return true;

+    } else if (getType.type == tSeries) {

+        series = new cSeries();

+        series->seriesId = getType.seriesId;

+        series->episodeId = getType.episodeId;

+        pScraper->Service("GetSeries", series);

+        return true;

+    }

+    return false;

+}

+

+int cDetailView::NumActors(void) {

+    if (series) {

+        return series->actors.size();

+    } else if (movie) {

+        return movie->actors.size();

+    }    

+    return 0;

+}

+

+void cDetailView::SetScraperTokens(void) {

+    if (movie) {

+        tabs->AddIntToken((int)eScraperIT::ismovie, true);

+        tabs->AddIntToken((int)eScraperIT::isseries, false);

+

+        tabs->AddStringToken((int)eScraperST::movietitle, movie->title.c_str());

+        tabs->AddStringToken((int)eScraperST::movieoriginalTitle, movie->originalTitle.c_str());

+        tabs->AddStringToken((int)eScraperST::movietagline, movie->tagline.c_str());

+        tabs->AddStringToken((int)eScraperST::movieoverview, movie->overview.c_str());

+        tabs->AddStringToken((int)eScraperST::moviegenres, movie->genres.c_str());

+        tabs->AddStringToken((int)eScraperST::moviehomepage, movie->homepage.c_str());

+        tabs->AddStringToken((int)eScraperST::moviereleasedate, movie->releaseDate.c_str());

         stringstream pop;

-        pop << movie.popularity;

-        tabs->AddStringToken("moviepopularity", pop.str());

+        pop << movie->popularity;

+        tabs->AddStringToken((int)eScraperST::moviepopularity, pop.str().c_str());

         stringstream vote;

-        vote << movie.voteAverage;

-        tabs->AddStringToken("movievoteaverage", pop.str());

-        tabs->AddStringToken("posterpath", movie.poster.path);

-        tabs->AddStringToken("fanartpath", movie.fanart.path);

-        tabs->AddStringToken("collectionposterpath", movie.collectionPoster.path);

-        tabs->AddStringToken("collectionfanartpath", movie.collectionFanart.path);

-

-        tabs->AddIntToken("movieadult", movie.adult);

-        tabs->AddIntToken("moviebudget", movie.budget);

-        tabs->AddIntToken("movierevenue", movie.revenue);

-        tabs->AddIntToken("movieruntime", movie.runtime);

-        tabs->AddIntToken("posterwidth", movie.poster.width);

-        tabs->AddIntToken("posterheight", movie.poster.height);

-        tabs->AddIntToken("fanartwidth", movie.fanart.width);

-        tabs->AddIntToken("fanartheight", movie.fanart.height);

-        tabs->AddIntToken("collectionposterwidth", movie.collectionPoster.width);

-        tabs->AddIntToken("collectionposterheight", movie.collectionPoster.height);

-        tabs->AddIntToken("collectionfanartwidth", movie.collectionFanart.width);

-        tabs->AddIntToken("collectionfanartheight", movie.collectionFanart.height);

-

-        for (vector<cActor>::iterator act = movie.actors.begin(); act != movie.actors.end(); act++) {

-            map< string, string > actor;

-            actor.insert(pair<string, string>("actors[name]", (*act).name));

-            actor.insert(pair<string, string>("actors[role]", (*act).role));

-            actor.insert(pair<string, string>("actors[thumb]", (*act).actorThumb.path));

-            stringstream actWidth, actHeight;

-            actWidth << (*act).actorThumb.width;

-            actHeight << (*act).actorThumb.height;

-            actor.insert(pair<string, string>("actors[thumbwidth]", actWidth.str()));

-            actor.insert(pair<string, string>("actors[thumbheight]", actHeight.str()));

-            tabs->AddLoopToken("actors", actor);

+        vote << movie->voteAverage;

+        tabs->AddStringToken((int)eScraperST::movievoteaverage, pop.str().c_str());

+        tabs->AddStringToken((int)eScraperST::posterpath, movie->poster.path.c_str());

+        tabs->AddStringToken((int)eScraperST::fanartpath, movie->fanart.path.c_str());

+        tabs->AddStringToken((int)eScraperST::collectionposterpath, movie->collectionPoster.path.c_str());

+        tabs->AddStringToken((int)eScraperST::collectionfanartpath, movie->collectionFanart.path.c_str());

+

+        tabs->AddIntToken((int)eScraperIT::movieadult, movie->adult);

+        tabs->AddIntToken((int)eScraperIT::moviebudget, movie->budget);

+        tabs->AddIntToken((int)eScraperIT::movierevenue, movie->revenue);

+        tabs->AddIntToken((int)eScraperIT::movieruntime, movie->runtime);

+        tabs->AddIntToken((int)eScraperIT::posterwidth, movie->poster.width);

+        tabs->AddIntToken((int)eScraperIT::posterheight, movie->poster.height);

+        tabs->AddIntToken((int)eScraperIT::fanartwidth, movie->fanart.width);

+        tabs->AddIntToken((int)eScraperIT::fanartheight, movie->fanart.height);

+        tabs->AddIntToken((int)eScraperIT::collectionposterwidth, movie->collectionPoster.width);

+        tabs->AddIntToken((int)eScraperIT::collectionposterheight, movie->collectionPoster.height);

+        tabs->AddIntToken((int)eScraperIT::collectionfanartwidth, movie->collectionFanart.width);

+        tabs->AddIntToken((int)eScraperIT::collectionfanartheight, movie->collectionFanart.height);

+

+        int actorsIndex = tabs->GetLoopIndex("actors");

+        int i=0;

+        for (vector<cActor>::iterator act = movie->actors.begin(); act != movie->actors.end(); act++) {

+            tabs->AddLoopToken(actorsIndex, i, (int)eScraperLT::name, (*act).name.c_str());

+            tabs->AddLoopToken(actorsIndex, i, (int)eScraperLT::role, (*act).role.c_str());

+            tabs->AddLoopToken(actorsIndex, i, (int)eScraperLT::thumb, (*act).actorThumb.path.c_str());

+            tabs->AddLoopToken(actorsIndex, i, (int)eScraperLT::thumbwidth, *cString::sprintf("%d", (*act).actorThumb.width));

+            tabs->AddLoopToken(actorsIndex, i, (int)eScraperLT::thumbheight, *cString::sprintf("%d", (*act).actorThumb.height));

+            i++;

         }

-

-    } else if (getType.type == tSeries) {

-        cSeries series;

-        series.seriesId = getType.seriesId;

-        series.episodeId = getType.episodeId;

-        pScraper->Service("GetSeries", &series);

-        tabs->AddIntToken("ismovie", false);

-        tabs->AddIntToken("isseries", true);

+    } else if (series) {

+        tabs->AddIntToken((int)eScraperIT::ismovie, false);

+        tabs->AddIntToken((int)eScraperIT::isseries, true);

         //Series Basics

-        tabs->AddStringToken("seriesname", series.name);

-        tabs->AddStringToken("seriesoverview", series.overview);

-        tabs->AddStringToken("seriesfirstaired", series.firstAired);

-        tabs->AddStringToken("seriesnetwork", series.network);

-        tabs->AddStringToken("seriesgenre", series.genre);

+        tabs->AddStringToken((int)eScraperST::seriesname, series->name.c_str());

+        tabs->AddStringToken((int)eScraperST::seriesoverview, series->overview.c_str());

+        tabs->AddStringToken((int)eScraperST::seriesfirstaired, series->firstAired.c_str());

+        tabs->AddStringToken((int)eScraperST::seriesnetwork, series->network.c_str());

+        tabs->AddStringToken((int)eScraperST::seriesgenre, series->genre.c_str());

         stringstream rating;

-        rating << series.rating;

-        tabs->AddStringToken("seriesrating", rating.str());

-        tabs->AddStringToken("seriesstatus", series.status);

+        rating << series->rating;

+        tabs->AddStringToken((int)eScraperST::seriesrating, rating.str().c_str());

+        tabs->AddStringToken((int)eScraperST::seriesstatus, series->status.c_str());

         //Episode Information

-        tabs->AddIntToken("episodenumber", series.episode.number);

-        tabs->AddIntToken("episodeseason", series.episode.season);

-        tabs->AddStringToken("episodetitle", series.episode.name);

-        tabs->AddStringToken("episodefirstaired", series.episode.firstAired);

-        tabs->AddStringToken("episodegueststars", series.episode.guestStars);

-        tabs->AddStringToken("episodeoverview", series.episode.overview);

+        tabs->AddIntToken((int)eScraperIT::episodenumber, series->episode.number);

+        tabs->AddIntToken((int)eScraperIT::episodeseason, series->episode.season);

+        tabs->AddStringToken((int)eScraperST::episodetitle, series->episode.name.c_str());

+        tabs->AddStringToken((int)eScraperST::episodefirstaired, series->episode.firstAired.c_str());

+        tabs->AddStringToken((int)eScraperST::episodegueststars, series->episode.guestStars.c_str());

+        tabs->AddStringToken((int)eScraperST::episodeoverview, series->episode.overview.c_str());

         stringstream eprating;

-        eprating << series.episode.rating;

-        tabs->AddStringToken("episoderating", eprating.str());

-        tabs->AddIntToken("episodeimagewidth", series.episode.episodeImage.width);

-        tabs->AddIntToken("episodeimageheight", series.episode.episodeImage.height);

-        tabs->AddStringToken("episodeimagepath", series.episode.episodeImage.path);

+        eprating << series->episode.rating;

+        tabs->AddStringToken((int)eScraperST::episoderating, eprating.str().c_str());

+        tabs->AddIntToken((int)eScraperIT::episodeimagewidth, series->episode.episodeImage.width);

+        tabs->AddIntToken((int)eScraperIT::episodeimageheight, series->episode.episodeImage.height);

+        tabs->AddStringToken((int)eScraperST::episodeimagepath, series->episode.episodeImage.path.c_str());

         //Seasonposter

-        tabs->AddIntToken("seasonposterwidth", series.seasonPoster.width);

-        tabs->AddIntToken("seasonposterheight", series.seasonPoster.height);

-        tabs->AddStringToken("seasonposterpath", series.seasonPoster.path);

+        tabs->AddIntToken((int)eScraperIT::seasonposterwidth, series->seasonPoster.width);

+        tabs->AddIntToken((int)eScraperIT::seasonposterheight, series->seasonPoster.height);

+        tabs->AddStringToken((int)eScraperST::seasonposterpath, series->seasonPoster.path.c_str());

 

         //Posters

-        int current = 1;

-        for(vector<cTvMedia>::iterator poster = series.posters.begin(); poster != series.posters.end(); poster++) {

-            stringstream labelWidth, labelHeight, labelPath;

-            labelWidth << "seriesposter" << current << "width";

-            labelHeight << "seriesposter" << current << "height";

-            labelPath << "seriesposter" << current << "path";

-

-            tabs->AddIntToken(labelWidth.str(), (*poster).width);

-            tabs->AddIntToken(labelHeight.str(), (*poster).height);

-            tabs->AddStringToken(labelPath.str(), (*poster).path);

-            current++;

+        int indexInt = (int)eScraperIT::seriesposter1width;

+        int indexStr = (int)eScraperST::seriesposter1path;

+        for(vector<cTvMedia>::iterator poster = series->posters.begin(); poster != series->posters.end(); poster++) {

+            tabs->AddIntToken(indexInt, (*poster).width);

+            tabs->AddIntToken(indexInt+1, (*poster).height);

+            tabs->AddStringToken(indexStr, (*poster).path.c_str());

+            indexInt += 2;

+            indexStr++;

         }

-        if (current < 3) {

-            for (; current < 4; current++) {

-                stringstream labelWidth, labelHeight, labelPath;

-                labelWidth << "seriesposter" << current << "width";

-                labelHeight << "seriesposter" << current << "height";

-                labelPath << "seriesposter" << current << "path";

-                

-                tabs->AddIntToken(labelWidth.str(), 0);

-                tabs->AddIntToken(labelHeight.str(), 0);

-                tabs->AddStringToken(labelPath.str(), "");

-            }

-        }

-

         //Banners

-        current = 1;

-        for(vector<cTvMedia>::iterator banner = series.banners.begin(); banner != series.banners.end(); banner++) {

-            stringstream labelWidth, labelHeight, labelPath;

-            labelWidth << "seriesbanner" << current << "width";

-            labelHeight << "seriesbanner" << current << "height";

-            labelPath << "seriesbanner" << current << "path";

-            

-            tabs->AddIntToken(labelWidth.str(), (*banner).width);

-            tabs->AddIntToken(labelHeight.str(), (*banner).height);

-            tabs->AddStringToken(labelPath.str(), (*banner).path);

-            current++;

-        }

-        if (current < 3) {

-            for (; current < 4; current++) {

-                stringstream labelWidth, labelHeight, labelPath;

-                labelWidth << "seriesbanner" << current << "width";

-                labelHeight << "seriesbanner" << current << "height";

-                labelPath << "seriesbanner" << current << "path";

-                

-                tabs->AddIntToken(labelWidth.str(), 0);

-                tabs->AddIntToken(labelHeight.str(), 0);

-                tabs->AddStringToken(labelPath.str(), "");

-            }

+        indexInt = (int)eScraperIT::seriesbanner1width;

+        indexStr = (int)eScraperST::seriesbanner1path;

+        for(vector<cTvMedia>::iterator banner = series->banners.begin(); banner != series->banners.end(); banner++) {

+            tabs->AddIntToken(indexInt, (*banner).width);

+            tabs->AddIntToken(indexInt+1, (*banner).height);

+            tabs->AddStringToken(indexStr, (*banner).path.c_str());

+            indexInt += 2;

+            indexStr++;

         }

-        

         //Fanarts

-        current = 1;

-        for(vector<cTvMedia>::iterator fanart = series.fanarts.begin(); fanart != series.fanarts.end(); fanart++) {

-            stringstream labelWidth, labelHeight, labelPath;

-            labelWidth << "seriesfanart" << current << "width";

-            labelHeight << "seriesfanart" << current << "height";

-            labelPath << "seriesfanart" << current << "path";

-            

-            tabs->AddIntToken(labelWidth.str(), (*fanart).width);

-            tabs->AddIntToken(labelHeight.str(), (*fanart).height);

-            tabs->AddStringToken(labelPath.str(), (*fanart).path);

-            current++;

+        indexInt = (int)eScraperIT::seriesfanart1width;

+        indexStr = (int)eScraperST::seriesfanart1path;

+        for(vector<cTvMedia>::iterator fanart = series->fanarts.begin(); fanart != series->fanarts.end(); fanart++) {

+            tabs->AddIntToken(indexInt, (*fanart).width);

+            tabs->AddIntToken(indexInt+1, (*fanart).height);

+            tabs->AddStringToken(indexStr, (*fanart).path.c_str());

+            indexInt += 2;

+            indexStr++;

         }

-        if (current < 3) {

-            for (; current < 4; current++) {

-                stringstream labelWidth, labelHeight, labelPath;

-                labelWidth << "seriesfanart" << current << "width";

-                labelHeight << "seriesfanart" << current << "height";

-                labelPath << "seriesfanart" << current << "path";

-                

-                tabs->AddIntToken(labelWidth.str(), 0);

-                tabs->AddIntToken(labelHeight.str(), 0);

-                tabs->AddStringToken(labelPath.str(), "");

-            }

-        }

-        

         //Actors

-        for (vector<cActor>::iterator act = series.actors.begin(); act != series.actors.end(); act++) {

-            map< string, string > actor;

-            actor.insert(pair<string, string>("actors[name]", (*act).name));

-            actor.insert(pair<string, string>("actors[role]", (*act).role));

-            actor.insert(pair<string, string>("actors[thumb]", (*act).actorThumb.path));

-            stringstream actWidth, actHeight;

-            actWidth << (*act).actorThumb.width;

-            actHeight << (*act).actorThumb.height;

-            actor.insert(pair<string, string>("actors[thumbwidth]", actWidth.str()));

-            actor.insert(pair<string, string>("actors[thumbheight]", actHeight.str()));

-            tabs->AddLoopToken("actors", actor);

+        int actorsIndex = tabs->GetLoopIndex("actors");

+        int i=0;

+        for (vector<cActor>::iterator act = series->actors.begin(); act != series->actors.end(); act++) {

+            tabs->AddLoopToken(actorsIndex, i, (int)eScraperLT::name, (*act).name.c_str());

+            tabs->AddLoopToken(actorsIndex, i, (int)eScraperLT::role, (*act).role.c_str());

+            tabs->AddLoopToken(actorsIndex, i, (int)eScraperLT::thumb, (*act).actorThumb.path.c_str());

+            tabs->AddLoopToken(actorsIndex, i, (int)eScraperLT::thumbwidth, *cString::sprintf("%d", (*act).actorThumb.width));

+            tabs->AddLoopToken(actorsIndex, i, (int)eScraperLT::thumbheight, *cString::sprintf("%d", (*act).actorThumb.height));

+            i++;

         }

-

     } else {

-        tabs->AddIntToken("ismovie", false);

-        tabs->AddIntToken("isseries", false);

+        tabs->AddIntToken((int)eScraperIT::ismovie, false);

+        tabs->AddIntToken((int)eScraperIT::isseries, false);

     }

 }

 

@@ -620,16 +769,12 @@ void cDetailView::SetEpgPictures(int eventId) {
         stringstream picName;

         picName << eventId << "_" << i;

         bool epgPicAvailable = FileExists(epgImagePath, picName.str(), "jpg");

-        stringstream available;

-        stringstream path;

-        available << "epgpic" << i+1 << "avaialble";

-        path << "epgpic" << i+1 << "path";

         if (epgPicAvailable) {

-            tabs->AddIntToken(available.str(), true);

-            tabs->AddStringToken(path.str(), *cString::sprintf("%s%s.jpg", epgImagePath.c_str(), picName.str().c_str()));

+            tabs->AddIntToken((int)eDetailedEpgIT::epgpic1avaialble + i, true);

+            tabs->AddStringToken((int)eDetailedEpgST::epgpic1path + i, *cString::sprintf("%s%s.jpg", epgImagePath.c_str(), picName.str().c_str()));

         } else {

-            tabs->AddIntToken(available.str(), false);

-            tabs->AddStringToken(path.str(), "");            

+            tabs->AddIntToken((int)eDetailedEpgIT::epgpic1avaialble + i, false);

+            tabs->AddStringToken((int)eDetailedEpgST::epgpic1path + i, "");            

         }

     }

 }
\ No newline at end of file