frodovdr/vdr-plugin-skindesigner
1
0
Fork 0
mirror of https://projects.vdr-developer.org/git/vdr-plugin-skindesigner.git synced 2023-10-19 17:58:31 +02:00
Code Issues Releases Wiki Activity
c0297c01dc
vdr-plugin-skindesigner/coreengine/viewelementscommon.c
louis ac0e6dbc8d fixed line breaks
2016-02-06 09:55:15 +01:00

531 lines
22 KiB
C
Raw Blame History

#include "viewelementscommon.h"
#include "../config.h"
#include "../services/weatherforecast.h"
/******************************************************************
* cVeDateTime
******************************************************************/
cVeDateTime::cVeDateTime(void) {
lastMinute = -1;
}
cVeDateTime::~cVeDateTime(void) {
}
void cVeDateTime::Close(void) {
lastMinute = -1;
cViewElement::Close();
}
void cVeDateTime::SetTokenContainer(void) {
tokenContainer = new skindesignerapi::cTokenContainer();
tokenContainer->DefineStringToken("{time}", (int)eDateTimeST::time);
tokenContainer->DefineStringToken("{dayleadingzero}", (int)eDateTimeST::dayleadingzero);
tokenContainer->DefineStringToken("{dayname}", (int)eDateTimeST::dayname);
tokenContainer->DefineStringToken("{daynameshort}", (int)eDateTimeST::daynameshort);
tokenContainer->DefineStringToken("{month}", (int)eDateTimeST::month);
tokenContainer->DefineStringToken("{monthname}", (int)eDateTimeST::monthname);
tokenContainer->DefineStringToken("{monthnameshort}", (int)eDateTimeST::monthnameshort);
tokenContainer->DefineIntToken("{day}", (int)eDateTimeIT::day);
tokenContainer->DefineIntToken("{year}", (int)eDateTimeIT::year);
InheritTokenContainer();
}
bool cVeDateTime::Parse(bool forced) {
if (!cViewElement::Parse(forced))
return false;
time_t t = time(0); // get time now
struct tm * now = localtime(&t);
int min = now->tm_min;
if (!forced && min == lastMinute) {
return false;
}
lastMinute = min;
SetDirty();
tokenContainer->Clear();
tokenContainer->AddIntToken((int)eDateTimeIT::year, now->tm_year + 1900);
tokenContainer->AddIntToken((int)eDateTimeIT::day, now->tm_mday);
char monthname[20];
char monthshort[10];
strftime(monthshort, sizeof(monthshort), "%b", now);
strftime(monthname, sizeof(monthname), "%B", now);
tokenContainer->AddStringToken((int)eDateTimeST::monthname, monthname);
tokenContainer->AddStringToken((int)eDateTimeST::monthnameshort, monthshort);
tokenContainer->AddStringToken((int)eDateTimeST::month, *cString::sprintf("%02d", now->tm_mon + 1));
tokenContainer->AddStringToken((int)eDateTimeST::dayleadingzero, *cString::sprintf("%02d", now->tm_mday));
tokenContainer->AddStringToken((int)eDateTimeST::dayname, *WeekDayNameFull(now->tm_wday));
tokenContainer->AddStringToken((int)eDateTimeST::daynameshort, *WeekDayName(now->tm_wday));
tokenContainer->AddStringToken((int)eDateTimeST::time, *TimeString(t));
return true;
}
/******************************************************************
* cVeTime
******************************************************************/
cVeTime::cVeTime(void) {
lastSecond = -1;
}
cVeTime::~cVeTime(void) {
}
void cVeTime::Close(void) {
lastSecond = -1;
cViewElement::Close();
}
void cVeTime::SetTokenContainer(void) {
tokenContainer = new skindesignerapi::cTokenContainer();
tokenContainer->DefineIntToken("{sec}", (int)eTimeIT::sec);
tokenContainer->DefineIntToken("{min}", (int)eTimeIT::min);
tokenContainer->DefineIntToken("{hour}", (int)eTimeIT::hour);
tokenContainer->DefineIntToken("{hmins}", (int)eTimeIT::hmins);
InheritTokenContainer();
}
bool cVeTime::Parse(bool forced) {
if (!cViewElement::Parse(forced))
return false;
time_t t = time(0); // get time now
struct tm * now = localtime(&t);
int sec = now->tm_sec;
if (!forced && sec == lastSecond) {
return false;
}
lastSecond = sec;
SetDirty();
int min = now->tm_min;
int hour = now->tm_hour;
int hourMinutes = hour%12 * 5 + min / 12;
tokenContainer->Clear();
tokenContainer->AddIntToken((int)eTimeIT::sec, sec);
tokenContainer->AddIntToken((int)eTimeIT::min, min);
tokenContainer->AddIntToken((int)eTimeIT::hour, hour);
tokenContainer->AddIntToken((int)eTimeIT::hmins, hourMinutes);
return true;
}
/******************************************************************
* cVeMessage
******************************************************************/
cVeMessage::cVeMessage(void) {
changed = false;
text = NULL;
type = mtStatus;
}
cVeMessage::~cVeMessage(void) {
free(text);
}
void cVeMessage::SetTokenContainer(void) {
tokenContainer = new skindesignerapi::cTokenContainer();
tokenContainer->DefineStringToken("{text}", (int)eMessageST::text);
tokenContainer->DefineIntToken("{status}", (int)eMessageIT::status);
tokenContainer->DefineIntToken("{info}", (int)eMessageIT::info);
tokenContainer->DefineIntToken("{warning}", (int)eMessageIT::warning);
tokenContainer->DefineIntToken("{error}", (int)eMessageIT::error);
InheritTokenContainer();
}
void cVeMessage::Set(eMessageType type, const char *text) {
if (!text)
return;
free(this->text);
this->text = strdup(text);
this->type = type;
changed = true;
}
bool cVeMessage::Parse(bool forced) {
if (!cViewElement::Parse(forced) || !changed)
return false;
tokenContainer->Clear();
tokenContainer->AddIntToken((int)eMessageIT::status, (type == mtStatus) ? true : false);
tokenContainer->AddIntToken((int)eMessageIT::info, (type == mtInfo) ? true : false);
tokenContainer->AddIntToken((int)eMessageIT::warning, (type == mtWarning) ? true : false);
tokenContainer->AddIntToken((int)eMessageIT::error, (type == mtError) ? true : false);
tokenContainer->AddStringToken((int)eMessageST::text, text);
SetDirty();
changed = false;
return true;
}
/******************************************************************
* cVeDevices
******************************************************************/
cVeDevices::cVeDevices(void) {
lastRefresh = 0;
initial = true;
devicesIndex = -1;
lastSignalStrength = NULL;
lastSignalQuality = NULL;
recDevices = NULL;
}
cVeDevices::~cVeDevices(void) {
mutexDevices.Lock();
delete[] lastSignalStrength;
lastSignalStrength = NULL;
delete[] lastSignalQuality;
lastSignalQuality = NULL;
delete[] recDevices;
recDevices = NULL;
mutexDevices.Unlock();
}
void cVeDevices::Init(void) {
light = (attribs->Mode() == (int)eViewElementMode::light) ? true : false;
int totalDevices = cDevice::NumDevices();
for (int i = 0; i < totalDevices; i++) {
const cDevice *device = cDevice::GetDevice(i);
if (!device || !device->NumProvidedSystems()) {
continue;
}
devices.push_back(i);
}
numDevices = devices.size();
lastSignalStrength = new int[numDevices];
lastSignalQuality = new int[numDevices];
recDevices = new bool[numDevices];
mutexDevices.Lock();
for (int i=0; i<numDevices; i++) {
lastSignalStrength[i] = 0;
lastSignalQuality[i] = 0;
recDevices[i] = false;
}
mutexDevices.Unlock();
}
void cVeDevices::Close(void) {
devices.clear();
initial = true;
numDevices = 0;
mutexDevices.Lock();
delete[] lastSignalStrength;
lastSignalStrength = NULL;
delete[] lastSignalQuality;
lastSignalQuality = NULL;
delete[] recDevices;
recDevices = NULL;
mutexDevices.Unlock();
cViewElement::Close();
}
void cVeDevices::SetTokenContainer(void) {
tokenContainer = new skindesignerapi::cTokenContainer();
tokenContainer->DefineIntToken("{numdevices}", (int)eDevicesIT::numdevices);
tokenContainer->DefineLoopToken("{devices[num]}", (int)eDevicesLT::num);
tokenContainer->DefineLoopToken("{devices[type]}", (int)eDevicesLT::type);
tokenContainer->DefineLoopToken("{devices[istuned]}", (int)eDevicesLT::istuned);
tokenContainer->DefineLoopToken("{devices[livetv]}", (int)eDevicesLT::livetv);
tokenContainer->DefineLoopToken("{devices[recording]}", (int)eDevicesLT::recording);
tokenContainer->DefineLoopToken("{devices[hascam]}", (int)eDevicesLT::hascam);
tokenContainer->DefineLoopToken("{devices[cam]}", (int)eDevicesLT::cam);
tokenContainer->DefineLoopToken("{devices[signalstrength]}", (int)eDevicesLT::signalstrength);
tokenContainer->DefineLoopToken("{devices[signalquality]}", (int)eDevicesLT::signalquality);
tokenContainer->DefineLoopToken("{devices[channelnumber]}", (int)eDevicesLT::channelnumber);
tokenContainer->DefineLoopToken("{devices[channelname]}", (int)eDevicesLT::channelname);
tokenContainer->DefineLoopToken("{devices[channellogoexists]}", (int)eDevicesLT::channellogoexists);
tokenContainer->DefineLoopToken("{devices[channelid]}", (int)eDevicesLT::channelid);
tokenContainer->DefineLoopToken("{devices[source]}", (int)eDevicesLT::source);
devicesIndex = tokenContainer->LoopIndex("devices");
InheritTokenContainer();
}
bool cVeDevices::Parse(bool forced) {
if (!cViewElement::Parse(forced))
return false;
if (initial) {
Init();
initial = false;
} else {
//in light modus content is static
if (light)
return false;
//check if drawing is necessary
if (lastRefresh - cTimeMs::Now() < 500)
return false;
bool changed = false;
for (int i = 0; i < numDevices; i++) {
const cDevice *device = cDevice::GetDevice(devices[i]);
if (!device || !device->NumProvidedSystems()) {
continue;
}
int signalStrength = device->SignalStrength();
int signalQuality = device->SignalQuality();
int lastSigStr = 0;
int lastSigQual = 0;
mutexDevices.Lock();
if (lastSignalStrength && lastSignalQuality) {
lastSigStr = lastSignalStrength[i];
lastSigQual = lastSignalQuality[i];
}
mutexDevices.Unlock();
if ((signalStrength != lastSigStr) || (signalQuality != lastSigQual)) {
changed = true;
break;
}
}
if (!changed) {
return false;
}
}
//check device which currently displays live tv
int deviceLiveTV = -1;
cDevice *primaryDevice = cDevice::PrimaryDevice();
if (primaryDevice) {
if (!primaryDevice->Replaying() || primaryDevice->Transferring())
deviceLiveTV = cDevice::ActualDevice()->DeviceNumber();
else
deviceLiveTV = primaryDevice->DeviceNumber();
}
//check currently recording devices
for (cTimer *timer = Timers.First(); timer; timer = Timers.Next(timer)) {
if (!timer->Recording()) {
continue;
}
if (cRecordControl *RecordControl = cRecordControls::GetRecordControl(timer)) {
const cDevice *recDevice = RecordControl->Device();
if (recDevice) {
mutexDevices.Lock();
if (recDevices)
recDevices[recDevice->DeviceNumber()] = true;
mutexDevices.Unlock();
}
}
}
//create loop container
tokenContainer->Clear();
vector<int> loopInfo;
loopInfo.push_back(numDevices);
tokenContainer->CreateLoopTokenContainer(&loopInfo);
tokenContainer->AddIntToken((int)eDevicesIT::numdevices, numDevices);
for (int i = 0; i < numDevices; i++) {
const cDevice *device = cDevice::GetDevice(devices[i]);
if (!device || !device->NumProvidedSystems()) {
continue;
}
tokenContainer->AddLoopToken(devicesIndex, i, (int)eDevicesLT::num, *cString::sprintf("%d", i));
tokenContainer->AddLoopToken(devicesIndex, i, (int)eDevicesLT::type, *(device->DeviceType()));
cCamSlot *camSlot = device->CamSlot();
int camNumber = -1;
if (camSlot) {
camNumber = camSlot->SlotNumber();
tokenContainer->AddLoopToken(devicesIndex, i, (int)eDevicesLT::hascam, "1");
} else {
tokenContainer->AddLoopToken(devicesIndex, i, (int)eDevicesLT::hascam, "0");
}
tokenContainer->AddLoopToken(devicesIndex, i, (int)eDevicesLT::cam, *cString::sprintf("%d", camNumber));
int signalStrength = 0;
int signalQuality = 0;
if (!light) {
signalStrength = device->SignalStrength();
signalQuality = device->SignalQuality();
}
tokenContainer->AddLoopToken(devicesIndex, i, (int)eDevicesLT::signalstrength, *cString::sprintf("%d", signalStrength));
tokenContainer->AddLoopToken(devicesIndex, i, (int)eDevicesLT::signalstrength, *cString::sprintf("%d", signalQuality));
tokenContainer->AddLoopToken(devicesIndex, i, (int)eDevicesLT::livetv, i == deviceLiveTV ? "1" : "0");
bool isRecording = false;
mutexDevices.Lock();
if (recDevices && recDevices[i])
isRecording = true;
mutexDevices.Unlock();
tokenContainer->AddLoopToken(devicesIndex, i, (int)eDevicesLT::recording, isRecording ? "1" : "0");
const cChannel *channel = device->GetCurrentlyTunedTransponder();
const cSource *source = (channel) ? Sources.Get(channel->Source()) : NULL;
if (channel && channel->Number() > 0) {
tokenContainer->AddLoopToken(devicesIndex, i, (int)eDevicesLT::channelnumber, *cString::sprintf("%d", channel->Number()));
tokenContainer->AddLoopToken(devicesIndex, i, (int)eDevicesLT::channelname, channel->Name());
string channelID = *(channel->GetChannelID().ToString());
tokenContainer->AddLoopToken(devicesIndex, i, (int)eDevicesLT::channelid, channelID.c_str());
tokenContainer->AddLoopToken(devicesIndex, i, (int)eDevicesLT::channellogoexists, imgCache->LogoExists(channelID) ? "1" : "0");
tokenContainer->AddLoopToken(devicesIndex, i, (int)eDevicesLT::istuned, "1");
} else {
tokenContainer->AddLoopToken(devicesIndex, i, (int)eDevicesLT::istuned, "0");
}
tokenContainer->AddLoopToken(devicesIndex, i, (int)eDevicesLT::source, source ? source->Description() : "");
mutexDevices.Lock();
if (lastSignalStrength)
lastSignalStrength[i] = signalStrength;
if (lastSignalQuality)
lastSignalQuality[i] = signalQuality;
mutexDevices.Unlock();
}
SetDirty();
lastRefresh = cTimeMs::Now();
return true;
}
/******************************************************************
* cVeCurrentWeather
******************************************************************/
cVeCurrentWeather::cVeCurrentWeather(void) {
}
cVeCurrentWeather::~cVeCurrentWeather(void) {
}
void cVeCurrentWeather::SetTokenContainer(void) {
tokenContainer = new skindesignerapi::cTokenContainer();
tokenContainer->DefineStringToken("{timestamp}", (int)eCurrentWeatherST::timestamp);
tokenContainer->DefineStringToken("{summary}", (int)eCurrentWeatherST::summary);
tokenContainer->DefineStringToken("{icon}", (int)eCurrentWeatherST::icon);
tokenContainer->DefineStringToken("{precipitationtype}", (int)eCurrentWeatherST::precipitationtype);
tokenContainer->DefineStringToken("{windbearingstring}", (int)eCurrentWeatherST::windbearingstring);
tokenContainer->DefineStringToken("{temperature}", (int)eCurrentWeatherST::temperature);
tokenContainer->DefineStringToken("{apparenttemperature}", (int)eCurrentWeatherST::apparenttemperature);
tokenContainer->DefineStringToken("{mintemperature}", (int)eCurrentWeatherST::mintemperature);
tokenContainer->DefineStringToken("{maxtemperature}", (int)eCurrentWeatherST::maxtemperature);
tokenContainer->DefineStringToken("{precipitationintensity}", (int)eCurrentWeatherST::precipitationintensity);
tokenContainer->DefineStringToken("{windspeed}", (int)eCurrentWeatherST::windspeed);
tokenContainer->DefineStringToken("{visibility}", (int)eCurrentWeatherST::visibility);
tokenContainer->DefineStringToken("{pressure}", (int)eCurrentWeatherST::pressure);
tokenContainer->DefineStringToken("{ozone}", (int)eCurrentWeatherST::ozone);
tokenContainer->DefineIntToken("{precipitationprobability}", (int)eCurrentWeatherIT::precipitationprobability);
tokenContainer->DefineIntToken("{humidity}", (int)eCurrentWeatherIT::humidity);
tokenContainer->DefineIntToken("{windbearing}", (int)eCurrentWeatherIT::windbearing);
tokenContainer->DefineIntToken("{cloudcover}", (int)eCurrentWeatherIT::cloudcover);
InheritTokenContainer();
}
bool cVeCurrentWeather::Parse(bool forced) {
if (!cViewElement::Parse(forced))
return false;
static cPlugin *pWeatherForecast = cPluginManager::GetPlugin("weatherforecast");
if (!pWeatherForecast)
return false;
cServiceCurrentWeather currentWeather;
if (!pWeatherForecast->Service("GetCurrentWeather", &currentWeather)) {
return false;
}
SetDirty();
tokenContainer->Clear();
tokenContainer->AddStringToken((int)eCurrentWeatherST::timestamp, currentWeather.timeStamp.c_str());
tokenContainer->AddStringToken((int)eCurrentWeatherST::temperature, currentWeather.temperature.c_str());
tokenContainer->AddStringToken((int)eCurrentWeatherST::apparenttemperature, currentWeather.apparentTemperature.c_str());
tokenContainer->AddStringToken((int)eCurrentWeatherST::mintemperature, currentWeather.minTemperature.c_str());
tokenContainer->AddStringToken((int)eCurrentWeatherST::maxtemperature, currentWeather.maxTemperature.c_str());
tokenContainer->AddStringToken((int)eCurrentWeatherST::summary, currentWeather.summary.c_str());
tokenContainer->AddStringToken((int)eCurrentWeatherST::icon, currentWeather.icon.c_str());
tokenContainer->AddStringToken((int)eCurrentWeatherST::precipitationintensity, currentWeather.precipitationIntensity.c_str());
tokenContainer->AddStringToken((int)eCurrentWeatherST::precipitationtype, currentWeather.precipitationType.c_str());
tokenContainer->AddStringToken((int)eCurrentWeatherST::windspeed, currentWeather.windSpeed.c_str());
tokenContainer->AddStringToken((int)eCurrentWeatherST::windbearingstring, currentWeather.windBearingString.c_str());
tokenContainer->AddStringToken((int)eCurrentWeatherST::visibility, currentWeather.visibility.c_str());
tokenContainer->AddStringToken((int)eCurrentWeatherST::pressure, currentWeather.pressure.c_str());
tokenContainer->AddStringToken((int)eCurrentWeatherST::ozone, currentWeather.ozone.c_str());
tokenContainer->AddIntToken((int)eCurrentWeatherIT::precipitationprobability, currentWeather.precipitationProbability);
tokenContainer->AddIntToken((int)eCurrentWeatherIT::humidity, currentWeather.humidity);
tokenContainer->AddIntToken((int)eCurrentWeatherIT::windbearing, currentWeather.windBearing);
tokenContainer->AddIntToken((int)eCurrentWeatherIT::cloudcover, currentWeather.cloudCover);
return true;
}
/******************************************************************
* cVeCustomTokens
******************************************************************/
cVeCustomTokens::cVeCustomTokens(void) {
}
cVeCustomTokens::~cVeCustomTokens(void) {
}
void cVeCustomTokens::Reset(void) {
globals->ResetCustomTokenChange();
}
void cVeCustomTokens::SetTokenContainer(void) {
tokenContainer = new skindesignerapi::cTokenContainer();
int numTokens = config.numCustomTokens;
for (int i=0; i < numTokens; i++) {
cString nameIntToken = cString::sprintf("{customint%d}", i+1);
cString nameStringToken = cString::sprintf("{customstring%d}", i+1);
tokenContainer->DefineStringToken(*nameStringToken, i);
tokenContainer->DefineIntToken(*nameIntToken, i);
}
InheritTokenContainer();
}
bool cVeCustomTokens::Parse(bool forced) {
if (!cViewElement::Parse(forced))
return false;
if (!globals->CustomTokenChange())
return false;
tokenContainer->Clear();
map <int, string> customStringTokens = globals->GetCustomStringTokens();
for (map<int, string>::iterator it = customStringTokens.begin(); it != customStringTokens.end(); it++) {
int index = it->first;
if (index > 0 && index <= config.numCustomTokens) {
tokenContainer->AddStringToken(index-1, it->second.c_str());
}
}
map <int, int> customIntTokkens = globals-> GetCustomIntTokens();
for (map<int, int>::iterator it = customIntTokkens.begin(); it != customIntTokkens.end(); it++) {
int index = it->first;
if (index > 0 && index <= config.numCustomTokens) {
tokenContainer->AddIntToken(index-1, it->second);
}
}
SetDirty();
return true;
}
/******************************************************************
* cVeVolume
******************************************************************/
cVeVolume::cVeVolume(void) {
current = 0;
total = 0;
mute = false;
changed = true;
}
cVeVolume::~cVeVolume(void) {
}
void cVeVolume::SetTokenContainer(void) {
tokenContainer = new skindesignerapi::cTokenContainer();
tokenContainer->DefineIntToken("{volume}", (int)eDVVolumeIT::volume);
tokenContainer->DefineIntToken("{volpercent}", (int)eDVVolumeIT::volpercent);
tokenContainer->DefineIntToken("{maxvolume}", (int)eDVVolumeIT::maxvolume);
tokenContainer->DefineIntToken("{mute}", (int)eDVVolumeIT::mute);
InheritTokenContainer();
}
void cVeVolume::Set(int current, int total, bool mute) {
this->current = current;
this->total = total;
this->mute = mute;
changed = true;
}
bool cVeVolume::Parse(bool forced) {
if (!cViewElement::Parse(forced) || !changed)
return false;
tokenContainer->Clear();
tokenContainer->AddIntToken((int)eDVVolumeIT::volume, current);
tokenContainer->AddIntToken((int)eDVVolumeIT::maxvolume, total);
tokenContainer->AddIntToken((int)eDVVolumeIT::volpercent, (double)current *100 / (double)total);
tokenContainer->AddIntToken((int)eDVVolumeIT::mute, mute);
changed = false;
SetDirty();
return true;
}
Reference in New Issue View Git Blame Copy Permalink