fixed line breaks

1 files changed, 530 insertions, 530 deletions

diff --git a/coreengine/viewelementscommon.c b/coreengine/viewelementscommon.c
index 92538e5..0f9c85c 100644
--- a/coreengine/viewelementscommon.c
+++ b/coreengine/viewelementscommon.c
@@ -1,531 +1,531 @@
-#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;

+#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;
 }
\ No newline at end of file