Initial push tvguide 0.0.1

1 files changed, 541 insertions, 0 deletions

diff --git a/tvguideosd.c b/tvguideosd.c
new file mode 100644
index 0000000..8fca65a
--- /dev/null
+++ b/tvguideosd.c
@@ -0,0 +1,541 @@
+// --- Theme -------------------------------------------------------------

+static cTheme theme;

+

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

+THEME_CLR(theme, clrFontHeader, clrWhite);

+THEME_CLR(theme, clrFontButtons, clrWhite);

+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, 0xFFD42627);

+THEME_CLR(theme, clrButtonRedBlending, 0xFFE0E0E0);

+THEME_CLR(theme, clrButtonGreen, 0xFF004F00);

+THEME_CLR(theme, clrButtonGreenBlending, 0xFFE0E0E0);

+THEME_CLR(theme, clrButtonYellow, 0xFFffa300);

+THEME_CLR(theme, clrButtonYellowBlending, 0xFFE0E0E0);

+THEME_CLR(theme, clrButtonBlue, 0xFF0000fe);

+THEME_CLR(theme, clrButtonBlueBlending, 0xFFE0E0E0);

+

+#include "config.c"

+cTvguideConfig tvguideConfig;

+

+#include "osdmanager.c"

+cOsdManager osdManager;

+

+#include "setup.c"

+#include "imageloader.c"

+#include "styledpixmap.c"

+#include "timer.c"

+#include "messagebox.c"

+#include "timeline.c"

+#include "epggrid.c"

+#include "detailview.c"

+#include "channelcolumn.c"

+#include "footer.c"

+

+#include "tvguideosd.h"

+#include <stdlib.h>

+

+cTvGuideOsd::cTvGuideOsd(void) {

+	detailView = NULL;

+	detailViewActive = false;

+	timeLine = NULL;

+}

+

+cTvGuideOsd::~cTvGuideOsd() {

+	delete myTime;

+	columns.Clear();

+	if (detailView)

+		delete detailView;

+	delete timeLine;

+	delete footer;

+	cMessageBox::Destroy();

+	osdManager.deleteOsd();

+}

+

+void cTvGuideOsd::Show(void) {

+	int start = cTimeMs::Now();

+	bool ok = false;

+	ok = osdManager.setOsd();

+	if (ok) {

+		tvguideConfig.setDynamicValues(osdManager.Width(), osdManager.Height());

+		tvguideConfig.loadTheme();

+		osdManager.setBackground();

+		myTime = new cMyTime();

+		myTime->Now();

+		drawOsd();

+	}

+	esyslog("tvguide: Rendering took %d ms", int(cTimeMs::Now()-start));

+}

+

+void cTvGuideOsd::drawOsd() {

+	cPixmap::Lock();

+	cChannel *startChannel = Channels.GetByNumber(cDevice::CurrentChannel());

+	timeLine = new cTimeLine(myTime);

+	timeLine->drawDateViewer();

+	timeLine->drawTimeline();

+	timeLine->drawClock();

+	footer = new cFooter();

+	footer->drawRedButton();

+	footer->drawGreenButton();

+	footer->drawYellowButton();

+	footer->drawBlueButton();

+	osdManager.flush();

+	readChannels(startChannel);

+	drawGridsChannelJump();

+	osdManager.flush();

+	cPixmap::Unlock();

+}

+

+void cTvGuideOsd::readChannels(cChannel *channelStart) {

+	int i=0;

+	columns.Clear();

+	if (!channelStart)

+		return;

+	for (cChannel *channel = channelStart; channel; channel = Channels.Next(channel)) {

+      if (!channel->GroupSep()) {

+		cChannelColumn *column = new cChannelColumn(i, channel, myTime);

+		if (column->readGrids()) {

+			columns.Add(column);

+			i++;

+		} else {

+			delete column;

+		}

+	  }

+	  if (i == tvguideConfig.channelCols)

+	    break;

+    }

+}

+

+bool cTvGuideOsd::readChannelsReverse(cChannel *channelStart) {

+	bool doUpdate = false;

+	int i = tvguideConfig.channelCols;

+	if (!channelStart)

+		return false;

+	for (cChannel *channel = Channels.Prev(channelStart); channel; channel = Channels.Prev(channel)) {

+      if (!channel->GroupSep()) {

+		cChannelColumn *column = new cChannelColumn(i-1, channel, myTime);

+		if (column->readGrids()) {

+			if (i == tvguideConfig.channelCols) {

+				columns.Clear();

+				doUpdate = true;

+			}

+			columns.Ins(column, columns.First());

+			i--;

+		} else {

+			delete column;

+		}

+	  }

+	  if (i == 0)

+	    break;

+    }

+	return doUpdate;

+}

+

