frodovdr/vdr-plugin-skindesigner
1
0
Fork 0
mirror of https://projects.vdr-developer.org/git/vdr-plugin-skindesigner.git synced 2023-10-19 15:58:31 +00:00
Code Issues Releases Wiki Activity

introduced zapcockpit extension

Browse Source
This commit is contained in:
louis
2016-05-26 10:47:45 +02:00
parent ffb414cdee
commit a57c44b068
31 changed files with 3413 additions and 168 deletions
Download Patch File Download Diff File Expand all files Collapse all files

12
coreengine/area.c
View File

@@ -425,8 +425,14 @@ void cArea::SetViewPort(cRect &vp) {
void cArea::SetPosition(cPoint &pos, cPoint &ref) {
if (!pix)
return;
int x = (attribs->X() - ref.X()) + pos.X();
int y = (attribs->Y() - ref.Y()) + pos.Y();
int x0 = attribs->X() == -1 ? 0 : attribs->X();
int y0 = attribs->Y() == -1 ? 0 : attribs->Y();
int x = (x0 - ref.X()) + pos.X();
int y = (y0 - ref.Y()) + pos.Y();
/* Enable for xineliboutput OSD Bug
if (x < 0) x = 0;
if (y < 0) y = 0;
*/
pix->SetViewPort(cRect(x, y, pix->ViewPort().Width(), pix->ViewPort().Height()));
}
@@ -518,7 +524,7 @@ void cArea::CreatePixmap(cRect drawPort) {
}
int layer = attribs->Layer();
cRect viewPort(attribs->X(), attribs->Y(), attribs->Width(), attribs->Height());
cRect viewPort(attribs->X() == -1 ? 0 : attribs->X(), attribs->Y() == -1 ? 0 : attribs->Y(), attribs->Width(), attribs->Height());
pix = sdOsd->CreatePixmap(layer, viewPort, drawPort);
if (pix)
pix->Clear();

23
coreengine/attributes.c
View File

@@ -126,15 +126,18 @@ void cViewAttribs::SetOrientationDynamic(int id, const char *val) {
***************************************************************************/
cViewElementAttribs::cViewElementAttribs(int numAttributes) : cAttributes(numAttributes) {
name = NULL;
clearOnDisplay = NULL;
SetAttributesDefs();
}
cViewElementAttribs::cViewElementAttribs(const cViewElementAttribs &other) : cAttributes(other) {
name = NULL;
clearOnDisplay = NULL;
}
cViewElementAttribs::~cViewElementAttribs(void) {
free(name);
free(clearOnDisplay);
}
void cViewElementAttribs::Set(vector<stringpair> &attributes) {
@@ -158,6 +161,8 @@ void cViewElementAttribs::Set(vector<stringpair> &attributes) {
SetOrientation(id, attVal);
} else if (IdEqual(id, (int)eViewElementAttribs::name)) {
name = strdup(attVal);
} else if (IdEqual(id, (int)eViewElementAttribs::clearondisplay)) {
clearOnDisplay = strdup(attVal);
} else {
attribCtors[id] = new cNumericExpr(attVal);
if (id == (int)eViewElementAttribs::starty + (int)eCommonAttribs::count) {
@@ -178,6 +183,7 @@ void cViewElementAttribs::SetAttributesDefs(void) {
attribIDs.insert(pair<string, int>("orientation", (int)eViewElementAttribs::orientation));
attribIDs.insert(pair<string, int>("mode", (int)eViewElementAttribs::mode));
attribIDs.insert(pair<string, int>("name", (int)eViewElementAttribs::name));
attribIDs.insert(pair<string, int>("clearondisplay", (int)eViewElementAttribs::clearondisplay));
attribNames.insert(pair<int, string>((int)eViewElementAttribs::delay, "delay"));
attribNames.insert(pair<int, string>((int)eViewElementAttribs::fadetime, "fadetime"));
attribNames.insert(pair<int, string>((int)eViewElementAttribs::shifttime, "shifttime"));
@@ -188,6 +194,7 @@ void cViewElementAttribs::SetAttributesDefs(void) {
attribNames.insert(pair<int, string>((int)eViewElementAttribs::orientation, "orientation"));
attribNames.insert(pair<int, string>((int)eViewElementAttribs::mode, "mode"));
attribNames.insert(pair<int, string>((int)eViewElementAttribs::name, "name"));
attribNames.insert(pair<int, string>((int)eViewElementAttribs::clearondisplay, "clearondisplay"));
}
eOrientation cViewElementAttribs::Orientation(void) {
@@ -233,6 +240,10 @@ void cViewListAttribs::Set(vector<stringpair> &attributes) {
determinateFont = strdup(attVal);
} else if (IdEqual(id, (int)eViewListAttribs::orientation)) {
SetOrientation(id, attVal);
} else if (IdEqual(id, (int)eViewListAttribs::shifttype)) {
SetShiftType(id, attVal);
} else if (IdEqual(id, (int)eViewListAttribs::shiftmode)) {
SetShiftMode(id, attVal);
} else {
attribCtors[id] = new cNumericExpr(attVal);
}
@@ -271,12 +282,24 @@ void cViewListAttribs::SetAttributesDefs(void) {
attribIDs.insert(pair<string, int>("determinatefont", (int)eViewListAttribs::determinatefont));
attribIDs.insert(pair<string, int>("numlistelements", (int)eViewListAttribs::numlistelements));
attribIDs.insert(pair<string, int>("orientation", (int)eViewListAttribs::orientation));
attribIDs.insert(pair<string, int>("fadetime", (int)eViewListAttribs::fadetime));
attribIDs.insert(pair<string, int>("shifttime", (int)eViewListAttribs::shifttime));
attribIDs.insert(pair<string, int>("shifttype", (int)eViewListAttribs::shifttype));
attribIDs.insert(pair<string, int>("shiftmode", (int)eViewListAttribs::shiftmode));
attribIDs.insert(pair<string, int>("startx", (int)eViewListAttribs::startx));
attribIDs.insert(pair<string, int>("starty", (int)eViewListAttribs::starty));
attribIDs.insert(pair<string, int>("condition", (int)eViewListAttribs::condition));
attribNames.insert(pair<int, string>((int)eViewListAttribs::align, "align"));
attribNames.insert(pair<int, string>((int)eViewListAttribs::menuitemwidth, "menuitemwidth"));
attribNames.insert(pair<int, string>((int)eViewListAttribs::determinatefont, "determinatefont"));
attribNames.insert(pair<int, string>((int)eViewListAttribs::numlistelements, "numlistelements"));
attribNames.insert(pair<int, string>((int)eViewListAttribs::orientation, "orientation"));
attribNames.insert(pair<int, string>((int)eViewListAttribs::fadetime, "fadetime"));
attribNames.insert(pair<int, string>((int)eViewListAttribs::shifttime, "shifttime"));
attribNames.insert(pair<int, string>((int)eViewListAttribs::shifttype, "shifttype"));
attribNames.insert(pair<int, string>((int)eViewListAttribs::shiftmode, "shiftmode"));
attribNames.insert(pair<int, string>((int)eViewListAttribs::startx, "startx"));
attribNames.insert(pair<int, string>((int)eViewListAttribs::starty, "starty"));
attribNames.insert(pair<int, string>((int)eViewListAttribs::condition, "condition"));
}

7
coreengine/attributes.h
View File

@@ -30,6 +30,7 @@ public:
class cViewElementAttribs : public cAttributes {
private:
char *name;
char *clearOnDisplay;
void SetAttributesDefs(void);
public:
cViewElementAttribs(int numAttributes);
@@ -45,6 +46,7 @@ public:
int ShiftType(void) { return GetValue((int)eViewElementAttribs::shifttype); };
int ShiftMode(void) { return GetValue((int)eViewElementAttribs::shiftmode); };
const char *Name(void) { return name; };
const char *ClearOnDisplay(void) { return clearOnDisplay; };
void Debug(void);
};
/******************************************************************
@@ -63,6 +65,11 @@ public:
const char *DeterminateFont(void);
eAlign Align(void);
eOrientation Orientation(void);
int FadeTime(void) { return GetValue((int)eViewListAttribs::fadetime); };
int ShiftTime(void) { return GetValue((int)eViewListAttribs::shifttime); };
cPoint ShiftStartpoint(void) { return cPoint(GetValue((int)eViewListAttribs::startx), GetValue((int)eViewListAttribs::starty)); };
int ShiftType(void) { return GetValue((int)eViewListAttribs::shifttype); };
int ShiftMode(void) { return GetValue((int)eViewListAttribs::shiftmode); };
void Debug(void);
};
/******************************************************************

279
coreengine/definitions.h
View File

@@ -45,6 +45,13 @@ enum class eVeDisplayChannel {
signalquality,
scrapercontent,
ecminfo,
channelhints,
channeldetail,
channellistback,
channellistdetail,
grouplistback,
groupchannellistback,
groupchannellistdetail,
count
};
/******************************************************************
@@ -276,6 +283,101 @@ enum class eScraperPosterBannerIT {
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
};
/******************************************************************
* Tokens displaychannel viewelements
*******************************************************************/
@@ -417,6 +519,46 @@ enum class eDCSignalQualityIT {
count
};
enum class eDCChannelHintsIT {
numhints = 0,
count
};
enum class eDCChannelHintsLT {
channelnumber = 0,
channelname,
channelid,
channellogoexists,
count
};
enum class eDCChannelDetailST {
channelname = (int)eScraperST::count,
currenttitle,
currentshorttext,
currentdescription,
currentstart,
currentstop,
currentdurationminutes,
nexttitle,
nextshorttext,
nextdescription,
nextstart,
nextstop,
nextdurationminutes,
count
};
enum class eDCChannelDetailIT {
channelnumber = (int)eScraperIT::count,
currentduration,
currentdurationhours,
currentelapsed,
currentremaining,
nextduration,
nextdurationhours,
count
};
/******************************************************************
* Tokens displaymenu viewelements
*******************************************************************/
@@ -601,7 +743,7 @@ enum class eDMTemperaturesIT {
};
/******************************************************************
* Tokens displaymenu listelements
* Tokens listelements
*******************************************************************/
enum class eLeMenuDefaultST {
column1 = 0,
@@ -1057,6 +1199,39 @@ enum class eCeMenuRecordingsIT {
count
};
enum class eLeChannelListST {
name = 0,
channelid,
presenteventtitle,
presenteventstart,
presenteventstop,
nexteventtitle,
nexteventstart,
nexteventstop,
count
};
enum class eLeChannelListIT {
nummenuitem = 0,
current,
number,
channellogoexists,
presenteventelapsed,
presenteventremaining,
count
};
enum class eLeGroupListST {
groupname = 0,
count
};
enum class eLeGroupListIT {
nummenuitem = 0,
current,
numchannels,
count
};
/******************************************************************
* Tokens displaymenu detailed views
*******************************************************************/
@@ -1151,101 +1326,6 @@ enum class eDmTabsLT {
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 eDmDetailedEpgST {
title = (int)eScraperST::count,
shorttext,
@@ -1567,6 +1647,7 @@ enum class eViewElementAttribs {
mode,
orientation,
name,
clearondisplay,
count
};
@@ -1576,6 +1657,12 @@ enum class eViewListAttribs {
determinatefont,
numlistelements,
orientation,
fadetime,
shifttime,
shifttype,
shiftmode,
startx,
starty,
condition,
count
};

127
coreengine/listelements.c
View File

@@ -2021,3 +2021,130 @@ bool cLeAudioTracks::Parse(bool forced) {
tokenContainer->AddStringToken((int)eLeDisplayTracksST::title, text);
return true;
}
/******************************************************************
* cLeChannelList
******************************************************************/
cLeChannelList::cLeChannelList(void) {
channel = NULL;
}
cLeChannelList::cLeChannelList(const cLeChannelList &other) : cListElement(other) {
channel = NULL;
}
cLeChannelList::~cLeChannelList(void) {
}
void cLeChannelList::SetTokenContainer(void) {
tokenContainer = new skindesignerapi::cTokenContainer();
tokenContainer->DefineStringToken("{name}", (int)eLeChannelListST::name);
tokenContainer->DefineStringToken("{channelid}", (int)eLeChannelListST::channelid);
tokenContainer->DefineStringToken("{presenteventtitle}", (int)eLeChannelListST::presenteventtitle);
tokenContainer->DefineStringToken("{presenteventstart}", (int)eLeChannelListST::presenteventstart);
tokenContainer->DefineStringToken("{presenteventstop}", (int)eLeChannelListST::presenteventstop);
tokenContainer->DefineStringToken("{nexteventtitle}", (int)eLeChannelListST::nexteventtitle);
tokenContainer->DefineStringToken("{nexteventstart}", (int)eLeChannelListST::nexteventstart);
tokenContainer->DefineStringToken("{nexteventstop}", (int)eLeChannelListST::nexteventstop);
tokenContainer->DefineIntToken("{nummenuitem}", (int)eLeChannelListIT::nummenuitem);
tokenContainer->DefineIntToken("{current}", (int)eLeChannelListIT::current);
tokenContainer->DefineIntToken("{number}", (int)eLeChannelListIT::number);
tokenContainer->DefineIntToken("{channellogoexists}", (int)eLeChannelListIT::channellogoexists);
tokenContainer->DefineIntToken("{presenteventelapsed}", (int)eLeChannelListIT::presenteventelapsed);
tokenContainer->DefineIntToken("{presenteventremaining}", (int)eLeChannelListIT::presenteventremaining);
InheritTokenContainer();
}
void cLeChannelList::Set(const cChannel *channel) {
dirty = true;
this->channel = channel;
}
bool cLeChannelList::Parse(bool forced) {
if (!cViewElement::Parse(forced))
return false;
if (!dirty)
return false;
tokenContainer->Clear();
tokenContainer->AddIntToken((int)eLeChannelListIT::nummenuitem, num);
tokenContainer->AddIntToken((int)eLeChannelListIT::current, current);
tokenContainer->AddIntToken((int)eLeChannelListIT::number, channel->Number());
tokenContainer->AddStringToken((int)eLeChannelListST::name, channel->Name());
cString channelID = channel->GetChannelID().ToString();
tokenContainer->AddStringToken((int)eLeChannelListST::channelid, *channelID);
tokenContainer->AddIntToken((int)eLeChannelListIT::channellogoexists, imgCache->LogoExists(*channelID));
#if defined (APIVERSNUM) && (APIVERSNUM >= 20301)
LOCK_SCHEDULES_READ;
const cSchedules* schedules = Schedules;
#else
cSchedulesLock schedulesLock;
const cSchedules* schedules = (cSchedules*)cSchedules::Schedules(schedulesLock);
#endif
const cSchedule *schedule = schedules->GetSchedule(channel);
if (schedule) {
const cEvent *presentEvent = schedule->GetPresentEvent();
if (presentEvent) {
tokenContainer->AddStringToken((int)eLeChannelListST::presenteventtitle, presentEvent->Title());
tokenContainer->AddStringToken((int)eLeChannelListST::presenteventstart, *presentEvent->GetTimeString());
tokenContainer->AddStringToken((int)eLeChannelListST::presenteventstop, *presentEvent->GetEndTimeString());
tokenContainer->AddIntToken((int)eLeChannelListIT::presenteventelapsed, (time(0) - presentEvent->StartTime())/60);
tokenContainer->AddIntToken((int)eLeChannelListIT::presenteventremaining, presentEvent->Duration()/60 - (time(0) - presentEvent->StartTime())/60);
}
const cList<cEvent> *events = schedule->Events();
if (events && presentEvent) {
const cEvent *nextEvent = events->Next(presentEvent);
if (nextEvent) {
tokenContainer->AddStringToken((int)eLeChannelListST::nexteventtitle, nextEvent->Title());
tokenContainer->AddStringToken((int)eLeChannelListST::nexteventstart, *nextEvent->GetTimeString());
tokenContainer->AddStringToken((int)eLeChannelListST::nexteventstop, *nextEvent->GetEndTimeString());
}
}
}
return true;
}
/******************************************************************
* cLeGroupList
******************************************************************/
cLeGroupList::cLeGroupList(void) {
group = NULL;
numChannels = 0;
}
cLeGroupList::cLeGroupList(const cLeGroupList &other) : cListElement(other) {
group = NULL;
numChannels = 0;
}
cLeGroupList::~cLeGroupList(void) {
}
void cLeGroupList::SetTokenContainer(void) {
tokenContainer = new skindesignerapi::cTokenContainer();
tokenContainer->DefineStringToken("{groupname}", (int)eLeGroupListST::groupname);
tokenContainer->DefineIntToken("{numchannels}", (int)eLeGroupListIT::numchannels);
tokenContainer->DefineIntToken("{nummenuitem}", (int)eLeGroupListIT::nummenuitem);
tokenContainer->DefineIntToken("{current}", (int)eLeGroupListIT::current);
InheritTokenContainer();
}
void cLeGroupList::Set(const char *group, int numChannels) {
dirty = true;
this->group = group;
this->numChannels = numChannels;
}
bool cLeGroupList::Parse(bool forced) {
if (!cViewElement::Parse(forced))
return false;
if (!dirty)
return false;
tokenContainer->Clear();
tokenContainer->AddIntToken((int)eLeGroupListIT::nummenuitem, num);
tokenContainer->AddIntToken((int)eLeGroupListIT::current, current);
tokenContainer->AddIntToken((int)eLeGroupListIT::numchannels, numChannels);
tokenContainer->AddStringToken((int)eLeGroupListST::groupname, group);
return true;
}

31
coreengine/listelements.h
View File

@@ -339,4 +339,35 @@ public:
bool Parse(bool forced = true);
};
/******************************************************************
* cLeChannelList
******************************************************************/
class cLeChannelList : public cListElement {
private:
const cChannel *channel;
public:
cLeChannelList(void);
cLeChannelList(const cLeChannelList &other);
virtual ~cLeChannelList(void);
void SetTokenContainer(void);
void Set(const cChannel *channel);
bool Parse(bool forced = true);
};
/******************************************************************
* cLeGroupList
******************************************************************/
class cLeGroupList : public cListElement {
private:
const char *group;
int numChannels;
public:
cLeGroupList(void);
cLeGroupList(const cLeGroupList &other);
virtual ~cLeGroupList(void);
void SetTokenContainer(void);
void Set(const char *group, int numChannels);
bool Parse(bool forced = true);
};
#endif //__LISTELEMENTS_H

44
coreengine/view.c
View File

@@ -141,6 +141,12 @@ bool cView::ValidViewElement(const char *viewElement) {
bool cView::ValidViewList(const char *viewList) {
if (!strcmp(viewList, "menuitems"))
return true;
else if (!strcmp(viewList, "channellist"))
return true;
else if (!strcmp(viewList, "grouplist"))
return true;
else if (!strcmp(viewList, "groupchannellist"))
return true;
return false;
}
@@ -162,6 +168,8 @@ void cView::PreCache(void) {
continue;
viewElements[i]->SetContainer(contX, contY, attribs->Width(), attribs->Height());
viewElements[i]->Cache();
if (const char *clearOnDisplay = viewElements[i]->ClearOnDisplay())
SetClearOnDisplay(i, clearOnDisplay);
}
if (viewElementsHorizontal) {
for (int i=0; i < numViewElements; i++) {
@@ -209,6 +217,13 @@ void cView::Clear(int ve, bool forceClearBackground) {
viewElements[ve]->Clear(forceClearBackground);
}
void cView::SetDirty(int ve) {
if (!viewElements[ve])
return;
viewElements[ve]->SetDirty();
viewElements[ve]->SetRestartAnimation();
}
void cView::Render(int ve, bool force) {
if (!viewElements[ve])
return;
@@ -216,6 +231,18 @@ void cView::Render(int ve, bool force) {
viewElements[ve]->Render();
}
void cView::Hide(int ve) {
if (!viewElements[ve])
return;
viewElements[ve]->Hide();
}
void cView::Show(int ve) {
if (!viewElements[ve])
return;
viewElements[ve]->Show();
}
void cView::Close(void) {
delete fader;
fader = NULL;
@@ -435,3 +462,20 @@ void cView::DoScaleTv(const cRect *frame) {
}
}
}
void cView::SetClearOnDisplay(int ve, const char *clearOnDisplay) {
if (!strcmp(clearOnDisplay, "all")) {
viewElements[ve]->SetClearAll();
return;
}
vector<int> clearVEs;
for (map<string,int>::iterator it = viewElementNames.begin(); it != viewElementNames.end(); it++) {
string name = it->first;
int id = it->second;
if (strstr(clearOnDisplay, name.c_str())) {
clearVEs.push_back(id);
}
}
viewElements[ve]->SetClearOnDisplay(clearVEs);
}

6
coreengine/view.h
View File

@@ -26,6 +26,7 @@ using namespace std;
class cView : public cFadable, public cShiftable {
private:
void DoScaleTv(const cRect *frame);
void SetClearOnDisplay(int ve, const char *clearOnDisplay);
protected:
cSdOsd sdOsd;
cViewAttribs *attribs;
@@ -76,13 +77,16 @@ public:
//View API
virtual bool Init(void);
void Clear(int ve, bool forceClearBackground = false);
void SetDirty(int ve);
void Render(int ve, bool force = false);
void Hide(int ve);
void Show(int ve);
virtual void Close(void);
virtual void Flush(bool animFlush);
virtual void Debug(void);
//Fadable
bool Detached(void) { return false; };
int Delay(void) { return 0; };
//Fadable
int FadeTime(void);
virtual void SetTransparency(int transparency, bool force = false);
//Shiftable

453
coreengine/viewdisplaychannel.c
View File

@@ -24,9 +24,66 @@ cViewChannel::cViewChannel(void) {
veStatusInfo = NULL;
veScraperContent = NULL;
veEcmInfo = NULL;
#ifdef USE_ZAPCOCKPIT
veChannelHints = NULL;
veChannelDetail = NULL;
veChannelListDetail = NULL;
veGroupChannelListDetail = NULL;
channelList = NULL;
groupList = NULL;
groupChannelList = NULL;
#endif
}
cViewChannel::~cViewChannel() {
#ifdef USE_ZAPCOCKPIT
delete channelList;
delete groupList;
delete groupChannelList;
#endif
}
void cViewChannel::SetGlobals(cGlobals *globals) {
cView::SetGlobals(globals);
#ifdef USE_ZAPCOCKPIT
if (channelList)
channelList->SetGlobals(globals);
if (groupList)
groupList->SetGlobals(globals);
if (groupChannelList)
groupChannelList->SetGlobals(globals);
#endif
}
void cViewChannel::PreCache(void) {
cView::PreCache();
#ifdef USE_ZAPCOCKPIT
if (channelList) {
channelList->SetContainer(attribs->X(), attribs->Y(), attribs->Width(), attribs->Height());
channelList->PreCache();
}
if (groupList) {
groupList->SetContainer(attribs->X(), attribs->Y(), attribs->Width(), attribs->Height());
groupList->PreCache();
}
if (groupChannelList) {
groupChannelList->SetContainer(attribs->X(), attribs->Y(), attribs->Width(), attribs->Height());
groupChannelList->PreCache();
}
#endif
}
void cViewChannel::AddChannelViewList(const char *listName, cViewList *viewList) {
#ifdef USE_ZAPCOCKPIT
if (!strcmp(listName, "channellist"))
channelList = dynamic_cast<cViewListChannelList*>(viewList);
else if (!strcmp(listName, "grouplist"))
groupList = dynamic_cast<cViewListGroupList*>(viewList);
else if (!strcmp(listName, "groupchannellist"))
groupChannelList = dynamic_cast<cViewListChannelList*>(viewList);
else
esyslog("skindesigner: invalid view list %s in displaychannel", listName);
#endif
}
void cViewChannel::SetViewElements(void) {
@@ -43,6 +100,13 @@ void cViewChannel::SetViewElements(void) {
viewElementNames.insert(pair<string, int>("devices", (int)eVeDisplayChannel::devices));
viewElementNames.insert(pair<string, int>("currentweather", (int)eVeDisplayChannel::currentweather));
viewElementNames.insert(pair<string, int>("scrapercontent", (int)eVeDisplayChannel::scrapercontent));
viewElementNames.insert(pair<string, int>("channelhints", (int)eVeDisplayChannel::channelhints));
viewElementNames.insert(pair<string, int>("channeldetail", (int)eVeDisplayChannel::channeldetail));
viewElementNames.insert(pair<string, int>("channellistback", (int)eVeDisplayChannel::channellistback));
viewElementNames.insert(pair<string, int>("channellistdetail", (int)eVeDisplayChannel::channellistdetail));
viewElementNames.insert(pair<string, int>("grouplistback", (int)eVeDisplayChannel::grouplistback));
viewElementNames.insert(pair<string, int>("groupchannellistback", (int)eVeDisplayChannel::groupchannellistback));
viewElementNames.insert(pair<string, int>("groupchannellistdetail", (int)eVeDisplayChannel::groupchannellistdetail));
viewElementNames.insert(pair<string, int>("datetime", (int)eVeDisplayChannel::datetime));
viewElementNames.insert(pair<string, int>("time", (int)eVeDisplayChannel::time));
viewElementNames.insert(pair<string, int>("message", (int)eVeDisplayChannel::message));
@@ -83,6 +147,24 @@ void cViewChannel::SetViewElementObjects(void) {
{
veScraperContent = dynamic_cast<cVeDcScraperContent*>(viewElements[i]);
}
#ifdef USE_ZAPCOCKPIT
else if (dynamic_cast<cVeDcChannelListDetail*>(viewElements[i]))
{
veChannelListDetail = dynamic_cast<cVeDcChannelListDetail*>(viewElements[i]);
}
else if (dynamic_cast<cVeDcGroupChannelListDetail*>(viewElements[i]))
{
veGroupChannelListDetail = dynamic_cast<cVeDcGroupChannelListDetail*>(viewElements[i]);
}
else if (dynamic_cast<cVeDcChannelHints*>(viewElements[i]))
{
veChannelHints = dynamic_cast<cVeDcChannelHints*>(viewElements[i]);
}
else if (dynamic_cast<cVeDcChannelDetail*>(viewElements[i]))
{
veChannelDetail = dynamic_cast<cVeDcChannelDetail*>(viewElements[i]);
}
#endif
else if (dynamic_cast<cVeDcEcmInfo*>(viewElements[i]))
{
veEcmInfo = dynamic_cast<cVeDcEcmInfo*>(viewElements[i]);
@@ -100,8 +182,16 @@ void cViewChannel::SetViewElementObjects(void) {
void cViewChannel::ClearVariables(void) {
cView::ClearVariables();
#ifdef USE_ZAPCOCKPIT
viewType = dcDefault;
viewTypeLast = dcDefault;
initExtended = true;
displayList = false;
initList = false;
channelInput = false;
#endif
channelChange = false;
displayChannelGroups = false;
mode = dmDefault;
if (veCustomTokens)
veCustomTokens->Reset();
timersLoaded = false;
@@ -114,8 +204,23 @@ void cViewChannel::SetChannel(const cChannel *channel, int number) {
globalTimers.LoadTimers();
}
channelChange = true;
bool wasChannelGroups = displayChannelGroups;
displayChannelGroups = false;
//check if channelgroups have to be cleared
bool clearChannelGroups = (mode == dmChannelGroups) ? true : false;
mode = dmDefault;
#ifdef USE_ZAPCOCKPIT
//check if channel hints have to be cleared
if (number) {
channelInput = true;
} else if (channelInput) {
channelInput = false;
if (veChannelHints)
veChannelHints->Close();
}
if (veChannelDetail)
veChannelDetail->Clear(true);
#endif
if (veChannelInfo) {
veChannelInfo->Clear();
@@ -124,24 +229,15 @@ void cViewChannel::SetChannel(const cChannel *channel, int number) {
if (channel) {
if (!channel->GroupSep()) {
if (wasChannelGroups)
if (clearChannelGroups)
Clear((int)eVeDisplayChannel::channelgroup);
if (veStatusInfo)
veStatusInfo->Set(channel);
if (veEcmInfo)
veEcmInfo->Set(channel);
} else {
displayChannelGroups = true;
Clear((int)eVeDisplayChannel::channelinfo, true);
Clear((int)eVeDisplayChannel::epginfo, true);
Clear((int)eVeDisplayChannel::statusinfo, true);
Clear((int)eVeDisplayChannel::progressbar, true);
Clear((int)eVeDisplayChannel::screenresolution, true);
Clear((int)eVeDisplayChannel::signalquality, true);
Clear((int)eVeDisplayChannel::audioinfo, true);
Clear((int)eVeDisplayChannel::ecminfo, true);
Clear((int)eVeDisplayChannel::devices, true);
Clear((int)eVeDisplayChannel::customtokens, true);
mode = dmChannelGroups;
ClearBasic(false);
if (veChannelGroup)
veChannelGroup->Set(channel);
}
@@ -178,31 +274,310 @@ void cViewChannel::SetMessage(eMessageType type, const char *text) {
}
}
void cViewChannel::Flush(bool animFlush) {
if (init) {
sdOsd.LockFlush();
#ifdef USE_ZAPCOCKPIT
void cViewChannel::SetViewType(eDisplaychannelView viewType) {
viewTypeLast = this->viewType;
this->viewType = viewType;
}
int cViewChannel::MaxItems(void) {
initList = true;
if (viewType == dcChannelList && channelList)
return channelList->NumItems();
else if (viewType == dcGroupsList && groupList)
return groupList->NumItems();
else if (viewType == dcGroupsChannelList && groupChannelList)
return groupChannelList->NumItems();
return 0;
}
void cViewChannel::SetChannelInfo(const cChannel *channel) {
if (!channel)
return;
if (viewType == dcChannelInfo && veChannelDetail) {
ClearOnDisplay();
veChannelDetail->Set(channel);
Render((int)eVeDisplayChannel::channeldetail);
} else if (viewType == dcChannelListInfo && veChannelListDetail) {
veChannelListDetail->Set(channel);
Render((int)eVeDisplayChannel::channellistdetail);
} else if (viewType == dcGroupsChannelListInfo && veGroupChannelListDetail) {
veGroupChannelListDetail->Set(channel);
Render((int)eVeDisplayChannel::groupchannellistdetail);
}
}
void cViewChannel::SetChannelList(const cChannel *channel, int index, bool current) {
displayList = true;
if (viewType == dcChannelList && channelList) {
channelList->Set(channel, index, current);
} else if (viewType == dcGroupsChannelList && groupChannelList) {
groupChannelList->Set(channel, index, current);
}
}
void cViewChannel::SetGroupList(const char *group, int numChannels, int index, bool current) {
displayList = true;
if (groupList) {
groupList->Set(group, numChannels, index, current);
}
}
void cViewChannel::ClearList(void) {
if (viewType == dcChannelList && channelList)
channelList->Clear();
if (viewType == dcGroupsList && groupList)
groupList->Clear();
}
void cViewChannel::SetNumChannelHints(int num) {
if (veChannelHints)
veChannelHints->SetNumHints(num);
channelHints = true;
}
void cViewChannel::SetChannelHint(const cChannel *channel) {
if (veChannelHints)
veChannelHints->SetHint(channel);
}
#endif //USE_ZAPCOCKPIT
void cViewChannel::Close(void) {
delete fader;
fader = NULL;
delete shifter;
shifter = NULL;
if (initFinished && ShiftTime() > 0) {
cRect shiftbox = CoveredArea();
cPoint ref = cPoint(shiftbox.X(), shiftbox.Y());
cPoint end = ShiftStart(shiftbox);
shifter = new cAnimation((cShiftable*)this, end, ref, false);
shifter->Shift();
delete shifter;
shifter = NULL;
} else if (initFinished && FadeTime() > 0) {
fader = new cAnimation((cFadable*)this, false);
fader->Fade();
delete fader;
fader = NULL;
}
UnScaleTv();
ClearVariables();
for (int i=0; i < numViewElements; i++) {
if (!viewElements[i])
continue;
viewElements[i]->Close();
}
#ifdef USE_ZAPCOCKPIT
if (channelList)
channelList->Close();
if (groupList)
groupList->Close();
if (groupChannelList)
groupChannelList->Close();
#endif
sdOsd.Flush();
sdOsd.DeleteOsd();
}
void cViewChannel::ClearBasic(bool clearBackground) {
if (clearBackground) {
Clear((int)eVeDisplayChannel::background, true);
Clear((int)eVeDisplayChannel::currentweather, true);
}
Clear((int)eVeDisplayChannel::channelinfo, true);
Clear((int)eVeDisplayChannel::epginfo, true);
Clear((int)eVeDisplayChannel::statusinfo, true);
Clear((int)eVeDisplayChannel::scrapercontent, true);
Clear((int)eVeDisplayChannel::progressbar, true);
Clear((int)eVeDisplayChannel::screenresolution, true);
Clear((int)eVeDisplayChannel::signalquality, true);
Clear((int)eVeDisplayChannel::audioinfo, true);
Clear((int)eVeDisplayChannel::ecminfo, true);
Clear((int)eVeDisplayChannel::devices, true);
Clear((int)eVeDisplayChannel::customtokens, true);
}
void cViewChannel::ClearExtended(void) {
#ifdef USE_ZAPCOCKPIT
//exit from channel list
if ((viewTypeLast == dcChannelList || viewTypeLast == dcChannelListInfo) && viewType == dcDefault && channelList) {
channelList->Clear();
Clear((int)eVeDisplayChannel::channellistback);
Clear((int)eVeDisplayChannel::channellistdetail);
SetDirty((int)eVeDisplayChannel::channellistback);
initExtended = true;
ShowBasic();
}
//exit from channellist info to channel list
if (viewTypeLast == dcChannelListInfo && viewType == dcChannelList) {
Clear((int)eVeDisplayChannel::channellistdetail);
SetDirty((int)eVeDisplayChannel::channellistdetail);
}
//exit from group list
if (viewTypeLast == dcGroupsList && viewType == dcDefault && groupList) {
groupList->Clear();
Clear((int)eVeDisplayChannel::grouplistback);
SetDirty((int)eVeDisplayChannel::grouplistback);
initExtended = true;
ShowBasic();
}
//exit from group channel list to group list
if (viewTypeLast == dcGroupsChannelList && viewType == dcGroupsList && groupChannelList) {
groupChannelList->Clear();
Clear((int)eVeDisplayChannel::groupchannellistback);
SetDirty((int)eVeDisplayChannel::groupchannellistback);
}
//exit from groupchannellist info to groupchannel list
if (viewTypeLast == dcGroupsChannelListInfo && viewType == dcGroupsChannelList) {
Clear((int)eVeDisplayChannel::groupchannellistdetail);
SetDirty((int)eVeDisplayChannel::groupchannellistdetail);
}
//exit from channel list
if ((viewTypeLast == dcGroupsChannelList || viewTypeLast == dcGroupsChannelListInfo) && viewType == dcDefault && groupList && groupChannelList) {
groupList->Clear();
groupChannelList->Clear();
Clear((int)eVeDisplayChannel::grouplistback);
Clear((int)eVeDisplayChannel::groupchannellistback);
Clear((int)eVeDisplayChannel::groupchannellistdetail);
SetDirty((int)eVeDisplayChannel::groupchannellistback);
SetDirty((int)eVeDisplayChannel::grouplistback);
SetDirty((int)eVeDisplayChannel::groupchannellistdetail);
initExtended = true;
ShowBasic();
}
//exit from channel info to channel or group list
if (viewTypeLast == dcChannelInfo && (viewType == dcChannelList || viewType == dcGroupsList)) {
Clear((int)eVeDisplayChannel::channeldetail, true);
}
viewTypeLast = dcDefault;
#endif
}
void cViewChannel::ClearOnDisplay(void) {
#ifdef USE_ZAPCOCKPIT
if (viewType == dcChannelInfo && veChannelDetail) {
vector<int> clear = veChannelDetail->GetClearOnDisplay();
for (vector<int>::iterator ve = clear.begin(); ve != clear.end(); ve++) {
Hide(*ve);
}
} else {
cViewElement *listBack = NULL;
if (viewType == dcChannelList)
listBack = viewElements[(int)eVeDisplayChannel::channellistback];
else if (viewType == dcGroupsList)
listBack = viewElements[(int)eVeDisplayChannel::grouplistback];
if (!listBack)
return;
if (listBack->DoClearAll()) {
HideBasic();
return;
}
vector<int> clear = listBack->GetClearOnDisplay();
for (vector<int>::iterator ve = clear.begin(); ve != clear.end(); ve++) {
Hide(*ve);
}
}
#endif
}
void cViewChannel::DrawBasic(bool initial) {
if (initial) {
Render((int)eVeDisplayChannel::background);
Render((int)eVeDisplayChannel::currentweather);
}
if (!displayChannelGroups) {
//normal display
if (!shifting) {
Render((int)eVeDisplayChannel::channelinfo);
Render((int)eVeDisplayChannel::epginfo);
Render((int)eVeDisplayChannel::statusinfo);
Render((int)eVeDisplayChannel::scrapercontent);
Render((int)eVeDisplayChannel::progressbar, channelChange);
Render((int)eVeDisplayChannel::screenresolution);
Render((int)eVeDisplayChannel::signalquality);
Render((int)eVeDisplayChannel::audioinfo);
Render((int)eVeDisplayChannel::ecminfo);
Render((int)eVeDisplayChannel::devices);
Render((int)eVeDisplayChannel::customtokens);
Render((int)eVeDisplayChannel::message);
Render((int)eVeDisplayChannel::channelinfo);
Render((int)eVeDisplayChannel::epginfo);
Render((int)eVeDisplayChannel::statusinfo);
Render((int)eVeDisplayChannel::scrapercontent);
Render((int)eVeDisplayChannel::progressbar, channelChange);
Render((int)eVeDisplayChannel::screenresolution);
Render((int)eVeDisplayChannel::signalquality);
Render((int)eVeDisplayChannel::audioinfo);
Render((int)eVeDisplayChannel::ecminfo);
Render((int)eVeDisplayChannel::devices);
Render((int)eVeDisplayChannel::customtokens);
Render((int)eVeDisplayChannel::message);
#ifdef USE_ZAPCOCKPIT
if (channelHints) {
channelHints = false;
if (veChannelHints) {
if (veChannelHints->Active())
veChannelHints->Close();
veChannelHints->Parse();
veChannelHints->Render();
}
}
#endif
}
void cViewChannel::HideBasic(void) {
for (int ve = (int)eVeDisplayChannel::background; ve <= (int)eVeDisplayChannel::ecminfo; ve++) {
Hide(ve);
}
}
void cViewChannel::ShowBasic(void) {
for (int ve = (int)eVeDisplayChannel::background; ve <= (int)eVeDisplayChannel::ecminfo; ve++) {
Show(ve);
}
}
void cViewChannel::DrawExtended(void) {
#ifdef USE_ZAPCOCKPIT
if (!displayList)
return;
if (initExtended) {
ClearOnDisplay();
initExtended = false;
}
if (!init && initList)
sdOsd.LockFlush();
if (viewType == dcChannelList && channelList) {
Render((int)eVeDisplayChannel::channellistback);
channelList->Draw(mcUndefined);
if (initList)
channelList->StartAnimation();
} else if (viewType == dcGroupsList && groupList) {
Render((int)eVeDisplayChannel::grouplistback);
groupList->Draw(mcUndefined);
if (initList)
groupList->StartAnimation();
} else if (viewType == dcGroupsChannelList && groupChannelList) {
Render((int)eVeDisplayChannel::groupchannellistback);
groupChannelList->Draw(mcUndefined);
if (initList)
groupChannelList->StartAnimation();
}
if (!init && initList)
sdOsd.UnlockFlush();
displayList = false;
initList = false;
#endif
}
void cViewChannel::Flush(bool animFlush) {
if (init) {
sdOsd.LockFlush();
}
#ifdef USE_ZAPCOCKPIT
ClearExtended();
#endif
//Basic Display Handling
if (mode == dmDefault) {
if (!shifting) {
DrawBasic(init);
}
} else if (mode == dmChannelGroups) {
if (init) {
Render((int)eVeDisplayChannel::background);
Render((int)eVeDisplayChannel::currentweather);
}
} else {
//channelgroup display
Render((int)eVeDisplayChannel::channelgroup);
}
if (!shifting) {
@@ -210,6 +585,10 @@ void cViewChannel::Flush(bool animFlush) {
Render((int)eVeDisplayChannel::time);
}
channelChange = false;
#ifdef USE_ZAPCOCKPIT
DrawExtended();
#endif
cView::Flush(animFlush);
}

62
coreengine/viewdisplaychannel.h
View File

@@ -4,30 +4,72 @@
#include "view.h"
#include "../extensions/globaltimers.h"
enum eDisplayMode {
dmDefault,
dmChannelGroups
};
class cViewChannel : public cView {
private:
cVeMessage *veMessage;
cVeCustomTokens *veCustomTokens;
cVeDcChannelInfo *veChannelInfo;
cVeDcChannelGroup *veChannelGroup;
cVeDcEpgInfo *veEpgInfo;
cVeDcProgressBar *veProgressBar;
cVeDcStatusInfo *veStatusInfo;
cVeDcScraperContent *veScraperContent;
cVeDcEcmInfo *veEcmInfo;
cVeMessage *veMessage;
cVeCustomTokens *veCustomTokens;
cVeDcChannelInfo *veChannelInfo;
cVeDcChannelGroup *veChannelGroup;
cVeDcEpgInfo *veEpgInfo;
cVeDcProgressBar *veProgressBar;
cVeDcStatusInfo *veStatusInfo;
cVeDcScraperContent *veScraperContent;
cVeDcEcmInfo *veEcmInfo;
#ifdef USE_ZAPCOCKPIT
cVeDcChannelHints *veChannelHints;
cVeDcChannelDetail *veChannelDetail;
cVeDcChannelListDetail *veChannelListDetail;
cVeDcGroupChannelListDetail *veGroupChannelListDetail;
cViewListChannelList *channelList;
cViewListGroupList *groupList;
cViewListChannelList *groupChannelList;
eDisplaychannelView viewType;
eDisplaychannelView viewTypeLast;
bool initExtended;
bool displayList;
bool initList;
bool channelHints;
bool channelInput;
#endif
bool channelChange;
bool displayChannelGroups;
eDisplayMode mode;
bool timersLoaded;
cGlobalTimers globalTimers;
void SetViewElements(void);
void ClearVariables(void);
void SetViewElementObjects(void);
void ClearBasic(bool clearBackground);
void ClearExtended(void);
void ClearOnDisplay(void);
void DrawBasic(bool initial);
void HideBasic(void);
void ShowBasic(void);
void DrawExtended(void);
public:
cViewChannel(void);
virtual ~cViewChannel(void);
void SetGlobals(cGlobals *globals);
void PreCache(void);
void AddChannelViewList(const char *listName, cViewList *viewList);
void SetChannel(const cChannel *channel, int number);
void SetEvents(const cEvent *present, const cEvent *following);
void SetMessage(eMessageType type, const char *text);
#ifdef USE_ZAPCOCKPIT
void SetViewType(eDisplaychannelView viewType);
int MaxItems(void);
void SetChannelInfo(const cChannel *channel);
void SetChannelList(const cChannel *channel, int index, bool current);
void SetGroupList(const char *group, int numChannels, int index, bool current);
void ClearList(void);
void SetNumChannelHints(int num);
void SetChannelHint(const cChannel *channel);
#endif
void Close(void);
void Flush(bool animFlush);
};

22
coreengine/viewelement.c
View File

@@ -15,9 +15,11 @@ cViewElement::cViewElement(void) {
detached = false;
waitOnWakeup = true;
startAnimation = true;
restartAnimation = false;
globals = NULL;
tokenContainer = NULL;
attribs = new cViewElementAttribs((int)eViewElementAttribs::count);
clearAll = false;
detacher = NULL;
fader = NULL;
shifter = NULL;
@@ -34,10 +36,12 @@ cViewElement::cViewElement(const cViewElement &other) {
detached = false;
waitOnWakeup = true;
startAnimation = true;
restartAnimation = false;
globals = other.globals;
container.Set(other.container.X(), other.container.Y(), other.container.Width(), other.container.Height());
tokenContainer = NULL;
attribs = new cViewElementAttribs(*other.attribs);
clearAll = false;
for (const cAreaNode *node = other.areaNodes.First(); node; node = other.areaNodes.Next(node)) {
if (cArea *a = dynamic_cast<cArea*>((cAreaNode*)node)) {
@@ -101,6 +105,20 @@ cViewElement *cViewElement::CreateViewElement(const char *name, const char *view
e = new cVeDcSignalQuality();
else if (!strcmp(name, "scrapercontent") && !strcmp(viewname, "displaychannel"))
e = new cVeDcScraperContent();
else if (!strcmp(name, "channelhints"))
e = new cVeDcChannelHints();
else if (!strcmp(name, "channeldetail"))
e = new cVeDcChannelDetail();
else if (!strcmp(name, "channellistback"))
e = new cViewElement();
else if (!strcmp(name, "grouplistback"))
e = new cViewElement();
else if (!strcmp(name, "groupchannellistback"))
e = new cViewElement();
else if (!strcmp(name, "channellistdetail"))
e = new cVeDcChannelListDetail();
else if (!strcmp(name, "groupchannellistdetail"))
e = new cVeDcGroupChannelListDetail();
else if (!strcmp(name, "ecminfo"))
e = new cVeDcEcmInfo();
@@ -326,6 +344,7 @@ void cViewElement::Close(void) {
dirty = true;
init = true;
startAnimation = true;
restartAnimation = false;
drawn = false;
scrollingStarted = false;
blocked = false;
@@ -378,8 +397,9 @@ void cViewElement::Render(void) {
}
dirty = false;
drawn = true;
if (startAnimation) {
if (startAnimation || restartAnimation) {
startAnimation = false;
restartAnimation = false;
StartAnimation();
}
}

9
coreengine/viewelement.h
View File

@@ -27,9 +27,12 @@ protected:
bool waitOnWakeup;
bool scrollingStarted;
bool startAnimation;
bool restartAnimation;
cGlobals *globals;
cRect container;
cViewElementAttribs *attribs;
vector<int> clearOnDisplay;
bool clearAll;
cList<cAreaNode> areaNodes;
skindesignerapi::cTokenContainer *tokenContainer;
cList<cAnimation> scrollers;
@@ -74,6 +77,11 @@ public:
void StopScrolling(bool deletePixmaps = true);
eOrientation Orientation(void) { return attribs->Orientation(); };
virtual int Delay(void) { return attribs->Delay(); };
const char *ClearOnDisplay(void) { return attribs->ClearOnDisplay(); };
void SetClearOnDisplay(vector<int> clearOnDisplay) { this->clearOnDisplay = clearOnDisplay; };
vector<int> GetClearOnDisplay(void) { return clearOnDisplay; };
void SetClearAll(void) { clearAll = true; };
bool DoClearAll(void) { return clearAll; };
void ParseDetached(void);
void RenderDetached(void);
bool Shifting(void);
@@ -82,6 +90,7 @@ public:
int ShiftTime(void);
int ShiftMode(void);
void StartAnimation(void);
void SetRestartAnimation(void) { restartAnimation = true; };
virtual void SetTransparency(int transparency, bool force = false);
virtual void SetPosition(cPoint &position, cPoint &reference, bool force = false);
void SetStartShifting(void) { };

258
coreengine/viewelementsdisplaychannel.c
View File

@@ -676,3 +676,261 @@ bool cVeDcEcmInfo::CompareECMInfos(sDVBAPIEcmInfo *ecmInfo) {
return false;
return true;
}
/******************************************************************
* cVeDcChannelHints
******************************************************************/
cVeDcChannelHints::cVeDcChannelHints(void) {
hints = NULL;
numHints = 0;
current = 0;
hintsIndex = -1;
active = false;
}
cVeDcChannelHints::~cVeDcChannelHints(void) {
delete[] hints;
}
void cVeDcChannelHints::Close(void) {
cViewElement::Close();
}
void cVeDcChannelHints::SetTokenContainer(void) {
tokenContainer = new skindesignerapi::cTokenContainer();
tokenContainer->DefineIntToken("{numhints}", (int)eDCChannelHintsIT::numhints);
tokenContainer->DefineLoopToken("{hints[channelnumber]}", (int)eDCChannelHintsLT::channelnumber);
tokenContainer->DefineLoopToken("{hints[channelname]}", (int)eDCChannelHintsLT::channelname);
tokenContainer->DefineLoopToken("{hints[channelid]}", (int)eDCChannelHintsLT::channelid);
tokenContainer->DefineLoopToken("{hints[channellogoexists]}", (int)eDCChannelHintsLT::channellogoexists);
hintsIndex = tokenContainer->LoopIndex("hints");
InheritTokenContainer();
}
void cVeDcChannelHints::SetNumHints(int num) {
delete[] hints;
numHints = num;
hints = new const cChannel*[num];
current = 0;
active = true;
SetDirty();
}
void cVeDcChannelHints::SetHint(const cChannel *c) {
hints[current++] = c;
}
bool cVeDcChannelHints::Parse(bool forced) {
if (!cViewElement::Parse(forced))
return false;
if (!Dirty())
return false;
if (!hints)
return false;
tokenContainer->Clear();
tokenContainer->AddIntToken((int)eDCChannelHintsIT::numhints, numHints);
vector<int> loopInfo;
loopInfo.push_back(numHints);
tokenContainer->CreateLoopTokenContainer(&loopInfo);
for (int i=0; i < numHints; i++) {
if (hints[i]) {
tokenContainer->AddLoopToken(hintsIndex, i, (int)eDCChannelHintsLT::channelnumber, *cString::sprintf("%d", hints[i]->Number()));
tokenContainer->AddLoopToken(hintsIndex, i, (int)eDCChannelHintsLT::channelname, hints[i]->Name());
cString channelID = hints[i]->GetChannelID().ToString();
tokenContainer->AddLoopToken(hintsIndex, i, (int)eDCChannelHintsLT::channelid, *channelID);
bool logoExists = imgCache->LogoExists(*channelID);
tokenContainer->AddLoopToken(hintsIndex, i, (int)eDCChannelHintsLT::channellogoexists, *cString::sprintf("%d", logoExists ? 1 : 0));
}
}
return true;
}
/******************************************************************
* cVeDcChannelDetail
******************************************************************/
cVeDcChannelDetail::cVeDcChannelDetail(void) {
channel = NULL;
}
cVeDcChannelDetail::~cVeDcChannelDetail(void) {
channel = NULL;
}
void cVeDcChannelDetail::Close(void) {
channel = NULL;
cViewElement::Close();
}
void cVeDcChannelDetail::SetTokenContainer(void) {
tokenContainer = new skindesignerapi::cTokenContainer();
tokenContainer->DefineStringToken("{channelname}", (int)eDCChannelDetailST::channelname);
tokenContainer->DefineStringToken("{currenttitle}", (int)eDCChannelDetailST::currenttitle);
tokenContainer->DefineStringToken("{currentshorttext}", (int)eDCChannelDetailST::currentshorttext);
tokenContainer->DefineStringToken("{currentdescription}", (int)eDCChannelDetailST::currentdescription);
tokenContainer->DefineStringToken("{currentstart}", (int)eDCChannelDetailST::currentstart);
tokenContainer->DefineStringToken("{currentstop}", (int)eDCChannelDetailST::currentstop);
tokenContainer->DefineStringToken("{currentdurationminutes}", (int)eDCChannelDetailST::currentdurationminutes);
tokenContainer->DefineStringToken("{nexttitle}", (int)eDCChannelDetailST::nexttitle);
tokenContainer->DefineStringToken("{nextshorttext}", (int)eDCChannelDetailST::nextshorttext);
tokenContainer->DefineStringToken("{nextdescription}", (int)eDCChannelDetailST::nextdescription);
tokenContainer->DefineStringToken("{nextstart}", (int)eDCChannelDetailST::nextstart);
tokenContainer->DefineStringToken("{nextstop}", (int)eDCChannelDetailST::nextstop);
tokenContainer->DefineStringToken("{nextdurationminutes}", (int)eDCChannelDetailST::nextdurationminutes);
tokenContainer->DefineIntToken("{channelnumber}", (int)eDCChannelDetailIT::channelnumber);
tokenContainer->DefineIntToken("{currentduration}", (int)eDCChannelDetailIT::currentduration);
tokenContainer->DefineIntToken("{currentdurationhours}", (int)eDCChannelDetailIT::currentdurationhours);
tokenContainer->DefineIntToken("{currentelapsed}", (int)eDCChannelDetailIT::currentelapsed);
tokenContainer->DefineIntToken("{currentremaining}", (int)eDCChannelDetailIT::currentremaining);
tokenContainer->DefineIntToken("{nextduration}", (int)eDCChannelDetailIT::nextduration);
tokenContainer->DefineIntToken("{nextdurationhours}", (int)eDCChannelDetailIT::nextdurationhours);
tokenContainer->DefineStringToken("{movietitle}", (int)eScraperST::movietitle);
tokenContainer->DefineStringToken("{movieoriginalTitle}", (int)eScraperST::movieoriginalTitle);
tokenContainer->DefineStringToken("{movietagline}", (int)eScraperST::movietagline);
tokenContainer->DefineStringToken("{movieoverview}", (int)eScraperST::movieoverview);
tokenContainer->DefineStringToken("{moviegenres}", (int)eScraperST::moviegenres);
tokenContainer->DefineStringToken("{moviehomepage}", (int)eScraperST::moviehomepage);
tokenContainer->DefineStringToken("{moviereleasedate}", (int)eScraperST::moviereleasedate);
tokenContainer->DefineStringToken("{moviepopularity}", (int)eScraperST::moviepopularity);
tokenContainer->DefineStringToken("{movievoteaverage}", (int)eScraperST::movievoteaverage);
tokenContainer->DefineStringToken("{posterpath}", (int)eScraperST::posterpath);
tokenContainer->DefineStringToken("{fanartpath}", (int)eScraperST::fanartpath);
tokenContainer->DefineStringToken("{moviecollectionName}", (int)eScraperST::moviecollectionName);
tokenContainer->DefineStringToken("{collectionposterpath}", (int)eScraperST::collectionposterpath);
tokenContainer->DefineStringToken("{collectionfanartpath}", (int)eScraperST::collectionfanartpath);
tokenContainer->DefineStringToken("{seriesname}", (int)eScraperST::seriesname);
tokenContainer->DefineStringToken("{seriesoverview}", (int)eScraperST::seriesoverview);
tokenContainer->DefineStringToken("{seriesfirstaired}", (int)eScraperST::seriesfirstaired);
tokenContainer->DefineStringToken("{seriesnetwork}", (int)eScraperST::seriesnetwork);
tokenContainer->DefineStringToken("{seriesgenre}", (int)eScraperST::seriesgenre);
tokenContainer->DefineStringToken("{seriesrating}", (int)eScraperST::seriesrating);
tokenContainer->DefineStringToken("{seriesstatus}", (int)eScraperST::seriesstatus);
tokenContainer->DefineStringToken("{episodetitle}", (int)eScraperST::episodetitle);
tokenContainer->DefineStringToken("{episodefirstaired}", (int)eScraperST::episodefirstaired);
tokenContainer->DefineStringToken("{episodegueststars}", (int)eScraperST::episodegueststars);
tokenContainer->DefineStringToken("{episodeoverview}", (int)eScraperST::episodeoverview);
tokenContainer->DefineStringToken("{episoderating}", (int)eScraperST::episoderating);
tokenContainer->DefineStringToken("{episodeimagepath}", (int)eScraperST::episodeimagepath);
tokenContainer->DefineStringToken("{seasonposterpath}", (int)eScraperST::seasonposterpath);
tokenContainer->DefineStringToken("{seriesposter1path}", (int)eScraperST::seriesposter1path);
tokenContainer->DefineStringToken("{seriesposter2path}", (int)eScraperST::seriesposter2path);
tokenContainer->DefineStringToken("{seriesposter3path}", (int)eScraperST::seriesposter3path);
tokenContainer->DefineStringToken("{seriesfanart1path}", (int)eScraperST::seriesfanart1path);
tokenContainer->DefineStringToken("{seriesfanart2path}", (int)eScraperST::seriesfanart2path);
tokenContainer->DefineStringToken("{seriesfanart3path}", (int)eScraperST::seriesfanart3path);
tokenContainer->DefineStringToken("{seriesbanner1path}", (int)eScraperST::seriesbanner1path);
tokenContainer->DefineStringToken("{seriesbanner2path}", (int)eScraperST::seriesbanner2path);
tokenContainer->DefineStringToken("{seriesbanner3path}", (int)eScraperST::seriesbanner3path);
tokenContainer->DefineIntToken("{ismovie}", (int)eScraperIT::ismovie);
tokenContainer->DefineIntToken("{moviebudget}", (int)eScraperIT::moviebudget);
tokenContainer->DefineIntToken("{movierevenue}", (int)eScraperIT::movierevenue);
tokenContainer->DefineIntToken("{movieadult}", (int)eScraperIT::movieadult);
tokenContainer->DefineIntToken("{movieruntime}", (int)eScraperIT::movieruntime);
tokenContainer->DefineIntToken("{isseries}", (int)eScraperIT::isseries);
tokenContainer->DefineIntToken("{posterwidth}", (int)eScraperIT::posterwidth);
tokenContainer->DefineIntToken("{posterheight}", (int)eScraperIT::posterheight);
tokenContainer->DefineIntToken("{fanartwidth}", (int)eScraperIT::fanartwidth);
tokenContainer->DefineIntToken("{fanartheight}", (int)eScraperIT::fanartheight);
tokenContainer->DefineIntToken("{movieiscollection}", (int)eScraperIT::movieiscollection);
tokenContainer->DefineIntToken("{collectionposterwidth}", (int)eScraperIT::collectionposterwidth);
tokenContainer->DefineIntToken("{collectionposterheight}", (int)eScraperIT::collectionposterheight);
tokenContainer->DefineIntToken("{collectionfanartwidth}", (int)eScraperIT::collectionfanartwidth);
tokenContainer->DefineIntToken("{collectionfanartheight}", (int)eScraperIT::collectionfanartheight);
tokenContainer->DefineIntToken("{epgpicavailable}", (int)eScraperIT::epgpicavailable);
tokenContainer->DefineIntToken("{episodenumber}", (int)eScraperIT::episodenumber);
tokenContainer->DefineIntToken("{episodeseason}", (int)eScraperIT::episodeseason);
tokenContainer->DefineIntToken("{episodeimagewidth}", (int)eScraperIT::episodeimagewidth);
tokenContainer->DefineIntToken("{episodeimageheight}", (int)eScraperIT::episodeimageheight);
tokenContainer->DefineIntToken("{seasonposterwidth}", (int)eScraperIT::seasonposterwidth);
tokenContainer->DefineIntToken("{seasonposterheight}", (int)eScraperIT::seasonposterheight);
tokenContainer->DefineIntToken("{seriesposter1width}", (int)eScraperIT::seriesposter1width);
tokenContainer->DefineIntToken("{seriesposter1height}", (int)eScraperIT::seriesposter1height);
tokenContainer->DefineIntToken("{seriesposter2width}", (int)eScraperIT::seriesposter2width);
tokenContainer->DefineIntToken("{seriesposter2height}", (int)eScraperIT::seriesposter2height);
tokenContainer->DefineIntToken("{seriesposter3width}", (int)eScraperIT::seriesposter3width);
tokenContainer->DefineIntToken("{seriesposter3height}", (int)eScraperIT::seriesposter3height);
tokenContainer->DefineIntToken("{seriesfanart1width}", (int)eScraperIT::seriesfanart1width);
tokenContainer->DefineIntToken("{seriesfanart1height}", (int)eScraperIT::seriesfanart1height);
tokenContainer->DefineIntToken("{seriesfanart2width}", (int)eScraperIT::seriesfanart2width);
tokenContainer->DefineIntToken("{seriesfanart2height}", (int)eScraperIT::seriesfanart2height);
tokenContainer->DefineIntToken("{seriesfanart3width}", (int)eScraperIT::seriesfanart3width);
tokenContainer->DefineIntToken("{seriesfanart3height}", (int)eScraperIT::seriesfanart3height);
tokenContainer->DefineIntToken("{seriesbanner1width}", (int)eScraperIT::seriesbanner1width);
tokenContainer->DefineIntToken("{seriesbanner1height}", (int)eScraperIT::seriesbanner1height);
tokenContainer->DefineIntToken("{seriesbanner2width}", (int)eScraperIT::seriesbanner2width);
tokenContainer->DefineIntToken("{seriesbanner2height}", (int)eScraperIT::seriesbanner2height);
tokenContainer->DefineIntToken("{seriesbanner3width}", (int)eScraperIT::seriesbanner3width);
tokenContainer->DefineIntToken("{seriesbanner3height}", (int)eScraperIT::seriesbanner3height);
tokenContainer->DefineLoopToken("{actors[name]}", (int)eScraperLT::name);
tokenContainer->DefineLoopToken("{actors[role]}", (int)eScraperLT::role);
tokenContainer->DefineLoopToken("{actors[thumb]}", (int)eScraperLT::thumb);
tokenContainer->DefineLoopToken("{actors[thumbwidth]}", (int)eScraperLT::thumbwidth);
tokenContainer->DefineLoopToken("{actors[thumbheight]}", (int)eScraperLT::thumbheight);
actorsIndex = tokenContainer->LoopIndex("actors");
InheritTokenContainer();
}
void cVeDcChannelDetail::Set(const cChannel *c) {
channel = c;
}
bool cVeDcChannelDetail::Parse(bool forced) {
if (!cViewElement::Parse(forced))
return false;
if (!channel)
return false;
SetDirty();
tokenContainer->Clear();
tokenContainer->AddIntToken((int)eDCChannelDetailIT::channelnumber, channel->Number());
tokenContainer->AddStringToken((int)eDCChannelDetailST::channelname, channel->Name());
#if defined (APIVERSNUM) && (APIVERSNUM >= 20301)
LOCK_SCHEDULES_READ;
const cSchedules* schedules = Schedules;
#else
cSchedulesLock schedulesLock;
const cSchedules* schedules = (cSchedules*)cSchedules::Schedules(schedulesLock);
#endif
const cSchedule *schedule = schedules->GetSchedule(channel);
if (schedule) {
const cEvent *presentEvent = schedule->GetPresentEvent();
if (presentEvent) {
tokenContainer->AddStringToken((int)eDCChannelDetailST::currenttitle, presentEvent->Title());
tokenContainer->AddStringToken((int)eDCChannelDetailST::currentshorttext, presentEvent->ShortText());
tokenContainer->AddStringToken((int)eDCChannelDetailST::currentdescription, presentEvent->Description());
tokenContainer->AddStringToken((int)eDCChannelDetailST::currentstart, *presentEvent->GetTimeString());
tokenContainer->AddStringToken((int)eDCChannelDetailST::currentstop, *presentEvent->GetEndTimeString());
tokenContainer->AddIntToken((int)eDCChannelDetailIT::currentduration, presentEvent->Duration()/60);
tokenContainer->AddIntToken((int)eDCChannelDetailIT::currentelapsed, (time(0) - presentEvent->StartTime())/60);
tokenContainer->AddIntToken((int)eDCChannelDetailIT::currentremaining, presentEvent->Duration()/60 - (time(0) - presentEvent->StartTime())/60);
tokenContainer->AddIntToken((int)eDCChannelDetailIT::currentdurationhours, presentEvent->Duration() / 3600);
tokenContainer->AddStringToken((int)eDCChannelDetailST::currentdurationminutes, *cString::sprintf("%.2d", (presentEvent->Duration() / 60)%60));
vector<int> loopInfo;
bool scrapInfoAvailable = LoadFullScrapInfo(presentEvent, NULL);
int numActors = NumActors();
loopInfo.push_back(numActors);
tokenContainer->CreateLoopTokenContainer(&loopInfo);
if (scrapInfoAvailable) {
SetFullScrapInfo(tokenContainer, actorsIndex);
}
}
const cList<cEvent> *events = schedule->Events();
if (events && presentEvent) {
const cEvent *nextEvent = events->Next(presentEvent);
if (nextEvent) {
tokenContainer->AddStringToken((int)eDCChannelDetailST::nexttitle, nextEvent->Title());
tokenContainer->AddStringToken((int)eDCChannelDetailST::nextshorttext, nextEvent->ShortText());
tokenContainer->AddStringToken((int)eDCChannelDetailST::nextdescription, nextEvent->Description());
tokenContainer->AddStringToken((int)eDCChannelDetailST::nextstart, *nextEvent->GetTimeString());
tokenContainer->AddStringToken((int)eDCChannelDetailST::nextstop, *nextEvent->GetEndTimeString());
tokenContainer->AddIntToken((int)eDCChannelDetailIT::nextduration, nextEvent->Duration() / 60);
tokenContainer->AddIntToken((int)eDCChannelDetailIT::nextdurationhours, nextEvent->Duration() / 3600);
tokenContainer->AddStringToken((int)eDCChannelDetailST::nextdurationminutes, *cString::sprintf("%.2d", (nextEvent->Duration() / 60)%60));
}
}
}
return true;
}

49
coreengine/viewelementsdisplaychannel.h
View File

@@ -150,4 +150,53 @@ public:
bool Parse(bool forced = false);
};
/******************************************************************
* cVeDcChannelHints
******************************************************************/
class cVeDcChannelHints : public cViewElement {
private:
const cChannel **hints;
int numHints;
int current;
int hintsIndex;
bool active;
public:
cVeDcChannelHints(void);
virtual ~cVeDcChannelHints(void);
void Close(void);
void SetTokenContainer(void);
void SetNumHints(int num);
void SetHint(const cChannel *c);
bool Parse(bool forced = false);
bool Active(void) { return active; };
};
/******************************************************************
* cVeDcChannelDetail
******************************************************************/
class cVeDcChannelDetail : public cViewElement, public cScrapManager {
private:
const cChannel *channel;
int actorsIndex;
public:
cVeDcChannelDetail(void);
virtual ~cVeDcChannelDetail(void);
void Close(void);
void SetTokenContainer(void);
void Set(const cChannel *c);
bool Parse(bool forced = false);
};
class cVeDcChannelListDetail : public cVeDcChannelDetail {
public:
cVeDcChannelListDetail(void) {};
virtual ~cVeDcChannelListDetail(void) {};
};
class cVeDcGroupChannelListDetail : public cVeDcChannelDetail {
public:
cVeDcGroupChannelListDetail(void) {};
virtual ~cVeDcGroupChannelListDetail(void) {};
};
#endif //__VIEWELEMENTSDC_H

8
coreengine/viewelementsdisplaymenu.c
View File

@@ -411,10 +411,10 @@ bool cVeDmTimers::Parse(bool forced) {
}
bool isRecording = Timer->Recording();
if (!isRecording) {
if (cEpgTimer_Interface_V1* epgTimer = dynamic_cast<cEpgTimer_Interface_V1*>((cTimer*)Timer)) {
if (epgTimer->State() == 'R')
isRecording = true;
}
if (cEpgTimer_Interface_V1* epgTimer = dynamic_cast<cEpgTimer_Interface_V1*>((cTimer*)Timer)) {
if (epgTimer->State() == 'R')
isRecording = true;
}
}
tokenContainer->AddLoopToken(timerIndex, i, (int)eDMTimersLT::recording, isRecording ? "1" : "0");

221
coreengine/viewlist.c
View File

@@ -9,6 +9,8 @@ cViewList::cViewList(void) {
listElements = NULL;
plugId = -1;
plugMenuId = -1;
fader = NULL;
shifter = NULL;
}
cViewList::~cViewList(void) {
@@ -25,6 +27,8 @@ cViewList::~cViewList(void) {
}
delete[] listElements;
delete tokenContainer;
delete fader;
delete shifter;
}
void cViewList::SetGlobals(cGlobals *globals) {
@@ -66,6 +70,12 @@ cViewList *cViewList::CreateViewList(const char *name) {
l = new cViewListAudioTracks();
else if (startswith(name, "menuplugin"))
l = new cViewListPlugin();
else if (startswith(name, "channellist"))
l = new cViewListChannelList();
else if (startswith(name, "grouplist"))
l = new cViewListGroupList();
else if (startswith(name, "groupchannellist"))
l = new cViewListChannelList();
else
esyslog("skindesigner: unknown viewlist %s", name);
return l;
@@ -91,6 +101,12 @@ cViewElement *cViewList::CreateListElement(const char *name) {
le = new cLeAudioTracks();
else if (startswith(name, "menuplugin"))
le = new cLeMenuPlugin();
else if (startswith(name, "channellist"))
le = new cLeChannelList();
else if (startswith(name, "grouplist"))
le = new cLeGroupList();
else if (startswith(name, "groupchannellist"))
le = new cLeChannelList();
else
esyslog("skindesigner: unknown viewlist %s", name);
return le;
@@ -207,21 +223,85 @@ void cViewList::Clear(void) {
}
void cViewList::Close(void) {
delete fader;
fader = NULL;
delete shifter;
shifter = NULL;
if (!listElements)
return;
for (int i = 0; i < numElements; i++) {
listElements[i]->StopBlinking();
listElements[i]->StopScrolling();
}
for (int i = 0; i < numElements; i++) {
for (int i = 0; i < numElements; i++)
listElements[i]->Close();
}
void cViewList::SetTransparency(int transparency, bool force) {
for (int i = 0; i < numElements; i++) {
if (listElements[i])
listElements[i]->SetTransparency(transparency, force);
}
}
void cViewList::SetTransparency(int transparency) {
cRect cViewList::CoveredArea(void) {
cRect unionArea;
for (int i = 0; i < numElements; i++) {
if (listElements[i])
unionArea.Combine(listElements[i]->CoveredArea());
}
return unionArea;
}
void cViewList::SetPosition(cPoint &position, cPoint &reference, bool force) {
for (int i = 0; i < numElements; i++) {
if (listElements[i])
listElements[i]->SetPosition(position, reference, force);
}
}
void cViewList::RegisterAnimation(void) {
for (int i = 0; i < numElements; i++) {
if (listElements[i]) {
listElements[i]->RegisterAnimation();
break;
}
}
}
void cViewList::UnregisterAnimation(void) {
for (int i = 0; i < numElements; i++) {
if (listElements[i]) {
listElements[i]->UnregisterAnimation();
break;
}
}
}
void cViewList::StartAnimation(void) {
if (ShiftTime() > 0) {
cRect shiftbox = CoveredArea();
cPoint ref = cPoint(shiftbox.X(), shiftbox.Y());
cPoint start = ShiftStart(shiftbox);
SetPosition(start, ref);
Flush(false);
delete shifter;
shifter = new cAnimation((cShiftable*)this, start, ref, true);
shifter->Start();
} else if (FadeTime() > 0) {
SetTransparency(100);
Flush(false);
delete fader;
fader = new cAnimation((cFadable*)this, true);
fader->Start();
}
}
void cViewList::Flush(bool animFlush) {
for (int i = 0; i < numElements; i++) {
if (listElements[i]) {
listElements[i]->SetTransparency(transparency);
listElements[i]->Flush(animFlush);
break;
}
}
}
@@ -231,6 +311,27 @@ void cViewList::Debug(void) {
attribs->Debug();
}
cPoint cViewList::ShiftStart(cRect &shiftbox) {
eShiftType type = (eShiftType)attribs->ShiftType();
cPoint start;
if (type == eShiftType::none) {
start = attribs->ShiftStartpoint();
} else if (type == eShiftType::left) {
start.SetX(-shiftbox.Width());
start.SetY(shiftbox.Y());
} else if (type == eShiftType::right) {
start.SetX(cOsd::OsdWidth());
start.SetY(shiftbox.Y());
} else if (type == eShiftType::top) {
start.SetX(shiftbox.X());
start.SetY(-shiftbox.Height());
} else if (type == eShiftType::bottom) {
start.SetX(shiftbox.X());
start.SetY(cOsd::OsdHeight());
}
return start;
}
/******************************************************************
* cViewListDefault
******************************************************************/
@@ -927,3 +1028,117 @@ void cViewListAudioTracks::Draw(void) {
}
}
}
/******************************************************************
* cViewListChannelList
******************************************************************/
cViewListChannelList::cViewListChannelList(void) {
listChannelList = NULL;
}
cViewListChannelList::~cViewListChannelList(void) {
delete[] listChannelList;
}
void cViewListChannelList::Prepare(int start, int step) {
if (!listElement)
return;
cLeChannelList *tpl = dynamic_cast<cLeChannelList*>(listElement);
if (!tpl) return;
listChannelList = new cLeChannelList*[numElements];
listElements = new cListElement*[numElements];
int pos = start;
for (int i = 0; i < numElements; i++) {
listChannelList[i] = new cLeChannelList(*tpl);
listElements[i] = listChannelList[i];
listChannelList[i]->SetNumber(i);
listChannelList[i]->SetTokenContainer();
int x, y, width, height;
if (orientation == eOrientation::vertical) {
x = attribs->X();
y = pos;
width = attribs->Width();
height = step;
listChannelList[i]->SetAreaHeight(height);
} else {
x = pos;
y = attribs->Y();
width = step;
height = attribs->Height();
listChannelList[i]->SetAreaWidth(width);
}
listChannelList[i]->SetContainer(x, y, width, height);
listChannelList[i]->Cache();
pos += step;
}
}
void cViewListChannelList::Set(const cChannel *channel, int index, bool current) {
if (index < 0 || index >= numElements)
return;
if (!current)
listChannelList[index]->StopScrolling();
listChannelList[index]->SetCurrent(current);
listChannelList[index]->SetSelectable(true);
listChannelList[index]->Set(channel);
}
/******************************************************************
* cViewListGroupList
******************************************************************/
cViewListGroupList::cViewListGroupList(void) {
listGroupList = NULL;
}
cViewListGroupList::~cViewListGroupList(void) {
delete[] listGroupList;
}
void cViewListGroupList::Prepare(int start, int step) {
if (!listElement)
return;
cLeGroupList *tpl = dynamic_cast<cLeGroupList*>(listElement);
if (!tpl) return;
listGroupList = new cLeGroupList*[numElements];
listElements = new cListElement*[numElements];
int pos = start;
for (int i = 0; i < numElements; i++) {
listGroupList[i] = new cLeGroupList(*tpl);
listElements[i] = listGroupList[i];
listGroupList[i]->SetNumber(i);
listGroupList[i]->SetTokenContainer();
int x, y, width, height;
if (orientation == eOrientation::vertical) {
x = attribs->X();
y = pos;
width = attribs->Width();
height = step;
listGroupList[i]->SetAreaHeight(height);
} else {
x = pos;
y = attribs->Y();
width = step;
height = attribs->Height();
listGroupList[i]->SetAreaWidth(width);
}
listGroupList[i]->SetContainer(x, y, width, height);
listGroupList[i]->Cache();
pos += step;
}
}
void cViewListGroupList::Set(const char *group, int numChannels, int index, bool current) {
if (index < 0 || index >= numElements)
return;
if (!current)
listGroupList[index]->StopScrolling();
listGroupList[index]->SetCurrent(current);
listGroupList[index]->SetSelectable(true);
listGroupList[index]->Set(group, numChannels);
}

44
coreengine/viewlist.h
View File

@@ -6,7 +6,7 @@
#include "listelements.h"
#include "area.h"
class cViewList {
class cViewList : public cFadable, public cShiftable {
protected:
int plugId;
int plugMenuId;
@@ -19,7 +19,10 @@ protected:
cViewElement *listElement;
cViewElement *currentElement;
cListElement **listElements;
cAnimation *fader;
cAnimation *shifter;
virtual void Prepare(int start, int step) {};
cPoint ShiftStart(cRect &shiftbox);
public:
cViewList(void);
virtual ~cViewList(void);
@@ -40,7 +43,22 @@ public:
void Draw(eMenuCategory menuCat);
void Clear(void);
virtual void Close(void);
void SetTransparency(int transparency);
//Fadable
bool Detached(void) { return false; };
int Delay(void) { return 0; };
int FadeTime(void) { return attribs->FadeTime(); };
void SetTransparency(int transparency, bool force = false);
//Shiftable
int ShiftTime(void) { return attribs->ShiftTime(); };
int ShiftMode(void) { return attribs->ShiftMode(); };
void SetPosition(cPoint &position, cPoint &reference, bool force = false);
void SetStartShifting(void) { };
void SetEndShifting(void) { };
void RegisterAnimation(void);
void UnregisterAnimation(void);
cRect CoveredArea(void);
void StartAnimation(void);
void Flush(bool animFlush);
void Debug(void);
};
@@ -154,4 +172,26 @@ public:
void SetCurrentTrack(int index);
void Draw(void);
};
class cViewListChannelList : public cViewList {
private:
cLeChannelList **listChannelList;
protected:
void Prepare(int start, int step);
public:
cViewListChannelList(void);
virtual ~cViewListChannelList(void);
void Set(const cChannel *channel, int index, bool current);
};
class cViewListGroupList : public cViewList {
private:
cLeGroupList **listGroupList;
protected:
void Prepare(int start, int step);
public:
cViewListGroupList(void);
virtual ~cViewListGroupList(void);
void Set(const char *group, int numChannels, int index, bool current);
};
#endif //__VIEWLIST_H

36
coreengine/xmlparser.c
View File

@@ -40,6 +40,7 @@ bool cXmlParser::ParseView(void) {
view->SetAttributes(rootAttribs);
cViewMenu *menuView = dynamic_cast<cViewMenu*>(view);
cViewChannel *channelView = dynamic_cast<cViewChannel*>(view);
cViewTracks *tracksView = dynamic_cast<cViewTracks*>(view);
if (!LevelDown())
@@ -48,6 +49,13 @@ bool cXmlParser::ParseView(void) {
do {
if (view->ValidViewElement(NodeName())) {
ParseViewElement(NodeName());
} else if (channelView) {
if (view->ValidViewList(NodeName())) {
ParseViewList(NULL, NodeName());
} else {
esyslog("skindesigner: unknown node %s", NodeName());
return false;
}
} else if (menuView) {
if (menuView->ValidSubView(NodeName())) {
ParseSubView(NodeName());
@@ -334,7 +342,7 @@ void cXmlParser::ParsePluginViewElement(bool isScrollbar, bool isTabLabels) {
}
}
void cXmlParser::ParseViewList(cView *subView) {
void cXmlParser::ParseViewList(cView *subView, const char *listName) {
if (!view)
return;
@@ -345,7 +353,11 @@ void cXmlParser::ParseViewList(cView *subView) {
name = view->GetViewName();
vector<stringpair> attribs = ParseAttributes();
cViewList *viewList = cViewList::CreateViewList(name);
cViewList *viewList = NULL;
if (!listName)
viewList = cViewList::CreateViewList(name);
else
viewList = cViewList::CreateViewList(listName);
viewList->SetAttributes(attribs);
if (!LevelDown())
@@ -353,7 +365,11 @@ void cXmlParser::ParseViewList(cView *subView) {
do {
if (CheckNodeName("currentelement")) {
cViewElement *currentElement = cViewList::CreateCurrentElement(name);
cViewElement *currentElement = NULL;
if (!listName)
currentElement = cViewList::CreateCurrentElement(name);
else
currentElement = cViewList::CreateCurrentElement(listName);
currentElement->SetOsd(sdOsd);
vector<stringpair> attribsList = ParseAttributes();
currentElement->SetAttributes(attribsList);
@@ -375,7 +391,11 @@ void cXmlParser::ParseViewList(cView *subView) {
LevelUp();
viewList->AddCurrentElement(currentElement);
} else if (CheckNodeName("listelement")) {
cViewElement *listElement = cViewList::CreateListElement(name);
cViewElement *listElement = NULL;
if (!listName)
listElement = cViewList::CreateListElement(name);
else
listElement = cViewList::CreateListElement(listName);
listElement->SetOsd(sdOsd);
vector<stringpair> attribsList = ParseAttributes();
listElement->SetAttributes(attribsList);
@@ -402,8 +422,12 @@ void cXmlParser::ParseViewList(cView *subView) {
if (subView)
subView->AddViewList(viewList);
else
view->AddViewList(viewList);
else if (listName) {
cViewChannel *channelView = dynamic_cast<cViewChannel*>(view);
channelView->AddChannelViewList(listName, viewList);
} else {
view->AddViewList(viewList);
}
}

2
coreengine/xmlparser.h
View File

@@ -29,7 +29,7 @@ private:
bool ParseSubView(string name);
void ParseViewElement(string name, cView *subView = NULL);
void ParsePluginViewElement(bool isScrollbar = false, bool isTabLabels = false);
void ParseViewList(cView *subView = NULL);
void ParseViewList(cView *subView = NULL, const char *listName = NULL);
void ParseViewTab(cView *subView);
void ParseViewTabPlugin(void);
void ParseGrid(void);