diff -r 000000000000 -r 16d8024aca5e src/hbcore/effects/hbeffectfxmldata.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/hbcore/effects/hbeffectfxmldata.cpp Mon Apr 19 14:02:13 2010 +0300 @@ -0,0 +1,376 @@ +/**************************************************************************** +** +** Copyright (C) 2008-2010 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (developer.feedback@nokia.com) +** +** This file is part of the HbCore module of the UI Extensions for Mobile. +** +** GNU Lesser General Public License Usage +** This file may be used under the terms of the GNU Lesser General Public +** License version 2.1 as published by the Free Software Foundation and +** appearing in the file LICENSE.LGPL included in the packaging of this file. +** Please review the following information to ensure the GNU Lesser General +** Public License version 2.1 requirements will be met: +** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain additional +** rights. These rights are described in the Nokia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** If you have questions regarding the use of this file, please contact +** Nokia at developer.feedback@nokia.com. +** +****************************************************************************/ + +#include "hbeffectfxmldata_p.h" +#include + +static const float LoopUndefined = -1; + +// 0.0 is min allowed value but comparing it to this value for fuzzy comparison +static const float LoopMinDefined = -0.00001f; + +/* + + HbEffectFxmlData, HbEffectFxmlFilterData and HbEffectFxmlParamData are sharable classes, + HbEffectFxmlData and HbEffectFxmlParamData are sharable classes, + i.e. they can be created with the HbMemoryManager::SharedMemory type, + in which case all their internal data will be allocated from a shared + memory chunk instead of using normal new, malloc, etc. This means that + they will not contain any pointers to memory allocated within the + creator process so other processes can access the same data by + receiving the offset via IPC and performing a cast to get a valid + HbEffectFxmlData pointer. + + Note that passing HbMemoryManager::SharedMemory will lead to + assertions and failures in regular applications, this flag should only + be used in the theme server because the shared memory is not writable + for other applications. + + The shared behavior can be disabled by passing + HbMemoryManager::HeapMemory to the constructors (which is also the + default). + + Note that the assignment and pass-by-value semantics (i.e. when does the data + get transferred from shared to local memory) depend on the underlying shared + container behavior, see HbVector and HbString. Clients usually do not have to + worry about this, as long as it is guaranteed that the shared memory content + will remain valid. + +*/ + +// class HbEffectFxmlFilterData + +HbEffectFxmlFilterData::HbEffectFxmlFilterData(HbMemoryManager::MemoryType memType) + : mMemoryType(memType), + mType(memType), + mBlending(memType), + mFxmlParams(memType) +{ +} + +HbEffectFxmlFilterData::~HbEffectFxmlFilterData() +{ +} + +QString HbEffectFxmlFilterData::type() const +{ + return mType; +} + +void HbEffectFxmlFilterData::setType(const QString &value) +{ + mType = value; +} + +QString HbEffectFxmlFilterData::blending() const +{ + return mBlending; +} + +void HbEffectFxmlFilterData::setBlending(const QString &value) +{ + mBlending = value; +} + +void HbEffectFxmlFilterData::appendParamData(const HbEffectFxmlParamData &data) +{ + mFxmlParams.append(data); +} + +QList HbEffectFxmlFilterData::paramData() const +{ + // Make a regular QList. Note that some of the underlying structures may + // still stay in shared memory. + QList paramDataList; + foreach (const HbEffectFxmlParamData &data, mFxmlParams) { + paramDataList.append(data); + } + return paramDataList; +} + +HbMemoryManager::MemoryType HbEffectFxmlFilterData::memoryType() const +{ + return mMemoryType; +} + +// class HbEffectFxmlParamData + +HbEffectFxmlParamData::HbEffectFxmlParamData(HbMemoryManager::MemoryType memType) + : mMemoryType(memType), + mName(memType), + mValue(memType), + mDuration(memType), + mStartRef(memType), + mStartVal(memType), + mEndRef(memType), + mEndVal(memType), + mLoopStart(LoopUndefined), + mLoopEnd(LoopUndefined), + mAttributes(memType), + mKeyFrames(memType) +{ +} + +HbEffectFxmlParamData::~HbEffectFxmlParamData() +{ +} + +QString HbEffectFxmlParamData::name() const +{ + return mName; +} + +void HbEffectFxmlParamData::setName(const QString &value) +{ + mName = value; +} + +QString HbEffectFxmlParamData::duration() const +{ + return mDuration; +} + +void HbEffectFxmlParamData::setDuration(const QString &value) +{ + mDuration = value; +} + +QString HbEffectFxmlParamData::getAttribute(const QString &attrName) const +{ + foreach (const HbEffectFxmlAttrListEntry &a, mAttributes) { + if (a.mKey == attrName) + return a.mValue; + } + return QString(); +} + +void HbEffectFxmlParamData::setAttribute(const QString &attrName, const QString &value) +{ + for (int i = 0, ie = mAttributes.count(); i != ie; ++i) { + if (mAttributes.at(i).mKey == attrName) { + mAttributes[i].mValue = value; + return; + } + } + HbEffectFxmlAttrListEntry a(mMemoryType); + a.mKey = attrName; + a.mValue = value; + mAttributes.append(a); +} + +QString HbEffectFxmlParamData::getValue() const +{ + return mValue; +} + +bool HbEffectFxmlParamData::getValue(qreal &value) const +{ + bool ok = false; + + QString strValue = getValue(); + if (!strValue.isEmpty()) { + qreal temp = strValue.toFloat(&ok); + if (ok) { + value = temp; + } + } + return ok; +} + +void HbEffectFxmlParamData::setValue(const QString &value) +{ + mValue = value; +} + +QList HbEffectFxmlParamData::keyFrames() const +{ + // Make a regular QList. Note that some of the underlying structures may + // still stay in shared memory. + QList keyFrameList; + foreach (const HbKeyFrame &keyFrame, mKeyFrames) { + keyFrameList.append(keyFrame); + } + return keyFrameList; +} + +void HbEffectFxmlParamData::append(const HbKeyFrame &keyFrame) +{ + mKeyFrames.append(keyFrame); +} + +QString HbEffectFxmlParamData::startRef() const +{ + return mStartRef; +} + +void HbEffectFxmlParamData::setStartRef(const QString& value) +{ + mStartRef = value; +} + +QString HbEffectFxmlParamData::endRef() const +{ + return mEndRef; +} + +void HbEffectFxmlParamData::setEndRef(const QString& value) +{ + mEndRef = value; +} + +bool HbEffectFxmlParamData::loopDefined() const +{ + return mLoopStart > LoopMinDefined && mLoopEnd > LoopMinDefined; +} + +float HbEffectFxmlParamData::loopStart() const +{ + return mLoopStart; +} + +void HbEffectFxmlParamData::setLoopStart(float value) +{ + mLoopStart = value; +} + +float HbEffectFxmlParamData::loopEnd() const +{ + return mLoopEnd; +} + +void HbEffectFxmlParamData::setLoopEnd(float value) +{ + mLoopEnd = value; +} + +HbMemoryManager::MemoryType HbEffectFxmlParamData::memoryType() const +{ + return mMemoryType; +} + + +// ----------------------------------------------------------------------------- +// Class HbEffectFxmlData +// ----------------------------------------------------------------------------- +// +HbEffectFxmlData::HbEffectFxmlData(HbMemoryManager::MemoryType memType) + : mMemoryType(memType), + mFxmlParams(memType), + mFilters(memType) +{ +} + +HbEffectFxmlData::~HbEffectFxmlData() +{ +} + +bool HbEffectFxmlData::isNull() const +{ + return !mFxmlParams.count() && !mFilters.count(); +} + +void HbEffectFxmlData::appendParamData(const HbEffectFxmlParamData &data) +{ + mFxmlParams.append(data); +} + +QList HbEffectFxmlData::paramData() const +{ + // Make a regular QList. Note that some of the underlying structures may + // still stay in shared memory. + QList paramDataList; + foreach (const HbEffectFxmlParamData &data, mFxmlParams) { + paramDataList.append(data); + } + return paramDataList; +} + +void HbEffectFxmlData::appendFilterData(const HbEffectFxmlFilterData &data) +{ + mFilters.append(data); +} + +QList HbEffectFxmlData::filterData() const +{ + // Make a regular QList. Note that some of the underlying structures may + // still stay in shared memory. + QList paramDataList; + foreach (const HbEffectFxmlFilterData &data, mFilters) { + paramDataList.append(data); + } + return paramDataList; +} + +HbMemoryManager::MemoryType HbEffectFxmlData::memoryType() const +{ + return mMemoryType; +} +HbEffectInfo::HbEffectInfo():mItem(0) +{ + +} + +bool HbEffectInfo::fromTheme() const +{ + return mFromTheme; +} + +HbEffectInfo::~HbEffectInfo() +{ +} +QString HbEffectInfo::componentType() const +{ + return mComponentType; +} +QString HbEffectInfo::xmlFileFullPath() const +{ + return mDefFileFullPath; +} +QString HbEffectInfo::effectEvent() const +{ + return mEffectEvent; +} +bool HbEffectInfo::inUse() const +{ + return mInUse; +} +QGraphicsItem *HbEffectInfo::item() const +{ + return mItem; +} +bool HbEffectInfo::shared() const +{ + return mShared; +} + + +void HbEffectInfo::setEffectData(HbEffectFxmlData fxmlData) +{ + mFxmlData = fxmlData; +} +HbEffectFxmlData HbEffectInfo::effectData() const +{ + return mFxmlData; +}