frodovdr
/
vdr-plugin-skindesigner
mirror of https://projects.vdr-developer.org/git/vdr-plugin-skindesigner.git
1
0
Fork 0
Code Issues Releases Wiki Activity
vdr-plugin-skindesigner/coreengine/viewdisplaymenu.c

1706 lines
58 KiB
C
Raw Blame History

#include "viewdisplaymenu.h"
#include "../config.h"
/************************************************************************************
* cViewMenu
************************************************************************************/
cViewMenu::cViewMenu(void) {
menuDefault = NULL;
menuMain = NULL;
menuSetup = NULL;
menuSchedules = NULL;
menuChannels = NULL;
menuTimers = NULL;
menuRecordings = NULL;
menuDetailedEpg = NULL;
menuDetailedRec = NULL;
menuDetailedText = NULL;
ClearVariables();
viewId = eViewType::DisplayMenu;
viewName = strdup("displaymenu");
numViewElements = (int)eVeDisplayMenu::count;
viewElements = new cViewElement*[numViewElements];
for (int i=0; i < numViewElements; i++) {
viewElements[i] = NULL;
}
viewElementsHorizontal = new cViewElement*[numViewElements];
for (int i=0; i < numViewElements; i++) {
viewElementsHorizontal[i] = NULL;
}
SetViewElements();
int numPluginMenus = plgManager->GetNumPluginMenus();
numSubviews = (int)eSvDisplayMenu::count + numPluginMenus;
subViews = new cSubView*[numSubviews];
for (int i=0; i < numSubviews; i++) {
subViews[i] = NULL;
}
SetSubViews();
menuCat = mcUnknown;
plugName = NULL;
}
cViewMenu::~cViewMenu() {
for (int i=0; i< numSubviews; i++)
delete subViews[i];
delete[] subViews;
}
void cViewMenu::SetGlobals(cGlobals *globals) {
cView::SetGlobals(globals);
for (int i=0; i < numSubviews; ++i) {
if (subViews[i]) {
subViews[i]->SetGlobals(globals);
}
}
}
void cViewMenu::PreCache(void) {
cView::PreCache();
for (int i=0; i < numSubviews; i++) {
if (subViews[i]) {
subViews[i]->SetContainer(0, 0, attribs->Width(), attribs->Height());
subViews[i]->PreCache();
//setting default viewelements for subviews
for (int ve = (int)eVeDisplayMenu::background; ve < (int)eVeDisplayMenu::count; ve++) {
if (viewElements[ve] && !subViews[i]->ViewElementSet(ve)) {
subViews[i]->SetViewElement((eVeDisplayMenu)ve, viewElements[ve]);
}
}
for (int ve = (int)eVeDisplayMenu::background; ve < (int)eVeDisplayMenu::count; ve++) {
if (viewElementsHorizontal[ve] && !subViews[i]->ViewElementHorizontalSet(ve)) {
subViews[i]->SetViewElementHorizontal((eVeDisplayMenu)ve, viewElementsHorizontal[ve]);
}
}
}
}
}
void cViewMenu::SetViewElementObjects(void) {
//setting subviews
for (int i=0; i < numSubviews; i++) {
if (!subViews[i])
continue;
if (i == (int)eSvDisplayMenu::menudefault)
menuDefault = dynamic_cast<cViewMenuDefault*>(subViews[i]);
else if (i == (int)eSvDisplayMenu::main)
menuMain = dynamic_cast<cViewMenuMain*>(subViews[i]);
else if (i == (int)eSvDisplayMenu::setup)
menuSetup = dynamic_cast<cViewMenuSetup*>(subViews[i]);
else if (i == (int)eSvDisplayMenu::schedules)
menuSchedules = dynamic_cast<cViewMenuSchedules*>(subViews[i]);
else if (i == (int)eSvDisplayMenu::channels)
menuChannels = dynamic_cast<cViewMenuChannels*>(subViews[i]);
else if (i == (int)eSvDisplayMenu::timers)
menuTimers = dynamic_cast<cViewMenuTimers*>(subViews[i]);
else if (i == (int)eSvDisplayMenu::recordings)
menuRecordings = dynamic_cast<cViewMenuRecordings*>(subViews[i]);
else if (i == (int)eSvDisplayMenu::detailepg)
menuDetailedEpg = dynamic_cast<cViewMenuDetail*>(subViews[i]);
else if (i == (int)eSvDisplayMenu::detailrec)
menuDetailedRec = dynamic_cast<cViewMenuDetail*>(subViews[i]);
else if (i == (int)eSvDisplayMenu::detailtext)
menuDetailedText = dynamic_cast<cViewMenuDetail*>(subViews[i]);
}
}
void cViewMenu::SetViewElements(void) {
viewElementNames.insert(pair<string, int>("background", (int)eVeDisplayMenu::background));
viewElementNames.insert(pair<string, int>("header", (int)eVeDisplayMenu::header));
viewElementNames.insert(pair<string, int>("datetime", (int)eVeDisplayMenu::datetime));
viewElementNames.insert(pair<string, int>("time", (int)eVeDisplayMenu::time));
viewElementNames.insert(pair<string, int>("colorbuttons", (int)eVeDisplayMenu::colorbuttons));
viewElementNames.insert(pair<string, int>("message", (int)eVeDisplayMenu::message));
viewElementNames.insert(pair<string, int>("scrollbar", (int)eVeDisplayMenu::scrollbar));
viewElementNames.insert(pair<string, int>("sortmode", (int)eVeDisplayMenu::sortmode));
}
void cViewMenu::SetSubViews(void) {
//adding VDR submenus
subviewNames.insert(pair<string, int>("menudefault", (int)eSvDisplayMenu::menudefault));
subviewNames.insert(pair<string, int>("menumain", (int)eSvDisplayMenu::main));
subviewNames.insert(pair<string, int>("menusetup", (int)eSvDisplayMenu::setup));
subviewNames.insert(pair<string, int>("menuschedules", (int)eSvDisplayMenu::schedules));
subviewNames.insert(pair<string, int>("menuchannels", (int)eSvDisplayMenu::channels));
subviewNames.insert(pair<string, int>("menutimers", (int)eSvDisplayMenu::timers));
subviewNames.insert(pair<string, int>("menurecordings", (int)eSvDisplayMenu::recordings));
subviewNames.insert(pair<string, int>("menudetailedepg", (int)eSvDisplayMenu::detailepg));
subviewNames.insert(pair<string, int>("menudetailedrecording", (int)eSvDisplayMenu::detailrec));
subviewNames.insert(pair<string, int>("menudetailedtext", (int)eSvDisplayMenu::detailtext));
//adding additional plugin subviews
int subViewNumber = (int)eSvDisplayMenu::count;
map <int,skindesignerapi::sPlugMenu> *plugMenus = NULL;
string plugName = "";
int plugId = -1;
plgManager->InitPluginMenuIterator();
while ( plugMenus = plgManager->GetPluginMenus(plugName, plugId) ) {
for (map <int,skindesignerapi::sPlugMenu>::iterator it = plugMenus->begin(); it != plugMenus->end(); it++) {
int menuNumber = it->first;
cString menuName = cString::sprintf("menuplugin-%s-%d", plugName.c_str(), menuNumber);
subviewNames.insert(pair<string, int>(*menuName, subViewNumber));
plgManager->AddSubviewMapping(plugId, menuNumber, subViewNumber);
subViewNumber++;
}
}
}
void cViewMenu::ClearVariables(void) {
cView::ClearVariables();
menuChange = true;
listChange = true;
detailViewInit = false;
menuCat = mcUnknown;
pluginIdSet = false;
plugId = -1;
plugMenuId = -1;
activeSubview = NULL;
activeSubviewLast = NULL;
}
int cViewMenu::SubviewId(const char *name) {
map<string, int>::iterator hit = subviewNames.find(name);
if (hit != subviewNames.end())
return (int)hit->second;
return ATTR_UNKNOWN;
}
bool cViewMenu::ValidSubView(const char *subView) {
if (SubviewId(subView) != ATTR_UNKNOWN)
return true;
return false;
}
cSubView *cViewMenu::CreateSubview(const char *name) {
cSubView *sv = NULL;
if (!strcmp(name, "menudefault"))
sv = new cViewMenuDefault(name);
else if (!strcmp(name, "menumain"))
sv = new cViewMenuMain(name);
else if (!strcmp(name, "menusetup"))
sv = new cViewMenuSetup(name);
else if (!strcmp(name, "menuschedules"))
sv = new cViewMenuSchedules(name);
else if (!strcmp(name, "menuchannels"))
sv = new cViewMenuChannels(name);
else if (!strcmp(name, "menutimers"))
sv = new cViewMenuTimers(name);
else if (!strcmp(name, "menurecordings"))
sv = new cViewMenuRecordings(name);
else if (!strcmp(name, "menudetailedepg"))
sv = new cViewMenuDetail(name);
else if (!strcmp(name, "menudetailedrecording"))
sv = new cViewMenuDetail(name);
else if (!strcmp(name, "menudetailedtext"))
sv = new cViewMenuDetail(name);
return sv;
}
cSubView *cViewMenu::CreatePluginview(const char *plugname, int plugId, int menuNumber, int menuType) {
cString menuName = cString::sprintf("menuplugin-%s-%d", plugname, menuNumber);
cSubView *pv = NULL;
if (menuType == skindesignerapi::mtList)
pv = new cViewMenuPlugin(*menuName);
else if (menuType == skindesignerapi::mtText)
pv = new cViewMenuDetail(*menuName);
if (pv) {
pv->SetPlugId(plugId);
pv->SetPlugMenuId(menuNumber);
}
return pv;
}
void cViewMenu::AddPluginview(cSubView *plugView) {
int id = SubviewId(plugView->GetViewName());
if (id == ATTR_UNKNOWN)
return;
subViews[id] = plugView;
}
void cViewMenu::AddSubview(const char *sSubView, cSubView *subView) {
int id = SubviewId(sSubView);
if (id == ATTR_UNKNOWN)
return;
subViews[id] = subView;
}
/* eMenuCategory:
-1 mcUndefined,
0 mcUnknown,
1 mcMain,
2 mcSchedule,
3 mcScheduleNow,
4 mcScheduleNext,
5 mcChannel,
6 mcChannelEdit,
7 mcTimer,
8 mcTimerEdit,
9 mcRecording,
10 mcRecordingInfo,
11 mcRecordingEdit,
12 mcPlugin,
13 mcPluginSetup,
14 mcSetup,
15 mcSetupOsd,
16 mcSetupEpg,
17 mcSetupDvb,
18 mcSetupLnb,
19 mcSetupCam,
20 mcSetupRecord,
21 mcSetupReplay,
22 mcSetupMisc,
23 mcSetupPlugins,
24 mcCommand,
25 mcEvent,
26 mcText,
27 mcFolder,
28 mcCam
*/
void cViewMenu::SetSubView(eMenuCategory MenuCat) {
//menuCat --> old menucat
//MenuCat --> new menucat
if (menuCat == mcMain) {
cViewMenuMain *menuMain = dynamic_cast<cViewMenuMain*>(activeSubview);
if (menuMain) {
plugName = menuMain->GetPlugin();
}
}
//first check plugin menu
if (MenuCat == mcPlugin) {
bool plugMenuFound = SetPluginSubView(MenuCat);
if (plugMenuFound) {
menuCat = MenuCat;
return;
}
}
//then check regular menus
bool catChange = false;
if (menuCat != MenuCat) {
catChange = true;
} else {
return;
}
cSubView *newSubview = NULL;
menuCat = MenuCat;
switch (MenuCat) {
case mcMain:
newSubview = subViews[(int)eSvDisplayMenu::main];
break;
case mcSchedule:
case mcScheduleNow:
case mcScheduleNext:
newSubview = subViews[(int)eSvDisplayMenu::schedules];
break;
case mcChannel:
newSubview = subViews[(int)eSvDisplayMenu::channels];
break;
case mcTimer:
newSubview = subViews[(int)eSvDisplayMenu::timers];
break;
case mcRecording:
newSubview = subViews[(int)eSvDisplayMenu::recordings];
break;
case mcSetup:
newSubview = subViews[(int)eSvDisplayMenu::setup];
break;
case mcEvent:
newSubview = subViews[(int)eSvDisplayMenu::detailepg];
break;
case mcRecordingInfo:
newSubview = subViews[(int)eSvDisplayMenu::detailrec];
break;
case mcText:
newSubview = subViews[(int)eSvDisplayMenu::detailtext];
break;
default:
newSubview = subViews[(int)eSvDisplayMenu::menudefault];
//setting plugin name for detecting plugins in default menus
cViewMenuDefault *menuDefault = dynamic_cast<cViewMenuDefault*>(newSubview);
if (menuDefault) {
menuDefault->SetPlugin(plugName);
}
break;
};
if (catChange) {
menuChange = true;
activeSubview->Clear();
activeSubviewLast = activeSubview;
activeSubview = newSubview;
if (!activeSubview)
activeSubview = subViews[(int)eSvDisplayMenu::menudefault];
activeSubview->SetMenuCategory(MenuCat);
}
}
bool cViewMenu::SetPluginSubView(eMenuCategory menuCat) {
if (!pluginIdSet)
return false;
cSubView *newSubview = NULL;
if (plugId >= 0 && plugMenuId >= 0) {
int subViewId = plgManager->GetSubviewId(plugId, plugMenuId);
if (subViewId >= 0 && subViews[subViewId]) {
newSubview = subViews[subViewId];
menuChange = true;
activeSubview->Clear();
activeSubviewLast = activeSubview;
activeSubview = newSubview;
activeSubview->SetMenuCategory(menuCat);
return true;
}
}
return false;
}
void cViewMenu::WakeViewElements(void) {
cView::WakeViewElements();
if (activeSubview)
activeSubview->WakeViewElements();
}
void cViewMenu::SetSortMode(eMenuSortMode sortMode) {
if (activeSubview)
activeSubview->SetSortMode(sortMode);
}
void cViewMenu::SetPluginMenu(int plugId, int plugMenuId) {
this->plugId = plugId;
this->plugMenuId = plugMenuId;
pluginIdSet = true;
}
int cViewMenu::NumListItems(void) {
return activeSubview->NumListItems();
}
eMenuOrientation cViewMenu::MenuOrientation(void) {
return activeSubview->MenuOrientation();
}
const cFont *cViewMenu::GetTextAreaFont(void) {
return activeSubview->GetTextAreaFont();
}
int cViewMenu::GetTextAreaWidth(void) {
if (!menuDetailedText)
return 0;
return menuDetailedText->GetWidth();
}
int cViewMenu::GetListWidth(void) {
return activeSubview->GetListWidth();
}
void cViewMenu::SetTitleHeader(const char *title) {
activeSubview->SetTitle(title);
}
void cViewMenu::SetMessage(eMessageType type, const char *text) {
activeSubview->SetMessage(type, text);
}
void cViewMenu::SetChannelHeader(const cEvent *event) {
if (menuChange && menuCat == mcSchedule) {
const cChannel *channel = Channels.GetByChannelID(event->ChannelID());
if (channel)
activeSubview->SetChannel(channel);
}
}
void cViewMenu::SetMenuButtons(const char *red, const char *green, const char *yellow, const char *blue) {
activeSubview->SetMenuButtons(red, green, yellow, blue);
}
void cViewMenu::SetScrollbar(int total, int offset) {
activeSubview->SetScrollbar(total, offset);
}
void cViewMenu::SetTabs(int tab1, int tab2, int tab3, int tab4, int tab5) {
menuDefault->SetTabs(tab1, tab2, tab3, tab4, tab5);
}
void cViewMenu::SetItem(const char *text, int index, bool current, bool selectable) {
if (menuCat == mcMain && menuMain) {
menuMain->SetItem(text, index, current, selectable);
} else if (menuCat == mcSetup && menuSetup) {
menuSetup->SetItem(text, index, current, selectable);
} else {
menuDefault->SetItem(text, index, current, selectable);
}
listChange = true;
}
bool cViewMenu::SetItemEvent(const cEvent *event, int index, bool current, bool selectable,
const cChannel *channel, bool withDate, eTimerMatch timerMatch) {
if (!menuSchedules)
return false;
menuSchedules->SetItem(event, index, current, selectable, channel, withDate, timerMatch);
listChange = true;
return true;
}
bool cViewMenu::SetItemTimer(const cTimer *timer, int index, bool current, bool selectable) {
if (!menuTimers)
return false;
menuTimers->SetItem(timer, index, current, selectable);
listChange = true;
return true;
}
bool cViewMenu::SetItemChannel(const cChannel *channel, int index, bool current, bool selectable, bool withProvider) {
if (!menuChannels)
return false;
menuChannels->SetItem(channel, index, current, selectable, withProvider);
listChange = true;
return true;
}
bool cViewMenu::SetItemRecording(const cRecording *recording, int index, bool current, bool selectable, int level, int total, int New) {
if (!menuRecordings)
return false;
menuRecordings->SetItem(recording, index, current, selectable, level, total, New);
listChange = true;
return true;
}
bool cViewMenu::SetItemPlugin(skindesignerapi::cTokenContainer *tk, int index, bool current, bool selectable) {
cViewMenuPlugin *menuPlugin = dynamic_cast<cViewMenuPlugin*>(activeSubview);
if (!menuPlugin) {
return false;
}
menuPlugin->SetItem(tk, index, current, selectable);
listChange = true;
return true;
}
void cViewMenu::SetEvent(const cEvent *event) {
menuDetailedEpg->SetEvent(event);
detailViewInit = true;
}
void cViewMenu::SetRecording(const cRecording *recording) {
menuDetailedRec->SetRecording(recording);
detailViewInit = true;
}
void cViewMenu::SetText(const char *text) {
menuDetailedText->SetText(text);
detailViewInit = true;
}
bool cViewMenu::SetPluginText(skindesignerapi::cTokenContainer *tk) {
cViewMenuDetail *menuPlugin = dynamic_cast<cViewMenuDetail*>(activeSubview);
if (!menuPlugin) {
return false;
}
menuPlugin->SetPluginText(tk);
detailViewInit = true;
return true;
}
void cViewMenu::SetCurrentRecording(const char *currentRec) {
if (menuMain) {
menuMain->SetCurrentRecording(currentRec); }
}
void cViewMenu::KeyDetailView(bool up, bool page) {
cViewMenuDetail *detailView = dynamic_cast<cViewMenuDetail*>(activeSubview);
if (!detailView)
return;
if (up && page) {
detailView->KeyLeft();
} else if (!up && page) {
detailView->KeyRight();
} else if (up && !page) {
detailView->KeyUp();
} else if (!up && !page) {
detailView->KeyDown();
}
}
bool cViewMenu::Init(void) {
activeSubview = subViews[(int)eSvDisplayMenu::main];
return cView::Init();
}
void cViewMenu::Close(void) {
delete fader;
fader = NULL;
if (FadeTime() > 0) {
fader = new cAnimation((cFadable*)this, false);
fader->Fade();
delete fader;
fader = NULL;
}
for (int i=0; i < numSubviews; i++) {
if (subViews[i]) {
subViews[i]->Close();
}
}
for (int i=0; i < numViewElements; i++) {
if (viewElements[i]) {
viewElements[i]->Close();
}
if (viewElementsHorizontal[i]) {
viewElementsHorizontal[i]->Close();
}
}
UnScaleTv();
ClearVariables();
sdOsd.DeleteOsd();
}
void cViewMenu::Clear(void) {
activeSubview->ClearViewList();
}
void cViewMenu::Flush(void) {
if (init) {
sdOsd.LockFlush();
}
bool staticInitiated = false;
if (menuChange) {
newTvFrame = activeSubview->GetTvFrame();
menuInit = true;
activeSubview->DrawStaticVEs();
pluginIdSet = false;
menuChange = false;
staticInitiated = true;
}
if (listChange) {
activeSubview->DrawList();
listChange = false;
}
if (detailViewInit) {
if (!staticInitiated)
activeSubview->DrawStaticVEs();
activeSubview->DrawDetailedView();
pluginIdSet = false;
detailViewInit = false;
}
activeSubview->DrawDynamicVEs();
cView::Flush();
}
void cViewMenu::SetTransparency(int transparency, bool forceDetached) {
activeSubview->SetTransparency(transparency, forceDetached);
if (menuDetailedEpg)
menuDetailedEpg->SetTransparency(transparency);
if (menuDetailedRec)
menuDetailedRec->SetTransparency(transparency);
if (menuDetailedText)
menuDetailedText->SetTransparency(transparency);
}
void cViewMenu::Debug(void) {
cView::Debug();
for (int i=0; i < numSubviews; i++) {
if (subViews[i]) {
subViews[i]->Debug();
}
}
}
/***********************************************************
* cSubView
***********************************************************/
cSubView::cSubView(const char *name) {
menuCat = mcUnknown;
plugId = -1;
plugMenuId = -1;
this->viewName = strdup(name);
numViewElements = (int)eVeDisplayMenu::count;
viewElements = new cViewElement*[numViewElements];
for (int i=0; i < numViewElements; i++) {
viewElements[i] = NULL;
}
viewElementsHorizontal = new cViewElement*[numViewElements];
for (int i=0; i < numViewElements; i++) {
viewElementsHorizontal[i] = NULL;
}
background = NULL;
header = NULL;
datetime = NULL;
time = NULL;
message = NULL;
sortmode = NULL;
colorbuttons = NULL;
scrollbar = NULL;
viewList = NULL;
viewListVertical = NULL;
viewListHorizontal = NULL;
SetViewElements();
}
cSubView::~cSubView(void) {
delete viewListHorizontal;
delete viewListVertical;
}
void cSubView::SetGlobals(cGlobals *globals) {
cView::SetGlobals(globals);
if (viewListVertical)
viewListVertical->SetGlobals(globals);
if (viewListHorizontal)
viewListHorizontal->SetGlobals(globals);
}
void cSubView::PreCache(void) {
attribs->SetContainer(container.X(), container.Y(), container.Width(), container.Height());
attribs->Cache();
cView::PreCache();
if (viewListVertical) {
viewListVertical->SetPlugId(plugId);
viewListVertical->SetPlugMenuId(plugMenuId);
viewListVertical->SetContainer(attribs->X(), attribs->Y(), attribs->Width(), attribs->Height());
viewListVertical->PreCache();
}
if (viewListHorizontal) {
viewListHorizontal->SetPlugId(plugId);
viewListHorizontal->SetPlugMenuId(plugMenuId);
viewListHorizontal->SetContainer(attribs->X(), attribs->Y(), attribs->Width(), attribs->Height());
viewListHorizontal->PreCache();
}
}
bool cSubView::ViewElementSet(int ve) {
if (ve >= 0 && ve < (int)eVeDisplayMenu::count && viewElements[ve])
return true;
return false;
}
bool cSubView::ViewElementHorizontalSet(int ve) {
if (ve >= 0 && ve < (int)eVeDisplayMenu::count && viewElementsHorizontal[ve])
return true;
return false;
}
void cSubView::SetViewElement(eVeDisplayMenu ve, cViewElement *viewElement) {
switch (ve) {
case eVeDisplayMenu::background:
if (!background)
background = viewElement;
break;
case eVeDisplayMenu::header:
if (!header)
header = dynamic_cast<cVeDmHeader*>(viewElement);
break;
case eVeDisplayMenu::datetime:
if (!datetime)
datetime = dynamic_cast<cVeDateTime*>(viewElement);
break;
case eVeDisplayMenu::time:
if (!time)
time = dynamic_cast<cVeTime*>(viewElement);
break;
case eVeDisplayMenu::message:
if (!message)
message = dynamic_cast<cVeMessage*>(viewElement);
break;
case eVeDisplayMenu::sortmode:
if (!sortmode)
sortmode = dynamic_cast<cVeDmSortmode*>(viewElement);
break;
case eVeDisplayMenu::colorbuttons:
if (!colorbuttons)
colorbuttons = dynamic_cast<cVeDmColorbuttons*>(viewElement);
break;
case eVeDisplayMenu::scrollbar:
if (!scrollbar)
scrollbar = dynamic_cast<cVeDmScrollbar*>(viewElement);
break;
default:
break;
};
}
void cSubView::SetViewElementHorizontal(eVeDisplayMenu ve, cViewElement *viewElement) {
eOrientation orientation = attribs->Orientation();
if (orientation != eOrientation::horizontal)
return;
switch (ve) {
case eVeDisplayMenu::background:
if (!background)
background = viewElement;
break;
case eVeDisplayMenu::header:
if (!header)
header = dynamic_cast<cVeDmHeader*>(viewElement);
break;
case eVeDisplayMenu::datetime:
if (!datetime)
datetime = dynamic_cast<cVeDateTime*>(viewElement);
break;
case eVeDisplayMenu::time:
if (!time)
time = dynamic_cast<cVeTime*>(viewElement);
break;
case eVeDisplayMenu::message:
if (!message)
message = dynamic_cast<cVeMessage*>(viewElement);
break;
case eVeDisplayMenu::sortmode:
if (!sortmode)
sortmode = dynamic_cast<cVeDmSortmode*>(viewElement);
break;
case eVeDisplayMenu::colorbuttons:
if (!colorbuttons)
colorbuttons = dynamic_cast<cVeDmColorbuttons*>(viewElement);
break;
case eVeDisplayMenu::scrollbar:
if (!scrollbar)
scrollbar = dynamic_cast<cVeDmScrollbar*>(viewElement);
break;
default:
break;
};
}
void cSubView::AddViewList(cViewList *viewList) {
eOrientation orientation = viewList->Orientation();
if (orientation == eOrientation::vertical) {
viewListVertical = viewList;
} else if (orientation == eOrientation::horizontal) {
viewListHorizontal = viewList;
} else {
viewListVertical = viewList;
}
}
int cSubView::NumListItems(void) {
if (viewList)
return viewList->NumItems();
return 0;
}
eMenuOrientation cSubView::MenuOrientation(void) {
eOrientation orientation = attribs->Orientation();
if (orientation == eOrientation::horizontal)
return moHorizontal;
return moVertical;
}
void cSubView::SetTitle(const char *title) {
if (header) {
header->SetTitle(title);
}
}
void cSubView::SetChannel(const cChannel *channel) {
if (header) {
header->SetChannel(channel);
}
}
void cSubView::SetMessage(eMessageType type, const char *text) {
if (!message)
return;
if (!text) {
message->Clear();
message->Hide();
return;
}
message->Set(type, text);
message->Show();
if (message->Parse())
message->Render();
}
void cSubView::SetMenuButtons(const char *red, const char *green, const char *yellow, const char *blue) {
if (!colorbuttons)
return;
colorbuttons->SetButtons(red, green, yellow, blue);
if (colorbuttons->Parse()) {
colorbuttons->Show();
colorbuttons->Render();
}
}
void cSubView::SetScrollbar(int total, int offset) {
if (!scrollbar)
return;
scrollbar->SetList(total, offset, NumListItems());
if (scrollbar->Parse()) {
scrollbar->Show();
scrollbar->Render();
}
}
void cSubView::SetSortMode(eMenuSortMode sortMode) {
if (!sortmode)
return;
sortmode->Set(sortMode);
if (sortmode->Parse()) {
sortmode->Show();
sortmode->Render();
}
}
void cSubView::Close(void) {
ClearVariables();
for (int i=0; i < numViewElements; i++) {
if (!viewElements[i])
continue;
viewElements[i]->Close();
}
for (int i=0; i < numViewElements; i++) {
if (!viewElementsHorizontal[i])
continue;
viewElementsHorizontal[i]->Close();
}
if (viewList)
viewList->Close();
}
void cSubView::ClearViewList(void) {
if (viewList)
viewList->Clear();
}
void cSubView::WakeViewElements(void) {
for (int i = 0; i < numViewElements; i++) {
if (viewElements[i]) {
viewElements[i]->WakeUp();
}
if (viewElementsHorizontal[i]) {
viewElementsHorizontal[i]->WakeUp();
}
}
}
void cSubView::Clear(void) {
if (background) background->Hide();
if (datetime) datetime->Hide();
if (time) time->Hide();
if (header) header->Hide();
if (colorbuttons) colorbuttons->Hide();
if (scrollbar) scrollbar->Hide();
if (sortmode) {
sortmode->Reset();
sortmode->Hide();
}
if (viewList) viewList->Close();
}
void cSubView::DrawStaticVEs(void) {
if (background) {
background->Show();
background->Render();
}
if (header) {
header->Show();
header->Set(menuCat);
if (header->Parse())
header->Render();
}
}
void cSubView::DrawDynamicVEs(void) {
if (datetime) {
datetime->Show();
if (datetime->Parse())
datetime->Render();
}
if (time) {
time->Show();
if (time->Parse()) {
time->Render();
}
}
}
void cSubView::DrawList(void) {
if (viewList) {
viewList->Draw(menuCat);
}
}
void cSubView::SetTransparency(int transparency, bool forceDetached) {
for (int i = 0; i < numViewElements; i++) {
if (viewElements[i] && (!viewElements[i]->Detached() || forceDetached)) {
viewElements[i]->SetTransparency(transparency);
}
if (viewElementsHorizontal[i] && (!viewElementsHorizontal[i]->Detached() || forceDetached)) {
viewElementsHorizontal[i]->SetTransparency(transparency);
}
}
if (viewList)
viewList->SetTransparency(transparency);
}
/***********************************************************
* Protected Functions
***********************************************************/
void cSubView::SetViewElementObjects(void) {
eOrientation orientation = attribs->Orientation();
if (orientation == eOrientation::horizontal && viewElementsHorizontal[(int)eVeDisplayMenu::background])
background = viewElementsHorizontal[(int)eVeDisplayMenu::background];
else if (viewElements[(int)eVeDisplayMenu::background])
background = viewElements[(int)eVeDisplayMenu::background];
if (orientation == eOrientation::horizontal && viewElementsHorizontal[(int)eVeDisplayMenu::header])
header = dynamic_cast<cVeDmHeader*>(viewElementsHorizontal[(int)eVeDisplayMenu::header]);
else if (viewElements[(int)eVeDisplayMenu::header])
header = dynamic_cast<cVeDmHeader*>(viewElements[(int)eVeDisplayMenu::header]);
if (orientation == eOrientation::horizontal && viewElementsHorizontal[(int)eVeDisplayMenu::datetime])
datetime = dynamic_cast<cVeDateTime*>(viewElementsHorizontal[(int)eVeDisplayMenu::datetime]);
else if (viewElements[(int)eVeDisplayMenu::datetime])
datetime = dynamic_cast<cVeDateTime*>(viewElements[(int)eVeDisplayMenu::datetime]);
if (orientation == eOrientation::horizontal && viewElementsHorizontal[(int)eVeDisplayMenu::time])
time = dynamic_cast<cVeTime*>(viewElementsHorizontal[(int)eVeDisplayMenu::time]);
else if (viewElements[(int)eVeDisplayMenu::time])
time = dynamic_cast<cVeTime*>(viewElements[(int)eVeDisplayMenu::time]);
if (orientation == eOrientation::horizontal && viewElementsHorizontal[(int)eVeDisplayMenu::message])
message = dynamic_cast<cVeMessage*>(viewElementsHorizontal[(int)eVeDisplayMenu::message]);
else if (viewElements[(int)eVeDisplayMenu::message])
message = dynamic_cast<cVeMessage*>(viewElements[(int)eVeDisplayMenu::message]);
if (orientation == eOrientation::horizontal && viewElementsHorizontal[(int)eVeDisplayMenu::sortmode])
sortmode = dynamic_cast<cVeDmSortmode*>(viewElementsHorizontal[(int)eVeDisplayMenu::sortmode]);
else if (viewElements[(int)eVeDisplayMenu::sortmode])
sortmode = dynamic_cast<cVeDmSortmode*>(viewElements[(int)eVeDisplayMenu::sortmode]);
if (orientation == eOrientation::horizontal && viewElementsHorizontal[(int)eVeDisplayMenu::colorbuttons])
colorbuttons = dynamic_cast<cVeDmColorbuttons*>(viewElementsHorizontal[(int)eVeDisplayMenu::colorbuttons]);
else if (viewElements[(int)eVeDisplayMenu::colorbuttons])
colorbuttons = dynamic_cast<cVeDmColorbuttons*>(viewElements[(int)eVeDisplayMenu::colorbuttons]);
if (orientation == eOrientation::horizontal && viewElementsHorizontal[(int)eVeDisplayMenu::scrollbar])
scrollbar = dynamic_cast<cVeDmScrollbar*>(viewElementsHorizontal[(int)eVeDisplayMenu::scrollbar]);
else if (viewElements[(int)eVeDisplayMenu::scrollbar])
scrollbar = dynamic_cast<cVeDmScrollbar*>(viewElements[(int)eVeDisplayMenu::scrollbar]);
if (attribs->Orientation() == eOrientation::horizontal)
viewList = viewListHorizontal;
else
viewList = viewListVertical;
}
void cSubView::SetViewElements(void) {
viewElementNames.insert(pair<string, int>("background", (int)eVeDisplayMenu::background));
viewElementNames.insert(pair<string, int>("header", (int)eVeDisplayMenu::header));
viewElementNames.insert(pair<string, int>("datetime", (int)eVeDisplayMenu::datetime));
viewElementNames.insert(pair<string, int>("time", (int)eVeDisplayMenu::time));
viewElementNames.insert(pair<string, int>("colorbuttons", (int)eVeDisplayMenu::colorbuttons));
viewElementNames.insert(pair<string, int>("message", (int)eVeDisplayMenu::message));
viewElementNames.insert(pair<string, int>("scrollbar", (int)eVeDisplayMenu::scrollbar));
viewElementNames.insert(pair<string, int>("sortmode", (int)eVeDisplayMenu::sortmode));
}
/***********************************************************
* cViewMenuDefault
***********************************************************/
cViewMenuDefault::cViewMenuDefault(const char *name) : cSubView(name) {
listDefault = NULL;
}
cViewMenuDefault::~cViewMenuDefault(void) {
}
void cViewMenuDefault::SetViewElementObjects(void) {
cSubView::SetViewElementObjects();
listDefault = dynamic_cast<cViewListDefault*>(viewList);
}
void cViewMenuDefault::SetTabs(int tab1, int tab2, int tab3, int tab4, int tab5) {
if (listDefault)
listDefault->SetTabs(tab1, tab2, tab3, tab4, tab5);
}
void cViewMenuDefault::SetPlugin(const char *plugName) {
listDefault->SetPlugin(plugName);
}
void cViewMenuDefault::SetItem(const char *text, int index, bool current, bool selectable) {
listDefault->Set(text, index, current, selectable);
}
const cFont *cViewMenuDefault::GetTextAreaFont(void) {
if (!listDefault)
return NULL;
return listDefault->GetListFont();
}
int cViewMenuDefault::GetListWidth(void) {
if (!listDefault)
return 0;
return listDefault->GetListWidth();
}
/************************************************************************************
* cViewMenuMain
************************************************************************************/
cViewMenuMain::cViewMenuMain(const char *name) : cSubView(name) {
for (int i=0; i < numViewElements; i++) {
delete viewElements[i];
}
delete[] viewElements;
numViewElements = (int)eVeDisplayMenuMain::count;
viewElements = new cViewElement*[numViewElements];
for (int i=0; i < numViewElements; i++) {
viewElements[i] = NULL;
}
delete[] viewElementsHorizontal;
viewElementsHorizontal = new cViewElement*[numViewElements];
for (int i=0; i < numViewElements; i++) {
viewElementsHorizontal[i] = NULL;
}
listMain = NULL;
timers = NULL;
devices = NULL;
weather = NULL;
discusage = NULL;
load = NULL;
memory = NULL;
vdrstats = NULL;
temperatures = NULL;
currentSchedule = NULL;
lastRecordings = NULL;
customTokens = NULL;
lastDrawDynamic = 0;
SetViewElements();
}
cViewMenuMain::~cViewMenuMain() {
}
void cViewMenuMain::ClearVariables(void) {
init = true;
}
void cViewMenuMain::SetViewElements(void) {
viewElementNames.insert(pair<string, int>("timers", (int)eVeDisplayMenuMain::timers));
viewElementNames.insert(pair<string, int>("devices", (int)eVeDisplayMenuMain::devices));
viewElementNames.insert(pair<string, int>("currentweather", (int)eVeDisplayMenuMain::currentweather));
viewElementNames.insert(pair<string, int>("currentschedule", (int)eVeDisplayMenuMain::currentschedule));
viewElementNames.insert(pair<string, int>("discusage", (int)eVeDisplayMenuMain::discusage));
viewElementNames.insert(pair<string, int>("systemload", (int)eVeDisplayMenuMain::systemload));
viewElementNames.insert(pair<string, int>("systemmemory", (int)eVeDisplayMenuMain::systemmemory));
viewElementNames.insert(pair<string, int>("vdrstatistics", (int)eVeDisplayMenuMain::vdrstatistics));
viewElementNames.insert(pair<string, int>("temperatures", (int)eVeDisplayMenuMain::temperatures));
viewElementNames.insert(pair<string, int>("lastrecordings", (int)eVeDisplayMenuMain::lastrecordings));
viewElementNames.insert(pair<string, int>("customtokens", (int)eVeDisplayMenuMain::customtokens));
}
void cViewMenuMain::SetViewElementObjects(void) {
cSubView::SetViewElementObjects();
eOrientation orientation = attribs->Orientation();
if (orientation == eOrientation::horizontal && viewElementsHorizontal[(int)eVeDisplayMenuMain::timers])
timers = dynamic_cast<cVeDmTimers*>(viewElementsHorizontal[(int)eVeDisplayMenuMain::timers]);
else if (viewElements[(int)eVeDisplayMenuMain::timers])
timers = dynamic_cast<cVeDmTimers*>(viewElements[(int)eVeDisplayMenuMain::timers]);
if (orientation == eOrientation::horizontal && viewElementsHorizontal[(int)eVeDisplayMenuMain::devices])
devices = dynamic_cast<cVeDevices*>(viewElementsHorizontal[(int)eVeDisplayMenuMain::devices]);
else if (viewElements[(int)eVeDisplayMenuMain::devices])
devices = dynamic_cast<cVeDevices*>(viewElements[(int)eVeDisplayMenuMain::devices]);
if (orientation == eOrientation::horizontal && viewElementsHorizontal[(int)eVeDisplayMenuMain::currentweather])
weather = dynamic_cast<cVeCurrentWeather*>(viewElementsHorizontal[(int)eVeDisplayMenuMain::currentweather]);
else if (viewElements[(int)eVeDisplayMenuMain::currentweather])
weather = dynamic_cast<cVeCurrentWeather*>(viewElements[(int)eVeDisplayMenuMain::currentweather]);
if (orientation == eOrientation::horizontal && viewElementsHorizontal[(int)eVeDisplayMenuMain::currentschedule])
currentSchedule = dynamic_cast<cVeDmCurrentschedule*>(viewElementsHorizontal[(int)eVeDisplayMenuMain::currentschedule]);
else if (viewElements[(int)eVeDisplayMenuMain::currentschedule])
currentSchedule = dynamic_cast<cVeDmCurrentschedule*>(viewElements[(int)eVeDisplayMenuMain::currentschedule]);
if (orientation == eOrientation::horizontal && viewElementsHorizontal[(int)eVeDisplayMenuMain::discusage])
discusage = dynamic_cast<cVeDmDiscusage*>(viewElementsHorizontal[(int)eVeDisplayMenuMain::discusage]);
else if (viewElements[(int)eVeDisplayMenuMain::discusage])
discusage = dynamic_cast<cVeDmDiscusage*>(viewElements[(int)eVeDisplayMenuMain::discusage]);
if (orientation == eOrientation::horizontal && viewElementsHorizontal[(int)eVeDisplayMenuMain::systemload])
load = dynamic_cast<cVeDmSystemload*>(viewElementsHorizontal[(int)eVeDisplayMenuMain::systemload]);
else if (viewElements[(int)eVeDisplayMenuMain::systemload])
load = dynamic_cast<cVeDmSystemload*>(viewElements[(int)eVeDisplayMenuMain::systemload]);
if (orientation == eOrientation::horizontal && viewElementsHorizontal[(int)eVeDisplayMenuMain::systemmemory])
memory = dynamic_cast<cVeDmSystemmemory*>(viewElementsHorizontal[(int)eVeDisplayMenuMain::systemmemory]);
else if (viewElements[(int)eVeDisplayMenuMain::systemmemory])
memory = dynamic_cast<cVeDmSystemmemory*>(viewElements[(int)eVeDisplayMenuMain::systemmemory]);
if (orientation == eOrientation::horizontal && viewElementsHorizontal[(int)eVeDisplayMenuMain::vdrstatistics])
vdrstats = dynamic_cast<cVeDmVdrstatistics*>(viewElementsHorizontal[(int)eVeDisplayMenuMain::vdrstatistics]);
else if (viewElements[(int)eVeDisplayMenuMain::vdrstatistics])
vdrstats = dynamic_cast<cVeDmVdrstatistics*>(viewElements[(int)eVeDisplayMenuMain::vdrstatistics]);
if (orientation == eOrientation::horizontal && viewElementsHorizontal[(int)eVeDisplayMenuMain::temperatures])
temperatures = dynamic_cast<cVeDmTemperatures*>(viewElementsHorizontal[(int)eVeDisplayMenuMain::temperatures]);
else if (viewElements[(int)eVeDisplayMenuMain::temperatures])
temperatures = dynamic_cast<cVeDmTemperatures*>(viewElements[(int)eVeDisplayMenuMain::temperatures]);
if (orientation == eOrientation::horizontal && viewElementsHorizontal[(int)eVeDisplayMenuMain::lastrecordings])
lastRecordings = dynamic_cast<cVeDmLastrecordings*>(viewElementsHorizontal[(int)eVeDisplayMenuMain::lastrecordings]);
else if (viewElements[(int)eVeDisplayMenuMain::lastrecordings])
lastRecordings = dynamic_cast<cVeDmLastrecordings*>(viewElements[(int)eVeDisplayMenuMain::lastrecordings]);
if (orientation == eOrientation::horizontal && viewElementsHorizontal[(int)eVeDisplayMenuMain::customtokens])
customTokens = dynamic_cast<cVeCustomTokens*>(viewElementsHorizontal[(int)eVeDisplayMenuMain::customtokens]);
else if (viewElements[(int)eVeDisplayMenuMain::customtokens])
customTokens = dynamic_cast<cVeCustomTokens*>(viewElements[(int)eVeDisplayMenuMain::customtokens]);
if (devices) devices->SetDetached();
if (weather) weather->SetDetached();
if (discusage) discusage->SetDetached();
if (load) load->SetDetached();
if (memory) memory->SetDetached();
if (vdrstats) vdrstats->SetDetached();
if (temperatures) temperatures->SetDetached();
if (timers) timers->SetDetached();
if (currentSchedule) currentSchedule->SetDetached();
if (lastRecordings) lastRecordings->SetDetached();
if (customTokens) customTokens->SetDetached();
listMain = dynamic_cast<cViewListMain*>(viewList);
}
void cViewMenuMain::Clear(void) {
cSubView::Clear();
lastDrawDynamic = 0;
if (devices)
devices->Hide();
if (weather)
weather->Hide();
if (discusage)
discusage->Hide();
if (load) {
load->Reset();
load->Hide();
}
if (memory) {
memory->Reset();
memory->Hide();
}
if (vdrstats) {
vdrstats->Reset();
vdrstats->Hide();
}
if (temperatures) {
temperatures->Reset();
temperatures->Hide();
}
if (timers) {
timers->Hide();
}
if (currentSchedule) {
currentSchedule->Hide();
}
if (lastRecordings) {
lastRecordings->Hide();
}
if (customTokens) {
customTokens->Reset();
customTokens->Hide();
}
}
void cViewMenuMain::SetItem(const char *text, int index, bool current, bool selectable) {
listMain->Set(text, index, current, selectable);
}
void cViewMenuMain::SetCurrentRecording(const char *currentRec) {
if (currentSchedule)
currentSchedule->SetRecording(currentRec);
}
void cViewMenuMain::DrawStaticVEs(void) {
cSubView::DrawStaticVEs();
if (weather) {
weather->Show();
if (weather->Parse())
weather->Render();
}
if (discusage) {
discusage->Show();
if (discusage->Parse())
discusage->Render();
}
if (timers) {
timers->Show();
if (timers->Parse())
timers->Render();
}
if (currentSchedule) {
currentSchedule->Show();
if (currentSchedule->Parse())
currentSchedule->Render();
}
if (lastRecordings) {
lastRecordings->Show();
if (lastRecordings->Parse())
lastRecordings->Render();
}
}
void cViewMenuMain::DrawDynamicVEs(void) {
cSubView::DrawDynamicVEs();
//draw main menu dynamic elements
//only every 3 seconds
uint64_t now = cTimeMs::Now();
if (now - lastDrawDynamic < 3000)
return;
else {
lastDrawDynamic = now;
}
if (devices) {
devices->Show();
if (devices->Parse())
devices->Render();
}
if (load) {
load->Show();
if (load->Parse())
load->Render();
}
if (memory) {
memory->Show();
if (memory->Parse())
memory->Render();
}
if (vdrstats) {
vdrstats->Show();
if (vdrstats->Parse())
vdrstats->Render();
}
if (temperatures) {
temperatures->Show();
if (temperatures->Parse())
temperatures->Render();
}
if (customTokens) {
customTokens->Show();
if (customTokens->Parse())
customTokens->Render();
}
}
const char *cViewMenuMain::GetPlugin(void) {
return listMain->GetPlugin();
}
/***********************************************************
* cViewMenuSetup
***********************************************************/
cViewMenuSetup::cViewMenuSetup(const char *name) : cSubView(name) {
listSetup = NULL;
}
cViewMenuSetup::~cViewMenuSetup(void) {
}
void cViewMenuSetup::SetViewElementObjects(void) {
cSubView::SetViewElementObjects();
listSetup = dynamic_cast<cViewListMain*>(viewList);
}
void cViewMenuSetup::SetItem(const char *text, int index, bool current, bool selectable) {
listSetup->Set(text, index, current, selectable);
}
/***********************************************************
* cViewMenuSchedules
***********************************************************/
cViewMenuSchedules::cViewMenuSchedules(const char *name) : cSubView(name) {
listSchedules = NULL;
}
cViewMenuSchedules::~cViewMenuSchedules(void) {
}
void cViewMenuSchedules::SetViewElementObjects(void) {
cSubView::SetViewElementObjects();
listSchedules = dynamic_cast<cViewListSchedules*>(viewList);
}
void cViewMenuSchedules::SetItem(const cEvent *event, int index, bool current, bool selectable,
const cChannel *channel, bool withDate, eTimerMatch timerMatch) {
bool epgSearchFavMenu = (menuCat == mcSchedule && channel) ? true : false;
listSchedules->IsEpgSearchFav(epgSearchFavMenu);
if (header) header->IsEpgSearchFav(epgSearchFavMenu);
listSchedules->Set(event, index, current, selectable, channel, withDate, timerMatch);
}
/***********************************************************
* cViewMenuChannels
***********************************************************/
cViewMenuChannels::cViewMenuChannels(const char *name) : cSubView(name) {
listChannels = NULL;
}
cViewMenuChannels::~cViewMenuChannels(void) {
}
void cViewMenuChannels::SetViewElementObjects(void) {
cSubView::SetViewElementObjects();
listChannels = dynamic_cast<cViewListChannels*>(viewList);
}
void cViewMenuChannels::SetItem(const cChannel *channel, int index, bool current, bool selectable, bool withProvider) {
listChannels->Set(channel, index, current, selectable, withProvider);
}
/***********************************************************
* cViewMenuTimers
***********************************************************/
cViewMenuTimers::cViewMenuTimers(const char *name) : cSubView(name) {
listTimers = NULL;
}
cViewMenuTimers::~cViewMenuTimers(void) {
}
void cViewMenuTimers::SetViewElementObjects(void) {
cSubView::SetViewElementObjects();
listTimers = dynamic_cast<cViewListTimers*>(viewList);
}
void cViewMenuTimers::SetItem(const cTimer *timer, int index, bool current, bool selectable) {
listTimers->Set(timer, index, current, selectable);
}
/***********************************************************
* cViewMenuRecordings
***********************************************************/
cViewMenuRecordings::cViewMenuRecordings(const char *name) : cSubView(name) {
listRecordings = NULL;
}
cViewMenuRecordings::~cViewMenuRecordings(void) {
}
void cViewMenuRecordings::SetViewElementObjects(void) {
cSubView::SetViewElementObjects();
listRecordings = dynamic_cast<cViewListRecordings*>(viewList);
}
void cViewMenuRecordings::SetItem(const cRecording *recording, int index, bool current, bool selectable, int level, int total, int New) {
listRecordings->Set(recording, index, current, selectable, level, total, New);
}
/***********************************************************
* cViewMenuPlugin
***********************************************************/
cViewMenuPlugin::cViewMenuPlugin(const char *name) : cSubView(name) {
listPlugin = NULL;
}
cViewMenuPlugin::~cViewMenuPlugin(void) {
}
void cViewMenuPlugin::SetViewElementObjects(void) {
cSubView::SetViewElementObjects();
listPlugin = dynamic_cast<cViewListPlugin*>(viewList);
}
void cViewMenuPlugin::SetItem(skindesignerapi::cTokenContainer *tk, int index, bool current, bool selectable) {
listPlugin->Set(tk, index, current, selectable);
}
/***********************************************************
* cViewMenuDetail
***********************************************************/
cViewMenuDetail::cViewMenuDetail(const char *name) : cSubView(name) {
firstTab = true;
for (int i=0; i < numViewElements; i++) {
delete viewElements[i];
}
delete[] viewElements;
numViewElements = (int)eVeDisplayDetailedMenu::count;
viewElements = new cViewElement*[numViewElements];
for (int i=0; i < numViewElements; i++) {
viewElements[i] = NULL;
}
delete[] viewElementsHorizontal;
viewElementsHorizontal = new cViewElement*[numViewElements];
for (int i=0; i < numViewElements; i++) {
viewElementsHorizontal[i] = NULL;
}
SetViewElements();
detailedheaderEpg = NULL;
detailedheaderRec = NULL;
detailedheaderPlug = NULL;
tablabels = NULL;
detailViewEpg = NULL;
detailViewRec = NULL;
detailViewText = NULL;
detailViewPlugin = NULL;
SetDetailedView();
}
cViewMenuDetail::~cViewMenuDetail(void) {
}
void cViewMenuDetail::SetDetailedView(void) {
if (!strcmp(viewName, "menudetailedepg")) {
detailViewEpg = new cViewDetailEpg();
detailView = detailViewEpg;
} else if (!strcmp(viewName, "menudetailedrecording")) {
detailViewRec = new cViewDetailRec();
detailView = detailViewRec;
} else if (!strcmp(viewName, "menudetailedtext")) {
detailViewText = new cViewDetailText();
detailView = detailViewText;
} else if (startswith(viewName, "menuplugin")) {
detailViewPlugin = new cViewDetailPlugin();
detailView = detailViewPlugin;
} else {
esyslog("skindesigner: invalid detailedview %s", viewName);
}
if (detailView) {
detailView->SetOsd(&sdOsd);
}
}
void cViewMenuDetail::AddTab(cArea *tab) {
if (firstTab) {
tab->SetActiveTab(true);
firstTab = false;
}
detailView->AddArea(tab);
}
void cViewMenuDetail::SetGlobals(cGlobals *globals) {
cView::SetGlobals(globals);
detailView->SetGlobals(globals);
}
void cViewMenuDetail::PreCache(void) {
attribs->SetContainer(container.X(), container.Y(), container.Width(), container.Height());
attribs->Cache();
if (plugId >= 0 && plugMenuId >= 0) {
cVeDmDetailheaderPlugin *dhPlug = dynamic_cast<cVeDmDetailheaderPlugin*>(viewElements[(int)eVeDisplayDetailedMenu::detailheader]);
dhPlug->SetPlugId(plugId);
dhPlug->SetPlugMenuId(plugMenuId);
dhPlug->SetTokenContainer();
}
cView::PreCache();
detailView->SetPlugId(plugId);
detailView->SetPlugMenuId(plugMenuId);
detailView->SetTokenContainer();
detailView->SetContainer(attribs->X(), attribs->Y(), attribs->Width(), attribs->Height());
detailView->Cache();
}
int cViewMenuDetail::GetWidth(void) {
return detailView->GetWidth();
}
void cViewMenuDetail::SetViewElements(void) {
viewElementNames.insert(pair<string, int>("detailheader", (int)eVeDisplayDetailedMenu::detailheader));
viewElementNames.insert(pair<string, int>("tablabels", (int)eVeDisplayDetailedMenu::tablabels));
}
void cViewMenuDetail::SetViewElementObjects(void) {
cSubView::SetViewElementObjects();
if (viewElements[(int)eVeDisplayDetailedMenu::detailheader]) {
if (!strcmp(viewName, "menudetailedepg"))
detailedheaderEpg = dynamic_cast<cVeDmDetailheaderEpg*>(viewElements[(int)eVeDisplayDetailedMenu::detailheader]);
else if (!strcmp(viewName, "menudetailedrecording"))
detailedheaderRec = dynamic_cast<cVeDmDetailheaderRec*>(viewElements[(int)eVeDisplayDetailedMenu::detailheader]);
else if (startswith(viewName, "menuplugin"))
detailedheaderPlug = dynamic_cast<cVeDmDetailheaderPlugin*>(viewElements[(int)eVeDisplayDetailedMenu::detailheader]);
}
if (viewElements[(int)eVeDisplayDetailedMenu::tablabels])
tablabels = dynamic_cast<cVeDmTablabels*>(viewElements[(int)eVeDisplayDetailedMenu::tablabels]);
}
void cViewMenuDetail::SetEvent(const cEvent *event) {
if (detailedheaderEpg)
detailedheaderEpg->SetEvent(event);
if (detailViewEpg)
detailViewEpg->SetEvent(event);
}
void cViewMenuDetail::SetRecording(const cRecording *recording) {
if (detailedheaderRec)
detailedheaderRec->SetRecording(recording);
if (detailViewRec)
detailViewRec->SetRecording(recording);
}
void cViewMenuDetail::SetText(const char *text) {
if (detailViewText)
detailViewText->SetText(text);
}
void cViewMenuDetail::SetPluginText(skindesignerapi::cTokenContainer *tk) {
if (detailedheaderPlug)
detailedheaderPlug->Set(tk);
if (detailViewPlugin)
detailViewPlugin->Set(tk);
}
void cViewMenuDetail::Clear(void) {
cSubView::Close();
if (detailedheaderEpg) {
detailedheaderEpg->Close();
} else if (detailedheaderRec) {
detailedheaderRec->Close();
} else if (detailedheaderPlug) {
detailedheaderPlug->Close();
}
if (header) {
header->Hide();
}
if (detailView) {
detailView->Close();
}
}
void cViewMenuDetail::Close(void) {
cSubView::Close();
if (detailView) {
detailView->Close();
}
}
void cViewMenuDetail::DrawStaticVEs(void) {
cSubView::DrawStaticVEs();
if (detailedheaderEpg && detailedheaderEpg->Parse()) {
detailedheaderEpg->Render();
} else if (detailedheaderRec && detailedheaderRec->Parse()) {
detailedheaderRec->Render();
} else if (detailedheaderPlug && detailedheaderPlug->Parse()) {
detailedheaderPlug->Render();
}
}
void cViewMenuDetail::DrawDynamicVEs(void) {
if (datetime) {
datetime->Show();
if (datetime->Parse())
datetime->Render();
}
if (time) {
time->Show();
if (time->Parse())
time->Render();
}
}
void cViewMenuDetail::DrawDetailedView(void) {
detailView->Clear();
detailView->ResetTabs();
if (detailView->Parse()) {
detailView->Render();
}
if (scrollbar) {
scrollbar->Show();
DrawScrollbar();
}
vector<const char*> tabs;
int activeTab = detailView->GetTabs(tabs);
if (tablabels) {
tablabels->SetTabs(tabs);
tablabels->SetActiveTab(activeTab);
if (tablabels->Parse())
tablabels->Render();
}
}
void cViewMenuDetail::KeyLeft(void) {
if (detailView->NumTabs() > 1) {
detailView->Clear();
detailView->PrevTab();
detailView->SetDirty();
if (tablabels) {
tablabels->Clear();
tablabels->SetActiveTab(detailView->ActiveTab());
if (tablabels->Parse())
tablabels->Render();
}
sdOsd.Flush();
detailView->Render();
if (scrollbar) {
DrawScrollbar();
}
} else {
//scroll page
if (detailView->ScrollUp(true)) {
if (scrollbar)
DrawScrollbar();
}
}
}
void cViewMenuDetail::KeyRight(void) {
if (detailView->NumTabs() > 1) {
detailView->Clear();
detailView->NextTab();
detailView->SetDirty();
if (tablabels) {
tablabels->Clear();
tablabels->SetActiveTab(detailView->ActiveTab());
if (tablabels->Parse())
tablabels->Render();
}
sdOsd.Flush();
detailView->Render();
if (scrollbar) {
DrawScrollbar();
}
} else {
//scroll page
if (detailView->ScrollDown(true)) {
if (scrollbar)
DrawScrollbar();
}
}
}
void cViewMenuDetail::KeyUp(void) {
if (detailView->ScrollUp()) {
if (scrollbar)
DrawScrollbar();
}
}
void cViewMenuDetail::KeyDown(void) {
if (scrollbar && detailView->ScrollDown()) {
if (scrollbar)
DrawScrollbar();
}
}
void cViewMenuDetail::SetTransparency(int transparency, bool forceDetached) {
if (detailedheaderEpg)
detailedheaderEpg->SetTransparency(transparency);
if (detailedheaderRec)
detailedheaderRec->SetTransparency(transparency);
if (tablabels)
tablabels->SetTransparency(transparency);
if (detailView)
detailView->SetTransparency(transparency);
}
void cViewMenuDetail::DrawScrollbar(void) {
int barheight = 0;
int offset = 0;
bool end = true;
detailView->Scrollbar(barheight, offset, end);
scrollbar->SetDetail(barheight, offset, end);
scrollbar->Render();
}
Reference in New Issue View Git Blame Copy Permalink