+void cTvGuideOsd::drawGridsChannelJump() {

+	if (columns.Count() == 0)

+		return;

+	activeGrid = columns.First()->getActive();

+	if (activeGrid)

+		activeGrid->SetActive();

+	for (cChannelColumn *column = columns.First(); column; column = columns.Next(column)) {

+		column->createHeader();

+		column->drawGrids();

+	}

+}

+

+void cTvGuideOsd::drawGridsTimeJump() {

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

+	}

+}

+

+void cTvGuideOsd::setNextActiveGrid(cEpgGrid *next) {

+	if (!next || !activeGrid) {

+		return;

+	}

+	activeGrid->SetInActive();

+	activeGrid->Draw();	

+	activeGrid = next;

+	activeGrid->SetActive();

+	activeGrid->Draw();

+}

+

+void cTvGuideOsd::processKeyUp() {

+	if (detailViewActive) {

+		detailView->scrollUp();

+	} else {

+		if (activeGrid == NULL) {

+			ScrollBack();

+			//Search for new active Grid

+			cEpgGrid *actGrid = NULL;

+			for (cChannelColumn *column = columns.First(); column; column = columns.Next(column)) {

+				actGrid = column->getActive();

+				if (actGrid) {

+					activeGrid = actGrid;

+					activeGrid->SetActive();

+					activeGrid->Draw();

+					break;

+				}

+			}

+		} else if (activeGrid->StartTime() <= myTime->GetStart()) {

+			activeGrid->debug();

+			ScrollBack();

+		} else {

+			cEpgGrid *prev = NULL;

+			prev = activeGrid->column->getPrev(activeGrid);

+			if (prev) {

+				setNextActiveGrid(prev);

+			} else {

+				ScrollBack();

+				prev = activeGrid->column->getPrev(activeGrid);

+				if (prev) {

+					setNextActiveGrid(prev);

+				}

+			}

+		}

+	}

+	osdManager.flush();

+}

+

+void cTvGuideOsd::processKeyDown() {

+	if (detailViewActive) {

+		detailView->scrollDown();

+	} else {

+		if (activeGrid == NULL) {

+			ScrollForward();

+		} else if (activeGrid->EndTime() > myTime->GetStop()) {

+			ScrollForward();

+		} else {

+			cEpgGrid *next = NULL;

+			next = activeGrid->column->getNext(activeGrid);

+			if (next) {

+				setNextActiveGrid(next);

+			} else {

+				ScrollForward();

+				next = activeGrid->column->getNext(activeGrid);

+				if (next) {

+					setNextActiveGrid(next);

+				}

+			}

+		}

+	}

+	osdManager.flush();

+}

+

+void cTvGuideOsd::ScrollForward() {

+	myTime->AddStep(tvguideConfig.stepMinutes);

+	timeLine->drawDateViewer();

+	timeLine->drawClock();

+	timeLine->setTimeline();

+	for (cChannelColumn *column = columns.First(); column; column = columns.Next(column)) {

+		column->AddNewGridsAtEnd();

+		column->ClearOutdatedStart();

+		column->drawGrids();

+	}

+}

+

+void cTvGuideOsd::ScrollBack() {

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

+	}	

+}

+

