From d4ef992f8256d324221d15d3bef967eb044a9a86 Mon Sep 17 00:00:00 2001 From: louis Date: Tue, 26 Jan 2016 18:41:40 +0100 Subject: adaptions skindesigner 0.8.0 --- Makefile | 5 +- channelepg.c | 28 +- channelepg.h | 1 + channelgroups.c | 5 +- channelgroups.h | 3 +- channeljump.c | 3 +- channeljump.h | 1 + definitions.h | 546 +++++++++++++++++++++++ detailview.c | 897 ++++++++++++++++++++++---------------- detailview.h | 13 +- epggrid.c | 126 +++--- recmenu.c | 137 +++++- recmenu.h | 4 + recmenuitem.c | 298 +++++++------ recmenuitem.h | 1 + recmenus.c | 1 + searchtimer.c | 2 +- templates/plug-tvguideng-root.xml | 1 + timeline.c | 15 +- timeline.h | 5 +- tvguideng.c | 221 +++++++--- tvguidengosd.c | 174 +++++++- tvguidengosd.h | 51 +-- 23 files changed, 1773 insertions(+), 765 deletions(-) create mode 100644 definitions.h diff --git a/Makefile b/Makefile index c20f671..4082978 100644 --- a/Makefile +++ b/Makefile @@ -27,6 +27,7 @@ TMPDIR ?= /tmp export CFLAGS = $(call PKGCFG,cflags) export CXXFLAGS = $(call PKGCFG,cxxflags) +CXXFLAGS += -std=c++11 ### The version number of VDR's plugin API: @@ -102,7 +103,7 @@ all: $(SOFILE) i18n ### Implicit rules: %.o: %.c - $(CXX) $(CXXFLAGS) -c $(DEFINES) $(INCLUDES) -o $@ $< + $(CXX) $(CXXFLAGS) -std=c++11 -c $(DEFINES) $(INCLUDES) -o $@ $< ### Dependencies: @@ -142,7 +143,7 @@ install-i18n: $(I18Nmsgs) ### Targets: $(SOFILE): $(OBJS) - $(CXX) $(CXXFLAGS) $(LDFLAGS) -shared $(OBJS) $(LIBS) -o $@ + $(CXX) $(CXXFLAGS) -std=c++11 $(LDFLAGS) -shared $(OBJS) $(LIBS) -o $@ install-lib: $(SOFILE) install -D $^ $(DESTDIR)$(LIBDIR)/$^.$(APIVERSION) diff --git a/channelepg.c b/channelepg.c index d3d7986..bde905d 100644 --- a/channelepg.c +++ b/channelepg.c @@ -330,12 +330,12 @@ void cChannelEpg::DrawHeader(skindesignerapi::cViewGrid *channelsGrid) { int id = channel->Number(); if (init) { channelsGrid->ClearTokens(); - channelsGrid->AddIntToken("number", id); - channelsGrid->AddStringToken("name", channel->Name()); - string channelId = *(channel->GetChannelID().ToString()); - bool channelLogoExisis = channelsGrid->ChannelLogoExists(channelId); - channelsGrid->AddStringToken("channelid", channelId); - channelsGrid->AddIntToken("channellogoexists", channelLogoExisis); + channelsGrid->AddIntToken((int)eChannelGridIT::number, id); + channelsGrid->AddStringToken((int)eChannelGridST::name, channel->Name()); + cString channelId = channel->GetChannelID().ToString(); + bool channelLogoExisis = channelsGrid->ChannelLogoExists(*channelId); + channelsGrid->AddStringToken((int)eChannelGridST::channelid, *channelId); + channelsGrid->AddIntToken((int)eChannelGridIT::channellogoexists, channelLogoExisis); channelsGrid->SetGrid(id, x, y, width, height); init = false; } else { @@ -365,14 +365,14 @@ void cChannelEpg::DrawGrids(skindesignerapi::cViewGrid *epgGrid) { time_t gridStop = grid->EndTime(); if (grid->IsNew()) { epgGrid->ClearTokens(); - epgGrid->AddIntToken("color", grid->Id() % 2); - epgGrid->AddIntToken("dummy", grid->IsDummy()); - epgGrid->AddIntToken("timer", grid->HasTimer()); - epgGrid->AddIntToken("switchtimer", grid->HasSwitchTimer()); - epgGrid->AddStringToken("title", grid->Title()); - epgGrid->AddStringToken("shorttext", grid->ShortText()); - epgGrid->AddStringToken("start", *TimeString(gridStart)); - epgGrid->AddStringToken("stop", *TimeString(gridStop)); + epgGrid->AddIntToken((int)eSchedulesGridIT::color, grid->Id() % 2); + epgGrid->AddIntToken((int)eSchedulesGridIT::dummy, grid->IsDummy()); + epgGrid->AddIntToken((int)eSchedulesGridIT::timer, grid->HasTimer()); + epgGrid->AddIntToken((int)eSchedulesGridIT::switchtimer, grid->HasSwitchTimer()); + epgGrid->AddStringToken((int)eSchedulesGridST::title, grid->Title()); + epgGrid->AddStringToken((int)eSchedulesGridST::shorttext, grid->ShortText()); + epgGrid->AddStringToken((int)eSchedulesGridST::start, *TimeString(gridStart)); + epgGrid->AddStringToken((int)eSchedulesGridST::stop, *TimeString(gridStop)); } if (gridStart < startTime) { diff --git a/channelepg.h b/channelepg.h index 9785799..63f24d4 100644 --- a/channelepg.h +++ b/channelepg.h @@ -4,6 +4,7 @@ #include #include #include +#include "definitions.h" #include "config.h" #include "gridelement.h" #include "epgelement.h" diff --git a/channelgroups.c b/channelgroups.c index 5069795..9ea8bfb 100644 --- a/channelgroups.c +++ b/channelgroups.c @@ -122,10 +122,9 @@ double cChannelgroups::SetGroup(int groupId, int fields, double offset) { height = 1.0; offset += width; } - string groupName = channelGroups[groupId].GetName(); channelgroupGrid->ClearTokens(); - channelgroupGrid->AddIntToken("color", groupId % 2); - channelgroupGrid->AddStringToken("group", groupName); + channelgroupGrid->AddIntToken((int)eChannelgroupsGridIT::color, groupId % 2); + channelgroupGrid->AddStringToken((int)eChannelgroupsGridST::group, channelGroups[groupId].GetName()); channelgroupGrid->SetGrid(groupId, x, y, width, height); return offset; diff --git a/channelgroups.h b/channelgroups.h index e53d5b1..19c8e8f 100644 --- a/channelgroups.h +++ b/channelgroups.h @@ -4,6 +4,7 @@ #include #include #include +#include "definitions.h" #include "config.h" // --- cChannelGroup ------------------------------------------------------------- @@ -22,7 +23,7 @@ public: int StartChannel(void) { return channelStart; }; void SetChannelStop(int stop) { channelStop = stop; }; int StopChannel(void) { return channelStop; }; - string GetName(void) { return name; }; + const char *GetName(void) { return name.c_str(); }; void Debug(void); }; diff --git a/channeljump.c b/channeljump.c index 4dcd20c..935a129 100644 --- a/channeljump.c +++ b/channeljump.c @@ -17,8 +17,7 @@ cChannelJump::~cChannelJump(void) { void cChannelJump::Draw(void) { channelJump->Clear(); channelJump->ClearTokens(); - string channelString = *BuildChannelString(); - channelJump->AddStringToken("channel", channelString); + channelJump->AddStringToken((int)eChannelJumpST::channel, *BuildChannelString()); channelJump->Display(); } diff --git a/channeljump.h b/channeljump.h index beca9d8..251482a 100644 --- a/channeljump.h +++ b/channeljump.h @@ -2,6 +2,7 @@ #define __TVGUIDE_CHANNELJUMP_H #include +#include "definitions.h" // --- cChannelJump ------------------------------------------------------------- diff --git a/definitions.h b/definitions.h new file mode 100644 index 0000000..d2c8119 --- /dev/null +++ b/definitions.h @@ -0,0 +1,546 @@ +#ifndef __DEFINITIONS_H +#define __DEFINITIONS_H + +/****************************************************************** +* Menus +*******************************************************************/ +enum class eViews { + rootView = 0, + detailView, + recMenu, + recMenu2, + recMenu3, + count +}; + +/****************************************************************** +* Viewelements +*******************************************************************/ +enum class eViewElementsRoot { + backgroundHor = 0, + backgroundVer, + headerHor, + headerVer, + footerHor, + footerVer, + timeHor, + timeVer, + dateTimelineHor, + dateTimelineVer, + timeIndicatorHor, + timeIndicatorVer, + channelJump, + count +}; + +enum class eViewElementsDetail { + background = 0, + header, + footer, + time, + count +}; + +enum class eViewElementsRecMenu { + background = 0, + scrollbar, + count +}; + +/****************************************************************** +* Viewgrids +*******************************************************************/ +enum class eViewGridsRoot { + channelsHor = 0, + channelsVer, + schedulesHor, + schedulesVer, + channelGroupsHor, + channelGroupsVer, + timelineHor, + timelineVer, + count +}; + +enum class eViewGridsRecMenu { + menu = 0, + count +}; + +/****************************************************************** +* Tokens Rootview Viewelements +*******************************************************************/ +enum class eHeaderST { + title = 0, + shorttext, + description, + start, + stop, + day, + date, + durationminutes, + channelname, + channelid, + posterpath, + count +}; + +enum class eHeaderIT { + isdummy = 0, + daynumeric, + month, + year, + running, + elapsed, + duration, + durationhours, + channelnumber, + channellogoexists, + hasposter, + posterwidth, + posterheight, + count +}; + +enum class eFooterIT { + red1 = 0, red2, red3, red4, + green1, green2, green3, green4, + yellow1, yellow2, yellow3, yellow4, + blue1, blue2, blue3, blue4, + count +}; + +enum class eFooterST { + red = 0, + green, + yellow, + blue, + count +}; + +enum class eTimeST { + time = 0, + monthname, + monthnameshort, + month, + dayleadingzero, + dayname, + daynameshort, + count +}; + +enum class eTimeIT { + sec = 0, + min, + hour, + hmins, + year, + day, + count +}; + +enum class eDateTimeST { + weekday = 0, + date, + count +}; + +enum class eTimeIndicatorIT { + percenttotal = 0, + count +}; + +enum class eChannelJumpST { + channel = 0, + count +}; + +/****************************************************************** +* Tokens Rootview Grids +*******************************************************************/ +enum class eChannelGridST { + name = 0, + channelid, + count +}; + +enum class eChannelGridIT { + number = 0, + channellogoexists, + count +}; + +enum class eSchedulesGridST { + title = 0, + shorttext, + start, + stop, + count +}; + +enum class eSchedulesGridIT { + color = 0, + dummy, + timer, + switchtimer, + count +}; + +enum class eTimelineGridST { + timestring = 0, + count +}; + +enum class eTimelineGridIT { + fullhour = 0, + count +}; + +enum class eChannelgroupsGridST { + group = 0, + count +}; + +enum class eChannelgroupsGridIT { + color = 0, + count +}; + +/****************************************************************** +* Tokens Detailview ViewElements +*******************************************************************/ +enum class eScrollbarIT { + height = 0, + offset, + count +}; + +enum class eScraperHeaderST { + posterpath = 0, + bannerpath, + count +}; + +enum class eScraperHeaderIT { + ismovie = 0, + isseries, + posteravailable, + posterwidth, + posterheight, + banneravailable, + bannerwidth, + bannerheight, + count +}; + +enum class eDetailedHeaderST { + title = eScraperHeaderST::count, + shorttext, + start, + stop, + day, + date, + durationminutes, + vps, + channelname, + channelid, + epgpicpath, + count +}; + +enum class eDetailedHeaderIT { + daynumeric = eScraperHeaderIT::count, + month, + year, + running, + elapsed, + duration, + durationhours, + channelnumber, + channellogoexists, + epgpicavailable, + count +}; + +enum class eTabsIT { + count = 0, +}; + +enum class eTabsST { + currenttab = 0, + prevtab, + nexttab, + count +}; + +enum class eTabsLT { + title = 0, + current, + count +}; + +enum class eScraperST { + movietitle = 0, + movieoriginalTitle, + movietagline, + movieoverview, + moviegenres, + moviehomepage, + moviereleasedate, + moviepopularity, + movievoteaverage, + posterpath, + fanartpath, + moviecollectionName, + collectionposterpath, + collectionfanartpath, + seriesname, + seriesoverview, + seriesfirstaired, + seriesnetwork, + seriesgenre, + seriesrating, + seriesstatus, + episodetitle, + episodefirstaired, + episodegueststars, + episodeoverview, + episoderating, + episodeimagepath, + seasonposterpath, + seriesposter1path, + seriesposter2path, + seriesposter3path, + seriesfanart1path, + seriesfanart2path, + seriesfanart3path, + seriesbanner1path, + seriesbanner2path, + seriesbanner3path, + count +}; + +enum class eScraperIT { + ismovie = 0, + moviebudget, + movierevenue, + movieadult, + movieruntime, + isseries, + posterwidth, + posterheight, + fanartwidth, + fanartheight, + movieiscollection, + collectionposterwidth, + collectionposterheight, + collectionfanartwidth, + collectionfanartheight, + epgpicavailable, + episodenumber, + episodeseason, + episodeimagewidth, + episodeimageheight, + seasonposterwidth, + seasonposterheight, + seriesposter1width, + seriesposter1height, + seriesposter2width, + seriesposter2height, + seriesposter3width, + seriesposter3height, + seriesfanart1width, + seriesfanart1height, + seriesfanart2width, + seriesfanart2height, + seriesfanart3width, + seriesfanart3height, + seriesbanner1width, + seriesbanner1height, + seriesbanner2width, + seriesbanner2height, + seriesbanner3width, + seriesbanner3height, + count +}; + +enum class eScraperLT { + //actors + name = 0, + role, + thumb, + thumbwidth, + thumbheight, + count +}; + +enum class eDetailedEpgST { + title = eScraperST::count, + shorttext, + description, + start, + stop, + day, + date, + durationminutes, + vps, + channelname, + channelid, + epgpic1path, + epgpic2path, + epgpic3path, + count +}; + +enum class eDetailedEpgIT { + daynumeric = eScraperIT::count, + month, + year, + running, + elapsed, + duration, + durationhours, + channelnumber, + channellogoexists, + hasreruns, + epgpic1avaialble, + epgpic2avaialble, + epgpic3avaialble, + count +}; + +enum class eRerunsLT { + title = 0, + shorttext, + date, + day, + start, + stop, + channelname, + channelnumber, + channelid, + channellogoexists, + count +}; + +/****************************************************************** +* Tokens RecMenu ViewElements +*******************************************************************/ +enum class eBackgroundRecMenuIT { + menuwidth = 0, + menuheight, + hasscrollbar, + count +}; + +enum class eScrollbarRecMenuIT { + menuwidth = 0, + posy, + totalheight, + height, + offset, + count +}; + +enum class eRecMenuIT { + info = 0, + lines, + button, + buttonyesno, + yes, + intselector, + value, + boolselector, + stringselector, + textinput, + editmode, + timeselector, + dayselector, + channelselector, + channelnumber, + channellogoexisis, + weekdayselector, + dayselected, + day0set, + day1set, + day2set, + day3set, + day4set, + day5set, + day6set, + directoryselector, + timerconflictheader, + overlapstartpercent, + overlapwidthpercent, + timerconflict, + infoactive, + deleteactive, + editactive, + searchactive, + timerstartpercent, + timerwidthpercent, + event, + hastimer, + recording, + recduration, + searchtimer, + timeractive, + activetimers, + recordingsdone, + timelineheader, + timerset, + channeltransponder, + timelinetimer, + timerstart, + timerwidth, + favorite, + count +}; + +enum class eRecMenuST { + line1 = 0, + line2, + line3, + line4, + value, + buttontext, + textyes, + textno, + text, + channelname, + channelid, + transponder, + day0abbr, + day1abbr, + day2abbr, + day3abbr, + day4abbr, + day5abbr, + day6abbr, + folder, + conflictstart, + conflictstop, + overlapstart, + overlapstop, + timertitle, + starttime, + stoptime, + date, + weekday, + title, + shorttext, + recname, + recstarttime, + recdate, + searchstring, + timerstart, + timerstop, + eventtitle, + eventshorttext, + eventstart, + eventstop, + favdesc, + count +}; + +#endif //__DEFINITIONS_H \ No newline at end of file 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::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::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 *reruns = LoadReruns(); + int numReruns = NumReruns(reruns); + + vector 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 *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* 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("reruns[title]", r->event->Title() ? r->event->Title() : "")); - rerun.insert(pair("reruns[shorttext]", r->event->ShortText() ? r->event->ShortText() : "")); - rerun.insert(pair("reruns[start]", *(r->event->GetTimeString()))); - rerun.insert(pair("reruns[start]", *(r->event->GetTimeString()))); - rerun.insert(pair("reruns[stop]", *(r->event->GetEndTimeString()))); - rerun.insert(pair("reruns[date]", *ShortDateString(r->event->StartTime()))); - rerun.insert(pair("reruns[day]", *WeekDayName(r->event->StartTime()))); - string channelID = *(r->event->ChannelID().ToString()); - rerun.insert(pair("reruns[channelid]", channelID)); - bool logoExists = tabs->ChannelLogoExists(channelID); - rerun.insert(pair("reruns[channellogoexists]", logoExists ? "1" : "0")); - - if (channel) { - stringstream channelNumber; - channelNumber << channel->Number(); - rerun.insert(pair("reruns[channelname]", channel->ShortName(true))); - rerun.insert(pair("reruns[channelnumber]", channelNumber.str())); - } else { - rerun.insert(pair("reruns[channelname]", "")); - rerun.insert(pair("reruns[channelnumber]", "")); - } - tabs->AddLoopToken("reruns", rerun); - } - delete list; + cList *result = NULL; + if (epgSearchPlugin->Service("Epgsearch-searchresults-v1.0", &data)) + result = data.pResultList; + return result; +} + +int cDetailView::NumReruns(cList *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 *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::iterator act = movie.actors.begin(); act != movie.actors.end(); act++) { - map< string, string > actor; - actor.insert(pair("actors[name]", (*act).name)); - actor.insert(pair("actors[role]", (*act).role)); - actor.insert(pair("actors[thumb]", (*act).actorThumb.path)); - stringstream actWidth, actHeight; - actWidth << (*act).actorThumb.width; - actHeight << (*act).actorThumb.height; - actor.insert(pair("actors[thumbwidth]", actWidth.str())); - actor.insert(pair("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::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::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::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::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::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::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::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::iterator act = series.actors.begin(); act != series.actors.end(); act++) { - map< string, string > actor; - actor.insert(pair("actors[name]", (*act).name)); - actor.insert(pair("actors[role]", (*act).role)); - actor.insert(pair("actors[thumb]", (*act).actorThumb.path)); - stringstream actWidth, actHeight; - actWidth << (*act).actorThumb.width; - actHeight << (*act).actorThumb.height; - actor.insert(pair("actors[thumbwidth]", actWidth.str())); - actor.insert(pair("actors[thumbheight]", actHeight.str())); - tabs->AddLoopToken("actors", actor); + int actorsIndex = tabs->GetLoopIndex("actors"); + int i=0; + for (vector::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 diff --git a/detailview.h b/detailview.h index f7685c0..517ec9c 100644 --- a/detailview.h +++ b/detailview.h @@ -1,6 +1,8 @@ #ifndef __TVGUIDE_DETAILVIEW_H #define __TVGUIDE_DETAILVIEW_H +#include "services/scraper2vdr.h" +#include "services/epgsearch.h" #include "config.h" #include @@ -10,6 +12,8 @@ private: int lastSecond; skindesignerapi::cOsdView *detailView; const cEvent *event; + cMovie *movie; + cSeries *series; skindesignerapi::cViewElement *back; skindesignerapi::cViewElement *header; skindesignerapi::cViewElement *footer; @@ -19,12 +23,17 @@ private: void DrawHeader(void); void DrawFooter(void); void SetTabTokens(void); - bool LoadReruns(void); + bool LoadScrapInfo(const cEvent *event); + int NumActors(void); void SetScraperTokens(void); + cList *LoadReruns(void); + int NumReruns(cList *reruns); + void SetReruns(cList *reruns); void SetEpgPictures(int eventId); public: cDetailView(skindesignerapi::cOsdView *detailView, const cEvent *event); virtual ~cDetailView(void); + void Activate(void) { detailView->Activate(); }; void Draw(void); void Left(void); void Right(void); @@ -33,6 +42,8 @@ public: bool DrawTime(void); void Flush(void) { detailView->Display(); }; const cEvent *GetEvent(void) { return event; }; + static void DefineTokens(eViewElementsDetail ve, skindesignerapi::cTokenContainer *tk); + static void DefineTabTokens(skindesignerapi::cTokenContainer *tk); }; #endif //__TVGUIDE_DETAILVIEW_H diff --git a/epggrid.c b/epggrid.c index 561d3cb..f2ec973 100644 --- a/epggrid.c +++ b/epggrid.c @@ -14,22 +14,22 @@ cEpgGrid::cEpgGrid(skindesignerapi::cOsdView *rootView, cTimeManager *timeManage channelsPerPage = (config.displayMode == eHorizontal) ? config.channelsPerPageHorizontal : config.channelsPerPageVertical; - back = rootView->GetViewElement(config.displayMode == eHorizontal ? verBackgroundHor : verBackgroundVer); + back = rootView->GetViewElement(config.displayMode == eHorizontal ? (int)eViewElementsRoot::backgroundHor : (int)eViewElementsRoot::backgroundVer); back->Display(); - header = rootView->GetViewElement(config.displayMode == eHorizontal ? verHeaderHor : verHeaderVer); - footer = rootView->GetViewElement(config.displayMode == eHorizontal ? verFooterHor : verFooterVer); - watch = rootView->GetViewElement(config.displayMode == eHorizontal ? verTimeHor : verTimeVer); + header = rootView->GetViewElement(config.displayMode == eHorizontal ? (int)eViewElementsRoot::headerHor : (int)eViewElementsRoot::headerVer); + footer = rootView->GetViewElement(config.displayMode == eHorizontal ? (int)eViewElementsRoot::footerHor : (int)eViewElementsRoot::footerVer); + watch = rootView->GetViewElement(config.displayMode == eHorizontal ? (int)eViewElementsRoot::timeHor : (int)eViewElementsRoot::timeVer); - channelsGrid = rootView->GetViewGrid(config.displayMode == eHorizontal ? vgChannelsHor : vgChannelsVer); - epgGrid = rootView->GetViewGrid(config.displayMode == eHorizontal ? vgSchedulesHor : vgSchedulesVer); + channelsGrid = rootView->GetViewGrid(config.displayMode == eHorizontal ? (int)eViewGridsRoot::channelsHor : (int)eViewGridsRoot::channelsVer); + epgGrid = rootView->GetViewGrid(config.displayMode == eHorizontal ? (int)eViewGridsRoot::schedulesHor : (int)eViewGridsRoot::schedulesVer); - skindesignerapi::cViewElement *timelineDate = rootView->GetViewElement(config.displayMode == eHorizontal ? verDateTimelineHor : verDateTimelineVer); - skindesignerapi::cViewElement *timeIndicator = rootView->GetViewElement(config.displayMode == eHorizontal ? verTimeIndicatorHor : verTimeIndicatorVer); - skindesignerapi::cViewGrid *timelineGrid = rootView->GetViewGrid(config.displayMode == eHorizontal ? vgTimelineHor : vgTimelineVer); + skindesignerapi::cViewElement *timelineDate = rootView->GetViewElement(config.displayMode == eHorizontal ? (int)eViewElementsRoot::dateTimelineHor : (int)eViewElementsRoot::dateTimelineVer); + skindesignerapi::cViewElement *timeIndicator = rootView->GetViewElement(config.displayMode == eHorizontal ? (int)eViewElementsRoot::timeIndicatorHor : (int)eViewElementsRoot::timeIndicatorVer); + skindesignerapi::cViewGrid *timelineGrid = rootView->GetViewGrid(config.displayMode == eHorizontal ? (int)eViewGridsRoot::timelineHor : (int)eViewGridsRoot::timelineVer); timeline = new cTimeline(timelineGrid, timelineDate, timeIndicator, timeManager); - skindesignerapi::cViewGrid *channelgroupsGrid = rootView->GetViewGrid(config.displayMode == eHorizontal ? vgChannelGroupsHor : vgChannelGroupsVer); + skindesignerapi::cViewGrid *channelgroupsGrid = rootView->GetViewGrid(config.displayMode == eHorizontal ? (int)eViewGridsRoot::channelGroupsHor : (int)eViewGridsRoot::channelGroupsVer); channelGroups = new cChannelgroups(channelgroupsGrid); channelGroups->Init(); } @@ -474,9 +474,9 @@ void cEpgGrid::DrawHeader(void) { return; int isDummy = 0; - string title = active->Title(); - string shorttext = ""; - string description = ""; + const char *title = active->Title(); + const char *shorttext = ""; + const char *description = ""; string start = ""; string stop = ""; string day = ""; @@ -548,30 +548,30 @@ void cEpgGrid::DrawHeader(void) { channellogoexists = header->ChannelLogoExists(channelid); } } - header->AddIntToken("isdummy", isDummy); - header->AddStringToken("title", title); - header->AddStringToken("shorttext", shorttext); - header->AddStringToken("description", description); - header->AddStringToken("start", start); - header->AddStringToken("stop", stop); - header->AddStringToken("day", day); - header->AddStringToken("date", date); - header->AddIntToken("daynumeric", daynumeric); - header->AddIntToken("month", month); - header->AddIntToken("year", year); - header->AddIntToken("running", running); - header->AddIntToken("elapsed", elapsed); - header->AddIntToken("duration", duration); - header->AddIntToken("durationhours", durationhours); - header->AddStringToken("durationminutes", durationminutes); - header->AddStringToken("channelname", channelname); - header->AddStringToken("channelid", channelid); - header->AddIntToken("channelnumber", channelnumber); - header->AddIntToken("channellogoexists", channellogoexists); - header->AddIntToken("hasposter", hasposter); - header->AddIntToken("posterwidth", posterwidth); - header->AddIntToken("posterheight", posterheight); - header->AddStringToken("posterpath", posterpath); + header->AddIntToken((int)eHeaderIT::isdummy, isDummy); + header->AddStringToken((int)eHeaderST::title, title); + header->AddStringToken((int)eHeaderST::shorttext, shorttext); + header->AddStringToken((int)eHeaderST::description, description); + header->AddStringToken((int)eHeaderST::start, start.c_str()); + header->AddStringToken((int)eHeaderST::stop, stop.c_str()); + header->AddStringToken((int)eHeaderST::day, day.c_str()); + header->AddStringToken((int)eHeaderST::date, date.c_str()); + header->AddIntToken((int)eHeaderIT::daynumeric, daynumeric); + header->AddIntToken((int)eHeaderIT::month, month); + header->AddIntToken((int)eHeaderIT::year, year); + header->AddIntToken((int)eHeaderIT::running, running); + header->AddIntToken((int)eHeaderIT::elapsed, elapsed); + header->AddIntToken((int)eHeaderIT::duration, duration); + header->AddIntToken((int)eHeaderIT::durationhours, durationhours); + header->AddStringToken((int)eHeaderST::durationminutes, durationminutes.c_str()); + header->AddStringToken((int)eHeaderST::channelname, channelname.c_str()); + header->AddStringToken((int)eHeaderST::channelid, channelid.c_str()); + header->AddIntToken((int)eHeaderIT::channelnumber, channelnumber); + header->AddIntToken((int)eHeaderIT::channellogoexists, channellogoexists); + header->AddIntToken((int)eHeaderIT::hasposter, hasposter); + header->AddIntToken((int)eHeaderIT::posterwidth, posterwidth); + header->AddIntToken((int)eHeaderIT::posterheight, posterheight); + header->AddStringToken((int)eHeaderST::posterpath, posterpath.c_str()); header->Display(); } @@ -608,21 +608,17 @@ void cEpgGrid::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; @@ -638,10 +634,10 @@ void cEpgGrid::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(); @@ -665,19 +661,19 @@ bool cEpgGrid::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; @@ -685,7 +681,7 @@ bool cEpgGrid::DrawTime(void) { } cChannelJump *cEpgGrid::GetChannelJumper(void) { - skindesignerapi::cViewElement *channelJump = rootView->GetViewElement(verChannelJump); + skindesignerapi::cViewElement *channelJump = rootView->GetViewElement((int)eViewElementsRoot::channelJump); int lastValidChannel = GetLastValidChannel(); return new cChannelJump(channelJump, lastValidChannel); } diff --git a/recmenu.c b/recmenu.c index 26724ed..3e55b00 100644 --- a/recmenu.c +++ b/recmenu.c @@ -47,9 +47,9 @@ cRecMenu::~cRecMenu(void) { void cRecMenu::Init(skindesignerapi::cOsdView *osdView) { this->osdView = osdView; - recMenuGrid = osdView->GetViewGrid(vgRecordingMenu); - scrollBar = osdView->GetViewElement(vemScrollbar); - back = osdView->GetViewElement(vemBackground); + recMenuGrid = osdView->GetViewGrid((int)eViewGridsRecMenu::menu); + scrollBar = osdView->GetViewElement((int)eViewElementsRecMenu::scrollbar); + back = osdView->GetViewElement((int)eViewElementsRecMenu::background); InitMenuItems(); } @@ -128,6 +128,121 @@ eRecMenuState cRecMenu::ProcessKey(eKeys Key) { return state; } +void cRecMenu::DefineTokens(eViewElementsRecMenu ve, skindesignerapi::cTokenContainer *tk) { + switch (ve) { + case eViewElementsRecMenu::background: + tk->DefineIntToken("{menuwidth}", (int)eBackgroundRecMenuIT::menuwidth); + tk->DefineIntToken("{menuheight}", (int)eBackgroundRecMenuIT::menuheight); + tk->DefineIntToken("{hasscrollbar}", (int)eBackgroundRecMenuIT::hasscrollbar); + break; + case eViewElementsRecMenu::scrollbar: + tk->DefineIntToken("{menuwidth}", (int)eScrollbarRecMenuIT::menuwidth); + tk->DefineIntToken("{posy}", (int)eScrollbarRecMenuIT::posy); + tk->DefineIntToken("{totalheight}", (int)eScrollbarRecMenuIT::totalheight); + tk->DefineIntToken("{height}", (int)eScrollbarRecMenuIT::height); + tk->DefineIntToken("{offset}", (int)eScrollbarRecMenuIT::offset); + break; + default: + break; + } +} + +void cRecMenu::DefineTokens(eViewGridsRecMenu vg, skindesignerapi::cTokenContainer *tk) { + tk->DefineIntToken("{info}", (int)eRecMenuIT::info); + tk->DefineIntToken("{lines}", (int)eRecMenuIT::lines); + tk->DefineIntToken("{button}", (int)eRecMenuIT::button); + tk->DefineIntToken("{buttonyesno}", (int)eRecMenuIT::buttonyesno); + tk->DefineIntToken("{yes}", (int)eRecMenuIT::yes); + tk->DefineIntToken("{intselector}", (int)eRecMenuIT::intselector); + tk->DefineIntToken("{intvalue}", (int)eRecMenuIT::value); + tk->DefineIntToken("{boolselector}", (int)eRecMenuIT::boolselector); + tk->DefineIntToken("{stringselector}", (int)eRecMenuIT::stringselector); + tk->DefineIntToken("{textinput}", (int)eRecMenuIT::textinput); + tk->DefineIntToken("{editmode}", (int)eRecMenuIT::editmode); + tk->DefineIntToken("{timeselector}", (int)eRecMenuIT::timeselector); + tk->DefineIntToken("{dayselector}", (int)eRecMenuIT::dayselector); + tk->DefineIntToken("{channelselector}", (int)eRecMenuIT::channelselector); + tk->DefineIntToken("{channelnumber}", (int)eRecMenuIT::channelnumber); + tk->DefineIntToken("{channellogoexisis}", (int)eRecMenuIT::channellogoexisis); + tk->DefineIntToken("{weekdayselector}", (int)eRecMenuIT::weekdayselector); + tk->DefineIntToken("{dayselected}", (int)eRecMenuIT::dayselected); + tk->DefineIntToken("{day0set}", (int)eRecMenuIT::day0set); + tk->DefineIntToken("{day1set}", (int)eRecMenuIT::day1set); + tk->DefineIntToken("{day2set}", (int)eRecMenuIT::day2set); + tk->DefineIntToken("{day3set}", (int)eRecMenuIT::day3set); + tk->DefineIntToken("{day4set}", (int)eRecMenuIT::day4set); + tk->DefineIntToken("{day5set}", (int)eRecMenuIT::day5set); + tk->DefineIntToken("{day6set}", (int)eRecMenuIT::day6set); + tk->DefineIntToken("{directoryselector}", (int)eRecMenuIT::directoryselector); + tk->DefineIntToken("{timerconflictheader}", (int)eRecMenuIT::timerconflictheader); + tk->DefineIntToken("{overlapstartpercent}", (int)eRecMenuIT::overlapstartpercent); + tk->DefineIntToken("{overlapwidthpercent}", (int)eRecMenuIT::overlapwidthpercent); + tk->DefineIntToken("{timerconflict}", (int)eRecMenuIT::timerconflict); + tk->DefineIntToken("{infoactive}", (int)eRecMenuIT::infoactive); + tk->DefineIntToken("{deleteactive}", (int)eRecMenuIT::deleteactive); + tk->DefineIntToken("{editactive}", (int)eRecMenuIT::editactive); + tk->DefineIntToken("{searchactive}", (int)eRecMenuIT::searchactive); + tk->DefineIntToken("{timerstartpercent}", (int)eRecMenuIT::timerstartpercent); + tk->DefineIntToken("{timerwidthpercent}", (int)eRecMenuIT::timerwidthpercent); + tk->DefineIntToken("{event}", (int)eRecMenuIT::event); + tk->DefineIntToken("{hastimer}", (int)eRecMenuIT::hastimer); + tk->DefineIntToken("{recording}", (int)eRecMenuIT::recording); + tk->DefineIntToken("{recduration}", (int)eRecMenuIT::recduration); + tk->DefineIntToken("{searchtimer}", (int)eRecMenuIT::searchtimer); + tk->DefineIntToken("{timeractive}", (int)eRecMenuIT::timeractive); + tk->DefineIntToken("{activetimers}", (int)eRecMenuIT::activetimers); + tk->DefineIntToken("{recordingsdone}", (int)eRecMenuIT::recordingsdone); + tk->DefineIntToken("{timelineheader}", (int)eRecMenuIT::timelineheader); + tk->DefineIntToken("{timerset}", (int)eRecMenuIT::timerset); + tk->DefineIntToken("{channeltransponder}", (int)eRecMenuIT::channeltransponder); + tk->DefineIntToken("{timelinetimer}", (int)eRecMenuIT::timelinetimer); + tk->DefineIntToken("{timerstart}", (int)eRecMenuIT::timerstart); + tk->DefineIntToken("{timerwidth}", (int)eRecMenuIT::timerwidth); + tk->DefineIntToken("{favorite}", (int)eRecMenuIT::favorite); + tk->DefineStringToken("{line1}", (int)eRecMenuST::line1); + tk->DefineStringToken("{line2}", (int)eRecMenuST::line2); + tk->DefineStringToken("{line3}", (int)eRecMenuST::line3); + tk->DefineStringToken("{line4}", (int)eRecMenuST::line4); + tk->DefineStringToken("{stringvalue}", (int)eRecMenuST::value); + tk->DefineStringToken("{buttontext}", (int)eRecMenuST::buttontext); + tk->DefineStringToken("{textyes}", (int)eRecMenuST::textyes); + tk->DefineStringToken("{textno}", (int)eRecMenuST::textno); + tk->DefineStringToken("{text}", (int)eRecMenuST::text); + tk->DefineStringToken("{channelname}", (int)eRecMenuST::channelname); + tk->DefineStringToken("{channelid}", (int)eRecMenuST::channelid); + tk->DefineStringToken("{transponder}", (int)eRecMenuST::transponder); + tk->DefineStringToken("{day0abbr}", (int)eRecMenuST::day0abbr); + tk->DefineStringToken("{day1abbr}", (int)eRecMenuST::day1abbr); + tk->DefineStringToken("{day2abbr}", (int)eRecMenuST::day2abbr); + tk->DefineStringToken("{day3abbr}", (int)eRecMenuST::day3abbr); + tk->DefineStringToken("{day4abbr}", (int)eRecMenuST::day4abbr); + tk->DefineStringToken("{day5abbr}", (int)eRecMenuST::day5abbr); + tk->DefineStringToken("{day6abbr}", (int)eRecMenuST::day6abbr); + tk->DefineStringToken("{folder}", (int)eRecMenuST::folder); + tk->DefineStringToken("{conflictstart}", (int)eRecMenuST::conflictstart); + tk->DefineStringToken("{conflictstop}", (int)eRecMenuST::conflictstop); + tk->DefineStringToken("{overlapstart}", (int)eRecMenuST::overlapstart); + tk->DefineStringToken("{overlapstop}", (int)eRecMenuST::overlapstop); + tk->DefineStringToken("{timertitle}", (int)eRecMenuST::timertitle); + tk->DefineStringToken("{starttime}", (int)eRecMenuST::starttime); + tk->DefineStringToken("{stoptime}", (int)eRecMenuST::stoptime); + tk->DefineStringToken("{date}", (int)eRecMenuST::date); + tk->DefineStringToken("{weekday}", (int)eRecMenuST::weekday); + tk->DefineStringToken("{title}", (int)eRecMenuST::title); + tk->DefineStringToken("{shorttext}", (int)eRecMenuST::shorttext); + tk->DefineStringToken("{recname}", (int)eRecMenuST::recname); + tk->DefineStringToken("{recstarttime}", (int)eRecMenuST::recstarttime); + tk->DefineStringToken("{recdate}", (int)eRecMenuST::recdate); + tk->DefineStringToken("{searchstring}", (int)eRecMenuST::searchstring); + tk->DefineStringToken("{timerstart}", (int)eRecMenuST::timerstart); + tk->DefineStringToken("{timerstop}", (int)eRecMenuST::timerstop); + tk->DefineStringToken("{eventtitle}", (int)eRecMenuST::eventtitle); + tk->DefineStringToken("{eventshorttext}", (int)eRecMenuST::eventshorttext); + tk->DefineStringToken("{eventstart}", (int)eRecMenuST::eventstart); + tk->DefineStringToken("{eventstop}", (int)eRecMenuST::eventstop); + tk->DefineStringToken("{favdesc}", (int)eRecMenuST::favdesc); +} + /******************************************************************** * Protected Functions ********************************************************************/ @@ -437,9 +552,9 @@ void cRecMenu::SetLast(void) { void cRecMenu::DrawBackground(void) { back->Clear(); back->ClearTokens(); - back->AddIntToken("menuwidth", menuWidth + 2); - back->AddIntToken("menuheight", GetHeight() + 2); - back->AddIntToken("hasscrollbar", scrolling); + back->AddIntToken((int)eBackgroundRecMenuIT::menuwidth, menuWidth + 2); + back->AddIntToken((int)eBackgroundRecMenuIT::menuheight, GetHeight() + 2); + back->AddIntToken((int)eBackgroundRecMenuIT::hasscrollbar, scrolling); back->Display(); } @@ -456,15 +571,15 @@ void cRecMenu::DrawScrollbar(void) { int offset = (double)startPos / (double)menuItems.Count() * 1000; scrollBar->Clear(); scrollBar->ClearTokens(); - scrollBar->AddIntToken("menuwidth", menuWidth + 2); + scrollBar->AddIntToken((int)eScrollbarRecMenuIT::menuwidth, menuWidth + 2); int y = (100 - GetHeight())/2; if (header) y += header->GetHeight(); - scrollBar->AddIntToken("posy", y); - scrollBar->AddIntToken("totalheight", menuHeight); - scrollBar->AddIntToken("height", scrollBarHeight); - scrollBar->AddIntToken("offset", offset); + scrollBar->AddIntToken((int)eScrollbarRecMenuIT::posy, y); + scrollBar->AddIntToken((int)eScrollbarRecMenuIT::totalheight, menuHeight); + scrollBar->AddIntToken((int)eScrollbarRecMenuIT::height, scrollBarHeight); + scrollBar->AddIntToken((int)eScrollbarRecMenuIT::offset, offset); scrollBar->Display(); } diff --git a/recmenu.h b/recmenu.h index bd7a3df..64b35be 100644 --- a/recmenu.h +++ b/recmenu.h @@ -3,6 +3,7 @@ #include #include +#include "definitions.h" #include "recmenuitem.h" // --- cRecMenu ------------------------------------------------------------- @@ -52,11 +53,14 @@ public: cRecMenu(void); virtual ~cRecMenu(void); void Init(skindesignerapi::cOsdView *osdView); + void Activate(void) { osdView->Activate(); }; void DrawBackground(void); void Draw(void); void Hide(void) { hidden = true; osdView->Deactivate(true); }; void Show(void) { hidden = false; osdView->Activate(); }; void Flush(void) { osdView->Display(); }; virtual eRecMenuState ProcessKey(eKeys Key); + static void DefineTokens(eViewElementsRecMenu ve, skindesignerapi::cTokenContainer *tk); + static void DefineTokens(eViewGridsRecMenu vg, skindesignerapi::cTokenContainer *tk); }; #endif //__TVGUIDE_RECMENU_H \ No newline at end of file diff --git a/recmenuitem.c b/recmenuitem.c index 1533218..81fa2ed 100644 --- a/recmenuitem.c +++ b/recmenuitem.c @@ -57,12 +57,12 @@ cRecMenuItemInfo::~cRecMenuItemInfo(void) { void cRecMenuItemInfo::SetTokens(skindesignerapi::cViewGrid *menu) { menu->ClearTokens(); - menu->AddIntToken("info", 1); - menu->AddIntToken("lines", numLines); - menu->AddStringToken("line1", line1); - menu->AddStringToken("line2", line2); - menu->AddStringToken("line3", line3); - menu->AddStringToken("line4", line4); + menu->AddIntToken((int)eRecMenuIT::info, 1); + menu->AddIntToken((int)eRecMenuIT::lines, numLines); + menu->AddStringToken((int)eRecMenuST::line1, line1.c_str()); + menu->AddStringToken((int)eRecMenuST::line2, line2.c_str()); + menu->AddStringToken((int)eRecMenuST::line3, line3.c_str()); + menu->AddStringToken((int)eRecMenuST::line4, line4.c_str()); } // --- cRecMenuItemButton ------------------------------------------------------- @@ -80,8 +80,8 @@ cRecMenuItemButton::~cRecMenuItemButton(void) { void cRecMenuItemButton::SetTokens(skindesignerapi::cViewGrid *menu) { menu->ClearTokens(); - menu->AddIntToken("button", 1); - menu->AddStringToken("buttontext", text); + menu->AddIntToken((int)eRecMenuIT::button, 1); + menu->AddStringToken((int)eRecMenuST::buttontext, text.c_str()); } eRecMenuState cRecMenuItemButton::ProcessKey(eKeys Key) { @@ -116,10 +116,10 @@ cRecMenuItemButtonYesNo::~cRecMenuItemButtonYesNo(void) { void cRecMenuItemButtonYesNo::SetTokens(skindesignerapi::cViewGrid *menu) { menu->ClearTokens(); - menu->AddIntToken("buttonyesno", 1); - menu->AddIntToken("yes", yesActive); - menu->AddStringToken("textyes", textYes); - menu->AddStringToken("textno", textNo); + menu->AddIntToken((int)eRecMenuIT::buttonyesno, 1); + menu->AddIntToken((int)eRecMenuIT::yes, yesActive); + menu->AddStringToken((int)eRecMenuST::textyes, textYes.c_str()); + menu->AddStringToken((int)eRecMenuST::textno, textNo.c_str()); } eRecMenuState cRecMenuItemButtonYesNo::ProcessKey(eKeys Key) { @@ -176,9 +176,9 @@ cRecMenuItemInt::~cRecMenuItemInt(void) { void cRecMenuItemInt::SetTokens(skindesignerapi::cViewGrid *menu) { menu->ClearTokens(); - menu->AddIntToken("intselector", 1); - menu->AddIntToken("value", currentVal); - menu->AddStringToken("text", text); + menu->AddIntToken((int)eRecMenuIT::intselector, 1); + menu->AddIntToken((int)eRecMenuIT::value, currentVal); + menu->AddStringToken((int)eRecMenuST::text, text.c_str()); } eRecMenuState cRecMenuItemInt::ProcessKey(eKeys Key) { @@ -242,9 +242,9 @@ cRecMenuItemBool::~cRecMenuItemBool(void) { void cRecMenuItemBool::SetTokens(skindesignerapi::cViewGrid *menu) { menu->ClearTokens(); - menu->AddIntToken("boolselector", 1); - menu->AddIntToken("value", yes); - menu->AddStringToken("text", text); + menu->AddIntToken((int)eRecMenuIT::boolselector, 1); + menu->AddIntToken((int)eRecMenuIT::value, yes); + menu->AddStringToken((int)eRecMenuST::text, text.c_str()); } eRecMenuState cRecMenuItemBool::ProcessKey(eKeys Key) { @@ -290,9 +290,9 @@ cRecMenuItemSelect::~cRecMenuItemSelect(void) { void cRecMenuItemSelect::SetTokens(skindesignerapi::cViewGrid *menu) { menu->ClearTokens(); - menu->AddIntToken("stringselector", 1); - menu->AddStringToken("text", text); - menu->AddStringToken("value", strings[currentVal]); + menu->AddIntToken((int)eRecMenuIT::stringselector, 1); + menu->AddStringToken((int)eRecMenuST::text, text.c_str()); + menu->AddStringToken((int)eRecMenuST::value, strings[currentVal].c_str()); } eRecMenuState cRecMenuItemSelect::ProcessKey(eKeys Key) { @@ -502,13 +502,13 @@ void cRecMenuItemText::SetText(void) { void cRecMenuItemText::SetTokens(skindesignerapi::cViewGrid *menu) { menu->ClearTokens(); - menu->AddIntToken("textinput", 1); - menu->AddIntToken("editmode", InEditMode()); - menu->AddStringToken("text", text); + menu->AddIntToken((int)eRecMenuIT::textinput, 1); + menu->AddIntToken((int)eRecMenuIT::editmode, InEditMode()); + menu->AddStringToken((int)eRecMenuST::text, text.c_str()); if (buffer.size() > 0) { - menu->AddStringToken("value", buffer); + menu->AddStringToken((int)eRecMenuST::value, buffer.c_str()); } else { - menu->AddStringToken("value", value); + menu->AddStringToken((int)eRecMenuST::value, value); } } @@ -720,9 +720,9 @@ void cRecMenuItemTime::SetTokens(skindesignerapi::cViewGrid *menu) { default: snprintf(buf, sizeof(buf), "%02d:%02d", hh, mm); } menu->ClearTokens(); - menu->AddIntToken("timeselector", 1); - menu->AddStringToken("text", text); - menu->AddStringToken("value", buf); + menu->AddIntToken((int)eRecMenuIT::timeselector, 1); + menu->AddStringToken((int)eRecMenuST::text, text.c_str()); + menu->AddStringToken((int)eRecMenuST::value, buf); } eRecMenuState cRecMenuItemTime::ProcessKey(eKeys Key) { @@ -822,9 +822,9 @@ cRecMenuItemDay::~cRecMenuItemDay(void) { void cRecMenuItemDay::SetTokens(skindesignerapi::cViewGrid *menu) { menu->ClearTokens(); - menu->AddIntToken("dayselector", 1); - menu->AddStringToken("text", text); - menu->AddStringToken("value", *DateString(currentVal)); + menu->AddIntToken((int)eRecMenuIT::dayselector, 1); + menu->AddStringToken((int)eRecMenuST::text, text.c_str()); + menu->AddStringToken((int)eRecMenuST::value, *DateString(currentVal)); } eRecMenuState cRecMenuItemDay::ProcessKey(eKeys Key) { @@ -876,19 +876,19 @@ cRecMenuItemChannelChooser::~cRecMenuItemChannelChooser(void) { void cRecMenuItemChannelChooser::SetTokens(skindesignerapi::cViewGrid *menu) { menu->ClearTokens(); - menu->AddIntToken("channelselector", 1); - menu->AddStringToken("text", text); + menu->AddIntToken((int)eRecMenuIT::channelselector, 1); + menu->AddStringToken((int)eRecMenuST::text, text.c_str()); if (channel) { - menu->AddIntToken("channelnumber", channel->Number()); - menu->AddStringToken("channelname", channel->Name()); - string channelId = *(channel->GetChannelID().ToString()); - menu->AddStringToken("channelid", channelId); - menu->AddIntToken("channellogoexisis", menu->ChannelLogoExists(channelId)); + menu->AddIntToken((int)eRecMenuIT::channelnumber, channel->Number()); + menu->AddStringToken((int)eRecMenuST::channelname, channel->Name()); + cString channelId = channel->GetChannelID().ToString(); + menu->AddStringToken((int)eRecMenuST::channelid, *channelId); + menu->AddIntToken((int)eRecMenuIT::channellogoexisis, menu->ChannelLogoExists(*channelId)); } else { - menu->AddIntToken("channelnumber", 0); - menu->AddStringToken("channelname", tr("all Channels")); - menu->AddStringToken("channelid", ""); - menu->AddIntToken("channellogoexisis", false); + menu->AddIntToken((int)eRecMenuIT::channelnumber, 0); + menu->AddStringToken((int)eRecMenuST::channelname, tr("all Channels")); + menu->AddStringToken((int)eRecMenuST::channelid, ""); + menu->AddIntToken((int)eRecMenuIT::channellogoexisis, false); } } @@ -987,19 +987,15 @@ cRecMenuItemDayChooser::~cRecMenuItemDayChooser(void) { void cRecMenuItemDayChooser::SetTokens(skindesignerapi::cViewGrid *menu) { menu->ClearTokens(); - menu->AddIntToken("weekdayselector", 1); - menu->AddStringToken("text", text); - menu->AddIntToken("dayselected", selectedDay); + menu->AddIntToken((int)eRecMenuIT::weekdayselector, 1); + menu->AddStringToken((int)eRecMenuST::text, text.c_str()); + menu->AddIntToken((int)eRecMenuIT::dayselected, selectedDay); string days = trVDR("MTWTFSS"); for (unsigned day=0; dayAddStringToken(nameWeekday.str(), strDay); - menu->AddIntToken(nameWeekdaySet.str(), WeekDaySet(day)); + cString strDay = cString::sprintf("%c", days.at(day)); + menu->AddStringToken((int)eRecMenuST::day0abbr + day, *strDay); + menu->AddIntToken((int)eRecMenuIT::day0set + day, WeekDaySet(day)); } } @@ -1067,9 +1063,9 @@ cRecMenuItemSelectDirectory::cRecMenuItemSelectDirectory(string text, void cRecMenuItemSelectDirectory::SetTokens(skindesignerapi::cViewGrid *menu) { menu->ClearTokens(); - menu->AddIntToken("directoryselector", 1); - menu->AddStringToken("text", text); - menu->AddStringToken("folder", folders[currentVal]); + menu->AddIntToken((int)eRecMenuIT::directoryselector, 1); + menu->AddStringToken((int)eRecMenuST::text, text.c_str()); + menu->AddStringToken((int)eRecMenuST::folder, folders[currentVal].c_str()); } eRecMenuState cRecMenuItemSelectDirectory::ProcessKey(eKeys Key) { @@ -1135,17 +1131,17 @@ cRecMenuItemTimerConflictHeader::~cRecMenuItemTimerConflictHeader(void) { void cRecMenuItemTimerConflictHeader::SetTokens(skindesignerapi::cViewGrid *menu) { menu->ClearTokens(); - menu->AddIntToken("timerconflictheader", 1); - menu->AddStringToken("text", tr("Timer Conflict")); - menu->AddStringToken("conflictstart", *TimeString(conflictStart)); - menu->AddStringToken("conflictstop", *TimeString(conflictStop)); - menu->AddStringToken("overlapstart", *TimeString(overlapStart)); - menu->AddStringToken("overlapstop", *TimeString(overlapStop)); + menu->AddIntToken((int)eRecMenuIT::timerconflictheader, 1); + menu->AddStringToken((int)eRecMenuST::text, tr("Timer Conflict")); + menu->AddStringToken((int)eRecMenuST::conflictstart, *TimeString(conflictStart)); + menu->AddStringToken((int)eRecMenuST::conflictstop, *TimeString(conflictStop)); + menu->AddStringToken((int)eRecMenuST::overlapstart, *TimeString(overlapStart)); + menu->AddStringToken((int)eRecMenuST::overlapstop, *TimeString(overlapStop)); int olStart = (double)(overlapStart - conflictStart) / (double)(conflictStop - conflictStart) * 100; int olWidth = (double)(overlapStop - overlapStart) / (double)(conflictStop - conflictStart) * 100; - menu->AddIntToken("overlapstartpercent", olStart); - menu->AddIntToken("overlapwidthpercent", olWidth); + menu->AddIntToken((int)eRecMenuIT::overlapstartpercent, olStart); + menu->AddIntToken((int)eRecMenuIT::overlapwidthpercent, olWidth); } // --- cRecMenuItemTimer ------------------------------------------------------- @@ -1179,36 +1175,36 @@ cRecMenuItemTimer::~cRecMenuItemTimer(void) { void cRecMenuItemTimer::SetTokens(skindesignerapi::cViewGrid *menu) { menu->ClearTokens(); - menu->AddIntToken("timerconflict", 1); + menu->AddIntToken((int)eRecMenuIT::timerconflict, 1); const cChannel *channel = timer->Channel(); int channelTransponder = 0; - string channelName = ""; - string channelId = ""; + const char *channelName = NULL; + cString channelId = ""; if (channel) { channelTransponder = channel->Transponder(); channelName = channel->Name() ? channel->Name() : ""; - channelId = *(channel->GetChannelID().ToString()); + channelId = channel->GetChannelID().ToString(); } - menu->AddIntToken("transponder", channelTransponder); - menu->AddStringToken("channelname", channelName); - menu->AddStringToken("channelid", channelId); + menu->AddIntToken((int)eRecMenuIT::channeltransponder, channelTransponder); + menu->AddStringToken((int)eRecMenuST::channelname, channelName); + menu->AddStringToken((int)eRecMenuST::channelid, *channelId); const cEvent *event = timer->Event(); string timerTitle = ""; if (event && event->Title()) { timerTitle = event->Title(); } - menu->AddStringToken("timertitle", timerTitle); - menu->AddStringToken("starttime", *TimeString(timer->StartTime())); - menu->AddStringToken("stoptime", *TimeString(timer->StopTime())); - menu->AddStringToken("date", *ShortDateString(timer->StartTime())); - menu->AddStringToken("weekday", *WeekDayName(timer->StartTime())); + menu->AddStringToken((int)eRecMenuST::timertitle, timerTitle.c_str()); + menu->AddStringToken((int)eRecMenuST::starttime, *TimeString(timer->StartTime())); + menu->AddStringToken((int)eRecMenuST::stoptime, *TimeString(timer->StopTime())); + menu->AddStringToken((int)eRecMenuST::date, *ShortDateString(timer->StartTime())); + menu->AddStringToken((int)eRecMenuST::weekday, *WeekDayName(timer->StartTime())); - menu->AddIntToken("infoactive", (iconActive==0)?true:false); - menu->AddIntToken("deleteactive", (iconActive==1)?true:false); - menu->AddIntToken("editactive", (iconActive==2)?true:false); - menu->AddIntToken("searchactive", (iconActive==3)?true:false); + menu->AddIntToken((int)eRecMenuIT::infoactive, (iconActive==0)?true:false); + menu->AddIntToken((int)eRecMenuIT::deleteactive, (iconActive==1)?true:false); + menu->AddIntToken((int)eRecMenuIT::editactive, (iconActive==2)?true:false); + menu->AddIntToken((int)eRecMenuIT::searchactive, (iconActive==3)?true:false); int conflictTime = conflictStop - conflictStart; @@ -1216,10 +1212,10 @@ void cRecMenuItemTimer::SetTokens(skindesignerapi::cViewGrid *menu) { int timerWidth = (double)(timer->StopTime() - timer->StartTime()) / (double)conflictTime * 100; int olStart = (double)(overlapStart - conflictStart) / (double)(conflictStop - conflictStart) * 100; int olWidth = (double)(overlapStop - overlapStart) / (double)(conflictStop - conflictStart) * 100; - menu->AddIntToken("timerstartpercent", timerStart); - menu->AddIntToken("timerwidthpercent", timerWidth); - menu->AddIntToken("overlapstartpercent", olStart); - menu->AddIntToken("overlapwidthpercent", olWidth); + menu->AddIntToken((int)eRecMenuIT::timerstartpercent, timerStart); + menu->AddIntToken((int)eRecMenuIT::timerwidthpercent, timerWidth); + menu->AddIntToken((int)eRecMenuIT::overlapstartpercent, olStart); + menu->AddIntToken((int)eRecMenuIT::overlapwidthpercent, olWidth); } eRecMenuState cRecMenuItemTimer::ProcessKey(eKeys Key) { @@ -1273,27 +1269,27 @@ cRecMenuItemEvent::~cRecMenuItemEvent(void) { void cRecMenuItemEvent::SetTokens(skindesignerapi::cViewGrid *menu) { menu->ClearTokens(); - menu->AddIntToken("event", 1); + menu->AddIntToken((int)eRecMenuIT::event, 1); const cChannel *channel = Channels.GetByChannelID(event->ChannelID()); - string channelName = ""; - string channelId = ""; - if (channel && channel->Name()) { + const char *channelName = NULL; + cString channelId = ""; + if (channel) { channelName = channel->Name(); - channelId = *(channel->GetChannelID().ToString()); - menu->AddIntToken("channelnumber", channel->Number()); + channelId = channel->GetChannelID().ToString(); + menu->AddIntToken((int)eRecMenuIT::channelnumber, channel->Number()); } - menu->AddStringToken("channelname", channelName); - menu->AddStringToken("channelid", channelId); - menu->AddIntToken("channellogoexisis", menu->ChannelLogoExists(channelId)); - menu->AddStringToken("title", event->Title() ? event->Title() : ""); - menu->AddStringToken("shorttext", event->ShortText() ? event->ShortText() : ""); - menu->AddStringToken("date", *ShortDateString(event->StartTime())); - menu->AddStringToken("weekday", *WeekDayName(event->StartTime())); - menu->AddStringToken("starttime", *TimeString(event->StartTime())); - menu->AddStringToken("stoptime", *TimeString(event->EndTime())); - menu->AddIntToken("hastimer", event->HasTimer()); + menu->AddStringToken((int)eRecMenuST::channelname, channelName); + menu->AddStringToken((int)eRecMenuST::channelid, *channelId); + menu->AddIntToken((int)eRecMenuIT::channellogoexisis, menu->ChannelLogoExists(*channelId)); + menu->AddStringToken((int)eRecMenuST::title, event->Title()); + menu->AddStringToken((int)eRecMenuST::shorttext, event->ShortText()); + menu->AddStringToken((int)eRecMenuST::date, *ShortDateString(event->StartTime())); + menu->AddStringToken((int)eRecMenuST::weekday, *WeekDayName(event->StartTime())); + menu->AddStringToken((int)eRecMenuST::starttime, *TimeString(event->StartTime())); + menu->AddStringToken((int)eRecMenuST::stoptime, *TimeString(event->EndTime())); + menu->AddIntToken((int)eRecMenuIT::hastimer, event->HasTimer()); } eRecMenuState cRecMenuItemEvent::ProcessKey(eKeys Key) { @@ -1321,7 +1317,7 @@ cRecMenuItemRecording::cRecMenuItemRecording(cRecording *recording, bool active) void cRecMenuItemRecording::SetTokens(skindesignerapi::cViewGrid *menu) { menu->ClearTokens(); - menu->AddIntToken("recording", 1); + menu->AddIntToken((int)eRecMenuIT::recording, 1); if (!recording) return; const cRecordingInfo *recInfo = recording->Info(); @@ -1333,21 +1329,21 @@ void cRecMenuItemRecording::SetTokens(skindesignerapi::cViewGrid *menu) { if (channel && channel->Name()) { channelName = channel->Name(); channelId = *(channel->GetChannelID().ToString()); - menu->AddIntToken("channelnumber", channel->Number()); + menu->AddIntToken((int)eRecMenuIT::channelnumber, channel->Number()); } - menu->AddStringToken("channelname", channelName); - menu->AddStringToken("channelid", channelId); - menu->AddIntToken("channellogoexisis", menu->ChannelLogoExists(channelId)); + menu->AddStringToken((int)eRecMenuST::channelname, channelName.c_str()); + menu->AddStringToken((int)eRecMenuST::channelid, channelId.c_str()); + menu->AddIntToken((int)eRecMenuIT::channellogoexisis, menu->ChannelLogoExists(channelId)); string recName = recording->Name() ? recording->Name() : ""; string recDate = *ShortDateString(recording->Start()); string recStartTime = *TimeString(recording->Start()); int recDuration = recording->LengthInSeconds() / 60; - menu->AddStringToken("recname", recName); - menu->AddStringToken("recdate", recDate); - menu->AddStringToken("recstarttime", recStartTime); - menu->AddIntToken("recduration", recDuration); + menu->AddStringToken((int)eRecMenuST::recname, recName.c_str()); + menu->AddStringToken((int)eRecMenuST::recdate, recDate.c_str()); + menu->AddStringToken((int)eRecMenuST::recstarttime, recStartTime.c_str()); + menu->AddIntToken((int)eRecMenuIT::recduration, recDuration); } // --- cRecMenuItemSearchTimer ------------------------------------------------------- @@ -1371,14 +1367,14 @@ cRecMenuItemSearchTimer::~cRecMenuItemSearchTimer(void) { void cRecMenuItemSearchTimer::SetTokens(skindesignerapi::cViewGrid *menu) { menu->ClearTokens(); - menu->AddIntToken("searchtimer", 1); - menu->AddIntToken("timeractive", timer.Active()); - menu->AddStringToken("searchstring", timer.SearchString()); - menu->AddIntToken("activetimers", timer.GetNumTimers()); - menu->AddIntToken("recordingsdone", timer.GetNumRecordings()); - menu->AddIntToken("searchactive", (iconActive==0)?true:false); - menu->AddIntToken("editactive", (iconActive==1)?true:false); - menu->AddIntToken("deleteactive", (iconActive==2)?true:false); + menu->AddIntToken((int)eRecMenuIT::searchtimer, 1); + menu->AddIntToken((int)eRecMenuIT::timeractive, timer.Active()); + menu->AddStringToken((int)eRecMenuST::searchstring, timer.SearchString().c_str()); + menu->AddIntToken((int)eRecMenuIT::activetimers, timer.GetNumTimers()); + menu->AddIntToken((int)eRecMenuIT::recordingsdone, timer.GetNumRecordings()); + menu->AddIntToken((int)eRecMenuIT::searchactive, (iconActive==0)?true:false); + menu->AddIntToken((int)eRecMenuIT::editactive, (iconActive==1)?true:false); + menu->AddIntToken((int)eRecMenuIT::deleteactive, (iconActive==2)?true:false); } eRecMenuState cRecMenuItemSearchTimer::ProcessKey(eKeys Key) { @@ -1425,50 +1421,50 @@ cRecMenuItemTimelineHeader::~cRecMenuItemTimelineHeader(void) { void cRecMenuItemTimelineHeader::SetTokens(skindesignerapi::cViewGrid *menu) { menu->ClearTokens(); - menu->AddIntToken("timelineheader", 1); + menu->AddIntToken((int)eRecMenuIT::timelineheader, 1); string daydate = *DateString(day); - menu->AddStringToken("date", daydate); + menu->AddStringToken((int)eRecMenuST::date, daydate.c_str()); if (!timer) { - menu->AddIntToken("timerset", false); + menu->AddIntToken((int)eRecMenuIT::timerset, false); return; } - menu->AddIntToken("timerset", true); + menu->AddIntToken((int)eRecMenuIT::timerset, true); const cChannel *channel = timer->Channel(); - string channelName = ""; - string channelId = ""; + const char *channelName = NULL; + cString channelId = ""; int channelNumber = 0; int transponder = 0; if (channel) { - channelName = channel->Name() ? channel->Name() : ""; - channelId = *(channel->GetChannelID().ToString()); + channelName = channel->Name(); + channelId = channel->GetChannelID().ToString(); channelNumber = channel->Number(); transponder = channel->Transponder(); } - menu->AddStringToken("channelname", channelName); - menu->AddStringToken("channelid", channelId); - menu->AddIntToken("channelnumber", channelNumber); - menu->AddIntToken("channeltransponder", transponder); - menu->AddIntToken("channellogoexisis", menu->ChannelLogoExists(channelId)); + menu->AddStringToken((int)eRecMenuST::channelname, channelName); + menu->AddStringToken((int)eRecMenuST::channelid, *channelId); + menu->AddIntToken((int)eRecMenuIT::channelnumber, channelNumber); + menu->AddIntToken((int)eRecMenuIT::channeltransponder, transponder); + menu->AddIntToken((int)eRecMenuIT::channellogoexisis, menu->ChannelLogoExists(*channelId)); - menu->AddStringToken("timerstart", *TimeString(timer->StartTime())); - menu->AddStringToken("timerstop", *TimeString(timer->StopTime())); + menu->AddStringToken((int)eRecMenuST::timerstart, *TimeString(timer->StartTime())); + menu->AddStringToken((int)eRecMenuST::timerstop, *TimeString(timer->StopTime())); const cEvent *event = timer->Event(); - string eventTitle = ""; - string eventShortText = ""; - string eventStart = ""; - string eventStop = ""; + const char *eventTitle = NULL; + const char *eventShortText = ""; + cString eventStart = ""; + cString eventStop = ""; if (event) { - eventTitle = event->Title() ? event->Title() : ""; - eventShortText = event->ShortText() ? event->ShortText() : ""; - eventStart = *event->GetTimeString(); - eventStop = *event->GetEndTimeString(); + eventTitle = event->Title(); + eventShortText = event->ShortText(); + eventStart = event->GetTimeString(); + eventStop = event->GetEndTimeString(); } - menu->AddStringToken("eventtitle", eventTitle); - menu->AddStringToken("eventshorttext", eventShortText); - menu->AddStringToken("eventstart", eventStart); - menu->AddStringToken("eventstop", eventStop); + menu->AddStringToken((int)eRecMenuST::eventtitle, eventTitle); + menu->AddStringToken((int)eRecMenuST::eventshorttext, eventShortText); + menu->AddStringToken((int)eRecMenuST::eventstart, *eventStart); + menu->AddStringToken((int)eRecMenuST::eventstop, *eventStop); } // --- cRecMenuItemTimelineTimer ------------------------------------------------------- @@ -1486,7 +1482,7 @@ cRecMenuItemTimelineTimer::~cRecMenuItemTimelineTimer(void) { void cRecMenuItemTimelineTimer::SetTokens(skindesignerapi::cViewGrid *menu) { menu->ClearTokens(); - menu->AddIntToken("timelinetimer", 1); + menu->AddIntToken((int)eRecMenuIT::timelinetimer, 1); int secsPerDay = 24*60*60; time_t timerStart = timer->StartTime() - start; @@ -1498,8 +1494,8 @@ void cRecMenuItemTimelineTimer::SetTokens(skindesignerapi::cViewGrid *menu) { int percentStart = ((double)timerStart / (double)secsPerDay) * 1000; int percentWidth = ((double)(timerStop - timerStart) / (double)secsPerDay) * 1000; - menu->AddIntToken("timerstart", percentStart); - menu->AddIntToken("timerwidth", percentWidth); + menu->AddIntToken((int)eRecMenuIT::timerstart, percentStart); + menu->AddIntToken((int)eRecMenuIT::timerwidth, percentWidth); } cTimer *cRecMenuItemTimelineTimer::GetTimer(void) { @@ -1529,8 +1525,8 @@ cRecMenuItemFavorite::cRecMenuItemFavorite(cTVGuideSearchTimer favorite, void cRecMenuItemFavorite::SetTokens(skindesignerapi::cViewGrid *menu) { menu->ClearTokens(); - menu->AddIntToken("favorite", 1); - menu->AddStringToken("favdesc", favorite.SearchString()); + menu->AddIntToken((int)eRecMenuIT::favorite, 1); + menu->AddStringToken((int)eRecMenuST::favdesc, favorite.SearchString().c_str()); } eRecMenuState cRecMenuItemFavorite::ProcessKey(eKeys Key) { @@ -1554,8 +1550,8 @@ cRecMenuItemFavoriteStatic::cRecMenuItemFavoriteStatic(string text, eRecMenuStat void cRecMenuItemFavoriteStatic::SetTokens(skindesignerapi::cViewGrid *menu) { menu->ClearTokens(); - menu->AddIntToken("favorite", 1); - menu->AddStringToken("favdesc", text); + menu->AddIntToken((int)eRecMenuIT::favorite, 1); + menu->AddStringToken((int)eRecMenuST::favdesc, text.c_str()); } eRecMenuState cRecMenuItemFavoriteStatic::ProcessKey(eKeys Key) { diff --git a/recmenuitem.h b/recmenuitem.h index f1f7e69..05818b8 100644 --- a/recmenuitem.h +++ b/recmenuitem.h @@ -10,6 +10,7 @@ using namespace std; #include #include #include +#include "definitions.h" #include "searchtimer.h" enum eRecMenuState { diff --git a/recmenus.c b/recmenus.c index 1a7d867..d6327bd 100644 --- a/recmenus.c +++ b/recmenus.c @@ -548,6 +548,7 @@ void cRecMenuSearchTimerEdit::CreateMenuItems(void) { AddMenuItem(new cRecMenuItemBool(tr("Active"), timerActive, false, &timerActive, rmsSearchTimerSave)); vector searchModes; searchTimer.GetSearchModes(&searchModes); + esyslog("tvguideng: num search modes %ld", searchModes.size()); AddMenuItem(new cRecMenuItemSelect(tr("Search Mode"), searchModes, mode, false, &mode, rmsSearchTimerSave)); AddMenuItem(new cRecMenuItemBool(tr("Use Title"), useTitle, false, &useTitle, rmsSearchTimerSave)); AddMenuItem(new cRecMenuItemBool(tr("Use Subtitle"), useSubtitle, false, &useSubtitle, rmsSearchTimerSave)); diff --git a/searchtimer.c b/searchtimer.c index 6570c55..fe78f6c 100644 --- a/searchtimer.c +++ b/searchtimer.c @@ -238,7 +238,7 @@ bool cTVGuideSearchTimer::Parse(bool readTemplate) { } else if (useChannel == 1) { char *channelMinbuffer = NULL; char *channelMaxbuffer = NULL; - int channels = sscanf(values[value].c_str(), "%a[^|]|%a[^|]", &channelMinbuffer, &channelMaxbuffer); + int channels = sscanf(values[value].c_str(), "%m[^|]|%m[^|]", &channelMinbuffer, &channelMaxbuffer); channelMin = Channels.GetByChannelID(tChannelID::FromString(channelMinbuffer), true, true); if (!channelMin) { channelMin = channelMax = NULL; diff --git a/templates/plug-tvguideng-root.xml b/templates/plug-tvguideng-root.xml index d87176a..b4b3f22 100644 --- a/templates/plug-tvguideng-root.xml +++ b/templates/plug-tvguideng-root.xml @@ -108,6 +108,7 @@ diff --git a/timeline.c b/timeline.c index d48cb4b..bc2a31f 100644 --- a/timeline.c +++ b/timeline.c @@ -1,8 +1,12 @@ #include "timeline.h" +long cTimelineElement::idCounter; + // --- cTimelineElement ------------------------------------------------------------- cTimelineElement::cTimelineElement(time_t elementTime) { + id = idCounter; + idCounter++; init = true; this->elementTime = elementTime; } @@ -108,8 +112,8 @@ void cTimeline::Draw(void) { for (cTimelineElement *e = grids.First(); e; e = grids.Next(e)) { if (e->IsNew()) { timelineGrid->ClearTokens(); - timelineGrid->AddIntToken("fullhour", e->IsFullHour()); - timelineGrid->AddStringToken("timestring", e->ToString()); + timelineGrid->AddIntToken((int)eTimelineGridIT::fullhour, e->IsFullHour()); + timelineGrid->AddStringToken((int)eTimelineGridST::timestring, e->ToString().c_str()); timelineGrid->SetGrid(e->Id(), x, y, width, height); } else { timelineGrid->MoveGrid(e->Id(), x, y, width, height); @@ -129,9 +133,8 @@ void cTimeline::DrawDate(void) { weekday = weekdayNew; timelineDate->Clear(); timelineDate->ClearTokens(); - string date = *(timeManager->GetDate()); - timelineDate->AddStringToken("weekday", weekday); - timelineDate->AddStringToken("date", date); + timelineDate->AddStringToken((int)eDateTimeST::weekday, weekday.c_str()); + timelineDate->AddStringToken((int)eDateTimeST::date, *(timeManager->GetDate())); timelineDate->Display(); } @@ -142,7 +145,7 @@ void cTimeline::DrawTimeIndicator(void) { int percentTotal = distance*1000/(config.displayHours*60); timeIndicator->Clear(); timeIndicator->ClearTokens(); - timeIndicator->AddIntToken("percenttotal", percentTotal); + timeIndicator->AddIntToken((int)eTimeIndicatorIT::percenttotal, percentTotal); timeIndicator->Display(); } else if (timeIndicatorShown) { timeIndicatorShown = false; diff --git a/timeline.h b/timeline.h index 7675a6a..2d9bebf 100644 --- a/timeline.h +++ b/timeline.h @@ -4,6 +4,7 @@ #include #include #include +#include "definitions.h" #include "config.h" #include "timemanager.h" @@ -11,12 +12,14 @@ class cTimelineElement : public cListObject { private: + static long idCounter; + long id; bool init; time_t elementTime; public: cTimelineElement(time_t elementTime); virtual ~cTimelineElement(void); - long Id(void) { return elementTime; }; + long Id(void) { return id; }; bool IsNew(void); bool IsFullHour(void); string ToString(void) { return *TimeString(elementTime); }; diff --git a/tvguideng.c b/tvguideng.c index eed321a..52aeda1 100644 --- a/tvguideng.c +++ b/tvguideng.c @@ -11,15 +11,17 @@ #define DEFINE_CONFIG 1 #include "config.h" #include "setup.h" +#include "definitions.h" #include "tvguidengosd.h" -static const char *VERSION = "0.1.6"; +static const char *VERSION = "0.2.0"; static const char *DESCRIPTION = "TV Guide for Skindesigner Skins"; static const char *MAINMENUENTRY = "TV Guide NG"; class cPluginTvguideng : public cPlugin { private: - // Add any member variables or functions you may need here. + skindesignerapi::cPluginStructure *plugStruct; + void SkindesignerRegister(void); public: cPluginTvguideng(void); virtual ~cPluginTvguideng(); @@ -50,58 +52,19 @@ cPluginTvguideng::~cPluginTvguideng() { } const char *cPluginTvguideng::CommandLineHelp(void) { - return NULL; + return NULL; } bool cPluginTvguideng::ProcessArgs(int argc, char *argv[]) { - return true; + return true; } bool cPluginTvguideng::Initialize(void) { - return true; + return true; } bool cPluginTvguideng::Start(void) { - skindesignerapi::cPluginStructure plugStruct; - plugStruct.name = "tvguideng"; - plugStruct.libskindesignerAPIVersion = LIBSKINDESIGNERAPIVERSION; - plugStruct.SetView(viRootView, "root.xml"); - plugStruct.SetViewElement(viRootView, verBackgroundHor, "background_hor"); - plugStruct.SetViewElement(viRootView, verBackgroundVer, "background_ver"); - plugStruct.SetViewElement(viRootView, verHeaderHor, "header_hor"); - plugStruct.SetViewElement(viRootView, verHeaderVer, "header_ver"); - plugStruct.SetViewElement(viRootView, verTimeHor, "time_hor"); - plugStruct.SetViewElement(viRootView, verTimeVer, "time_ver"); - plugStruct.SetViewElement(viRootView, verFooterHor, "footer_hor"); - plugStruct.SetViewElement(viRootView, verFooterVer, "footer_ver"); - plugStruct.SetViewElement(viRootView, verDateTimelineHor, "datetimeline_hor"); - plugStruct.SetViewElement(viRootView, verDateTimelineVer, "datetimeline_ver"); - plugStruct.SetViewElement(viRootView, verTimeIndicatorHor, "timeindicator_hor"); - plugStruct.SetViewElement(viRootView, verTimeIndicatorVer, "timeindicator_ver"); - plugStruct.SetViewElement(viRootView, verChannelJump, "channeljump"); - plugStruct.SetViewGrid(viRootView, vgChannelsHor, "channels_hor"); - plugStruct.SetViewGrid(viRootView, vgChannelsVer, "channels_ver"); - plugStruct.SetViewGrid(viRootView, vgSchedulesHor, "schedules_hor"); - plugStruct.SetViewGrid(viRootView, vgSchedulesVer, "schedules_ver"); - plugStruct.SetViewGrid(viRootView, vgTimelineHor, "timeline_hor"); - plugStruct.SetViewGrid(viRootView, vgTimelineVer, "timeline_ver"); - plugStruct.SetViewGrid(viRootView, vgChannelGroupsHor, "channelgroups_hor"); - plugStruct.SetViewGrid(viRootView, vgChannelGroupsVer, "channelgroups_ver"); - //Detail View - plugStruct.SetSubView(viRootView, viDetailView, "detail.xml"); - plugStruct.SetViewElement(viDetailView, vedBackground, "background"); - plugStruct.SetViewElement(viDetailView, vedHeader, "header"); - plugStruct.SetViewElement(viDetailView, vedFooter, "footer"); - plugStruct.SetViewElement(viDetailView, vedTime, "time"); - //Search & Recording Menus - plugStruct.SetSubView(viRootView, viRecMenu, "recmenu.xml"); - plugStruct.SetViewElement(viRecMenu, vemBackground, "background"); - plugStruct.SetViewElement(viRecMenu, vemScrollbar, "scrollbar"); - plugStruct.SetViewGrid(viRecMenu, vgRecordingMenu, "recmenu"); - - if (!skindesignerapi::SkindesignerAPI::RegisterPlugin(&plugStruct)) { - esyslog("tvguideng: skindesigner not available"); - } + SkindesignerRegister(); return true; } @@ -115,43 +78,179 @@ void cPluginTvguideng::MainThreadHook(void) { } cString cPluginTvguideng::Active(void) { - return NULL; + return NULL; } time_t cPluginTvguideng::WakeupTime(void) { - return 0; + return 0; } cOsdObject *cPluginTvguideng::MainMenuAction(void) { - return new cTVGuideOSD(); + return new cTVGuideOSD(plugStruct); } cMenuSetupPage *cPluginTvguideng::SetupMenu(void) { - return new cTvGuideSetup(); + return new cTvGuideSetup(); } bool cPluginTvguideng::SetupParse(const char *Name, const char *Value) { - return config.SetupParse(Name, Value); + return config.SetupParse(Name, Value); } bool cPluginTvguideng::Service(const char *Id, void *Data) { - if (strcmp(Id, "MainMenuHooksPatch-v1.0::osSchedule") == 0 && config.replaceOriginalSchedule != 0) { - if (Data == NULL) - return true; - cOsdObject **guide = (cOsdObject**) Data; - if (guide) - *guide = MainMenuAction(); - return true; - } - return false; + if (strcmp(Id, "MainMenuHooksPatch-v1.0::osSchedule") == 0 && config.replaceOriginalSchedule != 0) { + if (Data == NULL) + return true; + cOsdObject **guide = (cOsdObject**) Data; + if (guide) + *guide = MainMenuAction(); + return true; + } + return false; } const char **cPluginTvguideng::SVDRPHelpPages(void) { - return NULL; + return NULL; } cString cPluginTvguideng::SVDRPCommand(const char *Command, const char *Option, int &ReplyCode) { - return NULL; + return NULL; +} + +void cPluginTvguideng::SkindesignerRegister(void) { + plugStruct = new skindesignerapi::cPluginStructure(); + plugStruct->name = "tvguideng"; + plugStruct->libskindesignerAPIVersion = LIBSKINDESIGNERAPIVERSION; + //Root View + plugStruct->RegisterRootView("root.xml"); + skindesignerapi::cTokenContainer *tkBackground = new skindesignerapi::cTokenContainer(); + //View Elements Root View + plugStruct->RegisterViewElement((int)eViews::rootView, (int)eViewElementsRoot::backgroundHor, "background_hor", tkBackground); + plugStruct->RegisterViewElement((int)eViews::rootView, (int)eViewElementsRoot::backgroundVer, "background_ver", tkBackground); + skindesignerapi::cTokenContainer *tkHeaderHor = new skindesignerapi::cTokenContainer(); + cTVGuideOSD::DefineTokens(eViewElementsRoot::headerHor, tkHeaderHor); + plugStruct->RegisterViewElement((int)eViews::rootView, (int)eViewElementsRoot::headerHor, "header_hor", tkHeaderHor); + skindesignerapi::cTokenContainer *tkHeaderVer = new skindesignerapi::cTokenContainer(); + cTVGuideOSD::DefineTokens(eViewElementsRoot::headerVer, tkHeaderVer); + plugStruct->RegisterViewElement((int)eViews::rootView, (int)eViewElementsRoot::headerVer, "header_ver", tkHeaderVer); + skindesignerapi::cTokenContainer *tkTimerHor = new skindesignerapi::cTokenContainer(); + cTVGuideOSD::DefineTokens(eViewElementsRoot::timeHor, tkTimerHor); + plugStruct->RegisterViewElement((int)eViews::rootView, (int)eViewElementsRoot::timeHor, "time_hor", tkTimerHor); + skindesignerapi::cTokenContainer *tkTimerVer = new skindesignerapi::cTokenContainer(); + cTVGuideOSD::DefineTokens(eViewElementsRoot::timeVer, tkTimerVer); + plugStruct->RegisterViewElement((int)eViews::rootView, (int)eViewElementsRoot::timeVer, "time_ver", tkTimerVer); + skindesignerapi::cTokenContainer *tkFooterHor = new skindesignerapi::cTokenContainer(); + cTVGuideOSD::DefineTokens(eViewElementsRoot::footerHor, tkFooterHor); + plugStruct->RegisterViewElement((int)eViews::rootView, (int)eViewElementsRoot::footerHor, "footer_hor", tkFooterHor); + skindesignerapi::cTokenContainer *tkFooterVer = new skindesignerapi::cTokenContainer(); + cTVGuideOSD::DefineTokens(eViewElementsRoot::footerVer, tkFooterVer); + plugStruct->RegisterViewElement((int)eViews::rootView, (int)eViewElementsRoot::footerVer, "footer_ver", tkFooterVer); + skindesignerapi::cTokenContainer *tkDateTimelineHor = new skindesignerapi::cTokenContainer(); + cTVGuideOSD::DefineTokens(eViewElementsRoot::dateTimelineHor, tkDateTimelineHor); + plugStruct->RegisterViewElement((int)eViews::rootView, (int)eViewElementsRoot::dateTimelineHor, "datetimeline_hor", tkDateTimelineHor); + skindesignerapi::cTokenContainer *tkDateTimelineVer = new skindesignerapi::cTokenContainer(); + cTVGuideOSD::DefineTokens(eViewElementsRoot::dateTimelineVer, tkDateTimelineVer); + plugStruct->RegisterViewElement((int)eViews::rootView, (int)eViewElementsRoot::dateTimelineVer, "datetimeline_ver", tkDateTimelineVer); + skindesignerapi::cTokenContainer *tkTimeIndHor = new skindesignerapi::cTokenContainer(); + cTVGuideOSD::DefineTokens(eViewElementsRoot::timeIndicatorHor, tkTimeIndHor); + plugStruct->RegisterViewElement((int)eViews::rootView, (int)eViewElementsRoot::timeIndicatorHor, "timeindicator_hor", tkTimeIndHor); + skindesignerapi::cTokenContainer *tkTimeIndVer = new skindesignerapi::cTokenContainer(); + cTVGuideOSD::DefineTokens(eViewElementsRoot::timeIndicatorVer, tkTimeIndVer); + plugStruct->RegisterViewElement((int)eViews::rootView, (int)eViewElementsRoot::timeIndicatorVer, "timeindicator_ver", tkTimeIndVer); + skindesignerapi::cTokenContainer *tkChanneljump = new skindesignerapi::cTokenContainer(); + cTVGuideOSD::DefineTokens(eViewElementsRoot::channelJump, tkChanneljump); + plugStruct->RegisterViewElement((int)eViews::rootView, (int)eViewElementsRoot::channelJump, "channeljump", tkChanneljump); + //View Grids Root View + skindesignerapi::cTokenContainer *tkChannelsHor = new skindesignerapi::cTokenContainer(); + cTVGuideOSD::DefineTokens(eViewGridsRoot::channelsHor, tkChannelsHor); + plugStruct->RegisterViewGrid((int)eViews::rootView, (int)eViewGridsRoot::channelsHor, "channels_hor", tkChannelsHor); + skindesignerapi::cTokenContainer *tkChannelsVer = new skindesignerapi::cTokenContainer(); + cTVGuideOSD::DefineTokens(eViewGridsRoot::channelsVer, tkChannelsVer); + plugStruct->RegisterViewGrid((int)eViews::rootView, (int)eViewGridsRoot::channelsVer, "channels_ver", tkChannelsVer); + skindesignerapi::cTokenContainer *tkSchedulesHor = new skindesignerapi::cTokenContainer(); + cTVGuideOSD::DefineTokens(eViewGridsRoot::schedulesHor, tkSchedulesHor); + plugStruct->RegisterViewGrid((int)eViews::rootView, (int)eViewGridsRoot::schedulesHor, "schedules_hor", tkSchedulesHor); + skindesignerapi::cTokenContainer *tkSchedulesVer = new skindesignerapi::cTokenContainer(); + cTVGuideOSD::DefineTokens(eViewGridsRoot::schedulesVer, tkSchedulesVer); + plugStruct->RegisterViewGrid((int)eViews::rootView, (int)eViewGridsRoot::schedulesVer, "schedules_ver", tkSchedulesVer); + skindesignerapi::cTokenContainer *tkTimelineHor = new skindesignerapi::cTokenContainer(); + cTVGuideOSD::DefineTokens(eViewGridsRoot::timelineHor, tkTimelineHor); + plugStruct->RegisterViewGrid((int)eViews::rootView, (int)eViewGridsRoot::timelineHor, "timeline_hor", tkTimelineHor); + skindesignerapi::cTokenContainer *tkTimelineVer = new skindesignerapi::cTokenContainer(); + cTVGuideOSD::DefineTokens(eViewGridsRoot::timelineVer, tkTimelineVer); + plugStruct->RegisterViewGrid((int)eViews::rootView, (int)eViewGridsRoot::timelineVer, "timeline_ver", tkTimelineVer); + skindesignerapi::cTokenContainer *tkChannelGroupsHor = new skindesignerapi::cTokenContainer(); + cTVGuideOSD::DefineTokens(eViewGridsRoot::channelGroupsHor, tkChannelGroupsHor); + plugStruct->RegisterViewGrid((int)eViews::rootView, (int)eViewGridsRoot::channelGroupsHor, "channelgroups_hor", tkChannelGroupsHor); + skindesignerapi::cTokenContainer *tkChannelGroupsVer = new skindesignerapi::cTokenContainer(); + cTVGuideOSD::DefineTokens(eViewGridsRoot::channelGroupsVer, tkChannelGroupsVer); + plugStruct->RegisterViewGrid((int)eViews::rootView, (int)eViewGridsRoot::channelGroupsVer, "channelgroups_ver", tkChannelGroupsVer); + + //Detail View + plugStruct->RegisterSubView((int)eViews::detailView, "detail.xml"); + //viewelements Detail View Menus + skindesignerapi::cTokenContainer *tkBackDetail = new skindesignerapi::cTokenContainer(); + cDetailView::DefineTokens(eViewElementsDetail::background, tkBackDetail); + plugStruct->RegisterViewElement((int)eViews::detailView, (int)eViewElementsDetail::background, "background", tkBackDetail); + skindesignerapi::cTokenContainer *tkHeaderDetail = new skindesignerapi::cTokenContainer(); + cDetailView::DefineTokens(eViewElementsDetail::header, tkHeaderDetail); + plugStruct->RegisterViewElement((int)eViews::detailView, (int)eViewElementsDetail::header, "header", tkHeaderDetail); + skindesignerapi::cTokenContainer *tkFooterDetail = new skindesignerapi::cTokenContainer(); + cDetailView::DefineTokens(eViewElementsDetail::footer, tkFooterDetail); + plugStruct->RegisterViewElement((int)eViews::detailView, (int)eViewElementsDetail::footer, "footer", tkFooterDetail); + skindesignerapi::cTokenContainer *tkTimeDetail = new skindesignerapi::cTokenContainer(); + cTVGuideOSD::DefineTokens(eViewElementsRoot::timeHor, tkTimeDetail); + plugStruct->RegisterViewElement((int)eViews::detailView, (int)eViewElementsDetail::time, "time", tkTimeDetail); + //TabbedView + skindesignerapi::cTokenContainer *tkTab = new skindesignerapi::cTokenContainer(); + cDetailView::DefineTabTokens(tkTab); + plugStruct->RegisterViewTab((int)eViews::detailView, tkTab); + + //Search & Recording Menus + plugStruct->RegisterSubView((int)eViews::recMenu, "recmenu.xml"); + //viewelements Recording Menus + skindesignerapi::cTokenContainer *tkBackRec = new skindesignerapi::cTokenContainer(); + cRecMenu::DefineTokens(eViewElementsRecMenu::background, tkBackRec); + plugStruct->RegisterViewElement((int)eViews::recMenu, (int)eViewElementsRecMenu::background, "background", tkBackRec); + skindesignerapi::cTokenContainer *tkScrollbarRec = new skindesignerapi::cTokenContainer(); + cRecMenu::DefineTokens(eViewElementsRecMenu::scrollbar, tkScrollbarRec); + plugStruct->RegisterViewElement((int)eViews::recMenu, (int)eViewElementsRecMenu::scrollbar, "scrollbar", tkScrollbarRec); + //grids Recording Menus + skindesignerapi::cTokenContainer *tkRecMenu = new skindesignerapi::cTokenContainer(); + cRecMenu::DefineTokens(eViewGridsRecMenu::menu, tkRecMenu); + plugStruct->RegisterViewGrid((int)eViews::recMenu, (int)eViewGridsRecMenu::menu, "recmenu", tkRecMenu); + + plugStruct->RegisterSubView((int)eViews::recMenu2, "recmenu.xml"); + //viewelements Recording Menus + skindesignerapi::cTokenContainer *tkBackRec2 = new skindesignerapi::cTokenContainer(); + cRecMenu::DefineTokens(eViewElementsRecMenu::background, tkBackRec2); + plugStruct->RegisterViewElement((int)eViews::recMenu2, (int)eViewElementsRecMenu::background, "background", tkBackRec2); + skindesignerapi::cTokenContainer *tkScrollbarRec2 = new skindesignerapi::cTokenContainer(); + cRecMenu::DefineTokens(eViewElementsRecMenu::scrollbar, tkScrollbarRec2); + plugStruct->RegisterViewElement((int)eViews::recMenu2, (int)eViewElementsRecMenu::scrollbar, "scrollbar", tkScrollbarRec2); + //grids Recording Menus + skindesignerapi::cTokenContainer *tkRecMenu2 = new skindesignerapi::cTokenContainer(); + cRecMenu::DefineTokens(eViewGridsRecMenu::menu, tkRecMenu2); + plugStruct->RegisterViewGrid((int)eViews::recMenu2, (int)eViewGridsRecMenu::menu, "recmenu", tkRecMenu2); + + plugStruct->RegisterSubView((int)eViews::recMenu3, "recmenu.xml"); + //viewelements Recording Menus + skindesignerapi::cTokenContainer *tkBackRec3 = new skindesignerapi::cTokenContainer(); + cRecMenu::DefineTokens(eViewElementsRecMenu::background, tkBackRec3); + plugStruct->RegisterViewElement((int)eViews::recMenu3, (int)eViewElementsRecMenu::background, "background", tkBackRec3); + skindesignerapi::cTokenContainer *tkScrollbarRec3 = new skindesignerapi::cTokenContainer(); + cRecMenu::DefineTokens(eViewElementsRecMenu::scrollbar, tkScrollbarRec3); + plugStruct->RegisterViewElement((int)eViews::recMenu3, (int)eViewElementsRecMenu::scrollbar, "scrollbar", tkScrollbarRec3); + //grids Recording Menus + skindesignerapi::cTokenContainer *tkRecMenu3 = new skindesignerapi::cTokenContainer(); + cRecMenu::DefineTokens(eViewGridsRecMenu::menu, tkRecMenu3); + plugStruct->RegisterViewGrid((int)eViews::recMenu3, (int)eViewGridsRecMenu::menu, "recmenu", tkRecMenu3); + + if (!skindesignerapi::SkindesignerAPI::RegisterPlugin(plugStruct)) { + esyslog("tvguideng: skindesigner not available"); + } else { + dsyslog("tvguideng: successfully registered at skindesigner, id %d", plugStruct->id); + } } VDRPLUGINCREATOR(cPluginTvguideng); // Don't touch this! diff --git a/tvguidengosd.c b/tvguidengosd.c index 59ea707..8024672 100644 --- a/tvguidengosd.c +++ b/tvguidengosd.c @@ -1,6 +1,6 @@ #include "tvguidengosd.h" -cTVGuideOSD::cTVGuideOSD(void) { +cTVGuideOSD::cTVGuideOSD(skindesignerapi::cPluginStructure *plugStruct) : cSkindesignerOsdObject(plugStruct) { timeManager = NULL; epgGrid = NULL; channelJumper = NULL; @@ -9,6 +9,7 @@ cTVGuideOSD::cTVGuideOSD(void) { } cTVGuideOSD::~cTVGuideOSD(void) { + esyslog("tvguideng: closing"); if (recMenuView && recMenuView->Active()) { recMenuView->Close(); } @@ -25,27 +26,26 @@ cTVGuideOSD::~cTVGuideOSD(void) { } void cTVGuideOSD::Show(void) { - bool skinDesignerAvailable = InitSkindesignerInterface("tvguideng"); - if (!skinDesignerAvailable) { - return; - esyslog("tvguideng: skindesigner not available"); + if (!SkindesignerAvailable()) { + esyslog("tvguideng: skindesigner not available but mandatorily needed - aborting"); + return; } - - skindesignerapi::cOsdView *rootView = GetOsdView(viRootView); + skindesignerapi::cOsdView *rootView = GetOsdView(); if (!rootView) { esyslog("tvguideng: used skindesigner skin does not support tvguideng"); return; } + SwitchTimers.Load(AddDirectory(cPlugin::ConfigDirectory("epgsearch"), "epgsearchswitchtimers.conf")); recMenuView = new cRecMenuView(); - pRemoteTimers = cPluginManager::CallFirstService("RemoteTimers::RefreshTimers-v1.0", NULL); + pRemoteTimers = cPluginManager::GetPlugin("remotetimers"); if (pRemoteTimers) { isyslog("tvguideng: remotetimers-plugin is available"); } if (config.useRemoteTimers && pRemoteTimers) { cString errorMsg; if (!pRemoteTimers->Service("RemoteTimers::RefreshTimers-v1.0", &errorMsg)) { - esyslog("tvguideng: %s", *errorMsg); + esyslog("tvguideng: Remotetimers Error: %s", *errorMsg); } } @@ -55,8 +55,8 @@ void cTVGuideOSD::Show(void) { epgGrid = new cEpgGrid(rootView, timeManager); cChannel *startChannel = Channels.GetByNumber(cDevice::CurrentChannel()); - epgGrid->Init(startChannel); + epgGrid->Activate(); epgGrid->DrawHeader(); epgGrid->DrawTime(); epgGrid->DrawFooter(); @@ -469,8 +469,9 @@ void cTVGuideOSD::DetailView(const cEvent *e) { epgGrid->Deactivate(true); if (recMenuView->Active()) recMenuView->Hide(true); - skindesignerapi::cOsdView *dV = GetOsdView(viRootView, viDetailView); + skindesignerapi::cOsdView *dV = GetOsdView((int)eViews::detailView); detailView = new cDetailView(dV, e); + detailView->Activate(); detailView->Draw(); detailView->DrawTime(); detailView->Flush(); @@ -492,20 +493,22 @@ void cTVGuideOSD::KeyRed(void) { if (!e) return; epgGrid->Deactivate(false); - skindesignerapi::cOsdView *recView = GetOsdView(viRootView, viRecMenu); - skindesignerapi::cOsdView *recViewBuffer = GetOsdView(viRootView, viRecMenu); - skindesignerapi::cOsdView *recViewBuffer2 = GetOsdView(viRootView, viRecMenu); + skindesignerapi::cOsdView *recView = GetOsdView((int)eViews::recMenu); + skindesignerapi::cOsdView *recViewBuffer = GetOsdView((int)eViews::recMenu2); + skindesignerapi::cOsdView *recViewBuffer2 = GetOsdView((int)eViews::recMenu3); recMenuView->Init(recView, recViewBuffer, recViewBuffer2); + recMenuView->Activate(); recMenuView->DisplayRecMenu(e); recMenuView->Flush(); } void cTVGuideOSD::Favorites(void) { epgGrid->Deactivate(false); - skindesignerapi::cOsdView *recView = GetOsdView(viRootView, viRecMenu); - skindesignerapi::cOsdView *recViewBuffer = GetOsdView(viRootView, viRecMenu); - skindesignerapi::cOsdView *recViewBuffer2 = GetOsdView(viRootView, viRecMenu); + skindesignerapi::cOsdView *recView = GetOsdView((int)eViews::recMenu); + skindesignerapi::cOsdView *recViewBuffer = GetOsdView((int)eViews::recMenu2); + skindesignerapi::cOsdView *recViewBuffer2 = GetOsdView((int)eViews::recMenu3); recMenuView->Init(recView, recViewBuffer, recViewBuffer2); + recMenuView->Activate(); recMenuView->DisplayFavorites(); recMenuView->Flush(); } @@ -530,10 +533,11 @@ void cTVGuideOSD::DisplaySearchRecordings(void) { if (!e) return; epgGrid->Deactivate(false); - skindesignerapi::cOsdView *recView = GetOsdView(viRootView, viRecMenu); - skindesignerapi::cOsdView *recViewBuffer = GetOsdView(viRootView, viRecMenu); - skindesignerapi::cOsdView *recViewBuffer2 = GetOsdView(viRootView, viRecMenu); + skindesignerapi::cOsdView *recView = GetOsdView((int)eViews::recMenu); + skindesignerapi::cOsdView *recViewBuffer = GetOsdView((int)eViews::recMenu2); + skindesignerapi::cOsdView *recViewBuffer2 = GetOsdView((int)eViews::recMenu3); recMenuView->Init(recView, recViewBuffer, recViewBuffer2); + recMenuView->Activate(); recMenuView->DisplayRecSearch(e); recMenuView->Flush(); } @@ -543,10 +547,134 @@ void cTVGuideOSD::DisplaySearchEPG(void) { if (!e) return; epgGrid->Deactivate(false); - skindesignerapi::cOsdView *recView = GetOsdView(viRootView, viRecMenu); - skindesignerapi::cOsdView *recViewBuffer = GetOsdView(viRootView, viRecMenu); - skindesignerapi::cOsdView *recViewBuffer2 = GetOsdView(viRootView, viRecMenu); + skindesignerapi::cOsdView *recView = GetOsdView((int)eViews::recMenu); + skindesignerapi::cOsdView *recViewBuffer = GetOsdView((int)eViews::recMenu2); + skindesignerapi::cOsdView *recViewBuffer2 = GetOsdView((int)eViews::recMenu3); recMenuView->Init(recView, recViewBuffer, recViewBuffer2); + recMenuView->Activate(); recMenuView->DisplaySearchEPG(e); recMenuView->Flush(); } + +void cTVGuideOSD::DefineTokens(eViewElementsRoot ve, skindesignerapi::cTokenContainer *tk) { + switch (ve) { + case eViewElementsRoot::backgroundHor: + case eViewElementsRoot::backgroundVer: + break; + case eViewElementsRoot::headerHor: + case eViewElementsRoot::headerVer: + tk->DefineIntToken("{isdummy}", (int)eHeaderIT::isdummy); + tk->DefineIntToken("{daynumeric}", (int)eHeaderIT::daynumeric); + tk->DefineIntToken("{month}", (int)eHeaderIT::month); + tk->DefineIntToken("{year}", (int)eHeaderIT::year); + tk->DefineIntToken("{running}", (int)eHeaderIT::running); + tk->DefineIntToken("{elapsed}", (int)eHeaderIT::elapsed); + tk->DefineIntToken("{duration}", (int)eHeaderIT::duration); + tk->DefineIntToken("{durationhours}", (int)eHeaderIT::durationhours); + tk->DefineIntToken("{channelnumber}", (int)eHeaderIT::channelnumber); + tk->DefineIntToken("{channellogoexists}", (int)eHeaderIT::isdummy); + tk->DefineIntToken("{hasposter}", (int)eHeaderIT::hasposter); + tk->DefineIntToken("{posterwidth}", (int)eHeaderIT::posterwidth); + tk->DefineIntToken("{posterheight}", (int)eHeaderIT::posterheight); + tk->DefineStringToken("{title}", (int)eHeaderST::title); + tk->DefineStringToken("{shorttext}", (int)eHeaderST::shorttext); + tk->DefineStringToken("{description}", (int)eHeaderST::description); + tk->DefineStringToken("{start}", (int)eHeaderST::start); + tk->DefineStringToken("{stop}", (int)eHeaderST::stop); + tk->DefineStringToken("{day}", (int)eHeaderST::day); + tk->DefineStringToken("{date}", (int)eHeaderST::date); + tk->DefineStringToken("{durationminutes}", (int)eHeaderST::durationminutes); + tk->DefineStringToken("{channelname}", (int)eHeaderST::channelname); + tk->DefineStringToken("{channelid}", (int)eHeaderST::channelid); + tk->DefineStringToken("{posterpath}", (int)eHeaderST::posterpath); + break; + case eViewElementsRoot::footerHor: + case eViewElementsRoot::footerVer: + 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; + case eViewElementsRoot::timeHor: + case eViewElementsRoot::timeVer: + tk->DefineIntToken("{sec}", (int)eTimeIT::sec); + tk->DefineIntToken("{min}", (int)eTimeIT::min); + tk->DefineIntToken("{hour}", (int)eTimeIT::hour); + tk->DefineIntToken("{hmins}", (int)eTimeIT::hmins); + tk->DefineIntToken("{year}", (int)eTimeIT::year); + tk->DefineIntToken("{day}", (int)eTimeIT::day); + tk->DefineStringToken("{time}", (int)eTimeST::time); + tk->DefineStringToken("{monthname}", (int)eTimeST::monthname); + tk->DefineStringToken("{monthnameshort}", (int)eTimeST::monthnameshort); + tk->DefineStringToken("{month}", (int)eTimeST::month); + tk->DefineStringToken("{dayleadingzero}", (int)eTimeST::dayleadingzero); + tk->DefineStringToken("{dayname}", (int)eTimeST::dayname); + tk->DefineStringToken("{daynameshort}", (int)eTimeST::daynameshort); + break; + case eViewElementsRoot::dateTimelineHor: + case eViewElementsRoot::dateTimelineVer: + tk->DefineStringToken("{weekday}", (int)eDateTimeST::weekday); + tk->DefineStringToken("{date}", (int)eDateTimeST::date); + break; + case eViewElementsRoot::timeIndicatorHor: + case eViewElementsRoot::timeIndicatorVer: + tk->DefineIntToken("{percenttotal}", (int)eTimeIndicatorIT::percenttotal); + break; + case eViewElementsRoot::channelJump: + tk->DefineStringToken("{channel}", (int)eChannelJumpST::channel); + break; + default: + break; + } +} + +void cTVGuideOSD::DefineTokens(eViewGridsRoot vg, skindesignerapi::cTokenContainer *tk) { + switch (vg) { + case eViewGridsRoot::channelsHor: + case eViewGridsRoot::channelsVer: + tk->DefineIntToken("{number}", (int)eChannelGridIT::number); + tk->DefineIntToken("{channellogoexists}", (int)eChannelGridIT::channellogoexists); + tk->DefineStringToken("{name}", (int)eChannelGridST::name); + tk->DefineStringToken("{channelid}", (int)eChannelGridST::channelid); + break; + case eViewGridsRoot::schedulesHor: + case eViewGridsRoot::schedulesVer: + tk->DefineIntToken("{color}", (int)eSchedulesGridIT::color); + tk->DefineIntToken("{dummy}", (int)eSchedulesGridIT::dummy); + tk->DefineIntToken("{timer}", (int)eSchedulesGridIT::timer); + tk->DefineIntToken("{switchtimer}", (int)eSchedulesGridIT::switchtimer); + tk->DefineStringToken("{title}", (int)eSchedulesGridST::title); + tk->DefineStringToken("{shorttext}", (int)eSchedulesGridST::shorttext); + tk->DefineStringToken("{start}", (int)eSchedulesGridST::start); + tk->DefineStringToken("{stop}", (int)eSchedulesGridST::stop); + break; + case eViewGridsRoot::channelGroupsHor: + case eViewGridsRoot::channelGroupsVer: + tk->DefineIntToken("{color}", (int)eChannelgroupsGridIT::color); + tk->DefineStringToken("{group}", (int)eChannelgroupsGridST::group); + break; + case eViewGridsRoot::timelineHor: + case eViewGridsRoot::timelineVer: + tk->DefineStringToken("{timestring}", (int)eTimelineGridST::timestring); + tk->DefineIntToken("{fullhour}", (int)eTimelineGridIT::fullhour); + break; + default: + break; + } +} diff --git a/tvguidengosd.h b/tvguidengosd.h index 4b8dc82..93b2f81 100644 --- a/tvguidengosd.h +++ b/tvguidengosd.h @@ -5,6 +5,7 @@ #include #include #include +#include "definitions.h" #include "config.h" #include "timemanager.h" #include "epggrid.h" @@ -13,52 +14,6 @@ #include "recmenuview.h" #include "recmanager.h" -enum eViews { - viRootView, - viDetailView, - viRecMenu -}; - -enum eViewElementsRoot { - verBackgroundHor, - verBackgroundVer, - verHeaderHor, - verHeaderVer, - verFooterHor, - verFooterVer, - verTimeHor, - verTimeVer, - verDateTimelineHor, - verDateTimelineVer, - verTimeIndicatorHor, - verTimeIndicatorVer, - verChannelJump -}; - -enum eViewGrids { - vgChannelsHor, - vgChannelsVer, - vgSchedulesHor, - vgSchedulesVer, - vgChannelGroupsHor, - vgChannelGroupsVer, - vgTimelineHor, - vgTimelineVer, - vgRecordingMenu -}; - -enum eViewElementsDetail { - vedBackground, - vedHeader, - vedFooter, - vedTime -}; - -enum eViewElementsRecMenu { - vemBackground, - vemScrollbar -}; - class cTVGuideOSD : public skindesignerapi::cSkindesignerOsdObject { private: cTimeManager *timeManager; @@ -92,10 +47,12 @@ private: void DisplaySearchRecordings(void); void DisplaySearchEPG(void); public: - cTVGuideOSD(void); + cTVGuideOSD(skindesignerapi::cPluginStructure *plugStruct); virtual ~cTVGuideOSD(void); virtual void Show(void); virtual eOSState ProcessKey(eKeys Key); + static void DefineTokens(eViewElementsRoot ve, skindesignerapi::cTokenContainer *tk); + static void DefineTokens(eViewGridsRoot vg, skindesignerapi::cTokenContainer *tk); }; #endif //__TVGUIDENGOSD_H -- cgit v1.2.3