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

Merge remote-tracking branch 'upstream/master'

Browse Source
This commit is contained in:
Peter Bieringer
2021-03-01 07:25:50 +01:00
parent 764f657620 402044d4c4
commit 105fe893a2
28 changed files with 662 additions and 130 deletions
Download Patch File Download Diff File Expand all files Collapse all files

32
coreengine/definitions.h
View File

@@ -129,6 +129,7 @@ enum class eVeDisplayReplay {
recinfo,
currenttime,
totaltime,
timeshifttimes,
endtime,
progressbar,
cutmarks,
@@ -433,6 +434,7 @@ enum class eDCProgressBarIT {
remaining,
permashift,
livebuffer,
currentremaining,
count
};
@@ -813,6 +815,7 @@ enum class eLeMenuDefaultIT {
remoteosd,
filebrowser,
epgsearch,
devstatus,
count
};
@@ -1489,6 +1492,13 @@ enum class eDRRecTitleST {
recsubtitle,
recdate,
rectime,
eventstart,
eventstop,
count
};
enum class eDRRecTitleIT {
timeshift = 0,
count
};
@@ -1513,6 +1523,11 @@ enum class eDRCurrentTimeST {
count
};
enum class eDRCurrentTimeIT {
timeshift = 0,
count
};
enum class eDRTotalTimeST {
rectotal = 0,
timeshifttotal,
@@ -1524,11 +1539,28 @@ enum class eDRTotalTimeIT {
count
};
enum class eDRTimeshiftTimesST {
recstart = 0,
playbacktime,
timeshiftrest,
count
};
enum class eDRTimeshiftTimesIT {
timeshift = 0,
count
};
enum class eDREndTimeST {
recend = 0,
count
};
enum class eDREndTimeIT {
timeshift = 0,
count
};
enum class eDRProgressbarIT {
current = 0,
total,

4
coreengine/listelements.c
View File

@@ -304,6 +304,7 @@ void cLeMenuDefault::SetTokenContainer(void) {
tokenContainer->DefineIntToken("{remoteosd}", (int)eLeMenuDefaultIT::remoteosd);
tokenContainer->DefineIntToken("{filebrowser}", (int)eLeMenuDefaultIT::filebrowser);
tokenContainer->DefineIntToken("{epgsearch}", (int)eLeMenuDefaultIT::epgsearch);
tokenContainer->DefineIntToken("{devstatus}", (int)eLeMenuDefaultIT::devstatus);
InheritTokenContainer();
}
@@ -430,6 +431,8 @@ void cLeMenuDefault::SetMenuCategory(void) {
tokenContainer->AddIntToken((int)eLeMenuDefaultIT::filebrowser, 1);
} else if (!strcmp(plugName, "epgsearch")) {
tokenContainer->AddIntToken((int)eLeMenuDefaultIT::epgsearch, 1);
} else if (!strcmp(plugName, "devstatus")) {
tokenContainer->AddIntToken((int)eLeMenuDefaultIT::devstatus, 1);
}
}
@@ -968,6 +971,7 @@ bool cCeMenuSchedules::Parse(bool forced) {
}
tokenContainer->AddIntToken((int)eCeMenuSchedulesIT::duration, event->Duration() / 60);
tokenContainer->AddIntToken((int)eCeMenuSchedulesIT::durationhours, event->Duration() / 3600);
tokenContainer->AddIntToken((int)eCeMenuSchedulesIT::durationminutes, (event->Duration() / 60) % 60);
if (timerMatch == tmFull || timerMatch == tmPartial) {
cTimer_Detail_V1 data;

142
coreengine/viewdisplayreplay.c
View File

@@ -6,6 +6,7 @@
cViewReplay::cViewReplay(void) {
veCustomTokens = NULL;
veTimeshiftTimes = NULL;
veEndTime = NULL;
veMessage = NULL;
veScraperContent = NULL;
@@ -45,6 +46,7 @@ void cViewReplay::SetViewElements(void) {
viewElementNames.insert(pair<string, int>("rectitle", (int)eVeDisplayReplay::rectitle));
viewElementNames.insert(pair<string, int>("recinfo", (int)eVeDisplayReplay::recinfo));
viewElementNames.insert(pair<string, int>("currenttime", (int)eVeDisplayReplay::currenttime));
viewElementNames.insert(pair<string, int>("timeshifttimes", (int)eVeDisplayReplay::timeshifttimes));
viewElementNames.insert(pair<string, int>("endtime", (int)eVeDisplayReplay::endtime));
viewElementNames.insert(pair<string, int>("totaltime", (int)eVeDisplayReplay::totaltime));
viewElementNames.insert(pair<string, int>("progressbar", (int)eVeDisplayReplay::progressbar));
@@ -92,6 +94,10 @@ void cViewReplay::SetViewElementObjects(void) {
{
veTotalTime = dynamic_cast<cVeDrTotalTime*>(viewElements[i]);
}
else if (dynamic_cast<cVeDrTimeshiftTimes*>(viewElements[i]))
{
veTimeshiftTimes = dynamic_cast<cVeDrTimeshiftTimes*>(viewElements[i]);
}
else if (dynamic_cast<cVeDrEndTime*>(viewElements[i]))
{
veEndTime = dynamic_cast<cVeDrEndTime*>(viewElements[i]);
@@ -142,17 +148,21 @@ void cViewReplay::PreCache(void) {
void cViewReplay::ClearVariables(void) {
cView::ClearVariables();
recording = NULL;
lastEvent = NULL;
modeOnly = false;
lastFlush = 0;
lastFlushModeOnly = 0;
message = false;
reclength = -1;
timeShiftActive = false;
timeShiftFramesTotal = -1;
timeShiftLength = -1;
timeShiftDuration = "";
timeshiftrest = "";
if (veCustomTokens)
veCustomTokens->Reset();
if (veTimeshiftTimes)
veTimeshiftTimes->Set(cString(""), cString(""), cString(""));
if (veEndTime)
veEndTime->Set(cString(""));
if (veCutMarks)
@@ -161,16 +171,73 @@ void cViewReplay::ClearVariables(void) {
globalTimers.ClearTimers();
}
void cViewReplay::SetTimeShift(int framesTotal, int timeShiftLength) {
timeShiftActive = true;
timeShiftFramesTotal = framesTotal;
this->timeShiftLength = timeShiftLength;
void cViewReplay::GetGlobalTimers(void) {
if (!timersLoaded) {
timersLoaded = true;
globalTimers.LoadTimers();
}
}
void cViewReplay::SetTimeShiftValues(int current, int total) {
if (!recording)
return;
const char *recName = recording->Name();
if (recName && *recName != '@')
return;
timeShiftActive = false;
#if APIVERSNUM >= 20101
int usage = recording->IsInUse();
if (usage & ruTimer)
timeShiftActive = true;
else {
GetGlobalTimers();
if (globalTimers.IsRecording(recording))
timeShiftActive = true;
}
#endif
if (!timeShiftActive)
return;
const cRecordingInfo *recInfo = recording->Info();
if (!recInfo)
return;
const cSchedule *Schedule = NULL;
{
LOCK_SCHEDULES_READ;
Schedule = Schedules->GetSchedule(recInfo->ChannelID());
}
if (!Schedule)
return;
// Get event at actual recording position
const cEvent *eventEnde = Schedule->GetEventAround(time(0));
if (!eventEnde)
return;
// End of live program
time_t liveEventStop = eventEnde->EndTime();
// Begin of timeshift recording
time_t recordingStart = time(0) - recording->LengthInSeconds();
// actual timeshiftlength in sec
timeShiftLength = liveEventStop - recordingStart;
// timeshiftlength until end of live program
timeShiftFramesTotal = total * ((double)timeShiftLength / (double)recording->LengthInSeconds());
// Get event at actual replay position (add 30sec for a better match)
int timeShiftSecondsAfter = (int)(recording->LengthInSeconds() * (1.0 - (double)current / (double)total)) + 30;
const cEvent *eventReplay = Schedule->GetEventAround(time(0) - timeShiftSecondsAfter);
// Display title at replay position
if (eventReplay && eventReplay != lastEvent && veRecTitle) {
veRecTitle->Set(recording, eventReplay, true);
veRecTitle->Parse();
lastEvent = eventReplay;
}
int mins = (timeShiftLength / 60) % 60;
int hours = (timeShiftLength / 3600) % 24;
timeShiftDuration = cString::sprintf("%d:%02d", hours, mins);
mins = (timeShiftSecondsAfter / 60) % 60;
hours = (timeShiftSecondsAfter / 3600) % 24;
timeshiftrest = cString::sprintf("%d:%02d", hours, mins);
}
void cViewReplay::SetRecording(const cRecording *recording) {
this->recording = recording;
if (veRecTitle) {
veRecTitle->Set(recording);
}
@@ -182,46 +249,6 @@ void cViewReplay::SetRecording(const cRecording *recording) {
}
}
void cViewReplay::GetTimers(void) {
if (!timersLoaded) {
timersLoaded = true;
globalTimers.LoadTimers();
}
}
void cViewReplay::SetTimeShiftValues(const cRecording *recording) {
//check for instant recording
if (!recording)
return;
const char *recName = recording->Name();
if (recName && *recName == '@')
return;
bool isTimeShift = false;
#if APIVERSNUM >= 20101
int usage = recording->IsInUse();
if (usage & ruTimer)
isTimeShift = true;
else {
if (globalTimers.IsRecording(recording))
isTimeShift = true;
}
#endif
if (!isTimeShift)
return;
const cRecordingInfo *recInfo = recording->Info();
if (!recInfo)
return;
const cEvent *event = recInfo->GetEvent();
if (!event)
return;
double fps = recording->FramesPerSecond();
time_t liveEventStop = event->EndTime();
time_t recordingStart = time(0) - recording->LengthInSeconds();
int framesTotal = (liveEventStop - recordingStart)*fps;
int recLength = liveEventStop - recordingStart;
SetTimeShift(framesTotal, recLength);
}
void cViewReplay::SetTitle(const char *title) {
if (veRecTitle) {
veRecTitle->Set(title);
@@ -236,32 +263,47 @@ void cViewReplay::SetTitle(const char *title) {
void cViewReplay::SetCurrent(const char *current) {
if (veCurrentTime)
veCurrentTime->Set(current);
veCurrentTime->Set(current, timeShiftActive);
Render((int)eVeDisplayReplay::currenttime);
}
void cViewReplay::SetTotal(const char *total) {
if (veTotalTime)
veTotalTime->Set(total, timeShiftActive, *timeShiftDuration);
veTotalTime->Set(total, *timeShiftDuration, timeShiftActive);
Render((int)eVeDisplayReplay::totaltime);
}
void cViewReplay::SetTimeshiftTimes(int current, int total) {
if (!veTimeshiftTimes || !recording)
return;
time_t recordingStart = 0;
time_t playbackTime = 0;
if (timeShiftActive) {
recordingStart = time(0) - recording->LengthInSeconds();
playbackTime = time(0) - (int)(recording->LengthInSeconds() * (1.0 - (double)current / (double)total));
} else
recordingStart = recording->Start();
veTimeshiftTimes->Set(TimeString(recordingStart), TimeString(playbackTime), timeshiftrest, timeShiftActive);
Render((int)eVeDisplayReplay::timeshifttimes);
}
void cViewReplay::SetEndTime(int current, int total) {
if (!veEndTime || reclength == 0)
if (!veEndTime || !recording)
return;
int totalLength = total;
int recordingLength = reclength;
int recordingLength = recording->LengthInSeconds();
if (timeShiftActive && timeShiftFramesTotal > 0) {
totalLength = timeShiftFramesTotal;
recordingLength = timeShiftLength;
}
double rest = (double)(totalLength - current) / (double)totalLength;
time_t end = time(0) + rest * recordingLength;
veEndTime->Set(TimeString(end));
veEndTime->Set(TimeString(end), timeShiftActive);
Render((int)eVeDisplayReplay::endtime);
}
void cViewReplay::SetProgressbar(int current, int total) {
SetTimeShiftValues(current, total);
if (veProgressbar)
veProgressbar->Set(current, total, timeShiftActive, timeShiftFramesTotal);
Render((int)eVeDisplayReplay::progressbar);

11
coreengine/viewdisplayreplay.h
View File

@@ -12,6 +12,7 @@ private:
cVeDrScraperContent *veScraperContent;
cVeDrCurrentTime *veCurrentTime;
cVeDrTotalTime *veTotalTime;
cVeDrTimeshiftTimes *veTimeshiftTimes;
cVeDrEndTime *veEndTime;
cVeDrProgressBar *veProgressbar;
cVeDrCutMarks *veCutMarks;
@@ -21,6 +22,8 @@ private:
cVeDrJump *veJump;
cVeDrOnPause *veOnPause;
cVeDrOnPause *veOnPauseModeOnly;
const cRecording *recording;
const cEvent *lastEvent;
bool modeOnly;
time_t lastFlush;
time_t lastFlushModeOnly;
@@ -29,9 +32,11 @@ private:
bool timeShiftActive;
int timeShiftFramesTotal;
int timeShiftLength;
cString timeshiftrest;
cString timeShiftDuration;
bool timersLoaded;
cGlobalTimers globalTimers;
void GetGlobalTimers(void);
void SetViewElements(void);
void ClearVariables(void);
void SetViewElementObjects(void);
@@ -41,14 +46,12 @@ public:
virtual ~cViewReplay(void);
void PreCache(void);
void SetModeOnly(bool modeOnly) { this->modeOnly = modeOnly; };
void SetRecordingLength(int length) { reclength = length; };
void SetTimeShift(int framesTotal, int timeShiftLength);
void SetRecording(const cRecording *recording);
void SetTimeShiftValues(int current, int total);
void SetTitle(const char *title);
void GetTimers(void);
void SetTimeShiftValues(const cRecording *recording);
void SetCurrent(const char *current);
void SetTotal(const char *total);
void SetTimeshiftTimes(int current, int total);
void SetEndTime(int current, int total);
void SetProgressbar(int current, int total);
void SetMarks(const cMarks *marks, int current, int total);

2
coreengine/viewelement.c
View File

@@ -169,6 +169,8 @@ cViewElement *cViewElement::CreateViewElement(const char *name, const char *view
e = new cVeDrCurrentTime();
else if (!strcmp(name, "totaltime"))
e = new cVeDrTotalTime();
else if (!strcmp(name, "timeshifttimes"))
e = new cVeDrTimeshiftTimes();
else if (!strcmp(name, "endtime"))
e = new cVeDrEndTime();
else if (!strcmp(name, "progressbar") && !strcmp(viewname, "displayreplay"))

10
coreengine/viewelementsdisplaychannel.c
View File

@@ -216,16 +216,19 @@ void cVeDcProgressBar::SetTokenContainer(void) {
tokenContainer->DefineIntToken("{remaining}", (int)eDCProgressBarIT::remaining);
tokenContainer->DefineIntToken("{permashift}", (int)eDCProgressBarIT::permashift);
tokenContainer->DefineIntToken("{livebuffer}", (int)eDCProgressBarIT::livebuffer);
tokenContainer->DefineIntToken("{currentremaining}", (int)eDCProgressBarIT::currentremaining);
InheritTokenContainer();
}
void cVeDcProgressBar::Set(const cEvent *p) {
if (!p) {
startTime = -1;
endTime = -1;
duration = -1;
return;
}
startTime = p->StartTime();
endTime = p-> EndTime();
duration = p->Duration();
int current = 0;
@@ -249,18 +252,24 @@ void cVeDcProgressBar::Set(const cEvent *p) {
} else {
tokenContainer->AddIntToken((int)eDCProgressBarIT::permashift, 0);
}
tokenContainer->AddIntToken((int)eDCProgressBarIT::currentremaining, (int)round((endTime - t) / 60));
}
bool cVeDcProgressBar::Parse(bool force) {
if (!cViewElement::Parse(force))
return false;
int current = 0;
time_t t = time(NULL);
if (t > startTime)
current = t - startTime;
if (!(current > currentLast + 3) && !force && !Dirty())
return false;
currentLast = current;
SetDirty();
if (duration <= 0) {
tokenContainer->AddIntToken((int)eDCProgressBarIT::duration, 0);
tokenContainer->AddIntToken((int)eDCProgressBarIT::elapsed, 0);
@@ -276,6 +285,7 @@ bool cVeDcProgressBar::Parse(bool force) {
} else {
tokenContainer->AddIntToken((int)eDCProgressBarIT::permashift, 0);
}
tokenContainer->AddIntToken((int)eDCProgressBarIT::currentremaining, (int)round((endTime - t) / 60));
}
return true;
}

3
coreengine/viewelementsdisplaychannel.h
View File

@@ -51,6 +51,7 @@ class cVeDcProgressBar : public cViewElement {
private:
int currentLast;
int startTime;
int endTime;
int duration;
int GetLiveBuffer(void);
public:
@@ -199,4 +200,4 @@ public:
cVeDcGroupChannelListDetail(void) {};
virtual ~cVeDcGroupChannelListDetail(void) {};
};
#endif //__VIEWELEMENTSDC_H
#endif //__VIEWELEMENTSDC_H

105
coreengine/viewelementsdisplayreplay.c
View File

@@ -8,7 +8,9 @@
******************************************************************/
cVeDrRecTitle::cVeDrRecTitle(void) {
recording = NULL;
event = NULL;
title = NULL;
timeshiftActive = false;
}
cVeDrRecTitle::~cVeDrRecTitle(void) {
@@ -21,19 +23,27 @@ void cVeDrRecTitle::SetTokenContainer(void) {
tokenContainer->DefineStringToken("{recsubtitle}", (int)eDRRecTitleST::recsubtitle);
tokenContainer->DefineStringToken("{recdate}", (int)eDRRecTitleST::recdate);
tokenContainer->DefineStringToken("{rectime}", (int)eDRRecTitleST::rectime);
tokenContainer->DefineStringToken("{eventstart}", (int)eDRRecTitleST::eventstart);
tokenContainer->DefineStringToken("{eventstop}", (int)eDRRecTitleST::eventstop);
tokenContainer->DefineIntToken("{timeshift}", (int)eDRRecTitleIT::timeshift);
InheritTokenContainer();
}
void cVeDrRecTitle::Set(const cRecording *recording) {
void cVeDrRecTitle::Set(const cRecording *recording, const cEvent *event, bool timeshiftActive) {
this->timeshiftActive = timeshiftActive;
if (this->title) {
free(this->title);
this->title = NULL;
}
if (this->recording)
this->recording = NULL;
if (this->event)
this->event = NULL;
if (!recording)
return;
this->recording = recording;
if (event)
this->event = event;
}
void cVeDrRecTitle::Set(const char *title) {
@@ -43,6 +53,8 @@ void cVeDrRecTitle::Set(const char *title) {
}
if (this->recording)
this->recording = NULL;
if (this->event)
this->event = NULL;
if (!title)
return;
free(this->title);
@@ -58,15 +70,29 @@ bool cVeDrRecTitle::Parse(bool force) {
tokenContainer->Clear();
if (recording) {
const char *recName = NULL;
const char *recShortText = NULL;
const cRecordingInfo *recInfo = recording->Info();
if (recInfo)
if (event) {
recName = event->Title();
recShortText = event->ShortText();
} else if (recInfo) {
recName = recInfo->Title();
if (!recName)
recShortText = recInfo->ShortText();
}
if (!recName) {
recName = recording->Name();
recShortText = "";
}
tokenContainer->AddStringToken((int)eDRRecTitleST::rectitle, recName);
tokenContainer->AddStringToken((int)eDRRecTitleST::recsubtitle, recInfo ? recInfo->ShortText() : "");
tokenContainer->AddStringToken((int)eDRRecTitleST::recsubtitle, recShortText);
tokenContainer->AddStringToken((int)eDRRecTitleST::recdate, *ShortDateString(recording->Start()));
tokenContainer->AddStringToken((int)eDRRecTitleST::rectime, *TimeString(recording->Start()));
tokenContainer->AddIntToken((int)eDRRecTitleIT::timeshift, timeshiftActive);
if (event) {
tokenContainer->AddStringToken((int)eDRRecTitleST::eventstart, *TimeString(event->StartTime()));
tokenContainer->AddStringToken((int)eDRRecTitleST::eventstop, *TimeString(event->EndTime()));
}
} else if (title) {
tokenContainer->AddStringToken((int)eDRRecTitleST::rectitle, title);
}
@@ -138,6 +164,7 @@ bool cVeDrRecInfo::Parse(bool force) {
cVeDrCurrentTime::cVeDrCurrentTime(void) {
changed = true;
current = NULL;
timeshiftActive = false;
}
cVeDrCurrentTime::~cVeDrCurrentTime(void) {
@@ -147,14 +174,16 @@ cVeDrCurrentTime::~cVeDrCurrentTime(void) {
void cVeDrCurrentTime::SetTokenContainer(void) {
tokenContainer = new skindesignerapi::cTokenContainer();
tokenContainer->DefineStringToken("{reccurrent}", (int)eDRCurrentTimeST::reccurrent);
tokenContainer->DefineIntToken("{timeshift}", (int)eDRCurrentTimeIT::timeshift);
InheritTokenContainer();
}
void cVeDrCurrentTime::Set(const char *current) {
void cVeDrCurrentTime::Set(const char *current, bool timeshiftActive) {
if (!current)
return;
free(this->current);
this->current = strdup(current);
this->timeshiftActive = timeshiftActive;
changed = true;
}
@@ -163,6 +192,7 @@ bool cVeDrCurrentTime::Parse(bool force) {
return false;
tokenContainer->Clear();
tokenContainer->AddStringToken((int)eDRCurrentTimeST::reccurrent, current);
tokenContainer->AddIntToken((int)eDRCurrentTimeIT::timeshift, timeshiftActive);
SetDirty();
changed = false;
return true;
@@ -174,8 +204,8 @@ bool cVeDrCurrentTime::Parse(bool force) {
cVeDrTotalTime::cVeDrTotalTime(void) {
changed = true;
total = NULL;
timeshiftActive = false;
timeshiftDuration = NULL;
timeshiftActive = false;
}
cVeDrTotalTime::~cVeDrTotalTime(void) {
@@ -191,7 +221,7 @@ void cVeDrTotalTime::SetTokenContainer(void) {
InheritTokenContainer();
}
void cVeDrTotalTime::Set(const char *total, bool timeshiftActive, const char *timeshiftDuration) {
void cVeDrTotalTime::Set(const char *total, const char *timeshiftDuration, bool timeshiftActive) {
if (!total)
return;
free(this->total);
@@ -216,11 +246,59 @@ bool cVeDrTotalTime::Parse(bool force) {
return true;
}
/******************************************************************
* cVeDrTimeshiftTimes
******************************************************************/
cVeDrTimeshiftTimes::cVeDrTimeshiftTimes(void) {
changed = true;
start = "";
playbacktime = "";
timeshiftrest = "";
timeshiftActive = false;
}
cVeDrTimeshiftTimes::~cVeDrTimeshiftTimes(void) {
}
void cVeDrTimeshiftTimes::SetTokenContainer(void) {
tokenContainer = new skindesignerapi::cTokenContainer();
tokenContainer->DefineStringToken("{recstart}", (int)eDRTimeshiftTimesST::recstart);
tokenContainer->DefineStringToken("{playbacktime}", (int)eDRTimeshiftTimesST::playbacktime);
tokenContainer->DefineStringToken("{timeshiftrest}", (int)eDRTimeshiftTimesST::timeshiftrest);
tokenContainer->DefineIntToken("{timeshift}", (int)eDRTimeshiftTimesIT::timeshift);
InheritTokenContainer();
}
void cVeDrTimeshiftTimes::Set(cString start, cString playbacktime, cString timeshiftrest, bool timeshiftActive) {
this->timeshiftActive = timeshiftActive;
if (strcmp(*this->start, *start) || strcmp(*this->playbacktime, *playbacktime) || strcmp(*this->timeshiftrest, *timeshiftrest)) {
this->start = start;
this->playbacktime = playbacktime;
this->timeshiftrest = timeshiftrest;
changed = true;
}
}
bool cVeDrTimeshiftTimes::Parse(bool force) {
if (!cViewElement::Parse(force) || !changed)
return false;
tokenContainer->Clear();
tokenContainer->AddStringToken((int)eDRTimeshiftTimesST::recstart, *start);
tokenContainer->AddStringToken((int)eDRTimeshiftTimesST::playbacktime, *playbacktime);
tokenContainer->AddStringToken((int)eDRTimeshiftTimesST::timeshiftrest, *timeshiftrest);
tokenContainer->AddIntToken((int)eDRTimeshiftTimesIT::timeshift, timeshiftActive);
SetDirty();
changed = false;
return true;
}
/******************************************************************
* cVeDrEndTime
******************************************************************/
cVeDrEndTime::cVeDrEndTime(void) {
changed = true;
end = "";
timeshiftActive = false;
}
cVeDrEndTime::~cVeDrEndTime(void) {
@@ -229,10 +307,12 @@ cVeDrEndTime::~cVeDrEndTime(void) {
void cVeDrEndTime::SetTokenContainer(void) {
tokenContainer = new skindesignerapi::cTokenContainer();
tokenContainer->DefineStringToken("{recend}", (int)eDREndTimeST::recend);
tokenContainer->DefineIntToken("{timeshift}", (int)eDREndTimeIT::timeshift);
InheritTokenContainer();
}
void cVeDrEndTime::Set(cString end) {
void cVeDrEndTime::Set(cString end, bool timeshiftActive) {
this->timeshiftActive = timeshiftActive;
if (strcmp(*this->end, *end)) {
this->end = end;
changed = true;
@@ -244,6 +324,7 @@ bool cVeDrEndTime::Parse(bool force) {
return false;
tokenContainer->Clear();
tokenContainer->AddStringToken((int)eDREndTimeST::recend, *end);
tokenContainer->AddIntToken((int)eDREndTimeIT::timeshift, timeshiftActive);
SetDirty();
changed = false;
return true;
@@ -255,8 +336,8 @@ bool cVeDrEndTime::Parse(bool force) {
cVeDrProgressBar::cVeDrProgressBar(void) {
current = -1;
total = -1;
timeshiftActive = false;
timeshiftTotal = -1;
timeshiftActive = false;
changed = true;
}
@@ -273,12 +354,13 @@ void cVeDrProgressBar::SetTokenContainer(void) {
}
void cVeDrProgressBar::Set(int current, int total, bool timeshiftActive, int timeshiftTotal) {
if (this->current == current)
if (!(this->current != current || this->total != total))
return;
this->current = current;
this->total = total;
this->timeshiftActive = timeshiftActive;
this->timeshiftTotal = timeshiftTotal;
changed = true;
}
@@ -302,6 +384,7 @@ bool cVeDrProgressBar::Parse(bool force) {
cVeDrCutMarks::cVeDrCutMarks(void) {
cutmarksIndex = -1;
lastMarks = NULL;
timeshiftActive = false;
Reset();
}
@@ -595,7 +678,7 @@ void cVeDrProgressModeonly::SetTokenContainer(void) {
}
void cVeDrProgressModeonly::Set(double fps, int current, int total) {
if (this->current == current)
if (!(this->current != current || this->total != total))
return;
this->fps = fps;
this->current = current;

38
coreengine/viewelementsdisplayreplay.h
View File

@@ -10,13 +10,15 @@
class cVeDrRecTitle : public cViewElement {
private:
const cRecording *recording;
const cEvent *event;
char *title;
bool timeshiftActive;
public:
cVeDrRecTitle(void);
virtual ~cVeDrRecTitle(void);
void SetTokenContainer(void);
void Set(const cRecording *recording);
void Set(const char *title);
void Set(const cRecording *recording = NULL, const cEvent *event = NULL, bool timeshiftActive = false);
void Set(const char *title = NULL);
bool Parse(bool forced = false);
};
@@ -41,11 +43,12 @@ class cVeDrCurrentTime : public cViewElement {
private:
bool changed;
char *current;
bool timeshiftActive;
public:
cVeDrCurrentTime(void);
virtual ~cVeDrCurrentTime(void);
void SetTokenContainer(void);
void Set(const char *current);
void Set(const char *current, bool timeshiftActive = false);
bool Parse(bool forced = false);
};
@@ -62,7 +65,25 @@ public:
cVeDrTotalTime(void);
virtual ~cVeDrTotalTime(void);
void SetTokenContainer(void);
void Set(const char *total, bool timeshiftActive, const char *timeshiftDuration);
void Set(const char *total, const char *timeshiftDuration = NULL, bool timeshiftActive = false);
bool Parse(bool forced = false);
};
/******************************************************************
* cVeDrTimeshiftTimes
******************************************************************/
class cVeDrTimeshiftTimes : public cViewElement {
private:
cString start;
cString playbacktime;
cString timeshiftrest;
bool changed;
bool timeshiftActive;
public:
cVeDrTimeshiftTimes(void);
virtual ~cVeDrTimeshiftTimes(void);
void SetTokenContainer(void);
void Set(cString start, cString playbacktime, cString timeshiftrest, bool timeshiftActive = false);
bool Parse(bool forced = false);
};
@@ -72,12 +93,13 @@ public:
class cVeDrEndTime : public cViewElement {
private:
cString end;
bool timeshiftActive;
bool changed;
public:
cVeDrEndTime(void);
virtual ~cVeDrEndTime(void);
void SetTokenContainer(void);
void Set(cString end);
void Set(cString end, bool timeshiftActive = false);
bool Parse(bool forced = false);
};
@@ -95,7 +117,7 @@ public:
cVeDrProgressBar(void);
virtual ~cVeDrProgressBar(void);
void SetTokenContainer(void);
void Set(int current, int total, bool timeshiftActive, int timeshiftTotal);
void Set(int current, int total, bool timeshiftActive = false, int timeshiftTotal = 0);
bool Parse(bool forced = false);
};
@@ -119,7 +141,7 @@ public:
cVeDrCutMarks(void);
virtual ~cVeDrCutMarks(void);
void SetTokenContainer(void);
void Set(const cMarks *marks, int current, int total, bool timeshiftActive, int timeshiftTotal);
void Set(const cMarks *marks, int current, int total, bool timeshiftActive = false, int timeshiftTotal = 0);
void Reset(void);
bool Parse(bool forced = false);
};
@@ -207,4 +229,4 @@ public:
bool Parse(bool forced = false);
};
#endif //__VIEWELEMENTSDR_H
#endif //__VIEWELEMENTSDR_H