Version 0.8.0 beta

1 files changed, 531 insertions, 0 deletions

diff --git a/coreengine/viewelementscommon.c b/coreengine/viewelementscommon.c
new file mode 100644
index 0000000..92538e5
--- /dev/null
+++ b/coreengine/viewelementscommon.c
@@ -0,0 +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;

+}
\ No newline at end of file