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

Compile under VDR 2.3.1

Browse Source
This commit is contained in:
kamel5 2018-03-08 13:02:38 +01:00 committed by kamel5
parent 8287bb5f7d
commit cbc6f44264
19 changed files with 670 additions and 5 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

27
channelcolumn.c
View File

@ -5,9 +5,15 @@ cChannelColumn::cChannelColumn(int num, const cChannel *channel, cMyTime *myTime
this->channel = channel;
this->num = num;
this->myTime = myTime;
#if defined (APIVERSNUM) && (APIVERSNUM >= 20301)
#else
hasTimer = channel->HasTimer();
#endif
hasSwitchTimer = SwitchTimers.ChannelInSwitchList(channel);
#if defined (APIVERSNUM) && (APIVERSNUM >= 20301)
#else
schedulesLock = new cSchedulesLock(false, 100);
#endif
header = NULL;
}
@ -15,7 +21,10 @@ cChannelColumn::~cChannelColumn(void) {
if (header)
delete header;
grids.Clear();
#if defined (APIVERSNUM) && (APIVERSNUM >= 20301)
#else
delete schedulesLock;
#endif
}
void cChannelColumn::clearGrids() {
@ -33,7 +42,12 @@ void cChannelColumn::drawHeader() {
}
bool cChannelColumn::readGrids() {
#if defined (APIVERSNUM) && (APIVERSNUM >= 20301)
LOCK_SCHEDULES_READ;
const cSchedules* schedules = Schedules;
#else
schedules = cSchedules::Schedules(*schedulesLock);
#endif
const cSchedule *Schedule = NULL;
Schedule = schedules->GetSchedule(channel);
if (!Schedule) {
@ -186,7 +200,12 @@ void cChannelColumn::AddNewGridsAtStart() {
return;
}
//if not, i have to add new ones to the list
#if defined (APIVERSNUM) && (APIVERSNUM >= 20301)
LOCK_SCHEDULES_READ;
const cSchedules* schedules = Schedules;
#else
schedules = cSchedules::Schedules(*schedulesLock);
#endif
const cSchedule *Schedule = NULL;
Schedule = schedules->GetSchedule(channel);
if (!Schedule) {
@ -234,7 +253,12 @@ void cChannelColumn::AddNewGridsAtEnd() {
return;
}
//if not, i have to add new ones to the list
#if defined (APIVERSNUM) && (APIVERSNUM >= 20301)
LOCK_SCHEDULES_READ;
const cSchedules* schedules = Schedules;
#else
schedules = cSchedules::Schedules(*schedulesLock);
#endif
const cSchedule *Schedule = NULL;
Schedule = schedules->GetSchedule(channel);
if (!Schedule) {
@ -342,7 +366,10 @@ cGrid *cChannelColumn::addDummyGrid(time_t start, time_t end, cGrid *firstGrid,
}
void cChannelColumn::SetTimers() {
#if defined (APIVERSNUM) && (APIVERSNUM >= 20301)
#else
hasTimer = channel->HasTimer();
#endif
hasSwitchTimer = SwitchTimers.ChannelInSwitchList(channel);
for (cGrid *grid = grids.First(); grid; grid = grids.Next(grid)) {
bool gridHadTimer = grid->HasTimer();

7
channelcolumn.h
View File

@ -20,7 +20,10 @@ private:
const cChannel *channel;
cHeaderGrid *header;
cList<cGrid> grids;
#if defined (APIVERSNUM) && (APIVERSNUM >= 20301)
#else
cSchedulesLock *schedulesLock;
#endif
const cSchedules *schedules;
bool hasTimer;
bool hasSwitchTimer;
@ -50,7 +53,11 @@ public:
void ClearOutdatedEnd();
int GetNum() {return num;};
void SetNum(int num) {this->num = num;};
#if defined (APIVERSNUM) && (APIVERSNUM >= 20301)
void setTimer();
#else
void setTimer() {hasTimer = channel->HasTimer();};
#endif
bool HasTimer() { return hasTimer; };
void setSwitchTimer() {hasSwitchTimer = SwitchTimers.ChannelInSwitchList(channel);};
bool HasSwitchTimer() { return hasSwitchTimer; };

14
channelgroups.c
View File

@ -10,12 +10,21 @@ cChannelGroups::~cChannelGroups(void) {
void cChannelGroups::ReadChannelGroups(void) {
bool setStart = false;
int lastChannelNumber = 0;
#if defined (APIVERSNUM) && (APIVERSNUM >= 20301)
LOCK_CHANNELS_READ;
const cChannel *first = Channels->First();
#else
const cChannel *first = Channels.First();
#endif
if (!first->GroupSep()) {
channelGroups.push_back(cChannelGroup(tr("Main Program")));
setStart = true;
}
#if defined (APIVERSNUM) && (APIVERSNUM >= 20301)
for (const cChannel *channel = Channels->First(); channel; channel = Channels->Next(channel)) {
#else
for (const cChannel *channel = Channels.First(); channel; channel = Channels.Next(channel)) {
#endif
if (setStart && (channelGroups.size() > 0)) {
channelGroups[channelGroups.size()-1].SetChannelStart(channel->Number());
setStart = false;
@ -103,7 +112,12 @@ void cChannelGroups::DrawChannelGroups(const cChannel *start, const cChannel *st
int groupLast = group;
int line = 0;
int lineStart = 0;
#if defined (APIVERSNUM) && (APIVERSNUM >= 20301)
LOCK_CHANNELS_READ;
for (const cChannel *channel = Channels->Next(start); channel; channel = Channels->Next(channel)) {
#else
for (const cChannel *channel = Channels.Next(start); channel; channel = Channels.Next(channel)) {
#endif
if (channel->GroupSep())
continue;
group = GetGroup(channel);

5
channeljump.c
View File

@ -11,7 +11,12 @@ cChannelJump::cChannelJump(cChannelGroups *channelGroups) {
pixmapText = NULL;
channel = 0;
if (!tvguideConfig.hideLastGroup) {
#if defined (APIVERSNUM) && (APIVERSNUM >= 20301)
LOCK_CHANNELS_READ;
maxChannels = Channels->MaxNumber();
#else
maxChannels = Channels.MaxNumber();
#endif
} else {
maxChannels = channelGroups->GetLastValidChannel();
}

15
detailview.c
View File

@ -9,7 +9,12 @@ cDetailView::~cDetailView(void){
Cancel(-1);
while (Active())
cCondWait::SleepMs(10);
#if defined (APIVERSNUM) && (APIVERSNUM >= 20301)
LOCK_CHANNELS_READ;
footer->LeaveDetailedViewMode(Channels->GetByChannelID(event->ChannelID()));
#else
footer->LeaveDetailedViewMode(Channels.GetByChannelID(event->ChannelID()));
#endif
if (view)
delete view;
}
@ -42,7 +47,12 @@ void cDetailView::InitiateView(void) {
dateTime = cString::sprintf("%s %s - %s (%d %s)", *event->GetDateString(), *event->GetTimeString(), *event->GetEndTimeString(), event->Duration()/60, tr("min"));
}
view->SetDateTime(*dateTime);
#if defined (APIVERSNUM) && (APIVERSNUM >= 20301)
LOCK_CHANNELS_READ;
view->SetChannel(Channels->GetByChannelID(event->ChannelID(), true));
#else
view->SetChannel(Channels.GetByChannelID(event->ChannelID(), true));
#endif
view->SetEventID(event->EventID());
view->SetEvent(event);
}
@ -90,7 +100,12 @@ std::string cDetailView::LoadReruns(void) {
continue;
i++;
sstrReruns << *DayDateTime(r->event->StartTime());
#if defined (APIVERSNUM) && (APIVERSNUM >= 20301)
LOCK_CHANNELS_READ;
const cChannel *channel = Channels->GetByChannelID(r->event->ChannelID(), true, true);
#else
cChannel *channel = Channels.GetByChannelID(r->event->ChannelID(), true, true);
#endif
if (channel) {
sstrReruns << ", " << trVDR("Channel") << " " << channel->Number() << ":";
sstrReruns << " " << channel->ShortName(true);

5
imagecache.c
View File

@ -280,7 +280,12 @@ void cImageCache::CreateLogoCache(void) {
return;
if (tvguideConfig.numLogosInitial > 0) {
int channelsCached = 0;
#if defined (APIVERSNUM) && (APIVERSNUM >= 20301)
LOCK_CHANNELS_READ;
for (const cChannel *channel = Channels->First(); channel; channel = Channels->Next(channel)) {
#else
for (const cChannel *channel = Channels.First(); channel; channel = Channels.Next(channel)) {
#endif
if (channelsCached >= tvguideConfig.numLogosInitial)
break;
if (!channel->GroupSep()) {

185
recmanager.c
View File

@ -10,6 +10,7 @@
#include "tools.h"
#include "switchtimer.h"
#include "timerconflict.h"
#include <vdr/timers.h>
#include "recmanager.h"
static int CompareRecording(const void *p1, const void *p2) {
@ -55,15 +56,27 @@ bool cRecManager::CheckEventForTimer(const cEvent *event) {
return hasTimer;
}
#if defined (APIVERSNUM) && (APIVERSNUM >= 20301)
const cTimer *cRecManager::GetTimerForEvent(const cEvent *event) {
const cTimer *timer = NULL;
#else
cTimer *cRecManager::GetTimerForEvent(const cEvent *event) {
cTimer *timer = NULL;
#endif
if (tvguideConfig.useRemoteTimers && pRemoteTimers) {
RemoteTimers_GetMatch_v1_0 rtMatch;
rtMatch.event = event;
pRemoteTimers->Service("RemoteTimers::GetMatch-v1.0", &rtMatch);
timer = rtMatch.timer;
#if defined (APIVERSNUM) && (APIVERSNUM >= 20301)
return timer;
}
LOCK_TIMERS_READ;
timer = Timers->GetMatch(event);
#else
} else
timer = Timers.GetMatch(event);
#endif
return timer;
}
@ -79,19 +92,36 @@ cTimer *cRecManager::createTimer(const cEvent *event, std::string path) {
cTimer *cRecManager::createLocalTimer(const cEvent *event, std::string path) {
cTimer *timer = new cTimer(event);
#if defined (APIVERSNUM) && (APIVERSNUM >= 20301)
LOCK_TIMERS_WRITE;
cTimer *t = Timers->GetTimer(timer);
#else
cTimer *t = Timers.GetTimer(timer);
#endif
if (t) {
t->OnOff();
#if defined (APIVERSNUM) && (APIVERSNUM >= 20301)
t->SetEvent(event);
#else
t->SetEventFromSchedule();
#endif
delete timer;
timer = t;
isyslog("timer %s reactivated", *t->ToDescr());
} else {
#if defined (APIVERSNUM) && (APIVERSNUM >= 20301)
Timers->Add(timer);
#else
Timers.Add(timer);
#endif
isyslog("timer %s added (active)", *timer->ToDescr());
}
SetTimerPath(timer, event, path);
#if defined (APIVERSNUM) && (APIVERSNUM >= 20301)
Timers->SetModified();
#else
Timers.SetModified();
#endif
return timer;
}
@ -148,7 +178,12 @@ void cRecManager::SetTimerPath(cTimer *timer, const cEvent *event, std::string p
}
void cRecManager::DeleteTimer(int timerID) {
#if defined (APIVERSNUM) && (APIVERSNUM >= 20301)
LOCK_TIMERS_READ;
const cTimer *t = Timers->Get(timerID);
#else
cTimer *t = Timers.Get(timerID);
#endif
if (!t)
return;
DeleteTimer(t);
@ -165,21 +200,43 @@ void cRecManager::DeleteTimer(const cEvent *event) {
}
void cRecManager::DeleteLocalTimer(const cEvent *event) {
#if defined (APIVERSNUM) && (APIVERSNUM >= 20301)
LOCK_TIMERS_READ;
const cTimer *t = Timers->GetMatch(event);
#else
cTimer *t = Timers.GetMatch(event);
#endif
if (!t)
return;
DeleteTimer(t);
}
#if defined (APIVERSNUM) && (APIVERSNUM >= 20301)
void cRecManager::DeleteTimer(const cTimer *timer) {
LOCK_TIMERS_WRITE;
cTimers* timers = Timers;
cTimer* t = timers->GetTimer((cTimer*)timer); // #TODO dirty cast
if (t->Recording()) {
t->Skip();
cRecordControls::Process(timers, time(NULL));
}
#else
void cRecManager::DeleteTimer(cTimer *timer) {
if (timer->Recording()) {
timer->Skip();
cRecordControls::Process(time(NULL));
}
#endif
isyslog("timer %s deleted", *timer->ToDescr());
#if defined (APIVERSNUM) && (APIVERSNUM >= 20301)
timers->Del(t, true);
timers->SetModified();
#else
Timers.Del(timer, true);
Timers.SetModified();
#endif
}
void cRecManager::DeleteRemoteTimer(const cEvent *event) {
@ -196,7 +253,11 @@ void cRecManager::DeleteRemoteTimer(const cEvent *event) {
}
}
#if defined (APIVERSNUM) && (APIVERSNUM >= 20301)
void cRecManager::SaveTimer(const cTimer *timer, cTimer newTimerSettings) {
#else
void cRecManager::SaveTimer(cTimer *timer, cTimer newTimerSettings) {
#endif
if (!timer)
return;
@ -208,33 +269,63 @@ void cRecManager::SaveTimer(cTimer *timer, cTimer newTimerSettings) {
int stop = newTimerSettings.Stop();
std::string fileName = newTimerSettings.File();
#if defined (APIVERSNUM) && (APIVERSNUM >= 20301)
((cTimer*)timer)->SetDay(day);
((cTimer*)timer)->SetStart(start);
((cTimer*)timer)->SetStop(stop);
((cTimer*)timer)->SetPriority(prio);
((cTimer*)timer)->SetLifetime(lifetime);
((cTimer*)timer)->SetFile(fileName.c_str());
#else
timer->SetDay(day);
timer->SetStart(start);
timer->SetStop(stop);
timer->SetPriority(prio);
timer->SetLifetime(lifetime);
timer->SetFile(fileName.c_str());
#endif
if (timer->HasFlags(tfActive) && !active)
#if defined (APIVERSNUM) && (APIVERSNUM >= 20301)
((cTimer*)timer)->ClrFlags(tfActive);
else if (!timer->HasFlags(tfActive) && active)
((cTimer*)timer)->SetFlags(tfActive);
#else
timer->ClrFlags(tfActive);
else if (!timer->HasFlags(tfActive) && active)
timer->SetFlags(tfActive);
timer->SetEventFromSchedule();
#endif
if (tvguideConfig.useRemoteTimers && pRemoteTimers) {
RemoteTimers_Timer_v1_0 rt;
#if defined (APIVERSNUM) && (APIVERSNUM >= 20301)
rt.timer = (cTimer*)timer;
#else
rt.timer = timer;
#endif
if (!pRemoteTimers->Service("RemoteTimers::ModTimer-v1.0", &rt))
rt.timer = NULL;
RefreshRemoteTimers();
} else {
#if defined (APIVERSNUM) && (APIVERSNUM >= 20301)
LOCK_TIMERS_WRITE;
Timers->SetModified();
#else
Timers.SetModified();
#endif
}
}
bool cRecManager::IsRecorded(const cEvent *event) {
#if defined (APIVERSNUM) && (APIVERSNUM >= 20301)
LOCK_TIMERS_WRITE;
cTimer *timer = Timers->GetMatch(event);
#else
cTimer *timer = Timers.GetMatch(event);
#endif
if (!timer)
return false;
return timer->Recording();
@ -260,7 +351,10 @@ cTVGuideTimerConflicts *cRecManager::CheckTimerConflict(void) {
}
void cRecManager::CreateSeriesTimer(cTimer *seriesTimer) {
#if defined (APIVERSNUM) && (APIVERSNUM >= 20301)
#else
seriesTimer->SetEventFromSchedule();
#endif
if (tvguideConfig.useRemoteTimers && pRemoteTimers) {
RemoteTimers_Timer_v1_0 rt;
rt.timer = seriesTimer;
@ -268,8 +362,15 @@ void cRecManager::CreateSeriesTimer(cTimer *seriesTimer) {
isyslog("%s", *rt.errorMsg);
RefreshRemoteTimers();
} else {
#if defined (APIVERSNUM) && (APIVERSNUM >= 20301)
LOCK_TIMERS_WRITE;
cTimers* timers = Timers;
timers->Add(seriesTimer);
timers->SetModified();
#else
Timers.Add(seriesTimer);
Timers.SetModified();
#endif
}
}
@ -316,9 +417,14 @@ const cEvent **cRecManager::PerformSearchTimerSearch(std::string epgSearchString
numResults = results.size();
if (numResults > 0) {
searchResults = new const cEvent *[numResults];
#if defined (APIVERSNUM) && (APIVERSNUM >= 20301)
LOCK_SCHEDULES_READ;
const cSchedules* schedules = Schedules;
#else
cSchedulesLock schedulesLock;
const cSchedules *schedules;
schedules = cSchedules::Schedules(schedulesLock);
#endif
const cEvent *event = NULL;
int index=0;
for (std::list<std::string>::iterator it=results.begin(); it != results.end(); ++it) {
@ -328,7 +434,12 @@ const cEvent **cRecManager::PerformSearchTimerSearch(std::string epgSearchString
int eventID = atoi(flds[1].c_str());
std::string channelID = flds[7];
tChannelID chanID = tChannelID::FromString(channelID.c_str());
#if defined (APIVERSNUM) && (APIVERSNUM >= 20301)
LOCK_CHANNELS_READ;
const cChannel *channel = Channels->GetByChannelID(chanID);
#else
cChannel *channel = Channels.GetByChannelID(chanID);
#endif
if (channel) {
const cSchedule *Schedule = NULL;
Schedule = schedules->GetSchedule(channel);
@ -435,24 +546,45 @@ void cRecManager::DeleteSearchTimer(cTVGuideSearchTimer *searchTimer, bool delTi
return;
int searchTimerID = searchTimer->GetID();
if (delTimers) {
#if defined (APIVERSNUM) && (APIVERSNUM >= 20301)
LOCK_TIMERS_WRITE;
cTimer *timer = Timers->First();
#else
cTimer *timer = Timers.First();
#endif
while(timer) {
if (!timer->Recording()) {
char* searchID = GetAuxValue(timer, "s-id");
if (searchID) {
if (searchTimerID == atoi(searchID)) {
#if defined (APIVERSNUM) && (APIVERSNUM >= 20301)
cTimer* timerNext = Timers->Next(timer);
#else
cTimer* timerNext = Timers.Next(timer);
#endif
DeleteTimer(timer);
timer = timerNext;
} else {
#if defined (APIVERSNUM) && (APIVERSNUM >= 20301)
timer = Timers->Next(timer);
#else
timer = Timers.Next(timer);
#endif
}
free(searchID);
} else {
#if defined (APIVERSNUM) && (APIVERSNUM >= 20301)
timer = Timers->Next(timer);
#else
timer = Timers.Next(timer);
#endif
}
} else {
#if defined (APIVERSNUM) && (APIVERSNUM >= 20301)
timer = Timers->Next(timer);
#else
timer = Timers.Next(timer);
#endif
}
}
}
@ -505,13 +637,24 @@ void cRecManager::DeleteSwitchTimer(const cEvent *event) {
}
}
#if defined (APIVERSNUM) && (APIVERSNUM >= 20301)
const cRecording **cRecManager::SearchForRecordings(std::string searchString, int &numResults) {
const cRecording **matchingRecordings = NULL;
#else
cRecording **cRecManager::SearchForRecordings(std::string searchString, int &numResults) {
cRecording **matchingRecordings = NULL;
#endif
int num = 0;
numResults = 0;
#if defined (APIVERSNUM) && (APIVERSNUM >= 20301)
LOCK_RECORDINGS_READ;
for (const cRecording *recording = Recordings->First(); recording; recording = Recordings->Next(recording)) {
#else
for (cRecording *recording = Recordings.First(); recording; recording = Recordings.Next(recording)) {
#endif
std::string s1 = recording->Name();
std::string s2 = searchString;
if (s1.empty() || s2.empty()) continue;
@ -542,7 +685,11 @@ cRecording **cRecManager::SearchForRecordings(std::string searchString, int &num
}
if (match) {
#if defined (APIVERSNUM) && (APIVERSNUM >= 20301)
matchingRecordings = (const cRecording **)realloc(matchingRecordings, (num + 1) * sizeof(cRecording *));
#else
matchingRecordings = (cRecording **)realloc(matchingRecordings, (num + 1) * sizeof(cRecording *));
#endif
matchingRecordings[num++] = recording;
}
}
@ -619,10 +766,26 @@ void cRecManager::GetFavorites(std::vector<cTVGuideSearchTimer> *favorites) {
const cEvent **cRecManager::WhatsOnNow(bool nowOrNext, int &numResults) {
std::vector<const cEvent*> tmpResults;
#if defined (APIVERSNUM) && (APIVERSNUM >= 20301)
LOCK_SCHEDULES_READ;
LOCK_CHANNELS_READ;
const cChannels* channels = Channels;
const cSchedules* schedules = Schedules;
#else
cSchedulesLock schedulesLock;
const cSchedules *schedules = cSchedules::Schedules(schedulesLock);
#endif
const cChannel *startChannel = NULL, *stopChannel = NULL;
if (tvguideConfig.favLimitChannels) {
#if defined (APIVERSNUM) && (APIVERSNUM >= 20301)
startChannel = Channels->GetByNumber(tvguideConfig.favStartChannel);
stopChannel = Channels->GetByNumber(tvguideConfig.favStopChannel);
}
if (!startChannel)
startChannel = Channels->First();
for (const cChannel *channel = startChannel; channel; channel = Channels->Next(channel)) {
#else
startChannel = Channels.GetByNumber(tvguideConfig.favStartChannel);
stopChannel = Channels.GetByNumber(tvguideConfig.favStopChannel);
}
@ -630,6 +793,7 @@ const cEvent **cRecManager::WhatsOnNow(bool nowOrNext, int &numResults) {
startChannel = Channels.First();
for (const cChannel *channel = startChannel; channel; channel = Channels.Next(channel)) {
#endif
if (channel->GroupSep()) continue;
const cSchedule *Schedule = schedules->GetSchedule(channel);
if (!Schedule) continue;
@ -679,10 +843,26 @@ const cEvent **cRecManager::UserDefinedTime(int userTime, int &numResults) {
if (searchTime < now)
searchTime += 24*60*60;
#if defined (APIVERSNUM) && (APIVERSNUM >= 20301)
LOCK_CHANNELS_READ;
LOCK_SCHEDULES_READ;
const cChannels* channels = Channels;
const cSchedules* schedules = Schedules;
#else
cSchedulesLock schedulesLock;
const cSchedules *schedules = cSchedules::Schedules(schedulesLock);
#endif
const cChannel *startChannel = NULL, *stopChannel = NULL;
if (tvguideConfig.favLimitChannels) {
#if defined (APIVERSNUM) && (APIVERSNUM >= 20301)
startChannel = Channels->GetByNumber(tvguideConfig.favStartChannel);
stopChannel = Channels->GetByNumber(tvguideConfig.favStopChannel);
}
if (!startChannel)
startChannel = Channels->First();
for (const cChannel *channel = startChannel; channel; channel = Channels->Next(channel)) {
#else
startChannel = Channels.GetByNumber(tvguideConfig.favStartChannel);
stopChannel = Channels.GetByNumber(tvguideConfig.favStopChannel);
}
@ -690,6 +870,7 @@ const cEvent **cRecManager::UserDefinedTime(int userTime, int &numResults) {
startChannel = Channels.First();
for (const cChannel *channel = startChannel; channel; channel = Channels.Next(channel)) {
#endif
if (channel->GroupSep()) continue;
const cSchedule *Schedule = schedules->GetSchedule(channel);
if (!Schedule) continue;

16
recmanager.h
View File

@ -28,17 +28,29 @@ public:
bool EpgSearchAvailable(void) {return epgSearchAvailable;};
bool RefreshRemoteTimers(void);
bool CheckEventForTimer(const cEvent *event);
#if defined (APIVERSNUM) && (APIVERSNUM >= 20301)
const cTimer *GetTimerForEvent(const cEvent *event);
#else
cTimer *GetTimerForEvent(const cEvent *event);
#endif
cTimer *createTimer(const cEvent *event, std::string path = "");
cTimer *createLocalTimer(const cEvent *event, std::string path);
cTimer *createRemoteTimer(const cEvent *event, std::string path);
void SetTimerPath(cTimer *timer, const cEvent *event, std::string path);
#if defined (APIVERSNUM) && (APIVERSNUM >= 20301)
void DeleteTimer(const cTimer *timer);
#else
void DeleteTimer(cTimer *timer);
#endif
void DeleteTimer(int timerID);
void DeleteTimer(const cEvent *event);
void DeleteLocalTimer(const cEvent *event);
void DeleteRemoteTimer(const cEvent *event);
#if defined (APIVERSNUM) && (APIVERSNUM >= 20301)
void SaveTimer(const cTimer *timer, cTimer newTimerSettings);
#else
void SaveTimer(cTimer *timer, cTimer newTimerSettings);
#endif
bool IsRecorded(const cEvent *event);
cTVGuideTimerConflicts *CheckTimerConflict(void);
void CreateSeriesTimer(cTimer *seriesTimer);
@ -52,7 +64,11 @@ public:
void UpdateSearchTimers(void);
bool CreateSwitchTimer(const cEvent *event, cSwitchTimer switchTimer);
void DeleteSwitchTimer(const cEvent *event);
#if defined (APIVERSNUM) && (APIVERSNUM >= 20301)
const cRecording **SearchForRecordings(std::string searchString, int &numResults);
#else
cRecording **SearchForRecordings(std::string searchString, int &numResults);
#endif
const cEvent **LoadReruns(const cEvent *event, int &numResults);
void GetFavorites(std::vector<cTVGuideSearchTimer> *favorites);
const cEvent **WhatsOnNow(bool nowOrNext, int &numResults);

61
recmenuitem.c
View File

@ -1817,7 +1817,12 @@ void cRecMenuItemEvent::Draw(void) {
if (!event)
return;
int logoX = DrawIcons();
#if defined (APIVERSNUM) && (APIVERSNUM >= 20301)
LOCK_CHANNELS_READ;
const cChannel *channel = Channels->GetByChannelID(event->ChannelID());
#else
const cChannel *channel = Channels.GetByChannelID(event->ChannelID());
#endif
cString channelName = "";
if (channel)
channelName = channel->Name();
@ -1913,7 +1918,11 @@ eRecMenuState cRecMenuItemEvent::ProcessKey(eKeys Key) {
// --- cRecMenuItemChannelChooser -------------------------------------------------------
cRecMenuItemChannelChooser::cRecMenuItemChannelChooser(cString text,
#if defined (APIVERSNUM) && (APIVERSNUM >= 20301)
const cChannel *initialChannel,
#else
cChannel *initialChannel,
#endif
bool active,
int *callback,
eRecMenuState action) {
@ -1998,15 +2007,29 @@ eRecMenuState cRecMenuItemChannelChooser::ProcessKey(eKeys Key) {
fresh = true;
if (!channel)
return rmsConsumed;
#if defined (APIVERSNUM) && (APIVERSNUM >= 20301)
const cChannel *prev = channel;
LOCK_CHANNELS_READ;
const cChannel *firstChannel = Channels->First();
#else
cChannel *prev = channel;
cChannel *firstChannel = Channels.First();
#endif
if(firstChannel->GroupSep())
#if defined (APIVERSNUM) && (APIVERSNUM >= 20301)
firstChannel = Channels->Next(firstChannel);
#else
firstChannel = Channels.Next(firstChannel);
#endif
if (prev == firstChannel) {
if (!initialChannelSet)
channel = NULL;
} else {
#if defined (APIVERSNUM) && (APIVERSNUM >= 20301)
while (prev = Channels->Prev(prev)) {
#else
while (prev = Channels.Prev(prev)) {
#endif
if(!prev->GroupSep()) {
channel = prev;
break;
@ -2023,14 +2046,30 @@ eRecMenuState cRecMenuItemChannelChooser::ProcessKey(eKeys Key) {
return rmsConsumed;
break; }
case kRight: {
#if defined (APIVERSNUM) && (APIVERSNUM >= 20301)
LOCK_CHANNELS_READ;
#endif
fresh = true;
if (!channel) {
#if defined (APIVERSNUM) && (APIVERSNUM >= 20301)
channel = Channels->First();
#else
channel = Channels.First();
#endif
if(channel->GroupSep())
#if defined (APIVERSNUM) && (APIVERSNUM >= 20301)
channel = Channels->Next(channel);
#else
channel = Channels.Next(channel);
#endif
} else {
#if defined (APIVERSNUM) && (APIVERSNUM >= 20301)
const cChannel *next = channel;
while (next = Channels->Next(next)) {
#else
cChannel *next = channel;
while (next = Channels.Next(next)) {
#endif
if(!next->GroupSep()) {
channel = next;
break;
@ -2052,7 +2091,12 @@ eRecMenuState cRecMenuItemChannelChooser::ProcessKey(eKeys Key) {
fresh = false;
}
channelNumber = channelNumber * 10 + (Key - k0);
#if defined (APIVERSNUM) && (APIVERSNUM >= 20301)
LOCK_CHANNELS_READ;
const cChannel *chanNew = Channels->GetByNumber(channelNumber);
#else
cChannel *chanNew = Channels.GetByNumber(channelNumber);
#endif
if (chanNew) {
channel = chanNew;
DrawValue();
@ -2214,7 +2258,11 @@ eRecMenuState cRecMenuItemDayChooser::ProcessKey(eKeys Key) {
}
// --- cRecMenuItemRecording -------------------------------------------------------
#if defined (APIVERSNUM) && (APIVERSNUM >= 20301)
cRecMenuItemRecording::cRecMenuItemRecording(const cRecording *recording, bool active) {
#else
cRecMenuItemRecording::cRecMenuItemRecording(cRecording *recording, bool active) {
#endif
selectable = true;
this->recording = recording;
this->active = active;
@ -2242,7 +2290,12 @@ void cRecMenuItemRecording::Draw(void) {
if (!recording)
return;
const cRecordingInfo *recInfo = recording->Info();
#if defined (APIVERSNUM) && (APIVERSNUM >= 20301)
LOCK_CHANNELS_READ;
const cChannel *channel = Channels->GetByChannelID(recInfo->ChannelID());
#else
cChannel *channel = Channels.GetByChannelID(recInfo->ChannelID());
#endif
cString channelName = tr("unknown channel");
if (channel)
channelName = channel->Name();
@ -2457,7 +2510,11 @@ void cRecMenuItemTimelineHeader::Show(void) {
// --- cRecMenuItemTimelineTimer -------------------------------------------------------
#if defined (APIVERSNUM) && (APIVERSNUM >= 20301)
cRecMenuItemTimelineTimer::cRecMenuItemTimelineTimer(const cTimer *timer, time_t start, time_t stop, std::vector<cTVGuideTimerConflict*> conflictsToday, cRecMenuItemTimelineHeader *header, bool active) {
#else
cRecMenuItemTimelineTimer::cRecMenuItemTimelineTimer(cTimer *timer, time_t start, time_t stop, std::vector<cTVGuideTimerConflict*> conflictsToday, cRecMenuItemTimelineHeader *header, bool active) {
#endif
conflicts = conflictsToday;
defaultBackground = false;
pixmapBack = NULL;
@ -2604,7 +2661,11 @@ void cRecMenuItemTimelineTimer::Show(void) {
if (pixmapTimerConflicts) pixmapTimerConflicts->SetLayer(6);
}
#if defined (APIVERSNUM) && (APIVERSNUM >= 20301)
const cTimer *cRecMenuItemTimelineTimer::GetTimerValue(void) {
#else
cTimer *cRecMenuItemTimelineTimer::GetTimerValue(void) {
#endif
return timer;
}

40
recmenuitem.h
View File

@ -123,7 +123,11 @@ public:
virtual bool GetBoolValue(void) { return false; };
virtual cString GetStringValue(void) { return cString(""); };
virtual const cEvent *GetEventValue(void) { return NULL; };
#if defined (APIVERSNUM) && (APIVERSNUM >= 20301)
virtual const cTimer *GetTimerValue(void) { return NULL; };
#else
virtual cTimer *GetTimerValue(void) { return NULL; };
#endif
virtual eRecMenuState ProcessKey(eKeys Key) { return rmsNotConsumed; };
};
@ -489,7 +493,11 @@ public:
class cRecMenuItemChannelChooser : public cRecMenuItem {
private:
cString text;
#if defined (APIVERSNUM) && (APIVERSNUM >= 20301)
const cChannel *channel;
#else
cChannel *channel;
#endif
int channelNumber;
int *callback;
bool initialChannelSet;
@ -498,7 +506,11 @@ private:
void DrawValue(void);
public:
cRecMenuItemChannelChooser (cString text,
#if defined (APIVERSNUM) && (APIVERSNUM >= 20301)
const cChannel *initialChannel,
#else
cChannel *initialChannel,
#endif
bool active = false,
int *callback = NULL,
eRecMenuState action = rmsNotConsumed);
@ -548,10 +560,18 @@ public:
// --- cRecMenuItemRecording -------------------------------------------------------
class cRecMenuItemRecording : public cRecMenuItem {
private:
#if defined (APIVERSNUM) && (APIVERSNUM >= 20301)
const cRecording *recording;
#else
cRecording *recording;
#endif
cPixmap *pixmapText;
public:
#if defined (APIVERSNUM) && (APIVERSNUM >= 20301)
cRecMenuItemRecording(const cRecording *recording, bool active);
#else
cRecMenuItemRecording(cRecording *recording, bool active);
#endif
virtual ~cRecMenuItemRecording(void);
void SetPixmaps(void);
void Hide(void);
@ -563,7 +583,11 @@ public:
class cRecMenuItemTimelineHeader : public cRecMenuItem {
private:
time_t day;
#if defined (APIVERSNUM) && (APIVERSNUM >= 20301)
const cTimer *timer;
#else
cTimer *timer;
#endif
std::vector<cTVGuideTimerConflict*> conflicts;
cPixmap *pixmapTimeline;
cPixmap *pixmapTimerInfo;
@ -579,7 +603,11 @@ public:
virtual ~cRecMenuItemTimelineHeader(void);
void SetDay(time_t day) { this->day = day; };
void SetPixmaps(void);
#if defined (APIVERSNUM) && (APIVERSNUM >= 20301)
void SetCurrentTimer(const cTimer *timer) { this->timer = timer; };
#else
void SetCurrentTimer(cTimer *timer) { this->timer = timer; };
#endif
void UnsetCurrentTimer(void) { timer = NULL; };
void RefreshTimerDisplay(void);
void Hide(void);
@ -590,7 +618,11 @@ public:
// --- cRecMenuItemTimelineTimer -------------------------------------------------------
class cRecMenuItemTimelineTimer : public cRecMenuItem {
private:
#if defined (APIVERSNUM) && (APIVERSNUM >= 20301)
const cTimer *timer;
#else
cTimer *timer;
#endif
std::vector<cTVGuideTimerConflict*> conflicts;
cPixmap *pixmapBack;
cPixmap *pixmapTimerConflicts;
@ -605,7 +637,11 @@ private:
void DrawTimerConflicts(void);
void DrawNoTimerInfo(void);
public:
#if defined (APIVERSNUM) && (APIVERSNUM >= 20301)
cRecMenuItemTimelineTimer(const cTimer *timer, time_t start, time_t stop, std::vector<cTVGuideTimerConflict*> conflictsToday, cRecMenuItemTimelineHeader *header, bool active);
#else
cRecMenuItemTimelineTimer(cTimer *timer, time_t start, time_t stop, std::vector<cTVGuideTimerConflict*> conflictsToday, cRecMenuItemTimelineHeader *header, bool active);
#endif
virtual ~cRecMenuItemTimelineTimer(void);
void setActive(void);
void setInactive(void);
@ -613,7 +649,11 @@ public:
void Hide(void);
void Show(void);
void Draw(void);
#if defined (APIVERSNUM) && (APIVERSNUM >= 20301)
const cTimer *GetTimerValue(void);
#else
cTimer *GetTimerValue(void);
#endif
eRecMenuState ProcessKey(eKeys Key);
};

61
recmenumanager.c
View File

@ -125,7 +125,12 @@ eOSState cRecMenuManager::StateMachine(eRecMenuState nextState) {
timerIndex = menu->GetTimerConflictIndex();
} else break;
int timerID = timerConflicts->GetCurrentConflictTimerID(timerIndex);
#if defined (APIVERSNUM) && (APIVERSNUM >= 20301)
LOCK_TIMERS_READ;
const cTimer *t = Timers->Get(timerID);
#else
cTimer *t = Timers.Get(timerID);
#endif
if (t) {
const cEvent *ev = t->Event();
if (ev) {
@ -156,7 +161,12 @@ eOSState cRecMenuManager::StateMachine(eRecMenuState nextState) {
timerIndex = menu->GetTimerConflictIndex();
} else break;
int timerID = timerConflicts->GetCurrentConflictTimerID(timerIndex);
#if defined (APIVERSNUM) && (APIVERSNUM >= 20301)
LOCK_TIMERS_READ;
const cTimer *timer = Timers->Get(timerID);
#else
cTimer *timer = Timers.Get(timerID);
#endif
if (timer) {
delete activeMenu;
activeMenu = new cRecMenuEditTimer(timer, rmsSaveTimerConflictMenu);
@ -167,7 +177,11 @@ eOSState cRecMenuManager::StateMachine(eRecMenuState nextState) {
//caller: cRecMenuEditTimer
//save timer from current timer conflict
cTimer timerModified;
#if defined (APIVERSNUM) && (APIVERSNUM >= 20301)
const cTimer *originalTimer;
#else
cTimer *originalTimer;
#endif
if (cRecMenuEditTimer *menu = dynamic_cast<cRecMenuEditTimer*>(activeMenu)) {
timerModified = menu->GetTimer();
originalTimer = menu->GetOriginalTimer();
@ -200,7 +214,12 @@ eOSState cRecMenuManager::StateMachine(eRecMenuState nextState) {
break;
case rmsEditTimer: {
//edit timer for active event
#if defined (APIVERSNUM) && (APIVERSNUM >= 20301)
LOCK_TIMERS_READ;
const cTimer *timer = recManager->GetTimerForEvent(event);
#else
cTimer *timer = recManager->GetTimerForEvent(event);
#endif
if (timer) {
delete activeMenu;
activeMenu = new cRecMenuEditTimer(timer, rmsSaveTimer);
@ -211,7 +230,11 @@ eOSState cRecMenuManager::StateMachine(eRecMenuState nextState) {
//caller: cRecMenuEditTimer
//save timer for active event
cTimer timerModified;
#if defined (APIVERSNUM) && (APIVERSNUM >= 20301)
const cTimer *originalTimer;
#else
cTimer *originalTimer;
#endif
if (cRecMenuEditTimer *menu = dynamic_cast<cRecMenuEditTimer*>(activeMenu)) {
timerModified = menu->GetTimer();
originalTimer = menu->GetOriginalTimer();
@ -230,7 +253,12 @@ eOSState cRecMenuManager::StateMachine(eRecMenuState nextState) {
recFolder = menu->GetFolder();
}
delete activeMenu;
#if defined (APIVERSNUM) && (APIVERSNUM >= 20301)
LOCK_CHANNELS_READ;
const cChannel *channel = Channels->GetByChannelID(event->ChannelID());
#else
cChannel *channel = Channels.GetByChannelID(event->ChannelID());
#endif
activeMenu = new cRecMenuSeriesTimer(channel, event, recFolder);
activeMenu->Display();
break; }
@ -472,7 +500,11 @@ eOSState cRecMenuManager::StateMachine(eRecMenuState nextState) {
activeMenu = new cRecMenuRecordingSearch(searchString);
} else {
int numSearchResults = 0;
#if defined (APIVERSNUM) && (APIVERSNUM >= 20301)
const cRecording **searchResult = recManager->SearchForRecordings(searchString, numSearchResults);
#else
cRecording **searchResult = recManager->SearchForRecordings(searchString, numSearchResults);
#endif
if (numSearchResults == 0) {
activeMenu = new cRecMenuRecordingSearchNotFound(searchString);
} else {
@ -606,7 +638,12 @@ eOSState cRecMenuManager::StateMachine(eRecMenuState nextState) {
timerConflict = menu->GetTimerConflictIndex();
} else break;
int timerID = timerConflicts->GetCurrentConflictTimerID(timerConflict);
#if defined (APIVERSNUM) && (APIVERSNUM >= 20301)
LOCK_TIMERS_READ;
const cTimer *timer = Timers->Get(timerID);
#else
cTimer *timer = Timers.Get(timerID);
#endif
if (timer) {
const cEvent *event = timer->Event();
if (event) {
@ -648,7 +685,12 @@ eOSState cRecMenuManager::StateMachine(eRecMenuState nextState) {
originalConflictIndex = menu->GetTimerConflictIndex();
} else break;
int originalTimerID = timerConflicts->GetCurrentConflictTimerID(originalConflictIndex);
#if defined (APIVERSNUM) && (APIVERSNUM >= 20301)
LOCK_TIMERS_READ;
const cTimer *timerOriginal = Timers->Get(originalTimerID);
#else
cTimer *timerOriginal = Timers.Get(originalTimerID);
#endif
if (replace && timerOriginal) {
recManager->DeleteTimer(timerOriginal->Event());
recManager->createTimer(replace);
@ -674,7 +716,11 @@ eOSState cRecMenuManager::StateMachine(eRecMenuState nextState) {
activeMenu->Display();
break; }
case rmsTimelineTimerEdit: {
#if defined (APIVERSNUM) && (APIVERSNUM >= 20301)
const cTimer *timer;
#else
cTimer *timer;
#endif
if (cRecMenuTimeline *menu = dynamic_cast<cRecMenuTimeline*>(activeMenu)) {
timer = menu->GetTimer();
} else break;
@ -686,7 +732,11 @@ eOSState cRecMenuManager::StateMachine(eRecMenuState nextState) {
break;}
case rmsTimelineTimerSave: {
cTimer timerModified;
#if defined (APIVERSNUM) && (APIVERSNUM >= 20301)
const cTimer *originalTimer;
#else
cTimer *originalTimer;
#endif
if (cRecMenuEditTimer *menu = dynamic_cast<cRecMenuEditTimer*>(activeMenu)) {
timerModified = menu->GetTimer();
originalTimer = menu->GetOriginalTimer();
@ -701,7 +751,11 @@ eOSState cRecMenuManager::StateMachine(eRecMenuState nextState) {
activeMenu->Display();
break; }
case rmsTimelineTimerDelete: {
#if defined (APIVERSNUM) && (APIVERSNUM >= 20301)
const cTimer *timer;
#else
cTimer *timer;
#endif
if (cRecMenuEditTimer *menu = dynamic_cast<cRecMenuEditTimer*>(activeMenu)) {
timer = menu->GetOriginalTimer();
} else break;
@ -818,9 +872,16 @@ void cRecMenuManager::DisplaySearchTimerList(void) {
activeMenu->Display();
}
#if defined (APIVERSNUM) && (APIVERSNUM >= 20301)
bool cRecMenuManager::DisplayTimerConflict(const cTimer *timer) {
int timerID = 0;
LOCK_TIMERS_READ;
for (const cTimer *t = Timers->First(); t; t = Timers->Next(t)) {
#else
bool cRecMenuManager::DisplayTimerConflict(cTimer *timer) {
int timerID = 0;
for (cTimer *t = Timers.First(); t; t = Timers.Next(t)) {
#endif
if (t == timer)
return DisplayTimerConflict(timerID);
timerID++;

4
recmenumanager.h
View File

@ -23,7 +23,11 @@ private:
void SetBackground(void);
void DeleteBackground(void);
void DisplaySearchTimerList(void);
#if defined (APIVERSNUM) && (APIVERSNUM >= 20301)
bool DisplayTimerConflict(const cTimer *timer);
#else
bool DisplayTimerConflict(cTimer *timer);
#endif
bool DisplayTimerConflict(int timerID);
void DisplayDetailedView(const cEvent *ev);
void DisplayFavoriteResults(std::string header, const cEvent **result, int numResults);

74
recmenus.c
View File

@ -105,7 +105,12 @@ std::string cRecMenuAskFolder::GetFolder(void) {
// --- cRecMenuConfirmTimer ---------------------------------------------------------
cRecMenuConfirmTimer::cRecMenuConfirmTimer(const cEvent *event) {
SetWidthPercent(50);
#if defined (APIVERSNUM) && (APIVERSNUM >= 20301)
LOCK_CHANNELS_READ;
const cString channelName = Channels->GetByChannelID(event->ChannelID())->Name();
#else
cString channelName = Channels.GetByChannelID(event->ChannelID())->Name();
#endif
cString message;
bool eventHasTimer = false;
if (tvguideConfig.useRemoteTimers && pRemoteTimers) {
@ -143,7 +148,12 @@ cRecMenuConfirmTimer::cRecMenuConfirmTimer(const cEvent *event) {
// --- cRecMenuConfirmDeleteTimer ---------------------------------------------------------
cRecMenuConfirmDeleteTimer::cRecMenuConfirmDeleteTimer(const cEvent *event) {
SetWidthPercent(50);
#if defined (APIVERSNUM) && (APIVERSNUM >= 20301)
LOCK_CHANNELS_READ;
const cString channelName = Channels->GetByChannelID(event->ChannelID())->Name();
#else
cString channelName = Channels.GetByChannelID(event->ChannelID())->Name();
#endif
cString text = cString::sprintf("%s\n%s\n%s %s - %s\n%s",
tr("Timer deleted"),
*channelName,
@ -165,7 +175,12 @@ cRecMenuConfirmDeleteTimer::cRecMenuConfirmDeleteTimer(const cEvent *event) {
// --- cRecMenuAskDeleteTimer ---------------------------------------------------------
cRecMenuAskDeleteTimer::cRecMenuAskDeleteTimer(const cEvent *event) {
SetWidthPercent(50);
#if defined (APIVERSNUM) && (APIVERSNUM >= 20301)
LOCK_CHANNELS_READ;
const cString channelName = Channels->GetByChannelID(event->ChannelID())->Name();
#else
cString channelName = Channels.GetByChannelID(event->ChannelID())->Name();
#endif
cString text = cString::sprintf("%s \"%s, %s\" %s",
tr("Timer"),
*channelName,
@ -228,7 +243,12 @@ cRecMenuTimerConflict::cRecMenuTimerConflict(cTVGuideTimerConflict *conflict) {
SetFooter(new cRecMenuItemButton(tr("Ignore Conflict"), rmsIgnoreTimerConflict, false, true));
int i=0;
for(std::vector<int>::iterator it = conflict->timerIDs.begin(); it != conflict->timerIDs.end(); it++) {
#if defined (APIVERSNUM) && (APIVERSNUM >= 20301)
LOCK_TIMERS_READ;
const cTimer *timer = Timers->Get(*it);
#else
const cTimer *timer = Timers.Get(*it);
#endif
if (timer) {
if (!AddMenuItemInitial(new cRecMenuItemTimer( timer,
rmsTimerConflictShowInfo,
@ -252,7 +272,12 @@ cRecMenuTimerConflict::cRecMenuTimerConflict(cTVGuideTimerConflict *conflict) {
cRecMenuItem *cRecMenuTimerConflict::GetMenuItem(int number) {
if ((number >= 0) && (number < conflict->timerIDs.size())) {
#if defined (APIVERSNUM) && (APIVERSNUM >= 20301)
LOCK_TIMERS_READ;
const cTimer *timer = Timers->Get(conflict->timerIDs[number]);
#else
const cTimer *timer = Timers.Get(conflict->timerIDs[number]);
#endif
cRecMenuItem *result = new cRecMenuItemTimer( timer,
rmsTimerConflictShowInfo,
rmsDeleteTimerConflictMenu,
@ -353,8 +378,14 @@ cRecMenuNoRerunsFound::cRecMenuNoRerunsFound(cString searchString) {
// --- cRecMenuConfirmRerunUsed ---------------------------------------------------------
cRecMenuConfirmRerunUsed::cRecMenuConfirmRerunUsed(const cEvent *original, const cEvent *replace) {
SetWidthPercent(70);
#if defined (APIVERSNUM) && (APIVERSNUM >= 20301)
LOCK_CHANNELS_READ;
const cString channelOrig = Channels->GetByChannelID(original->ChannelID())->Name();
const cString channelReplace = Channels->GetByChannelID(replace->ChannelID())->Name();
#else
cString channelOrig = Channels.GetByChannelID(original->ChannelID())->Name();
cString channelReplace = Channels.GetByChannelID(replace->ChannelID())->Name();
#endif
cString message1 = tr("Timer for");
cString message2 = tr("replaced by rerun");
cString text = cString::sprintf("%s\n\"%s\", %s %s, %s\n%s\n\"%s\", %s %s, %s",
@ -378,7 +409,12 @@ cRecMenuConfirmRerunUsed::cRecMenuConfirmRerunUsed(const cEvent *original, const
}
// --- cRecMenuEditTimer ---------------------------------------------------------
#if defined (APIVERSNUM) && (APIVERSNUM >= 20301)
cRecMenuEditTimer::cRecMenuEditTimer(const cTimer *timer, eRecMenuState nextState) {
const cTimer *originalTimer;
#else
cRecMenuEditTimer::cRecMenuEditTimer(cTimer *timer, eRecMenuState nextState) {
#endif
SetWidthPercent(70);
if (!timer)
return;
@ -435,7 +471,11 @@ cRecMenuEditTimer::cRecMenuEditTimer(cTimer *timer, eRecMenuState nextState) {
Arrange();
}
#if defined (APIVERSNUM) && (APIVERSNUM >= 20301)
const cTimer *cRecMenuEditTimer::GetOriginalTimer(void) {
#else
cTimer *cRecMenuEditTimer::GetOriginalTimer(void) {
#endif
return originalTimer;
}
@ -473,7 +513,11 @@ cTimer cRecMenuEditTimer::GetTimer(void) {
******************************************************************************************/
// --- cRecMenuSeriesTimer ---------------------------------------------------------
#if defined (APIVERSNUM) && (APIVERSNUM >= 20301)
cRecMenuSeriesTimer::cRecMenuSeriesTimer(const cChannel *initialChannel, const cEvent *event, std::string folder) {
#else
cRecMenuSeriesTimer::cRecMenuSeriesTimer(cChannel *initialChannel, const cEvent *event, std::string folder) {
#endif
if (!initialChannel)
return;
timerActive = true;
@ -508,7 +552,12 @@ cRecMenuSeriesTimer::cRecMenuSeriesTimer(cChannel *initialChannel, const cEvent
}
cTimer *cRecMenuSeriesTimer::GetTimer(void) {
#if defined (APIVERSNUM) && (APIVERSNUM >= 20301)
LOCK_CHANNELS_READ;
const cChannel *chan = Channels->GetByNumber(channel);
#else
cChannel *chan = Channels.GetByNumber(channel);
#endif
cTimer *seriesTimer = new cTimer(NULL, NULL, chan);
cString fileName = "TITLE EPISODE";
if (folder.size() > 0) {
@ -789,8 +838,14 @@ void cRecMenuSearchTimerEdit::InitMenuItems(void) {
startChannel = 1;
if (stopChannel == 0)
stopChannel = 1;
#if defined (APIVERSNUM) && (APIVERSNUM >= 20301)
LOCK_CHANNELS_READ;
useChannelSubMenu.push_back(new cRecMenuItemChannelChooser(tr("Start Channel"), Channels->GetByNumber(startChannel), false, &startChannel, rmsSearchTimerSave));
useChannelSubMenu.push_back(new cRecMenuItemChannelChooser(tr("Stop Channel"), Channels->GetByNumber(stopChannel), false, &stopChannel, rmsSearchTimerSave));
#else
useChannelSubMenu.push_back(new cRecMenuItemChannelChooser(tr("Start Channel"), Channels.GetByNumber(startChannel), false, &startChannel, rmsSearchTimerSave));
useChannelSubMenu.push_back(new cRecMenuItemChannelChooser(tr("Stop Channel"), Channels.GetByNumber(stopChannel), false, &stopChannel, rmsSearchTimerSave));
#endif
useTimeSubMenu.push_back(new cRecMenuItemTime(tr("Start after"), startTime, false, &startTime, rmsSearchTimerSave));
useTimeSubMenu.push_back(new cRecMenuItemTime(tr("Start before"), stopTime, false, &stopTime, rmsSearchTimerSave));
@ -1214,7 +1269,12 @@ const cEvent *cRecMenuSearchResults::GetEvent(void) {
// --- cRecMenuSearchConfirmTimer ---------------------------------------------------------
cRecMenuSearchConfirmTimer::cRecMenuSearchConfirmTimer(const cEvent *event, eRecMenuState nextAction) {
SetWidthPercent(50);
#if defined (APIVERSNUM) && (APIVERSNUM >= 20301)
LOCK_CHANNELS_READ;
const cString channelName = Channels->GetByChannelID(event->ChannelID())->Name();
#else
cString channelName = Channels.GetByChannelID(event->ChannelID())->Name();
#endif
cString message = tr("Timer created");
cString text = cString::sprintf("%s\n%s\n%s %s - %s\n%s",
*message,
@ -1279,7 +1339,11 @@ cRecMenuRecordingSearch::cRecMenuRecordingSearch(std::string search) {
}
// --- cRecMenuRecordingSearchResults ---------------------------------------------------------
#if defined (APIVERSNUM) && (APIVERSNUM >= 20301)
cRecMenuRecordingSearchResults::cRecMenuRecordingSearchResults(std::string searchString, const cRecording **searchResults, int numResults) {
#else
cRecMenuRecordingSearchResults::cRecMenuRecordingSearchResults(std::string searchString, cRecording **searchResults, int numResults) {
#endif
this->searchString = searchString;
this->searchResults = searchResults;
SetWidthPercent(80);
@ -1363,7 +1427,13 @@ void cRecMenuTimeline::SetStartStop(void) {
void cRecMenuTimeline::GetTimersForDay(void) {
timersToday.clear();
#if defined (APIVERSNUM) && (APIVERSNUM >= 20301)
LOCK_TIMERS_READ;
const cTimers* timers = Timers;
for (const cTimer *t = Timers->First(); t; t = Timers->Next(t)) {
#else
for (cTimer *t = Timers.First(); t; t = Timers.Next(t)) {
#endif
if (((t->StartTime() > timeStart) && (t->StartTime() <= timeStop)) || ((t->StopTime() > timeStart) && (t->StopTime() <= timeStop))) {
timersToday.push_back(t);
}
@ -1437,7 +1507,11 @@ void cRecMenuTimeline::ClearMenu(void) {
header->UnsetCurrentTimer();
}
#if defined (APIVERSNUM) && (APIVERSNUM >= 20301)
const cTimer *cRecMenuTimeline::GetTimer(void) {
#else
cTimer *cRecMenuTimeline::GetTimer(void) {
#endif
if (cRecMenuItemTimelineTimer *activeItem = dynamic_cast<cRecMenuItemTimelineTimer*>(GetActiveMenuItem()))
return activeItem->GetTimerValue();
return NULL;

31
recmenus.h
View File

@ -115,7 +115,11 @@ public:
// --- cRecMenuEditTimer ---------------------------------------------------------
class cRecMenuEditTimer: public cRecMenu {
private:
#if defined (APIVERSNUM) && (APIVERSNUM >= 20301)
const cTimer *originalTimer;
#else
cTimer *originalTimer;
#endif
bool timerActive;
time_t day;
int start;
@ -124,10 +128,15 @@ private:
int lifetime;
char folder[TEXTINPUTLENGTH];
public:
#if defined (APIVERSNUM) && (APIVERSNUM >= 20301)
cRecMenuEditTimer(const cTimer *timer, eRecMenuState nextState);
const cTimer *GetOriginalTimer(void);
#else
cRecMenuEditTimer(cTimer *timer, eRecMenuState nextState);
cTimer *GetOriginalTimer(void);
#endif
virtual ~cRecMenuEditTimer(void) {};
cTimer GetTimer(void);
cTimer *GetOriginalTimer(void);
};
/******************************************************************************************
@ -148,7 +157,11 @@ class cRecMenuSeriesTimer: public cRecMenu {
int lifetime;
void CalculateTimes(const cEvent *event);
public:
#if defined (APIVERSNUM) && (APIVERSNUM >= 20301)
cRecMenuSeriesTimer(const cChannel *initialChannel, const cEvent *event, std::string folder);
#else
cRecMenuSeriesTimer(cChannel *initialChannel, const cEvent *event, std::string folder);
#endif
virtual ~cRecMenuSeriesTimer(void) {};
cTimer *GetTimer(void);
};
@ -412,10 +425,18 @@ public:
class cRecMenuRecordingSearchResults: public cRecMenu {
private:
std::string searchString;
#if defined (APIVERSNUM) && (APIVERSNUM >= 20301)
const cRecording **searchResults;
#else
cRecording **searchResults;
#endif
int numResults;
public:
#if defined (APIVERSNUM) && (APIVERSNUM >= 20301)
cRecMenuRecordingSearchResults(std::string searchString, const cRecording **searchResults, int numResults);
#else
cRecMenuRecordingSearchResults(std::string searchString, cRecording **searchResults, int numResults);
#endif
cRecMenuItem *GetMenuItem(int number);
int GetTotalNumMenuItems(void);
virtual ~cRecMenuRecordingSearchResults(void) {
@ -438,7 +459,11 @@ public:
// --- cRecMenuTimeline ---------------------------------------------------------
class cRecMenuTimeline: public cRecMenu {
private:
#if defined (APIVERSNUM) && (APIVERSNUM >= 20301)
std::vector<const cTimer*> timersToday;
#else
std::vector<cTimer*> timersToday;
#endif
int numTimersToday;
time_t today;
time_t timeStart;
@ -459,7 +484,11 @@ public:
virtual ~cRecMenuTimeline(void) {
};
eRecMenuState ProcessKey(eKeys Key);
#if defined (APIVERSNUM) && (APIVERSNUM >= 20301)
const cTimer *GetTimer(void);
#else
cTimer *GetTimer(void);
#endif
};
/******************************************************************************************

44
searchtimer.c
View File

@ -16,8 +16,14 @@ cTVGuideSearchTimer::cTVGuideSearchTimer(void) {
startTime = 0000;
stopTime = 2359;
useChannel = false;
#if defined (APIVERSNUM) && (APIVERSNUM >= 20301)
LOCK_CHANNELS_READ;
channelMin = Channels->GetByNumber(cDevice::CurrentChannel());
channelMax = Channels->GetByNumber(cDevice::CurrentChannel());
#else
channelMin = Channels.GetByNumber(cDevice::CurrentChannel());
channelMax = Channels.GetByNumber(cDevice::CurrentChannel());
#endif
channelGroup = "";
useCase = false;
mode = 0;
@ -239,7 +245,12 @@ bool cTVGuideSearchTimer::Parse(bool readTemplate) {
char *channelMinbuffer = NULL;
char *channelMaxbuffer = NULL;
int channels = sscanf(values[value].c_str(), "%a[^|]|%a[^|]", &channelMinbuffer, &channelMaxbuffer);
#if defined (APIVERSNUM) && (APIVERSNUM >= 20301)
LOCK_CHANNELS_READ;
channelMin = Channels->GetByChannelID(tChannelID::FromString(channelMinbuffer), true, true);
#else
channelMin = Channels.GetByChannelID(tChannelID::FromString(channelMinbuffer), true, true);
#endif
if (!channelMin) {
channelMin = channelMax = NULL;
useChannel = 0;
@ -247,7 +258,11 @@ bool cTVGuideSearchTimer::Parse(bool readTemplate) {
if (channels == 1)
channelMax = channelMin;
else {
#if defined (APIVERSNUM) && (APIVERSNUM >= 20301)
channelMax = Channels->GetByChannelID(tChannelID::FromString(channelMaxbuffer), true, true);
#else
channelMax = Channels.GetByChannelID(tChannelID::FromString(channelMaxbuffer), true, true);
#endif
if (!channelMax) {
channelMin = channelMax = NULL;
useChannel = 0;
@ -511,7 +526,12 @@ int cTVGuideSearchTimer::GetNumTimers(void) {
int numTimers = 0;
if (ID < 0)
return numTimers;
#if defined (APIVERSNUM) && (APIVERSNUM >= 20301)
LOCK_TIMERS_READ;
for (const cTimer *timer = Timers->First(); timer; timer = Timers->Next(timer)) {
#else
for (cTimer *timer = Timers.First(); timer; timer = Timers.Next(timer)) {
#endif
char* searchID = GetAuxValue(timer, "s-id");
if (!searchID) continue;
if (ID == atoi(searchID))
@ -525,7 +545,12 @@ int cTVGuideSearchTimer::GetNumRecordings(void) {
int numRecordings = 0;
if (ID < 0)
return numRecordings;
#if defined (APIVERSNUM) && (APIVERSNUM >= 20301)
LOCK_RECORDINGS_READ;
for (const cRecording *recording = Recordings->First(); recording; recording = Recordings->Next(recording)) {
#else
for (cRecording *recording = Recordings.First(); recording; recording = Recordings.Next(recording)) {
#endif
if (recording->IsEdited())
continue;
if (!recording->Info())
@ -568,3 +593,22 @@ void cTVGuideSearchTimer::Dump(void) {
esyslog("tvguide searchtimer: useDescription: %d", useDescription);
}
void cTVGuideSearchTimer::SetStartChannel(int startChannel)
{
#if defined (APIVERSNUM) && (APIVERSNUM >= 20301)
LOCK_CHANNELS_READ;
channelMin = Channels->GetByNumber(startChannel);
#else
channelMin = Channels.GetByNumber(startChannel);
#endif
};
void cTVGuideSearchTimer::SetStopChannel(int stopChannel)
{
#if defined (APIVERSNUM) && (APIVERSNUM >= 20301)
LOCK_CHANNELS_READ;
channelMax = Channels->GetByNumber(stopChannel);
#else
channelMax = Channels.GetByNumber(stopChannel);
#endif
};

9
searchtimer.h
View File

@ -11,8 +11,13 @@ private:
int startTime;
int stopTime;
int useChannel;
#if defined (APIVERSNUM) && (APIVERSNUM >= 20301)
const cChannel *channelMin;
const cChannel *channelMax;
#else
cChannel *channelMin;
cChannel *channelMax;
#endif
std::string channelGroup;
int useCase;
int mode;
@ -106,8 +111,8 @@ public:
void SetUseSubtitle(bool useSubtitle) { this->useSubtitle = useSubtitle; };
void SetUseDesription(bool useDescription) { this->useDescription = useDescription; };
void SetUseChannel(bool useChannel) { this->useChannel = useChannel; };
void SetStartChannel(int startChannel) { channelMin = Channels.GetByNumber(startChannel); };
void SetStopChannel(int stopChannel) { channelMax = Channels.GetByNumber(stopChannel); };
void SetStartChannel(int startChannel);
void SetStopChannel(int stopChannel);
void SetUseTime(bool useTime) { this->useTime = useTime; };
void SetStartTime(int startTime) { this->startTime = startTime; };
void SetStopTime(int stopTime) { this->stopTime = stopTime; };

10
timerconflict.c
View File

@ -86,7 +86,12 @@ void cTVGuideTimerConflicts::CalculateConflicts(void) {
cTimeInterval *unionSet = NULL;
int numTimers = conflicts[i]->timerIDs.size();
for (int j=0; j < numTimers; j++) {
#if defined (APIVERSNUM) && (APIVERSNUM >= 20301)
LOCK_TIMERS_READ;
const cTimer *timer = Timers->Get(conflicts[i]->timerIDs[j]);
#else
const cTimer *timer = Timers.Get(conflicts[i]->timerIDs[j]);
#endif
if (timer) {
if (!unionSet) {
unionSet = new cTimeInterval(timer->StartTime(), timer->StopTime());
@ -105,7 +110,12 @@ void cTVGuideTimerConflicts::CalculateConflicts(void) {
cTimeInterval *intersect = NULL;
for (int j=0; j < numTimers; j++) {
#if defined (APIVERSNUM) && (APIVERSNUM >= 20301)
LOCK_TIMERS_READ;
const cTimer *timer = Timers->Get(conflicts[i]->timerIDs[j]);
#else
const cTimer *timer = Timers.Get(conflicts[i]->timerIDs[j]);
#endif
if (timer) {
if (!intersect) {
intersect = new cTimeInterval(timer->StartTime(), timer->StopTime());

57
tvguideosd.c
View File

@ -73,11 +73,20 @@ void cTvGuideOsd::Show(void) {
void cTvGuideOsd::drawOsd() {
cPixmap::Lock();
#if defined (APIVERSNUM) && (APIVERSNUM >= 20301)
LOCK_CHANNELS_READ;
const cChannel *startChannel = Channels->GetByNumber(cDevice::CurrentChannel());
#else
cChannel *startChannel = Channels.GetByNumber(cDevice::CurrentChannel());
#endif
int numBack = tvguideConfig.numGrids / 2;
int offset = 0;
const cChannel *newStartChannel = startChannel;
#if defined (APIVERSNUM) && (APIVERSNUM >= 20301)
for (; newStartChannel ; newStartChannel = Channels->Prev(newStartChannel)) {
#else
for (; newStartChannel ; newStartChannel = Channels.Prev(newStartChannel)) {
#endif
if (newStartChannel && !newStartChannel->GroupSep()) {
offset++;
}
@ -85,7 +94,11 @@ void cTvGuideOsd::drawOsd() {
break;
}
if (!newStartChannel)
#if defined (APIVERSNUM) && (APIVERSNUM >= 20301)
newStartChannel = Channels->First();
#else
newStartChannel = Channels.First();
#endif
offset--;
if (offset < 0)
offset = 0;
@ -122,7 +135,12 @@ void cTvGuideOsd::readChannels(const cChannel *channelStart) {
columns.Clear();
if (!channelStart)
return;
#if defined (APIVERSNUM) && (APIVERSNUM >= 20301)
LOCK_CHANNELS_READ;
for (const cChannel *channel = channelStart; channel; channel = Channels->Next(channel)) {
#else
for (const cChannel *channel = channelStart; channel; channel = Channels.Next(channel)) {
#endif
if (!channel->GroupSep()) {
if (channelGroups->IsInLastGroup(channel)) {
break;
@ -144,7 +162,11 @@ void cTvGuideOsd::readChannels(const cChannel *channelStart) {
int numCurrent = columns.Count();
int numBack = tvguideConfig.numGrids - numCurrent;
int newChannelNumber = columns.First()->getChannel()->Number() - numBack;
#if defined (APIVERSNUM) && (APIVERSNUM >= 20301)
const cChannel *newStart = Channels->GetByNumber(newChannelNumber);
#else
const cChannel *newStart = Channels.GetByNumber(newChannelNumber);
#endif
readChannels(newStart);
}
}
@ -213,7 +235,12 @@ void cTvGuideOsd::channelForward() {
bool colAdded = false;
if (!colRight) {
const cChannel *channelRight = activeGrid->column->getChannel();
#if defined (APIVERSNUM) && (APIVERSNUM >= 20301)
LOCK_CHANNELS_READ;
while (channelRight = Channels->Next(channelRight)) {
#else
while (channelRight = Channels.Next(channelRight)) {
#endif
if (!channelRight->GroupSep()) {
if (channelGroups->IsInLastGroup(channelRight)) {
break;
@ -263,7 +290,12 @@ void cTvGuideOsd::channelBack() {
bool colAdded = false;
if (!colLeft) {
const cChannel *channelLeft = activeGrid->column->getChannel();
#if defined (APIVERSNUM) && (APIVERSNUM >= 20301)
LOCK_CHANNELS_READ;
while (channelLeft = Channels->Prev(channelLeft)) {
#else
while (channelLeft = Channels.Prev(channelLeft)) {
#endif
if (!channelLeft->GroupSep()) {
colLeft = new cChannelColumn(0, channelLeft, myTime);
if (colLeft->readGrids()) {
@ -434,11 +466,21 @@ void cTvGuideOsd::processKeyGreen() {
if (tvguideConfig.channelJumpMode == eGroupJump) {
int prevNum = channelGroups->GetPrevGroupChannelNumber(currentChannel);
if (prevNum) {
#if defined (APIVERSNUM) && (APIVERSNUM >= 20301)
LOCK_CHANNELS_READ;
prev = Channels->GetByNumber(prevNum);
#else
prev = Channels.GetByNumber(prevNum);
#endif
}
} else if (tvguideConfig.channelJumpMode == eNumJump) {
int i = tvguideConfig.jumpChannels + 1;
#if defined (APIVERSNUM) && (APIVERSNUM >= 20301)
LOCK_CHANNELS_READ;
for (const cChannel *channel = firstChannel; channel; channel = Channels->Prev(channel)) {
#else
for (const cChannel *channel = firstChannel; channel; channel = Channels.Prev(channel)) {
#endif
if (!channel->GroupSep()) {
prev = channel;
i--;
@ -470,11 +512,21 @@ void cTvGuideOsd::processKeyYellow() {
if (tvguideConfig.channelJumpMode == eGroupJump) {
int nextNum = channelGroups->GetNextGroupChannelNumber(currentChannel);
if (nextNum) {
#if defined (APIVERSNUM) && (APIVERSNUM >= 20301)
LOCK_CHANNELS_READ;
next = Channels->GetByNumber(nextNum);
#else
next = Channels.GetByNumber(nextNum);
#endif
}
} else if (tvguideConfig.channelJumpMode == eNumJump) {
int i=0;
#if defined (APIVERSNUM) && (APIVERSNUM >= 20301)
LOCK_CHANNELS_READ;
for (const cChannel *channel = firstChannel; channel; channel = Channels->Next(channel)) {
#else
for (const cChannel *channel = firstChannel; channel; channel = Channels.Next(channel)) {
#endif
if (channelGroups->IsInLastGroup(channel)) {
break;
}
@ -625,7 +677,12 @@ void cTvGuideOsd::CheckTimeout(void) {
int newChannelNum = channelJumper->GetChannel();
delete channelJumper;
channelJumper = NULL;
#if defined (APIVERSNUM) && (APIVERSNUM >= 20301)
LOCK_CHANNELS_READ;
const cChannel *newChannel = Channels->GetByNumber(newChannelNum);
#else
const cChannel *newChannel = Channels.GetByNumber(newChannelNum);
#endif
if (newChannel) {
readChannels(newChannel);
if (columns.Count() > 0) {

10
view.c
View File

@ -120,7 +120,12 @@ void cView::DrawHeader(void) {
pixmapHeader->DrawText(cPoint(xText, ySubtitle), CutText(subTitle, textWidthMax, fontHeader).c_str(), theme.Color(clrFont), theme.Color(clrStatusHeader), fontHeader);
//REC Icon
eTimerMatch timerMatch=tmNone;
#if defined (APIVERSNUM) && (APIVERSNUM >= 20301)
LOCK_TIMERS_READ;
const cTimer *ti;
#else
cTimer *ti;
#endif
if (!event)
return;
if (tvguideConfig.useRemoteTimers && pRemoteTimers) {
@ -130,7 +135,12 @@ void cView::DrawHeader(void) {
timerMatch = (eTimerMatch)rtMatch.timerMatch;
ti = rtMatch.timer;
} else {
#if defined (APIVERSNUM) && (APIVERSNUM >= 20301)
LOCK_TIMERS_READ;
ti=Timers->GetMatch(event, &timerMatch);
#else
ti=Timers.GetMatch(event, &timerMatch);
#endif
}
if (timerMatch == tmFull) {
cString recIconText(" REC ");