+void cTvGuideOsd::processKeyLeft() {

+	if (detailViewActive)

+		return;

+	if (activeGrid == NULL)

+		return;

+	cChannelColumn *colLeft = columns.Prev(activeGrid->column);

+	if (!colLeft) {

+		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) {

+			if (columns.Count() == tvguideConfig.channelCols) {

+				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) {

+		cEpgGrid *left = colLeft->getNeighbor(activeGrid);

+		if (left) {

+			setNextActiveGrid(left);

+		}

+	}

+	osdManager.flush();

+}

+

+void cTvGuideOsd::processKeyRight() {

+	if (detailViewActive)

+		return;

+	if (activeGrid == NULL)

+		return;

+	cChannelColumn *colRight = columns.Next(activeGrid->column);

+	if (!colRight) {

+		cChannel *channelRight = activeGrid->column->getChannel();

+		while (channelRight = Channels.Next(channelRight)) {

+			if (!channelRight->GroupSep()) {

+				colRight = new cChannelColumn(tvguideConfig.channelCols - 1, channelRight, myTime);

+				if (colRight->readGrids()) {

+					break;

+				} else {

+					delete colRight;

+					colRight = NULL;

+				}

+			}

+		}

+		if (colRight) {

+			if (columns.Count() == tvguideConfig.channelCols) {

+				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) {

+		cEpgGrid *right = colRight->getNeighbor(activeGrid);

+		if (right) {

+			setNextActiveGrid(right);

+		}

+	}

+	osdManager.flush();

+}

+

+void cTvGuideOsd::processKeyOk() {

+	if (detailViewActive) {

+		delete detailView;

+		detailView = NULL;

+		detailViewActive = false;

+		osdManager.flush();

+	} else {

+		detailViewActive = true;

+		detailView = new cDetailView(activeGrid);

+		detailView->Start();

+	}

+}

+

+void cTvGuideOsd::processKeyRed() {

+	if (activeGrid == NULL)

+		return;

+    cTimer *timer = new cTimer(activeGrid->GetEvent());

+    cTimer *t = Timers.GetTimer(timer);

+	cString msg;

+	if (t) {

+        isyslog("timer %s already exists", *timer->ToDescr());

+		delete timer;

+		msg = cString::sprintf(tr("Timer not set! There is already a timer for this item."));

+    } else {

+        Timers.Add(timer);

+        Timers.SetModified();

+		msg = cString::sprintf("%s:\n%s (%s) %s - %s", tr("Timer set"), activeGrid->GetEvent()->Title(), timer->Channel()->Name(), *DayDateTime(timer->StartTime()), *TimeString(timer->StopTime()));

+		timer->SetEvent(activeGrid->GetEvent());

+		activeGrid->setTimer();

+		activeGrid->column->setTimer();

+		activeGrid->SetDirty();

+		activeGrid->Draw();

+		osdManager.flush();

+        isyslog("timer %s added (active)", *timer->ToDescr());

+    }

+	cMessageBox::Start(4000, msg);

+}

+

+void cTvGuideOsd::processKeyGreen() {

+	if (activeGrid == NULL)

+		return;

+	cChannel *currentChannel = activeGrid->column->getChannel();

+	bool doUpdate = readChannelsReverse(currentChannel);

+	if (doUpdate && (columns.Count() > 0)) {

+		drawGridsChannelJump();

+	}

+	osdManager.flush();

+}

+

+void cTvGuideOsd::processKeyYellow() {

+	if (activeGrid == NULL)

+		return;

+	cChannel *currentChannel = activeGrid->column->getChannel();

+	cChannel *next = NULL;

+	int i=0;

+	for (cChannel *channel = currentChannel; channel; channel = Channels.Next(channel)) {

+		if (!channel->GroupSep()) {

+			next = channel;

+			i++;

+		}

+		if (i == (tvguideConfig.jumpChannels+1))

+			break;

+    }

+	if (next) {

+		readChannels(next);

+		if (columns.Count() > 0) {

+			drawGridsChannelJump();

+		}

+		osdManager.flush();

+	}

+}

+

+eOSState cTvGuideOsd::processKeyBlue() {

+	if (activeGrid == NULL)

+		return osContinue;

+	cChannel *currentChannel = activeGrid->column->getChannel();

+	if (currentChannel) {

+		cDevice::PrimaryDevice()->SwitchChannel(currentChannel, true);

+		return osEnd;

+	}

+	return osContinue;

+}

+

+void cTvGuideOsd::processKey1() {

+	bool tooFarInPast = myTime->DelStep(tvguideConfig.bigStepHours*60);

+	if (tooFarInPast)

+		return;

+	drawGridsTimeJump();

+	timeLine->drawDateViewer();

+	timeLine->drawClock();

+	timeLine->setTimeline();

+	osdManager.flush();

+}

+

+void cTvGuideOsd::processKey3() {

+	myTime->AddStep(tvguideConfig.bigStepHours*60);

+	drawGridsTimeJump();

+	timeLine->drawDateViewer();

+	timeLine->drawClock();

+	timeLine->setTimeline();

+	osdManager.flush();

+}

+

+void cTvGuideOsd::processKey4() {

+	bool tooFarInPast = myTime->DelStep(tvguideConfig.hugeStepHours*60);

+	if (tooFarInPast)

+		return;

+	drawGridsTimeJump();

+	timeLine->drawDateViewer();

+	timeLine->drawClock();

+	timeLine->setTimeline();

+	osdManager.flush();

+}

+

+void cTvGuideOsd::processKey6() {

+	myTime->AddStep(tvguideConfig.hugeStepHours*60);

+	drawGridsTimeJump();

+	timeLine->drawDateViewer();

+	timeLine->drawClock();

+	timeLine->setTimeline();

+	osdManager.flush();

+}

+

+void cTvGuideOsd::processKey7() {

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

+}

+

+void cTvGuideOsd::processKey9() {

+	cMyTime *primeChecker = new cMyTime();

+	time_t nextPrime = primeChecker->getNextPrimetime(myTime->GetStart());

+	myTime->SetTime(nextPrime);

+	drawGridsTimeJump();

+	timeLine->drawDateViewer();

+	timeLine->drawClock();

+	timeLine->setTimeline();

+	osdManager.flush();

+}

+

+eOSState cTvGuideOsd::ProcessKey(eKeys Key) {

+	eOSState state = cOsdObject::ProcessKey(Key);

+	if (state == osUnknown) {

+		cPixmap::Lock();

+		state = osContinue;

+		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:     	processKeyOk(); break;

+			case kBack:	 	state=osEnd; break;

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

+		}

+		cPixmap::Unlock();

+	}

+	return state;

+}
\ No newline at end of file