vdr-plugin-tvguide/tvguideosd.c

705 lines
22 KiB
C
Raw Normal View History

2013-01-17 13:16:44 +01:00
// --- Theme -------------------------------------------------------------
static cTheme theme;
//BLENDING SETUP
#define CLR_BLENDING_NOPACITY 0xFFFFFFFF
#define CLR_BLENDING_DEFAULT 0xAAAAAAAA
#define CLR_BLENDING_OFF 0x00000000
THEME_CLR(theme, clrDoBlending, CLR_BLENDING_DEFAULT);
2013-01-17 13:16:44 +01:00
THEME_CLR(theme, clrBackgroundOSD, clrBlack);
THEME_CLR(theme, clrBackground, clrBlack);
THEME_CLR(theme, clrGrid1, 0xFF404749);
THEME_CLR(theme, clrGrid1Blending, 0xFF000000);
THEME_CLR(theme, clrGrid2, 0xFF20293F);
THEME_CLR(theme, clrGrid2Blending, 0xFF000000);
THEME_CLR(theme, clrHighlight, 0xFFFF4D00);
THEME_CLR(theme, clrHighlightBlending, 0xFF000000);
THEME_CLR(theme, clrFont, clrWhite);
2013-05-28 17:06:53 +02:00
THEME_CLR(theme, clrFontActive, clrWhite);
2013-01-17 13:16:44 +01:00
THEME_CLR(theme, clrFontHeader, clrWhite);
THEME_CLR(theme, clrFontButtons, clrWhite);
THEME_CLR(theme, clrStatusHeader, clrBlack);
THEME_CLR(theme, clrStatusHeaderBlending, clrBlack);
2013-01-17 13:16:44 +01:00
THEME_CLR(theme, clrHeader, clrBlack);
THEME_CLR(theme, clrHeaderBlending, 0xFFE0E0E0);
THEME_CLR(theme, clrBorder, clrWhite);
THEME_CLR(theme, clrTimeline1, clrWhite);
THEME_CLR(theme, clrTimeline1Blending, 0xFF828282);
THEME_CLR(theme, clrTimeline2, clrBlack);
THEME_CLR(theme, clrTimeline2Blending, 0xFF3F3F3F);
THEME_CLR(theme, clrButtonRed, 0x99BB0000);
THEME_CLR(theme, clrButtonRedBorder, 0xFFBB0000);
THEME_CLR(theme, clrButtonGreen, 0x9900BB00);
THEME_CLR(theme, clrButtonGreenBorder, 0xFF00BB00);
THEME_CLR(theme, clrButtonYellow, 0x99BBBB00);
THEME_CLR(theme, clrButtonYellowBorder, 0xFFBBBB00);
THEME_CLR(theme, clrButtonBlue, 0x990000BB);
THEME_CLR(theme, clrButtonBlueBorder, 0xFF0000BB);
THEME_CLR(theme, clrButtonBlend, 0xDD000000);
2013-07-09 00:17:42 +02:00
THEME_CLR(theme, clrRecMenuBackground, 0xB0000000);
THEME_CLR(theme, clrRecMenuTimerConflictBackground, 0xFFCCCCCC);
THEME_CLR(theme, clrRecMenuTimerConflictBar, 0xFF222222);
THEME_CLR(theme, clrRecMenuTimerConflictOverlap, 0xAAFF0000);
THEME_CLR(theme, clrRecMenuDayActive, 0xFF00FF00);
THEME_CLR(theme, clrRecMenuDayInactive, 0xFFFF0000);
THEME_CLR(theme, clrRecMenuDayHighlight, 0x44FFFFFF);
THEME_CLR(theme, clrRecMenuTextBack, 0xFF000000);
THEME_CLR(theme, clrRecMenuTextActiveBack, 0xFF404749);
THEME_CLR(theme, clrRecMenuKeyboardBack, 0xFF000000);
THEME_CLR(theme, clrRecMenuKeyboardBorder, clrWhite);
THEME_CLR(theme, clrRecMenuKeyboardHigh, 0x55FFFFFF);
THEME_CLR(theme, clrButtonRedKeyboard, 0xFFBB0000);
THEME_CLR(theme, clrButtonGreenKeyboard, 0xFF00BB00);
THEME_CLR(theme, clrButtonYellowKeyboard, 0xFFBBBB00);
2013-01-17 13:16:44 +01:00
#include "config.c"
cTvguideConfig tvguideConfig;
#include "osdmanager.c"
cOsdManager osdManager;
#include "services/epgsearch.h"
2013-07-09 00:17:42 +02:00
#include "tools.c"
#include "switchtimer.c"
2013-01-17 13:16:44 +01:00
#include "setup.c"
#include "imageloader.c"
#include "styledpixmap.c"
#include "timer.c"
#include "timeline.c"
#include "grid.c"
#include "headergrid.c"
#include "dummygrid.c"
2013-01-17 13:16:44 +01:00
#include "epggrid.c"
#include "statusheader.c"
2013-01-17 13:16:44 +01:00
#include "detailview.c"
#include "channelcolumn.c"
2013-05-31 13:58:22 +02:00
#include "channelgroup.c"
#include "channelgroups.c"
2013-01-17 13:16:44 +01:00
#include "footer.c"
2013-07-09 00:17:42 +02:00
#include "recmenuitem.c"
#include "recmenu.c"
#include "recmanager.c"
#include "recmenus.c"
#include "recmenumanager.c"
2013-01-17 13:16:44 +01:00
#include "tvguideosd.h"
#include <stdlib.h>
cTvGuideOsd::cTvGuideOsd(void) {
2013-05-26 11:38:05 +02:00
detailView = NULL;
detailViewActive = false;
activeGrid = NULL;
2013-05-26 11:38:05 +02:00
timeLine = NULL;
2013-07-09 00:17:42 +02:00
recMenuManager = NULL;
2013-01-17 13:16:44 +01:00
}
cTvGuideOsd::~cTvGuideOsd() {
2013-05-26 11:38:05 +02:00
delete myTime;
columns.Clear();
if (tvguideConfig.displayStatusHeader) {
delete statusHeader;
2013-05-26 11:38:05 +02:00
}
if (detailView)
2013-05-26 11:38:05 +02:00
delete detailView;
delete timeLine;
2013-05-31 13:58:22 +02:00
delete channelGroups;
2013-05-26 11:38:05 +02:00
delete footer;
2013-07-09 00:17:42 +02:00
delete recMenuManager;
2013-05-26 11:38:05 +02:00
osdManager.deleteOsd();
2013-01-17 13:16:44 +01:00
}
void cTvGuideOsd::Show(void) {
2013-05-26 11:38:05 +02:00
int start = cTimeMs::Now();
bool ok = false;
ok = osdManager.setOsd();
if (ok) {
tvguideConfig.setDynamicValues(osdManager.Width(), osdManager.Height());
tvguideConfig.loadTheme();
tvguideConfig.SetBlending();
2013-05-26 11:38:05 +02:00
osdManager.setBackground();
myTime = new cMyTime();
myTime->Now();
2013-07-09 00:17:42 +02:00
SwitchTimers.Load(AddDirectory(cPlugin::ConfigDirectory("epgsearch"), "epgsearchswitchtimers.conf"));
recMenuManager = new cRecMenuManager();
2013-05-26 11:38:05 +02:00
drawOsd();
}
esyslog("tvguide: Rendering took %d ms", int(cTimeMs::Now()-start));
2013-01-17 13:16:44 +01:00
}
void cTvGuideOsd::drawOsd() {
2013-05-26 11:38:05 +02:00
cPixmap::Lock();
cChannel *startChannel = Channels.GetByNumber(cDevice::CurrentChannel());
if (tvguideConfig.displayStatusHeader) {
statusHeader = new cStatusHeader();
statusHeader->ScaleVideo();
}
2013-05-26 11:38:05 +02:00
timeLine = new cTimeLine(myTime);
timeLine->drawDateViewer();
timeLine->drawTimeline();
timeLine->drawClock();
2013-05-31 13:58:22 +02:00
channelGroups = new cChannelGroups();
channelGroups->ReadChannelGroups();
//channelGroups->DumpGroups();
footer = new cFooter(channelGroups);
2013-05-26 11:38:05 +02:00
footer->drawRedButton();
2013-05-31 13:58:22 +02:00
if (tvguideConfig.channelJumpMode == eNumJump) {
footer->drawGreenButton();
footer->drawYellowButton();
}
2013-05-26 11:38:05 +02:00
footer->drawBlueButton();
osdManager.flush();
readChannels(startChannel);
drawGridsChannelJump();
osdManager.flush();
cPixmap::Unlock();
2013-01-17 13:16:44 +01:00
}
void cTvGuideOsd::readChannels(const cChannel *channelStart) {
2013-05-26 11:38:05 +02:00
int i=0;
2013-05-31 13:58:22 +02:00
bool foundEnough = false;
2013-05-26 11:38:05 +02:00
columns.Clear();
if (!channelStart)
return;
for (const cChannel *channel = channelStart; channel; channel = Channels.Next(channel)) {
2013-05-31 13:58:22 +02:00
if (!channel->GroupSep()) {
if (channelGroups->IsInLastGroup(channel)) {
break;
}
cChannelColumn *column = new cChannelColumn(i, channel, myTime);
if (column->readGrids()) {
columns.Add(column);
i++;
} else {
delete column;
}
2013-05-26 11:38:05 +02:00
}
2013-05-31 13:58:22 +02:00
if (i == tvguideConfig.numGrids) {
foundEnough = true;
break;
}
}
if (!foundEnough) {
int numCurrent = columns.Count();
int numBack = tvguideConfig.numGrids - numCurrent;
int newChannelNumber = columns.First()->getChannel()->Number() - numBack;
const cChannel *newStart = Channels.GetByNumber(newChannelNumber);
readChannels(newStart);
2013-01-17 13:16:44 +01:00
}
}
2013-07-15 17:27:55 +02:00
void cTvGuideOsd::drawGridsChannelJump(int offset) {
2013-05-26 11:38:05 +02:00
if (columns.Count() == 0)
return;
2013-07-15 17:27:55 +02:00
activeGrid = columns.Get(offset)->getActive();
2013-05-26 11:38:05 +02:00
if (activeGrid)
activeGrid->SetActive();
if (tvguideConfig.displayStatusHeader) {
statusHeader->DrawInfoText(activeGrid);
2013-05-26 11:38:05 +02:00
}
2013-05-31 13:58:22 +02:00
if (activeGrid && (tvguideConfig.channelJumpMode == eGroupJump)) {
footer->UpdateGroupButtons(activeGrid->column->getChannel());
}
if (tvguideConfig.displayChannelGroups) {
channelGroups->DrawChannelGroups(columns.First()->getChannel(), columns.Last()->getChannel());
}
for (cChannelColumn *column = columns.First(); column; column = columns.Next(column)) {
2013-05-26 11:38:05 +02:00
column->createHeader();
column->drawGrids();
}
2013-01-17 13:16:44 +01:00
}
void cTvGuideOsd::drawGridsTimeJump() {
2013-05-26 11:38:05 +02:00
if (columns.Count() == 0)
return;
cChannelColumn *colActive = NULL;
if (activeGrid) {
colActive = activeGrid->column;
} else {
colActive = columns.First();
}
for (cChannelColumn *column = columns.First(); column; column = columns.Next(column)) {
column->clearGrids();
column->readGrids();
column->drawGrids();
}
activeGrid = colActive->getActive();
if (activeGrid) {
activeGrid->SetActive();
activeGrid->Draw();
if (tvguideConfig.displayStatusHeader) {
statusHeader->DrawInfoText(activeGrid);
}
2013-05-26 11:38:05 +02:00
}
2013-01-17 13:16:44 +01:00
}
void cTvGuideOsd::setNextActiveGrid(cGrid *next) {
2013-05-26 11:38:05 +02:00
if (!next || !activeGrid) {
return;
}
activeGrid->SetInActive();
activeGrid->Draw();
activeGrid = next;
activeGrid->SetActive();
activeGrid->Draw();
if (tvguideConfig.displayStatusHeader) {
statusHeader->DrawInfoText(activeGrid);
}
2013-01-17 13:16:44 +01:00
}
2013-05-24 16:23:23 +02:00
void cTvGuideOsd::channelForward() {
cChannelColumn *colRight = columns.Next(activeGrid->column);
2013-05-31 13:58:22 +02:00
bool colAdded = false;
2013-05-26 11:38:05 +02:00
if (!colRight) {
const cChannel *channelRight = activeGrid->column->getChannel();
while (channelRight = Channels.Next(channelRight)) {
if (!channelRight->GroupSep()) {
2013-05-31 13:58:22 +02:00
if (channelGroups->IsInLastGroup(channelRight)) {
break;
}
2013-05-26 11:38:05 +02:00
colRight = new cChannelColumn(tvguideConfig.numGrids - 1, channelRight, myTime);
if (colRight->readGrids()) {
break;
} else {
delete colRight;
colRight = NULL;
}
}
}
if (colRight) {
2013-05-31 13:58:22 +02:00
colAdded = true;
2013-05-26 11:38:05 +02:00
if (columns.Count() == tvguideConfig.numGrids) {
cChannelColumn *cFirst = columns.First();
columns.Del(cFirst);
}
for (cChannelColumn *column = columns.First(); column; column = columns.Next(column)) {
column->SetNum(column->GetNum() - 1);
column->drawHeader();
column->drawGrids();
}
columns.Add(colRight);
colRight->createHeader();
colRight->drawGrids();
}
}
if (colRight) {
cGrid *right = colRight->getNeighbor(activeGrid);
if (right) {
setNextActiveGrid(right);
}
}
2013-05-31 13:58:22 +02:00
if (tvguideConfig.displayChannelGroups && colAdded) {
channelGroups->DrawChannelGroups(columns.First()->getChannel(), columns.Last()->getChannel());
}
if (activeGrid && (tvguideConfig.channelJumpMode == eGroupJump)) {
footer->UpdateGroupButtons(activeGrid->column->getChannel());
}
2013-05-26 11:38:05 +02:00
osdManager.flush();
2013-01-17 13:16:44 +01:00
}
2013-05-24 16:23:23 +02:00
void cTvGuideOsd::channelBack() {
2013-05-26 11:38:05 +02:00
cChannelColumn *colLeft = columns.Prev(activeGrid->column);
2013-05-31 13:58:22 +02:00
bool colAdded = false;
2013-05-26 11:38:05 +02:00
if (!colLeft) {
const cChannel *channelLeft = activeGrid->column->getChannel();
while (channelLeft = Channels.Prev(channelLeft)) {
if (!channelLeft->GroupSep()) {
colLeft = new cChannelColumn(0, channelLeft, myTime);
if (colLeft->readGrids()) {
break;
} else {
delete colLeft;
colLeft = NULL;
}
}
}
if (colLeft) {
2013-05-31 13:58:22 +02:00
colAdded = true;
2013-05-26 11:38:05 +02:00
if (columns.Count() == tvguideConfig.numGrids) {
cChannelColumn *cLast = columns.Last();
columns.Del(cLast);
}
for (cChannelColumn *column = columns.First(); column; column = columns.Next(column)) {
column->SetNum(column->GetNum() + 1);
column->drawHeader();
column->drawGrids();
}
columns.Ins(colLeft, columns.First());
colLeft->createHeader();
colLeft->drawGrids();
}
}
if (colLeft) {
cGrid *left = colLeft->getNeighbor(activeGrid);
if (left) {
setNextActiveGrid(left);
}
}
2013-05-31 13:58:22 +02:00
if (tvguideConfig.displayChannelGroups && colAdded) {
channelGroups->DrawChannelGroups(columns.First()->getChannel(), columns.Last()->getChannel());
}
if (activeGrid && (tvguideConfig.channelJumpMode == eGroupJump)) {
footer->UpdateGroupButtons(activeGrid->column->getChannel());
}
2013-05-26 11:38:05 +02:00
osdManager.flush();
2013-01-17 13:16:44 +01:00
}
2013-05-24 16:23:23 +02:00
void cTvGuideOsd::timeForward() {
bool actionDone = false;
if ( (myTime->GetEnd() - activeGrid->EndTime())/60 < 30 ) {
ScrollForward();
actionDone = true;
}
cGrid *next = activeGrid->column->getNext(activeGrid);
if (next) {
if ( (next->EndTime() < myTime->GetEnd())
|| ( (myTime->GetEnd() - next->StartTime())/60 > 30 ) ) {
setNextActiveGrid(next);
actionDone = true;
}
}
if (!actionDone) {
ScrollForward();
}
2013-05-26 11:38:05 +02:00
osdManager.flush();
2013-05-24 16:23:23 +02:00
}
void cTvGuideOsd::ScrollForward() {
myTime->AddStep(tvguideConfig.stepMinutes);
2013-05-26 11:38:05 +02:00
timeLine->drawDateViewer();
timeLine->drawClock();
timeLine->setTimeline();
for (cChannelColumn *column = columns.First(); column; column = columns.Next(column)) {
column->AddNewGridsAtEnd();
column->ClearOutdatedStart();
column->drawGrids();
}
2013-05-24 16:23:23 +02:00
}
void cTvGuideOsd::timeBack() {
bool actionDone = false;
if ( (activeGrid->StartTime() - myTime->GetStart())/60 < 30 ) {
ScrollBack();
actionDone = true;
}
cGrid *prev = activeGrid->column->getPrev(activeGrid);
if (prev) {
if ( (prev->StartTime() > myTime->GetStart())
|| ( (prev->EndTime() - myTime->GetStart())/60 > 30 )
|| ( prev->isFirst()) ) {
setNextActiveGrid(prev);
actionDone = true;
}
}
if (!actionDone) {
ScrollBack();
}
2013-05-26 11:38:05 +02:00
osdManager.flush();
2013-05-24 16:23:23 +02:00
}
void cTvGuideOsd::ScrollBack() {
2013-05-26 11:38:05 +02:00
bool tooFarInPast = myTime->DelStep(tvguideConfig.stepMinutes);
if (tooFarInPast)
return;
timeLine->drawDateViewer();
timeLine->drawClock();
timeLine->setTimeline();
for (cChannelColumn *column = columns.First(); column; column = columns.Next(column)) {
column->AddNewGridsAtStart();
column->ClearOutdatedEnd();
column->drawGrids();
}
2013-05-24 16:23:23 +02:00
}
void cTvGuideOsd::processKeyUp() {
if (!activeGrid) {
return;
}
2013-07-09 00:17:42 +02:00
if (tvguideConfig.displayMode == eVertical) {
timeBack();
} else if (tvguideConfig.displayMode == eHorizontal) {
channelBack();
2013-05-24 16:23:23 +02:00
}
}
void cTvGuideOsd::processKeyDown() {
2013-05-26 11:38:05 +02:00
if (!activeGrid) {
return;
2013-05-24 16:23:23 +02:00
}
2013-07-09 00:17:42 +02:00
if (tvguideConfig.displayMode == eVertical) {
timeForward();
} else if (tvguideConfig.displayMode == eHorizontal) {
channelForward();
2013-05-24 16:23:23 +02:00
}
}
void cTvGuideOsd::processKeyLeft() {
2013-05-26 11:38:05 +02:00
if (activeGrid == NULL)
return;
2013-05-24 16:23:23 +02:00
if (tvguideConfig.displayMode == eVertical) {
channelBack();
} else if (tvguideConfig.displayMode == eHorizontal) {
timeBack();
}
}
2013-01-17 13:16:44 +01:00
void cTvGuideOsd::processKeyRight() {
2013-05-26 11:38:05 +02:00
if (activeGrid == NULL)
return;
2013-05-24 16:23:23 +02:00
if (tvguideConfig.displayMode == eVertical) {
channelForward();
} else if (tvguideConfig.displayMode == eHorizontal) {
timeForward();
}
2013-01-17 13:16:44 +01:00
}
void cTvGuideOsd::processKeyRed() {
2013-05-26 11:38:05 +02:00
if ((activeGrid == NULL) || activeGrid->isDummy())
return;
2013-07-09 00:17:42 +02:00
recMenuManager->Start(activeGrid->GetEvent());
2013-01-17 13:16:44 +01:00
}
void cTvGuideOsd::processKeyGreen() {
2013-05-26 11:38:05 +02:00
if (activeGrid == NULL)
return;
2013-05-31 13:58:22 +02:00
2013-05-26 11:38:05 +02:00
const cChannel *currentChannel = activeGrid->column->getChannel();
2013-07-15 17:27:55 +02:00
const cChannel *firstChannel = columns.First()->getChannel();
int currentCol = activeGrid->column->GetNum();
const cChannel *prev = NULL;
2013-05-31 13:58:22 +02:00
if (tvguideConfig.channelJumpMode == eGroupJump) {
int prevNum = channelGroups->GetPrevGroupChannelNumber(currentChannel);
if (prevNum) {
prev = Channels.GetByNumber(prevNum);
}
} else if (tvguideConfig.channelJumpMode == eNumJump) {
int i = tvguideConfig.jumpChannels + 1;
2013-07-15 17:27:55 +02:00
for (const cChannel *channel = firstChannel; channel; channel = Channels.Prev(channel)) {
2013-05-31 13:58:22 +02:00
if (!channel->GroupSep()) {
prev = channel;
i--;
}
if (i == 0)
break;
2013-05-26 11:38:05 +02:00
}
}
if (prev) {
2013-05-26 11:38:05 +02:00
readChannels(prev);
if (columns.Count() > 0) {
2013-07-15 17:27:55 +02:00
drawGridsChannelJump(currentCol);
2013-05-26 11:38:05 +02:00
}
osdManager.flush();
}
2013-01-17 13:16:44 +01:00
}
void cTvGuideOsd::processKeyYellow() {
2013-05-26 11:38:05 +02:00
if (activeGrid == NULL)
return;
const cChannel *currentChannel = activeGrid->column->getChannel();
2013-07-15 17:27:55 +02:00
int currentCol = activeGrid->column->GetNum();
const cChannel *firstChannel = columns.First()->getChannel();
2013-05-26 11:38:05 +02:00
const cChannel *next = NULL;
2013-05-31 13:58:22 +02:00
if (tvguideConfig.channelJumpMode == eGroupJump) {
int nextNum = channelGroups->GetNextGroupChannelNumber(currentChannel);
if (nextNum) {
next = Channels.GetByNumber(nextNum);
}
} else if (tvguideConfig.channelJumpMode == eNumJump) {
int i=0;
2013-07-15 17:27:55 +02:00
for (const cChannel *channel = firstChannel; channel; channel = Channels.Next(channel)) {
2013-05-31 13:58:22 +02:00
if (channelGroups->IsInLastGroup(channel)) {
break;
}
if (!channel->GroupSep()) {
next = channel;
i++;
}
if (i == (tvguideConfig.jumpChannels+1)) {
break;
}
2013-05-26 11:38:05 +02:00
}
}
if (next) {
readChannels(next);
if (columns.Count() > 0) {
2013-07-15 17:27:55 +02:00
drawGridsChannelJump(currentCol);
2013-05-26 11:38:05 +02:00
}
osdManager.flush();
}
2013-01-17 13:16:44 +01:00
}
eOSState cTvGuideOsd::processKeyBlue() {
if (tvguideConfig.blueKeyMode == 0) {
return ChannelSwitch();
} else if (tvguideConfig.blueKeyMode == 1) {
DetailedEPG();
}
return osContinue;
}
eOSState cTvGuideOsd::processKeyOk() {
2013-07-09 00:17:42 +02:00
if (tvguideConfig.blueKeyMode == 0) {
DetailedEPG();
} else if (tvguideConfig.blueKeyMode == 1) {
return ChannelSwitch();
}
return osContinue;
}
eOSState cTvGuideOsd::ChannelSwitch() {
2013-05-26 11:38:05 +02:00
if (activeGrid == NULL)
return osContinue;
const cChannel *currentChannel = activeGrid->column->getChannel();
if (currentChannel) {
cDevice::PrimaryDevice()->SwitchChannel(currentChannel, true);
return osEnd;
}
return osContinue;
2013-01-17 13:16:44 +01:00
}
void cTvGuideOsd::DetailedEPG() {
2013-07-09 00:17:42 +02:00
if (!activeGrid->isDummy()) {
detailViewActive = true;
detailView = new cDetailView(activeGrid->GetEvent());
detailView->drawHeader();
detailView->drawContent();
detailView->drawScrollbar();
osdManager.flush();
}
}
2013-01-17 13:16:44 +01:00
void cTvGuideOsd::processKey1() {
2013-05-26 11:38:05 +02:00
bool tooFarInPast = myTime->DelStep(tvguideConfig.bigStepHours*60);
if (tooFarInPast)
return;
drawGridsTimeJump();
timeLine->drawDateViewer();
timeLine->drawClock();
timeLine->setTimeline();
osdManager.flush();
2013-01-17 13:16:44 +01:00
}
void cTvGuideOsd::processKey3() {
2013-05-26 11:38:05 +02:00
myTime->AddStep(tvguideConfig.bigStepHours*60);
drawGridsTimeJump();
timeLine->drawDateViewer();
timeLine->drawClock();
timeLine->setTimeline();
osdManager.flush();
2013-01-17 13:16:44 +01:00
}
void cTvGuideOsd::processKey4() {
2013-05-26 11:38:05 +02:00
bool tooFarInPast = myTime->DelStep(tvguideConfig.hugeStepHours*60);
if (tooFarInPast)
return;
drawGridsTimeJump();
timeLine->drawDateViewer();
timeLine->drawClock();
timeLine->setTimeline();
osdManager.flush();
2013-01-17 13:16:44 +01:00
}
void cTvGuideOsd::processKey6() {
2013-05-26 11:38:05 +02:00
myTime->AddStep(tvguideConfig.hugeStepHours*60);
drawGridsTimeJump();
timeLine->drawDateViewer();
timeLine->drawClock();
timeLine->setTimeline();
osdManager.flush();
2013-01-17 13:16:44 +01:00
}
void cTvGuideOsd::processKey7() {
2013-05-26 11:38:05 +02:00
cMyTime *primeChecker = new cMyTime();
primeChecker->Now();
time_t prevPrime = primeChecker->getPrevPrimetime(myTime->GetStart());
if (primeChecker->tooFarInPast(prevPrime))
return;
myTime->SetTime(prevPrime);
drawGridsTimeJump();
timeLine->drawDateViewer();
timeLine->drawClock();
timeLine->setTimeline();
osdManager.flush();
2013-01-17 13:16:44 +01:00
}
void cTvGuideOsd::processKey9() {
2013-05-26 11:38:05 +02:00
cMyTime *primeChecker = new cMyTime();
time_t nextPrime = primeChecker->getNextPrimetime(myTime->GetStart());
myTime->SetTime(nextPrime);
drawGridsTimeJump();
timeLine->drawDateViewer();
timeLine->drawClock();
timeLine->setTimeline();
osdManager.flush();
2013-01-17 13:16:44 +01:00
}
2013-07-09 00:17:42 +02:00
void cTvGuideOsd::SetTimers() {
for (cChannelColumn *column = columns.First(); column; column = columns.Next(column)) {
column->SetTimers();
}
}
2013-01-17 13:16:44 +01:00
eOSState cTvGuideOsd::ProcessKey(eKeys Key) {
2013-07-09 00:17:42 +02:00
eOSState state = osContinue;
cPixmap::Lock();
if (recMenuManager->isActive()) {
state = recMenuManager->ProcessKey(Key);
if (state == osEnd) {
SetTimers();
osdManager.flush();
}
2013-05-26 11:38:05 +02:00
state = osContinue;
2013-07-09 00:17:42 +02:00
} else if (detailViewActive) {
if ((Key & ~k_Repeat) == kRed) {
2013-07-09 00:17:42 +02:00
delete detailView;
detailView = NULL;
detailViewActive = false;
processKeyRed();
} else {
state = detailView->ProcessKey(Key);
if (state == osEnd) {
delete detailView;
detailView = NULL;
detailViewActive = false;
osdManager.flush();
state = osContinue;
}
2013-07-09 00:17:42 +02:00
}
} else {
2013-05-26 11:38:05 +02:00
switch (Key & ~k_Repeat) {
case kUp: processKeyUp(); break;
case kDown: processKeyDown(); break;
case kLeft: processKeyLeft(); break;
case kRight: processKeyRight(); break;
case kRed: processKeyRed(); break;
case kGreen: processKeyGreen(); break;
case kYellow: processKeyYellow(); break;
case kBlue: state = processKeyBlue(); break;
case kOk: state = processKeyOk(); break;
2013-07-09 00:17:42 +02:00
case kBack: state=osEnd; break;
2013-05-26 11:38:05 +02:00
case k1: processKey1(); break;
case k3: processKey3(); break;
case k4: processKey4(); break;
case k6: processKey6(); break;
case k7: processKey7(); break;
case k9: processKey9(); break;
default: break;
}
}
2013-07-09 00:17:42 +02:00
cPixmap::Unlock();
2013-05-26 11:38:05 +02:00
return state;
}
void cTvGuideOsd::dump() {
2013-05-26 11:38:05 +02:00
esyslog("tvguide: ------Dumping Content---------");
activeGrid->debug();
int i=1;
2013-05-26 11:38:05 +02:00
for (cChannelColumn *col = columns.First(); col; col = columns.Next(col)) {
col->dumpGrids();
}
2013-07-09 00:44:41 +02:00
}