khanat-opennel-code/code/ryzom/client/src/interface_v3/interface_ddx.cpp
thorbjorn fb9f11120a Fixed: Compile fixes for gcc 4.5.0
Example:

error: cannot call constructor ‘std::pair<std::basic_string<char>, CInterfaceDDX*>::pair’ directly
error:   for a function-style cast, remove the redundant ‘::pair’
2010-05-08 23:27:35 +02:00

1130 lines
29 KiB
C++

// Ryzom - MMORPG Framework <http://dev.ryzom.com/projects/ryzom/>
// Copyright (C) 2010 Winch Gate Property Limited
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero General Public License as
// published by the Free Software Foundation, either version 3 of the
// License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
#include "stdpch.h"
#include "interface_manager.h"
#include "interface_ddx.h"
#include "action_handler.h"
#include "ctrl_button.h"
#include "group_modal.h"
#include "../client_cfg.h"
#include "game_share/xml_auto_ptr.h"
//
using namespace std;
using namespace NLMISC;
// ***************************************************************************
// CParam
// ***************************************************************************
// ***************************************************************************
void CInterfaceDDX::CParam::DBToWidget()
{
if (Type != DataBase) return;
CInterfaceManager *pIM = CInterfaceManager::getInstance();
if (Widget == ColorButton)
{
CRGBA col = CRGBA::White;
CCDBNodeLeaf *pNL = pIM->getDbProp(Link,false);
if (pNL != NULL)
{
uint32 intCol = (uint32)pNL->getValue32();
col.R = (uint8) (intCol & 0xff);
col.G = (uint8) ((intCol >> 8) & 0xff);
col.B = (uint8) ((intCol >> 16) & 0xff);
col.A = (uint8) ((intCol >> 24) & 0xff);
}
CCtrlBaseButton *pBut = dynamic_cast<CCtrlBaseButton*>(Elt.getPtr());
if (pBut != NULL)
{
pBut->setColor(col);
pBut->setColorPushed(col);
pBut->setColorOver(col);
}
}
else if (Widget == BoolButton)
{
bool bVal = 0;
CCDBNodeLeaf *pNL = pIM->getDbProp(Link,false);
if (pNL != NULL)
{
bVal = pNL->getValue32()==0?false:true;
}
CCtrlBaseButton *pBut = dynamic_cast<CCtrlBaseButton*>(Elt.getPtr());
if (pBut != NULL)
{
pBut->setPushed(bVal);
}
}
else if (Widget == ScrollBarInt)
{
sint32 nVal = 0;
CCDBNodeLeaf *pNL = pIM->getDbProp(Link,false);
if (pNL != NULL)
{
nVal = pNL->getValue32();
}
CCtrlScroll *pCS = dynamic_cast<CCtrlScroll*>(Elt.getPtr());
if (pCS != NULL)
{
pCS->setValue (nVal);
pCS->setMinMax (Min, Max);
}
updateScrollView(nVal);
}
}
// ***************************************************************************
void CInterfaceDDX::CParam::CFGToWidget()
{
if (Type != ConfigFile) return;
if (Widget == BoolButton)
{
bool bVal = ClientCfg.readBool(Link);
CCtrlBaseButton *pBut = dynamic_cast<CCtrlBaseButton*>(Elt.getPtr());
if (pBut != NULL)
{
pBut->setPushed(bVal);
}
}
else if (Widget == ScrollBarInt)
{
sint32 nVal = ClientCfg.readInt(Link);
sint32 nMin = ClientCfg.readInt(Link+"_min");
sint32 nMax = ClientCfg.readInt(Link+"_max");
sint32 step = ClientCfg.readIntNoWarning(Link+"_step");
CCtrlScroll *pCS = dynamic_cast<CCtrlScroll*>(Elt.getPtr());
if (pCS != NULL)
{
pCS->setMinMax (nMin, nMax);
pCS->setStepValue(step);
pCS->setValue(nVal);
}
updateScrollView(nVal);
}
else if (Widget == ScrollBarFloat)
{
double rVal= ClientCfg.readDouble(Link);
tryRound(rVal);
sint32 nVal = (sint32)(10000*rVal);
sint32 nMin = (sint32)(10000*ClientCfg.readDouble(Link+"_min"));
sint32 nMax = (sint32)(10000*ClientCfg.readDouble(Link+"_max"));
sint32 step = (sint32)(10000*ClientCfg.readDoubleNoWarning(Link+"_step"));
CCtrlScroll *pCS = dynamic_cast<CCtrlScroll*>(Elt.getPtr());
if (pCS != NULL)
{
pCS->setMinMax (nMin, nMax);
pCS->setStepValue(step);
pCS->setValue (nVal);
}
updateScrollView(rVal);
}
}
// ***************************************************************************
void CInterfaceDDX::CParam::WidgetToDB()
{
if (Type != DataBase) return;
CInterfaceManager *pIM = CInterfaceManager::getInstance();
if (Widget == ColorButton)
{
CRGBA col = CRGBA::White;
CCtrlBaseButton *pBut = dynamic_cast<CCtrlBaseButton*>(Elt.getPtr());
if (pBut != NULL)
col = pBut->getColor();
CCDBNodeLeaf *pNL = pIM->getDbProp(Link,false);
if (pNL != NULL)
pNL->setValue32(col.R+(col.G<<8)+(col.B<<16)+(col.A<<24));
}
else if (Widget == BoolButton)
{
bool bVal = false;
CCtrlBaseButton *pBut = dynamic_cast<CCtrlBaseButton*>(Elt.getPtr());
if (pBut != NULL)
bVal = pBut->getPushed();
CCDBNodeLeaf *pNL = pIM->getDbProp(Link,false);
if (pNL != NULL)
{
pNL->setValue32(bVal?1:0);
}
}
else if (Widget == ScrollBarFloat)
{
// TODO
}
else if (Widget == ScrollBarInt)
{
sint32 nVal = 0;
CCtrlScroll *pCS = dynamic_cast<CCtrlScroll*>(Elt.getPtr());
if (pCS != NULL)
nVal = pCS->getValue();
CCDBNodeLeaf *pNL = pIM->getDbProp(Link,false);
if (pNL != NULL)
pNL->setValue32(nVal);
}
}
// ***************************************************************************
void CInterfaceDDX::CParam::WidgetToCFG()
{
if (Type != ConfigFile) return;
if (Widget == BoolButton)
{
bool bVal = false;
CCtrlBaseButton *pBut = dynamic_cast<CCtrlBaseButton*>(Elt.getPtr());
if (pBut != NULL)
bVal = pBut->getPushed();
ClientCfg.writeBool(Link, bVal);
}
else if (Widget == ScrollBarInt)
{
sint32 nVal = 0;
CCtrlScroll *pCS = dynamic_cast<CCtrlScroll*>(Elt.getPtr());
if (pCS != NULL)
nVal = pCS->getValue();
ClientCfg.writeInt(Link, nVal);
}
else if (Widget == ScrollBarFloat)
{
sint32 nVal = 0;
CCtrlScroll *pCS = dynamic_cast<CCtrlScroll*>(Elt.getPtr());
if (pCS != NULL)
nVal = pCS->getValue();
double rVal= nVal/10000.0;
tryRound(rVal);
ClientCfg.writeDouble(Link, rVal);
}
}
// ***************************************************************************
void CInterfaceDDX::CParam::WidgetToResultView()
{
if (Widget == ScrollBarInt)
{
sint32 nVal = 0;
CCtrlScroll *pCS = dynamic_cast<CCtrlScroll*>(Elt.getPtr());
if (pCS != NULL)
nVal = pCS->getValue();
updateScrollView(nVal);
}
else if (Widget == ScrollBarFloat)
{
sint32 nVal = 0;
CCtrlScroll *pCS = dynamic_cast<CCtrlScroll*>(Elt.getPtr());
if (pCS != NULL)
nVal = pCS->getValue();
double rVal= nVal/10000.0;
tryRound(rVal);
updateScrollView(rVal);
}
}
// ***************************************************************************
void CInterfaceDDX::CParam::backupDB()
{
if (Type != DataBase) return;
CInterfaceManager *pIM = CInterfaceManager::getInstance();
if (Widget == ColorButton)
{
CRGBA col = CRGBA::White;
CCDBNodeLeaf *pNL = pIM->getDbProp(Link,false);
if (pNL != NULL)
{
uint32 intCol = (uint32)pNL->getValue32();
RTBackupValue = intCol;
}
}
else if (Widget == ScrollBarInt)
{
sint32 nVal = 0;
CCDBNodeLeaf *pNL = pIM->getDbProp(Link,false);
if (pNL != NULL)
{
nVal = pNL->getValue32();
}
RTBackupValue = nVal;
}
}
// ***************************************************************************
void CInterfaceDDX::CParam::backupCFG()
{
if (Type != ConfigFile) return;
if (Widget == BoolButton)
{
bool bVal = ClientCfg.readBool(Link);
RTBackupValue = bVal;
}
else if (Widget == ScrollBarInt)
{
sint32 nVal = ClientCfg.readInt(Link);
RTBackupValue = nVal;
}
else if (Widget == ScrollBarFloat)
{
double rVal= ClientCfg.readDouble(Link);
tryRound(rVal);
sint32 nVal = (sint32)(10000*rVal);
RTBackupValue = nVal;
}
}
// ***************************************************************************
void CInterfaceDDX::CParam::restoreDB()
{
if (Type != DataBase) return;
if (RealTimeMode==RTModeFalse) return;
CInterfaceManager *pIM = CInterfaceManager::getInstance();
if (Widget == ColorButton)
{
CCDBNodeLeaf *pNL = pIM->getDbProp(Link,false);
if (pNL != NULL)
pNL->setValue32(RTBackupValue);
}
else if (Widget == ScrollBarFloat)
{
// TODO
}
else if (Widget == ScrollBarInt)
{
CCDBNodeLeaf *pNL = pIM->getDbProp(Link,false);
if (pNL != NULL)
pNL->setValue32(RTBackupValue);
}
}
// ***************************************************************************
void CInterfaceDDX::CParam::restoreCFG()
{
if (Type != ConfigFile) return;
if (RealTimeMode==RTModeFalse) return;
if (Widget == BoolButton)
{
ClientCfg.writeBool(Link, (RTBackupValue == 0) ? false : true);
}
else if (Widget == ScrollBarInt)
{
ClientCfg.writeInt(Link, RTBackupValue);
}
else if (Widget == ScrollBarFloat)
{
double rVal= RTBackupValue/10000.0;
tryRound(rVal);
ClientCfg.writeDouble(Link, rVal);
}
}
// ***************************************************************************
void CInterfaceDDX::CParam::updateScrollView(sint32 nVal)
{
if(ResultView)
{
ResultView->setText(ucstring(toString(nVal)) + ResultUnit);
}
}
// ***************************************************************************
void CInterfaceDDX::CParam::updateScrollView(double nVal)
{
if(ResultView)
{
// allow N digits
string fmt= toString("%%.%df", ResultDecimal);
ResultView->setText(ucstring(toString(fmt.c_str(), nVal)) + ResultUnit);
}
}
// ***************************************************************************
void CInterfaceDDX::CParam::tryRound(double rVal)
{
// Round?
if(RoundMode)
rVal= floor(rVal+0.5);
}
// ***************************************************************************
void CInterfaceDDX::CParam::restoreCFGPreset(uint presetVal)
{
if (Type != ConfigFile) return;
if (Widget == BoolButton)
{
// try to get the preset from cfg
CConfigFile::CVar *varPtr = ClientCfg.ConfigFile.getVarPtr(Link+"_ps"+toString(presetVal));
if(varPtr)
{
bool bVal = varPtr->asInt() != 0;
CCtrlBaseButton *pBut = dynamic_cast<CCtrlBaseButton*>(Elt.getPtr());
if (pBut != NULL)
{
pBut->setPushed(bVal);
}
}
}
else if (Widget == ScrollBarInt)
{
// try to get the preset from cfg
CConfigFile::CVar *varPtr = ClientCfg.ConfigFile.getVarPtr(Link+"_ps"+toString(presetVal));
if(varPtr)
{
sint32 nVal = varPtr->asInt();
CCtrlScroll *pCS = dynamic_cast<CCtrlScroll*>(Elt.getPtr());
if (pCS != NULL)
{
pCS->setValue(nVal);
}
updateScrollView(nVal);
}
}
else if (Widget == ScrollBarFloat)
{
// try to get the preset from cfg
CConfigFile::CVar *varPtr = ClientCfg.ConfigFile.getVarPtr(Link+"_ps"+toString(presetVal));
if(varPtr)
{
double rVal = varPtr->asDouble();
tryRound(rVal);
sint32 nVal = (sint32)(10000*rVal);
CCtrlScroll *pCS = dynamic_cast<CCtrlScroll*>(Elt.getPtr());
if (pCS != NULL)
{
pCS->setValue (nVal);
}
updateScrollView(rVal);
}
}
}
// ***************************************************************************
uint32 CInterfaceDDX::CParam::getPresetPossibleBF()
{
if (Type != ConfigFile) return 0;
uint32 ret= 0;
if (Widget == BoolButton)
{
// get the current value from cfg
bool curVal= ClientCfg.readBool(Link);
// compare to each preset from cfg
for(uint i=0;i<CInterfaceDDX::NumPreset;i++)
{
CConfigFile::CVar *varPtr = ClientCfg.ConfigFile.getVarPtr(Link+"_ps"+toString(i));
if(varPtr)
{
bool bVal = varPtr->asInt() != 0;
// if same value, then the current value is compatible with the preset
if(bVal == curVal)
ret|= 1<<i;
}
}
}
else if (Widget == ScrollBarInt)
{
// get the current value from cfg
sint32 curVal= ClientCfg.readInt(Link);
// compare to each preset from cfg
for(uint i=0;i<CInterfaceDDX::NumPreset;i++)
{
CConfigFile::CVar *varPtr = ClientCfg.ConfigFile.getVarPtr(Link+"_ps"+toString(i));
if(varPtr)
{
sint32 nVal = varPtr->asInt();
// if same value, then the current value is compatible with the preset
if(nVal == curVal)
ret|= 1<<i;
}
}
}
else if (Widget == ScrollBarFloat)
{
// get the current value from cfg
double curVal= ClientCfg.readDouble(Link);
tryRound(curVal);
// compare to each preset from cfg
for(uint i=0;i<CInterfaceDDX::NumPreset;i++)
{
CConfigFile::CVar *varPtr = ClientCfg.ConfigFile.getVarPtr(Link+"_ps"+toString(i));
if(varPtr)
{
double rVal = varPtr->asDouble();
tryRound(rVal);
// if same value, then the current value is compatible with the preset
if(rVal == curVal)
ret|= 1<<i;
}
}
}
return ret;
}
// ***************************************************************************
// CInterfaceDDX
// ***************************************************************************
// ***************************************************************************
CInterfaceDDX::CInterfaceDDX()
{
_PresetObs.Owner= this;
_ApplyButton= NULL;
}
// ***************************************************************************
CInterfaceDDX::~CInterfaceDDX()
{
// unregister observer
std::set<CCDBNodeLeaf*>::iterator it;
for(it=_PresetNodes.begin();it!=_PresetNodes.end();it++)
{
ICDBNode::CTextId id;
(*it)->removeObserver(&_PresetObs, id);
}
_Parameters.clear();
_PresetNodes.clear();
}
// ***************************************************************************
bool CInterfaceDDX::parse (xmlNodePtr cur, CInterfaceGroup *parentGroup)
{
CInterfaceManager *pIM = CInterfaceManager::getInstance();
if (!CInterfaceElement::parse(cur, parentGroup))
return false;
// bool ok = true;
cur = cur->children;
while (cur)
{
// Check that this is a param node
if ( stricmp((char*)cur->name,"param") == 0 )
{
CParam p;
bool bOK = true;
CXMLAutoPtr ptrUI((const char*)xmlGetProp (cur, (xmlChar*)"ui"));
p.Elt = _Parent->getId()+":"+string((const char*)ptrUI);
if (p.Elt == NULL) bOK = false;
CXMLAutoPtr ptrType((const char*)xmlGetProp (cur, (xmlChar*)"type"));
if (!ptrType) bOK = false;
if (stricmp((const char*)ptrType,"db") == 0)
p.Type = CParam::DataBase;
else if (stricmp((const char*)ptrType,"cfg") == 0)
p.Type = CParam::ConfigFile;
CXMLAutoPtr ptrWidget((const char*)xmlGetProp (cur, (xmlChar*)"widget"));
if (!ptrWidget) bOK = false;
if (stricmp((const char*)ptrWidget,"colbut") == 0)
p.Widget = CParam::ColorButton;
else if (stricmp((const char*)ptrWidget,"sbfloat") == 0)
p.Widget = CParam::ScrollBarFloat;
else if (stricmp((const char*)ptrWidget,"sbint") == 0)
p.Widget = CParam::ScrollBarInt;
else if (stricmp((const char*)ptrWidget,"boolbut") == 0)
p.Widget = CParam::BoolButton;
else if (stricmp((const char*)ptrWidget,"sbfloat_round") == 0)
{
p.Widget = CParam::ScrollBarFloat;
p.RoundMode = true;
}
CXMLAutoPtr ptrLink((const char*)xmlGetProp (cur, (xmlChar*)"link"));
if (!ptrLink) bOK = false;
else p.Link = (const char*)ptrLink;
if (p.Widget == CParam::ScrollBarInt)
{
CXMLAutoPtr ptrMin((const char*)xmlGetProp (cur, (xmlChar*)"min"));
if (!ptrMin) p.Min = 0;
else fromString((const char*)ptrMin, p.Min);
CXMLAutoPtr ptrMax((const char*)xmlGetProp (cur, (xmlChar*)"max"));
if (!ptrMax) p.Max = 255;
else fromString((const char*)ptrMax, p.Max);
}
CXMLAutoPtr ptrRealtime((const char*)xmlGetProp (cur, (xmlChar*)"realtime"));
if (!ptrRealtime) p.RealTimeMode = CParam::RTModeFalse;
else
{
if( !strcmp((const char*)ptrRealtime, "true"))
p.RealTimeMode= CParam::RTModeTrue;
else if( !strcmp((const char*)ptrRealtime, "end_scroll"))
p.RealTimeMode = CParam::RTModeEndScroll;
else
p.RealTimeMode = CParam::RTModeFalse;
}
// try to get the ui_view related
CXMLAutoPtr ptrUIView((const char*)xmlGetProp (cur, (xmlChar*)"ui_view"));
if(ptrUIView)
p.ResultView = _Parent->getId()+":"+string((const char*)ptrUIView);
CXMLAutoPtr ptrUIUnit((const char*)xmlGetProp (cur, (xmlChar*)"ui_unit"));
if(ptrUIUnit && ((const char*)ptrUIUnit)[0]!=0 )
p.ResultUnit = CI18N::get((const char*)ptrUIUnit);
CXMLAutoPtr ptrUIDecimal((const char*)xmlGetProp (cur, (xmlChar*)"ui_decimal"));
if(ptrUIDecimal)
fromString((const char*)ptrUIDecimal, p.ResultDecimal);
// try to get the preset db entry
if(p.Type==CParam::ConfigFile && bOK)
{
CXMLAutoPtr ptrPreset((const char*)xmlGetProp (cur, (xmlChar*)"preset"));
if(ptrPreset)
{
p.PresetDB = pIM->getDbProp((const char*)ptrPreset, false);
if(p.PresetDB)
{
// if not exist in the set, add it and register callback
if(_PresetNodes.insert(p.PresetDB).second)
{
ICDBNode::CTextId id;
p.PresetDB->addObserver(&_PresetObs, id);
}
}
}
}
// if ok, add this parameter!
if (bOK)
_Parameters.push_back(p);
}
// apply node?
else if( stricmp((char*)cur->name,"apply") == 0 )
{
CXMLAutoPtr ptrUI((const char*)xmlGetProp (cur, (xmlChar*)"ui"));
_ApplyButton = dynamic_cast<CCtrlBaseButton*>(pIM->getElementFromId(_Parent->getId(),(const char*)ptrUI));
}
cur = cur->next;
}
CDDXManager::getInstance()->add(this);
return true;
}
// ***************************************************************************
// Initialize parameters from external stuff (database, client.cfg ...)
void CInterfaceDDX::init()
{
// **** start values from CFG, and backup
for (uint i = 0; i < _Parameters.size(); ++i)
{
CParam &p = _Parameters[i];
if (p.Type == CParam::DataBase)
{
p.DBToWidget();
p.backupDB();
}
else if (p.Type == CParam::ConfigFile)
{
p.CFGToWidget();
p.backupCFG();
}
}
// **** initialize the preset
resetPreSet();
// **** Start apply frozen
if(_ApplyButton)
{
_ApplyButton->setFrozen(true);
}
}
// ***************************************************************************
void CInterfaceDDX::update()
{
for (uint i = 0; i < _Parameters.size(); ++i)
{
CParam &p = _Parameters[i];
if (p.Type == CParam::DataBase)
{
p.WidgetToDB();
p.backupDB();
}
else if (p.Type == CParam::ConfigFile)
{
p.WidgetToCFG();
p.backupCFG();
}
}
// Write the modified client.cfg
ClientCfg.IsInvalidated = true;
// **** set apply frozen
if(_ApplyButton)
{
_ApplyButton->setFrozen(true);
}
}
// ***************************************************************************
void CInterfaceDDX::cancel()
{
// Update scroll bars that are realtime
bool bMustSave = false;
uint i;
for (i = 0; i < _Parameters.size(); ++i)
{
CParam &p = _Parameters[i];
if (p.RealTimeMode==CParam::RTModeFalse) continue;
if (p.Type == CParam::DataBase)
{
p.restoreDB();
}
else if (p.Type == CParam::ConfigFile)
{
bMustSave = true;
p.restoreCFG();
}
}
if (bMustSave)
{
ClientCfg.IsInvalidated = true;
}
for (i = 0; i < _Parameters.size(); ++i)
{
CParam &p = _Parameters[i];
if (p.Type == CParam::DataBase)
{
p.DBToWidget();
}
else if (p.Type == CParam::ConfigFile)
{
p.CFGToWidget();
}
}
// **** reset the preset
resetPreSet();
// **** set apply frozen
if(_ApplyButton)
{
_ApplyButton->setFrozen(true);
}
}
// ***************************************************************************
void CInterfaceDDX::updateRealtime(CCtrlBase *pSB, bool updateOnScrollEnd)
{
// Update scroll bars that are realtime
bool bMustSave = false;
uint i;
for (i = 0; i < _Parameters.size(); ++i)
{
CParam &p = _Parameters[i];
if (p.Elt != pSB) continue;
if( (!updateOnScrollEnd && p.RealTimeMode==CParam::RTModeTrue) ||
(updateOnScrollEnd && p.RealTimeMode==CParam::RTModeEndScroll) )
{
if (p.Type == CParam::DataBase)
{
p.WidgetToDB();
}
else if (p.Type == CParam::ConfigFile)
{
bMustSave = true;
p.WidgetToCFG();
}
}
// even if not realtime, if has a preset setuped, set it to custom!
if(p.PresetDB)
{
p.PresetDB->setValue32(CustomPreset);
}
// even if not realtime, must update text view
p.WidgetToResultView();
}
if (bMustSave)
{
ClientCfg.IsInvalidated = true;
}
CCDBNodeBranch::flushObserversCalls();
for (i = 0; i < _Parameters.size(); ++i)
{
CParam &p = _Parameters[i];
if( (!updateOnScrollEnd && p.RealTimeMode==CParam::RTModeTrue) ||
(updateOnScrollEnd && p.RealTimeMode==CParam::RTModeEndScroll) )
{
if (p.Type == CParam::DataBase)
{
p.DBToWidget();
}
else if (p.Type == CParam::ConfigFile)
{
p.CFGToWidget();
}
}
}
// **** something changed, allow apply!
if(_ApplyButton)
{
_ApplyButton->setFrozen(false);
}
}
// ***************************************************************************
void CInterfaceDDX::updateParamPreset(CCDBNodeLeaf *presetChanged)
{
if(!presetChanged)
return;
// if not custom or bad id
uint presetVal= presetChanged->getValue32();
if(presetVal>=NumPreset)
return;
// **** check each parameter
for(uint i=0;i<_Parameters.size();i++)
{
CParam &param= _Parameters[i];
// if can be set by this preset modified
if(param.PresetDB == presetChanged)
{
// must be a config file param (see parse())
nlassert(param.Type==CParam::ConfigFile);
// restore preset
param.restoreCFGPreset(presetVal);
// if realTime, then must update CFG
if (param.RealTimeMode!=CParam::RTModeFalse)
{
param.WidgetToCFG();
ClientCfg.IsInvalidated= true;
}
}
}
// **** something changed, allow apply!
if(_ApplyButton)
{
_ApplyButton->setFrozen(false);
}
}
// ***************************************************************************
void CInterfaceDDX::validateApplyButton()
{
if(_ApplyButton)
{
_ApplyButton->setFrozen(false);
}
}
// ***************************************************************************
void CInterfaceDDX::resetPreSet()
{
nlassert(NumPreset<32);
// for each preset, assign a bitfield, where bit==1 <=> preset possible
std::map<CCDBNodeLeaf*, uint32> bfPreset;
std::set<CCDBNodeLeaf*>::iterator itSet;
// init as "preset possible"
for(itSet=_PresetNodes.begin();itSet!=_PresetNodes.end();itSet++)
{
bfPreset[*itSet]= (1<<NumPreset)-1;
}
// then for each parameter, invalidate preset according to value
for (uint i = 0; i < _Parameters.size(); ++i)
{
CParam &p = _Parameters[i];
if (p.Type == CParam::ConfigFile && p.PresetDB)
{
std::map<CCDBNodeLeaf*, uint32>::iterator it= bfPreset.find(p.PresetDB);
if(it!=bfPreset.end())
{
it->second&= p.getPresetPossibleBF();
}
}
}
// for each preset DB, assign the lowest preset possible
std::map<CCDBNodeLeaf*, uint32>::iterator itMap;
for(itMap= bfPreset.begin();itMap!=bfPreset.end();itMap++)
{
CCDBNodeLeaf *node= itMap->first;
uint32 bf= itMap->second;
// if no common preset is possible, then assign custom!
if(bf==0)
{
node->setValue32(CustomPreset);
}
// else assign the lowest bit
else
{
uint32 presetId= 0;
while( (bf&(1<<presetId)) == 0)
presetId++;
node->setValue32(presetId);
}
}
}
// ***************************************************************************
void CInterfaceDDX::CPresetObs::update(ICDBNode* node)
{
CCDBNodeLeaf *leaf= dynamic_cast<CCDBNodeLeaf*>(node);
if(leaf)
Owner->updateParamPreset(leaf);
}
// ***************************************************************************
// CDDXManager
// ***************************************************************************
// ***************************************************************************
CDDXManager* CDDXManager::_Instance = NULL;
// ***************************************************************************
CDDXManager::CDDXManager()
{
}
// ***************************************************************************
void CDDXManager::releaseInstance()
{
if( _Instance )
delete _Instance;
_Instance = NULL;
}
// ***************************************************************************
void CDDXManager::release()
{
std::map<std::string, CInterfaceDDX*>::iterator ite = _DDXes.begin();
while (ite != _DDXes.end())
{
delete ite->second;
ite++;
}
_DDXes.clear();
}
// ***************************************************************************
void CDDXManager::add(CInterfaceDDX *pDDX)
{
_DDXes.insert(pair<string,CInterfaceDDX*>(pDDX->getId(),pDDX));
}
// ***************************************************************************
CInterfaceDDX *CDDXManager::get(const std::string &ddxName)
{
map<string, CInterfaceDDX*>::iterator it = _DDXes.find(ddxName);
if (it == _DDXes.end())
{
it = _DDXes.find("ui:interface:"+ddxName);
}
if (it != _DDXes.end())
{
return it->second;
}
return NULL;
}
// ***************************************************************************
CInterfaceDDX *CDDXManager::getFromParent(const std::string &ddxParentName)
{
map<string, CInterfaceDDX*>::iterator it = _DDXes.begin();
while (it != _DDXes.end())
{
string parentName = it->first;
parentName = parentName.substr(0,parentName.rfind(":"));
if (parentName == ddxParentName)
return it->second;
it++;
}
return NULL;
}
// ***************************************************************************
// Update database or config file from the parameters (ddx memory zone)
class CHandlerDDXUpdate : public IActionHandler
{
public:
void execute (CCtrlBase * /* pCaller */, const std::string &sParams)
{
CDDXManager *pDM = CDDXManager::getInstance();
CInterfaceDDX *pDDX = pDM->get(sParams);
if (pDDX != NULL)
pDDX->update();
}
protected:
};
REGISTER_ACTION_HANDLER( CHandlerDDXUpdate, "ddx_update");
// ***************************************************************************
// Update the parameters (ddx mem zone) from database or config file
class CHandlerDDXInit : public IActionHandler
{
public:
void execute (CCtrlBase * /* pCaller */, const std::string &sParams)
{
CDDXManager *pDM = CDDXManager::getInstance();
CInterfaceDDX *pDDX = pDM->get(sParams);
if (pDDX != NULL)
pDDX->init();
}
protected:
};
REGISTER_ACTION_HANDLER( CHandlerDDXInit, "ddx_init");
// ***************************************************************************
// Cancel all realtime values
class CHandlerDDXCancel : public IActionHandler
{
public:
void execute (CCtrlBase * /* pCaller */, const std::string &sParams)
{
CDDXManager *pDM = CDDXManager::getInstance();
CInterfaceDDX *pDDX = pDM->get(sParams);
if (pDDX != NULL)
pDDX->cancel();
}
protected:
};
REGISTER_ACTION_HANDLER( CHandlerDDXCancel, "ddx_cancel");
// ***************************************************************************
class CHandlerDDXScroll : public IActionHandler
{
public:
void execute (CCtrlBase *pCaller, const std::string &sParams)
{
CDDXManager *pDM = CDDXManager::getInstance();
CInterfaceDDX *pDDX = pDM->get(sParams);
if (pDDX != NULL)
pDDX->updateRealtime(pCaller, false);
}
protected:
};
REGISTER_ACTION_HANDLER( CHandlerDDXScroll, "ddx_scroll");
// ***************************************************************************
class CHandlerDDXScrollEnd : public IActionHandler
{
public:
void execute (CCtrlBase *pCaller, const std::string &sParams)
{
CDDXManager *pDM = CDDXManager::getInstance();
CInterfaceDDX *pDDX = pDM->get(sParams);
if (pDDX != NULL)
pDDX->updateRealtime(pCaller, true);
}
protected:
};
REGISTER_ACTION_HANDLER( CHandlerDDXScrollEnd, "ddx_scroll_end");
// ***************************************************************************
// Automatically search for the ddx and launch an update
class CHandlerDDXColor : public IActionHandler
{
public:
void execute (CCtrlBase *pCaller, const std::string &/* sParams */)
{
CDDXManager *pDM = CDDXManager::getInstance();
if (pCaller == NULL) return;
CInterfaceManager *pIM = CInterfaceManager::getInstance();
CCtrlBase *pCB = pIM->getCtrlLaunchingModal();
// Search for a ddx in the parents
CInterfaceGroup *pIG = pCB->getParent();
bool found = false;
CInterfaceDDX *pDDX = NULL;
while (!found)
{
pDDX = pDM->getFromParent(pIG->getId());
if (pDDX != NULL) found = true;
else pIG = pIG->getParent();
if (pIG == NULL) return;
}
if (pDDX != NULL)
pDDX->updateRealtime(pCB, false);
}
protected:
};
REGISTER_ACTION_HANDLER( CHandlerDDXColor , "ddx_color");
// ***************************************************************************
// Automatically search for the ddx and launch an update
class CHandlerDDXBoolButton : public IActionHandler
{
public:
void execute (CCtrlBase *pCaller, const std::string &/* sParams */)
{
CDDXManager *pDM = CDDXManager::getInstance();
if (pCaller == NULL) return;
// Search for a ddx in the parents
CInterfaceGroup *pIG = pCaller->getParent();
bool found = false;
CInterfaceDDX *pDDX = NULL;
while (!found)
{
pDDX = pDM->getFromParent(pIG->getId());
if (pDDX != NULL) found = true;
else pIG = pIG->getParent();
if (pIG == NULL) return;
}
if (pDDX != NULL)
pDDX->updateRealtime(pCaller, false);
}
protected:
};
REGISTER_ACTION_HANDLER( CHandlerDDXBoolButton , "ddx_bool_button");