frodovdr/vdr-plugin-tvguide
1
0
Fork 0
mirror of https://projects.vdr-developer.org/git/vdr-plugin-tvguide.git synced 2023-10-05 13:01:48 +00:00
Code Issues Releases Wiki Activity

Change cGrid to cGridElement

Browse Source
This commit is contained in:
kamel5
2019-07-11 15:06:07 +02:00
parent 5ff172c987
commit d21b1496f0
14 changed files with 63 additions and 63 deletions
Download Patch File Download Diff File Expand all files Collapse all files

48
channelepg.c
View File

@@ -115,7 +115,7 @@ bool cChannelEpg::readGrids() {
}
void cChannelEpg::drawGrids() {
for (cGrid *grid = grids.First(); grid; grid = grids.Next(grid)) {
for (cGridElement *grid = grids.First(); grid; grid = grids.Next(grid)) {
grid->SetViewportHeight();
grid->PositionPixmap();
grid->Draw();
@@ -130,41 +130,41 @@ int cChannelEpg::getY() {
return geoManager.statusHeaderHeight + geoManager.timeLineHeight + num*geoManager.rowHeight;
}
cGrid * cChannelEpg::getActive() {
cGridElement *cChannelEpg::getActive() {
cTimeManager t;
t.Now();
for (cGrid *grid = grids.First(); grid; grid = grids.Next(grid)) {
for (cGridElement *grid = grids.First(); grid; grid = grids.Next(grid)) {
if (grid->Match(t.Get()))
return grid;
}
return grids.First();
}
cGrid * cChannelEpg::getNext(cGrid *activeGrid) {
cGridElement *cChannelEpg::getNext(cGridElement *activeGrid) {
if (activeGrid == NULL)
return NULL;
cGrid *next = grids.Next(activeGrid);
cGridElement *next = grids.Next(activeGrid);
if (next)
return next;
return NULL;
}
cGrid * cChannelEpg::getPrev(cGrid *activeGrid) {
cGridElement *cChannelEpg::getPrev(cGridElement *activeGrid) {
if (activeGrid == NULL)
return NULL;
cGrid *prev = grids.Prev(activeGrid);
cGridElement *prev = grids.Prev(activeGrid);
if (prev)
return prev;
return NULL;
}
cGrid * cChannelEpg::getNeighbor(cGrid *activeGrid) {
cGridElement *cChannelEpg::getNeighbor(cGridElement *activeGrid) {
if (!activeGrid)
return NULL;
cGrid *neighbor = NULL;
cGridElement *neighbor = NULL;
int overlap = 0;
int overlapNew = 0;
cGrid *grid = NULL;
cGridElement *grid = NULL;
grid = grids.First();
if (grid) {
for (; grid; grid = grids.Next(grid)) {
@@ -184,14 +184,14 @@ cGrid * cChannelEpg::getNeighbor(cGrid *activeGrid) {
return neighbor;
}
bool cChannelEpg::isFirst(cGrid *grid) {
bool cChannelEpg::isFirst(cGridElement *grid) {
if (grid == grids.First())
return true;
return false;
}
void cChannelEpg::AddNewGridsAtStart() {
cGrid *firstGrid = NULL;
cGridElement *firstGrid = NULL;
firstGrid = grids.First();
if (firstGrid == NULL)
return;
@@ -226,7 +226,7 @@ void cChannelEpg::AddNewGridsAtStart() {
if (event->EndTime() < timeManager->GetStart()) {
break;
}
cGrid *grid = addEpgGrid(event, firstGrid, col);
cGridElement *grid = addEpgGrid(event, firstGrid, col);
col = !col;
firstGrid = grid;
if (event->StartTime() <= timeManager->GetStart()) {
@@ -247,7 +247,7 @@ void cChannelEpg::AddNewGridsAtStart() {
}
void cChannelEpg::AddNewGridsAtEnd() {
cGrid *lastGrid = NULL;
cGridElement *lastGrid = NULL;
lastGrid = grids.Last();
if (lastGrid == NULL)
return;
@@ -302,7 +302,7 @@ void cChannelEpg::AddNewGridsAtEnd() {
}
void cChannelEpg::ClearOutdatedStart() {
cGrid *firstGrid = NULL;
cGridElement *firstGrid = NULL;
while (true) {
firstGrid = grids.First();
if (!firstGrid)
@@ -313,7 +313,7 @@ void cChannelEpg::ClearOutdatedStart() {
} else {
if (firstGrid->isDummy()) {
firstGrid->SetStartTime(timeManager->GetStart());
cGrid *next = getNext(firstGrid);
cGridElement *next = getNext(firstGrid);
if (next) {
firstGrid->SetEndTime(next->StartTime());
} else {
@@ -326,7 +326,7 @@ void cChannelEpg::ClearOutdatedStart() {
}
void cChannelEpg::ClearOutdatedEnd() {
cGrid *lastGrid = NULL;
cGridElement *lastGrid = NULL;
while (true) {
lastGrid = grids.Last();
if (!lastGrid)
@@ -337,7 +337,7 @@ void cChannelEpg::ClearOutdatedEnd() {
} else {
if (lastGrid->isDummy()) {
lastGrid->SetEndTime(timeManager->GetEnd());
cGrid *prev = getPrev(lastGrid);
cGridElement *prev = getPrev(lastGrid);
if (prev) {
lastGrid->SetStartTime(prev->EndTime());
} else {
@@ -349,8 +349,8 @@ void cChannelEpg::ClearOutdatedEnd() {
}
}
cGrid *cChannelEpg::addEpgGrid(const cEvent *event, cGrid *firstGrid, bool color) {
cGrid *grid = new cEpgGrid(this, event);
cGridElement *cChannelEpg::addEpgGrid(const cEvent *event, cGridElement *firstGrid, bool color) {
cGridElement *grid = new cEpgGrid(this, event);
grid->setText();
grid->SetColor(color);
if (!firstGrid)
@@ -360,8 +360,8 @@ cGrid *cChannelEpg::addEpgGrid(const cEvent *event, cGrid *firstGrid, bool color
return grid;
}
cGrid *cChannelEpg::addDummyGrid(time_t start, time_t end, cGrid *firstGrid, bool color) {
cGrid *dummy = new cDummyGrid(this, start, end);
cGridElement *cChannelEpg::addDummyGrid(time_t start, time_t end, cGridElement *firstGrid, bool color) {
cGridElement *dummy = new cDummyGrid(this, start, end);
dummy->setText();
dummy->SetColor(color);
if (!firstGrid)
@@ -376,7 +376,7 @@ void cChannelEpg::SetTimers() {
hasTimer = channel->HasTimer();
#endif
hasSwitchTimer = SwitchTimers.ChannelInSwitchList(channel);
for (cGrid *grid = grids.First(); grid; grid = grids.Next(grid)) {
for (cGridElement *grid = grids.First(); grid; grid = grids.Next(grid)) {
bool gridHadTimer = grid->HasTimer();
grid->SetTimer();
if (gridHadTimer || gridHadTimer != grid->HasTimer())
@@ -392,7 +392,7 @@ void cChannelEpg::SetTimers() {
void cChannelEpg::dumpGrids() {
esyslog("tvguide: ------Channel %s %d: %d entires ---------", channel->Name(), num, grids.Count());
int i=1;
for (cGrid *grid = grids.First(); grid; grid = grids.Next(grid)) {
for (cGridElement *grid = grids.First(); grid; grid = grids.Next(grid)) {
esyslog("tvguide: grid %d: start: %s, stop: %s", i, *cTimeManager::printTime(grid->StartTime()), *cTimeManager::printTime(grid->EndTime()));
i++;
}

18
channelepg.h
View File

@@ -7,7 +7,7 @@
#include "headergrid.h"
#include "switchtimer.h"
class cGrid;
class cGridElement;
class cEpgGrid;
class cHeaderGrid;
@@ -19,7 +19,7 @@ private:
int num;
const cChannel *channel;
cHeaderGrid *header;
cList<cGrid> grids;
cList<cGridElement> grids;
#if VDRVERSNUM >= 20301
#else
cSchedulesLock *schedulesLock;
@@ -27,8 +27,8 @@ private:
const cSchedules *schedules;
bool hasTimer;
bool hasSwitchTimer;
cGrid *addEpgGrid(const cEvent *event, cGrid *firstGrid, bool color);
cGrid *addDummyGrid(time_t start, time_t end, cGrid *firstGrid, bool color);
cGridElement *addEpgGrid(const cEvent *event, cGridElement *firstGrid, bool color);
cGridElement *addDummyGrid(time_t start, time_t end, cGridElement *firstGrid, bool color);
public:
cChannelEpg(int num, const cChannel *channel, cTimeManager *timeManager);
virtual ~cChannelEpg(void);
@@ -42,11 +42,11 @@ public:
int Stop() { return timeManager->GetEnd(); };
const char* Name() { return channel->Name(); };
const cChannel *getChannel() {return channel;}
cGrid * getActive();
cGrid * getNext(cGrid *activeGrid);
cGrid * getPrev(cGrid *activeGrid);
cGrid * getNeighbor(cGrid *activeGrid);
bool isFirst(cGrid *grid);
cGridElement *getActive();
cGridElement *getNext(cGridElement *activeGrid);
cGridElement *getPrev(cGridElement *activeGrid);
cGridElement *getNeighbor(cGridElement *activeGrid);
bool isFirst(cGridElement *grid);
void AddNewGridsAtStart();
void AddNewGridsAtEnd();
void ClearOutdatedStart();

2
dummygrid.c
View File

@@ -1,6 +1,6 @@
#include "dummygrid.h"
cDummyGrid::cDummyGrid(cChannelEpg *c, time_t start, time_t end) : cGrid(c) {
cDummyGrid::cDummyGrid(cChannelEpg *c, time_t start, time_t end) : cGridElement(c) {
this->start = start;
this->end = end;
strText = tr("No EPG Information available");

4
dummygrid.h
View File

@@ -6,7 +6,7 @@
// --- cDummyGrid -------------------------------------------------------------
class cDummyGrid : public cGrid {
class cDummyGrid : public cGridElement {
private:
time_t start;
time_t end;
@@ -24,7 +24,7 @@ public:
time_t EndTime() { return end; };
void SetStartTime(time_t start) { this->start = start; };
void SetEndTime(time_t end) { this->end = end; };
int calcOverlap(cGrid *neighbor);
int calcOverlap(cGridElement *neighbor);
void setTimer() {};
cString getText(void);
cString getTimeString(void);

2
epggrid.c
View File

@@ -3,7 +3,7 @@
#include "tools.h"
#include "epggrid.h"
cEpgGrid::cEpgGrid(cChannelEpg *c, const cEvent *event) : cGrid(c) {
cEpgGrid::cEpgGrid(cChannelEpg *c, const cEvent *event) : cGridElement(c) {
this->event = event;
extText = new cTextWrapper();
hasTimer = false;

2
epggrid.h
View File

@@ -6,7 +6,7 @@
// --- cEpgGrid -------------------------------------------------------------
class cEpgGrid : public cGrid {
class cEpgGrid : public cGridElement {
private:
const cTimer *timer;
const cEvent *event;

16
grid.c
View File

@@ -1,7 +1,7 @@
#include "channelepg.h"
#include "grid.h"
cGrid::cGrid(cChannelEpg *c) {
cGridElement::cGridElement(cChannelEpg *c) {
this->column = c;
text = new cTextWrapper();
dirty = true;
@@ -10,11 +10,11 @@ cGrid::cGrid(cChannelEpg *c) {
borderWidth = 10;
}
cGrid::~cGrid(void) {
cGridElement::~cGridElement(void) {
delete text;
}
void cGrid::setBackground() {
void cGridElement::setBackground() {
if (active) {
color = theme.Color(clrHighlight);
colorBlending = theme.Color(clrHighlightBlending);
@@ -29,7 +29,7 @@ void cGrid::setBackground() {
}
}
void cGrid::Draw() {
void cGridElement::Draw() {
if (!pixmap) {
return;
}
@@ -48,20 +48,20 @@ void cGrid::Draw() {
}
}
bool cGrid::isFirst(void) {
bool cGridElement::isFirst(void) {
if (column->isFirst(this))
return true;
return false;
}
bool cGrid::Match(time_t t) {
bool cGridElement::Match(time_t t) {
if ((StartTime() < t) && (EndTime() > t))
return true;
else
return false;
}
int cGrid::calcOverlap(cGrid *neighbor) {
int cGridElement::calcOverlap(cGridElement *neighbor) {
int overlap = 0;
if (intersects(neighbor)) {
if ((StartTime() <= neighbor->StartTime()) && (EndTime() <= neighbor->EndTime())) {
@@ -77,6 +77,6 @@ int cGrid::calcOverlap(cGrid *neighbor) {
return overlap;
}
bool cGrid::intersects(cGrid *neighbor) {
bool cGridElement::intersects(cGridElement *neighbor) {
return ! ( (neighbor->EndTime() <= StartTime()) || (neighbor->StartTime() >= EndTime()) );
}

10
grid.h
View File

@@ -8,7 +8,7 @@ class cChannelEpg;
// --- cEpgGrid -------------------------------------------------------------
class cGrid : public cListObject, public cStyledPixmap {
class cGridElement : public cListObject, public cStyledPixmap {
protected:
cTextWrapper *text;
int viewportHeight;
@@ -19,13 +19,13 @@ protected:
bool dirty;
bool hasTimer;
bool hasSwitchTimer;
bool intersects(cGrid *neighbor);
bool intersects(cGridElement *neighbor);
virtual time_t Duration(void) { return 0; };
virtual void drawText(void) {};
bool dummy;
public:
cGrid(cChannelEpg *c);
virtual ~cGrid(void);
cGridElement(cChannelEpg *c);
virtual ~cGridElement(void);
cChannelEpg *column;
virtual void SetViewportHeight(void) {};
virtual void PositionPixmap(void) {};
@@ -43,7 +43,7 @@ public:
virtual time_t EndTime(void) { return 0; };
virtual void SetStartTime(time_t start) {};
virtual void SetEndTime(time_t end) {};
int calcOverlap(cGrid *neighbor);
int calcOverlap(cGridElement *neighbor);
virtual void SetTimer(void) {};
virtual void SetSwitchTimer(void) {};
virtual cString getText(void) { return cString("");};

2
headergrid.c
View File

@@ -2,7 +2,7 @@
#include "tools.h"
#include "headergrid.h"
cHeaderGrid::cHeaderGrid(void) : cGrid(NULL) {
cHeaderGrid::cHeaderGrid(void) : cGridElement(NULL) {
pixmap = NULL;
pixmapLogo = NULL;
}

2
headergrid.h
View File

@@ -5,7 +5,7 @@
// --- cHeaderGrid -------------------------------------------------------------
class cHeaderGrid : public cGrid {
class cHeaderGrid : public cGridElement {
private:
cPixmap *pixmapLogo;
void drawChannelHorizontal(const cChannel *channel);

2
statusheader.c
View File

@@ -55,7 +55,7 @@ void cStatusHeader::ScaleVideo(void) {
}
}
void cStatusHeader::DrawInfoText(cGrid *grid) {
void cStatusHeader::DrawInfoText(cGridElement *grid) {
int border = 10;
int textWidth = 0;
textWidth = width - 2 * border;

2
statusheader.h
View File

@@ -19,7 +19,7 @@ public:
virtual ~cStatusHeader(void);
void Draw(void);
void ScaleVideo(void);
void DrawInfoText(cGrid *grid);
void DrawInfoText(cGridElement *grid);
};
#endif //__TVGUIDE_STATUSHEADER_H

10
tvguideosd.c
View File

@@ -219,7 +219,7 @@ void cTvGuideOsd::drawGridsTimeJump() {
}
}
void cTvGuideOsd::setNextActiveGrid(cGrid *next) {
void cTvGuideOsd::setNextActiveGrid(cGridElement *next) {
if (!next || !activeGrid) {
return;
}
@@ -278,7 +278,7 @@ void cTvGuideOsd::channelForward() {
}
}
if (colRight) {
cGrid *right = colRight->getNeighbor(activeGrid);
cGridElement *right = colRight->getNeighbor(activeGrid);
if (right) {
setNextActiveGrid(right);
}
@@ -335,7 +335,7 @@ void cTvGuideOsd::channelBack() {
}
if (colLeft) {
cGrid *left = colLeft->getNeighbor(activeGrid);
cGridElement *left = colLeft->getNeighbor(activeGrid);
if (left) {
setNextActiveGrid(left);
}
@@ -356,7 +356,7 @@ void cTvGuideOsd::timeForward() {
ScrollForward();
actionDone = true;
}
cGrid *next = activeGrid->column->getNext(activeGrid);
cGridElement *next = activeGrid->column->getNext(activeGrid);
if (next) {
if ( (next->EndTime() < timeManager->GetEnd())
|| ( (timeManager->GetEnd() - next->StartTime())/60 > 30 ) ) {
@@ -388,7 +388,7 @@ void cTvGuideOsd::timeBack() {
ScrollBack();
actionDone = true;
}
cGrid *prev = activeGrid->column->getPrev(activeGrid);
cGridElement *prev = activeGrid->column->getPrev(activeGrid);
if (prev) {
if ( (prev->StartTime() > timeManager->GetStart())
|| ( (prev->EndTime() - timeManager->GetStart())/60 > 30 )

4
tvguideosd.h
View File

@@ -18,7 +18,7 @@ class cTvGuideOsd : public cOsdObject {
private:
cTimeManager *timeManager;
cList<cChannelEpg> columns;
cGrid *activeGrid;
cGridElement *activeGrid;
cStatusHeader *statusHeader;
cDetailView *detailView;
cTimeLine *timeLine;
@@ -45,7 +45,7 @@ private:
void TimeJump(int mode);
void ChannelJump(int num);
void CheckTimeout(void);
void setNextActiveGrid(cGrid *next);
void setNextActiveGrid(cGridElement *next);
void channelForward();
void channelBack();
void timeForward();