ryzom/client/src/interface_v3/interface_ddx.cpp

   1 // Ryzom - MMORPG Framework <http://dev.ryzom.com/projects/ryzom/>
   2 // Copyright (C) 2010  Winch Gate Property Limited
   3 //
   4 // This source file has been modified by the following contributors:
   5 // Copyright (C) 2013  Laszlo KIS-ADAM (dfighter) <dfighter1985@gmail.com>
   6 // Copyright (C) 2020  Jan BOON (Kaetemi) <jan.boon@kaetemi.be>
   7 //
   8 // This program is free software: you can redistribute it and/or modify
   9 // it under the terms of the GNU Affero General Public License as
  10 // published by the Free Software Foundation, either version 3 of the
  11 // License, or (at your option) any later version.
  12 //
  13 // This program is distributed in the hope that it will be useful,
  14 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 // GNU Affero General Public License for more details.
  17 //
  18 // You should have received a copy of the GNU Affero General Public License
  19 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
  20
  21
  22
  23 #include "stdpch.h"
  24
  25 #include "interface_manager.h"
  26 #include "interface_ddx.h"
  27 #include "nel/gui/action_handler.h"
  28 #include "nel/gui/ctrl_button.h"
  29 #include "nel/gui/group_modal.h"
  30 #include "../client_cfg.h"
  31
  32 #include "nel/misc/xml_auto_ptr.h"
  33 //
  34
  35 using namespace std;
  36 using namespace NLMISC;
  37
  38 // ***************************************************************************
  39 // CParam
  40 // ***************************************************************************
  41
  42 // ***************************************************************************
  43 void CInterfaceDDX::CParam::DBToWidget()
  44 {
  45         if (Type != DataBase) return;
  46         CInterfaceManager *pIM = CInterfaceManager::getInstance();
  47
  48         if (Widget == ColorButton)
  49         {
  50                 CRGBA col = CRGBA::White;
  51                 CCDBNodeLeaf *pNL = NLGUI::CDBManager::getInstance()->getDbProp(Link,false);
  52                 if (pNL != NULL)
  53                 {
  54                         uint32 intCol = (uint32)pNL->getValue32();
  55                         col.R = (uint8) (intCol & 0xff);
  56                         col.G = (uint8) ((intCol >> 8) & 0xff);
  57                         col.B = (uint8) ((intCol >> 16) & 0xff);
  58                         col.A = (uint8) ((intCol >> 24) & 0xff);
  59                 }
  60                 CCtrlBaseButton *pBut = dynamic_cast<CCtrlBaseButton*>(Elt.getPtr());
  61                 if (pBut != NULL)
  62                 {
  63                         pBut->setColor(col);
  64                         pBut->setColorPushed(col);
  65                         pBut->setColorOver(col);
  66                 }
  67         }
  68         else if (Widget == BoolButton)
  69         {
  70                 bool bVal = 0;
  71                 CCDBNodeLeaf *pNL = NLGUI::CDBManager::getInstance()->getDbProp(Link,false);
  72                 if (pNL != NULL)
  73                 {
  74                         bVal = pNL->getValue32()==0?false:true;
  75                 }
  76                 CCtrlBaseButton *pBut = dynamic_cast<CCtrlBaseButton*>(Elt.getPtr());
  77                 if (pBut != NULL)
  78                 {
  79                         pBut->setPushed(bVal);
  80                 }
  81         }
  82         else if (Widget == ScrollBarInt)
  83         {
  84                 sint32 nVal = 0;
  85                 CCDBNodeLeaf *pNL = NLGUI::CDBManager::getInstance()->getDbProp(Link,false);
  86                 if (pNL != NULL)
  87                 {
  88                         nVal = pNL->getValue32();
  89                 }
  90                 CCtrlScroll *pCS = dynamic_cast<CCtrlScroll*>(Elt.getPtr());
  91                 if (pCS != NULL)
  92                 {
  93                         pCS->setValue (nVal);
  94                         pCS->setMinMax (Min, Max);
  95                 }
  96                 updateScrollView(nVal);
  97         }
  98 }
  99
 100
 101 // ***************************************************************************
 102 void CInterfaceDDX::CParam::CFGToWidget()
 103 {
 104         if (Type != ConfigFile) return;
 105
 106         if (Widget == BoolButton)
 107         {
 108                 bool bVal = ClientCfg.readBool(Link);
 109                 CCtrlBaseButton *pBut = dynamic_cast<CCtrlBaseButton*>(Elt.getPtr());
 110                 if (pBut != NULL)
 111                 {
 112                         pBut->setPushed(bVal);
 113                 }
 114         }
 115         else if (Widget == ScrollBarInt)
 116         {
 117                 sint32 nVal = ClientCfg.readInt(Link);
 118                 sint32 nMin = ClientCfg.readInt(Link+"_min");
 119                 sint32 nMax = ClientCfg.readInt(Link+"_max");
 120                 sint32 step = ClientCfg.readIntNoWarning(Link+"_step");
 121                 CCtrlScroll *pCS = dynamic_cast<CCtrlScroll*>(Elt.getPtr());
 122                 if (pCS != NULL)
 123                 {
 124                         pCS->setMinMax (nMin, nMax);
 125                         pCS->setStepValue(step);
 126                         pCS->setValue(nVal);
 127                 }
 128                 updateScrollView(nVal);
 129         }
 130         else if (Widget == ScrollBarFloat)
 131         {
 132                 double rVal= ClientCfg.readDouble(Link);
 133                 tryRound(rVal);
 134                 sint32 nVal = (sint32)(10000*rVal);
 135                 sint32 nMin = (sint32)(10000*ClientCfg.readDouble(Link+"_min"));
 136                 sint32 nMax = (sint32)(10000*ClientCfg.readDouble(Link+"_max"));
 137                 sint32 step = (sint32)(10000*ClientCfg.readDoubleNoWarning(Link+"_step"));
 138                 CCtrlScroll *pCS = dynamic_cast<CCtrlScroll*>(Elt.getPtr());
 139                 if (pCS != NULL)
 140                 {
 141                         pCS->setMinMax (nMin, nMax);
 142                         pCS->setStepValue(step);
 143                         pCS->setValue (nVal);
 144                 }
 145                 updateScrollView(rVal);
 146         }
 147 }
 148
 149 // ***************************************************************************
 150 void CInterfaceDDX::CParam::WidgetToDB()
 151 {
 152         if (Type != DataBase) return;
 153         CInterfaceManager *pIM = CInterfaceManager::getInstance();
 154
 155         if (Widget == ColorButton)
 156         {
 157                 CRGBA col = CRGBA::White;
 158                 CCtrlBaseButton *pBut = dynamic_cast<CCtrlBaseButton*>(Elt.getPtr());
 159                 if (pBut != NULL)
 160                         col = pBut->getColor();
 161                 CCDBNodeLeaf *pNL = NLGUI::CDBManager::getInstance()->getDbProp(Link,false);
 162                 if (pNL != NULL)
 163                         pNL->setValue32(col.R+(col.G<<8)+(col.B<<16)+(col.A<<24));
 164         }
 165         else if (Widget == BoolButton)
 166         {
 167                 bool bVal = false;
 168                 CCtrlBaseButton *pBut = dynamic_cast<CCtrlBaseButton*>(Elt.getPtr());
 169                 if (pBut != NULL)
 170                         bVal = pBut->getPushed();
 171                 CCDBNodeLeaf *pNL = NLGUI::CDBManager::getInstance()->getDbProp(Link,false);
 172                 if (pNL != NULL)
 173                 {
 174                         pNL->setValue32(bVal?1:0);
 175                 }
 176         }
 177         else if (Widget == ScrollBarFloat)
 178         {
 179                 // TODO
 180         }
 181         else if (Widget == ScrollBarInt)
 182         {
 183                 sint32 nVal = 0;
 184                 CCtrlScroll *pCS = dynamic_cast<CCtrlScroll*>(Elt.getPtr());
 185                 if (pCS != NULL)
 186                         nVal = pCS->getValue();
 187                 CCDBNodeLeaf *pNL = NLGUI::CDBManager::getInstance()->getDbProp(Link,false);
 188                 if (pNL != NULL)
 189                         pNL->setValue32(nVal);
 190         }
 191 }
 192
 193 // ***************************************************************************
 194 void CInterfaceDDX::CParam::WidgetToCFG()
 195 {
 196         if (Type != ConfigFile) return;
 197
 198         if (Widget == BoolButton)
 199         {
 200                 bool bVal = false;
 201                 CCtrlBaseButton *pBut = dynamic_cast<CCtrlBaseButton*>(Elt.getPtr());
 202                 if (pBut != NULL)
 203                         bVal = pBut->getPushed();
 204                 ClientCfg.writeBool(Link, bVal);
 205         }
 206         else if (Widget == ScrollBarInt)
 207         {
 208                 sint32 nVal = 0;
 209                 CCtrlScroll *pCS = dynamic_cast<CCtrlScroll*>(Elt.getPtr());
 210                 if (pCS != NULL)
 211                         nVal = pCS->getValue();
 212                 ClientCfg.writeInt(Link, nVal);
 213         }
 214         else if (Widget == ScrollBarFloat)
 215         {
 216                 sint32 nVal = 0;
 217                 CCtrlScroll *pCS = dynamic_cast<CCtrlScroll*>(Elt.getPtr());
 218                 if (pCS != NULL)
 219                         nVal = pCS->getValue();
 220                 double  rVal= nVal/10000.0;
 221                 tryRound(rVal);
 222                 ClientCfg.writeDouble(Link, rVal);
 223         }
 224 }
 225
 226 // ***************************************************************************
 227 void CInterfaceDDX::CParam::WidgetToResultView()
 228 {
 229         if (Widget == ScrollBarInt)
 230         {
 231                 sint32 nVal = 0;
 232                 CCtrlScroll *pCS = dynamic_cast<CCtrlScroll*>(Elt.getPtr());
 233                 if (pCS != NULL)
 234                         nVal = pCS->getValue();
 235                 updateScrollView(nVal);
 236         }
 237         else if (Widget == ScrollBarFloat)
 238         {
 239                 sint32 nVal = 0;
 240                 CCtrlScroll *pCS = dynamic_cast<CCtrlScroll*>(Elt.getPtr());
 241                 if (pCS != NULL)
 242                         nVal = pCS->getValue();
 243                 double  rVal= nVal/10000.0;
 244                 tryRound(rVal);
 245                 updateScrollView(rVal);
 246         }
 247 }
 248
 249 // ***************************************************************************
 250 void CInterfaceDDX::CParam::backupDB()
 251 {
 252         if (Type != DataBase) return;
 253         CInterfaceManager *pIM = CInterfaceManager::getInstance();
 254
 255         if (Widget == ColorButton)
 256         {
 257                 CCDBNodeLeaf *pNL = NLGUI::CDBManager::getInstance()->getDbProp(Link,false);
 258                 if (pNL != NULL)
 259                 {
 260                         uint32 intCol = (uint32)pNL->getValue32();
 261                         RTBackupValue = intCol;
 262                 }
 263         }
 264         else if (Widget == ScrollBarInt)
 265         {
 266                 sint32 nVal = 0;
 267                 CCDBNodeLeaf *pNL = NLGUI::CDBManager::getInstance()->getDbProp(Link,false);
 268                 if (pNL != NULL)
 269                 {
 270                         nVal = pNL->getValue32();
 271                 }
 272                 RTBackupValue = nVal;
 273         }
 274 }
 275
 276
 277 // ***************************************************************************
 278 void CInterfaceDDX::CParam::backupCFG()
 279 {
 280         if (Type != ConfigFile) return;
 281
 282         if (Widget == BoolButton)
 283         {
 284                 bool bVal = ClientCfg.readBool(Link);
 285                 RTBackupValue = bVal;
 286         }
 287         else if (Widget == ScrollBarInt)
 288         {
 289                 sint32 nVal = ClientCfg.readInt(Link);
 290                 RTBackupValue = nVal;
 291         }
 292         else if (Widget == ScrollBarFloat)
 293         {
 294                 double  rVal= ClientCfg.readDouble(Link);
 295                 tryRound(rVal);
 296                 sint32 nVal = (sint32)(10000*rVal);
 297                 RTBackupValue = nVal;
 298         }
 299 }
 300
 301 // ***************************************************************************
 302 void CInterfaceDDX::CParam::restoreDB()
 303 {
 304         if (Type != DataBase) return;
 305         if (RealTimeMode==RTModeFalse) return;
 306
 307         CInterfaceManager *pIM = CInterfaceManager::getInstance();
 308
 309         if (Widget == ColorButton)
 310         {
 311                 CCDBNodeLeaf *pNL = NLGUI::CDBManager::getInstance()->getDbProp(Link,false);
 312                 if (pNL != NULL)
 313                         pNL->setValue32(RTBackupValue);
 314         }
 315         else if (Widget == ScrollBarFloat)
 316         {
 317                 // TODO
 318         }
 319         else if (Widget == ScrollBarInt)
 320         {
 321                 CCDBNodeLeaf *pNL = NLGUI::CDBManager::getInstance()->getDbProp(Link,false);
 322                 if (pNL != NULL)
 323                         pNL->setValue32(RTBackupValue);
 324         }
 325 }
 326
 327 // ***************************************************************************
 328 void CInterfaceDDX::CParam::restoreCFG()
 329 {
 330         if (Type != ConfigFile) return;
 331         if (RealTimeMode==RTModeFalse) return;
 332
 333         if (Widget == BoolButton)
 334         {
 335                 ClientCfg.writeBool(Link, (RTBackupValue == 0) ? false : true);
 336         }
 337         else if (Widget == ScrollBarInt)
 338         {
 339                 ClientCfg.writeInt(Link, RTBackupValue);
 340         }
 341         else if (Widget == ScrollBarFloat)
 342         {
 343                 double  rVal= RTBackupValue/10000.0;
 344                 tryRound(rVal);
 345                 ClientCfg.writeDouble(Link, rVal);
 346         }
 347 }
 348
 349 // ***************************************************************************
 350 void CInterfaceDDX::CParam::updateScrollView(sint32 nVal)
 351 {
 352         if(ResultView)
 353         {
 354                 ResultView->setText(toString(nVal) + ResultUnit);
 355         }
 356 }
 357
 358 // ***************************************************************************
 359 void CInterfaceDDX::CParam::updateScrollView(double nVal)
 360 {
 361         if(ResultView)
 362         {
 363                 // allow N digits
 364                 string  fmt= toString("%%.%df", ResultDecimal);
 365                 ResultView->setText(toString(fmt.c_str(), nVal) + ResultUnit);
 366         }
 367 }
 368
 369 // ***************************************************************************
 370 void CInterfaceDDX::CParam::tryRound(double rVal)
 371 {
 372         // Round?
 373         if(RoundMode)
 374                 rVal= floor(rVal+0.5);
 375 }
 376
 377 // ***************************************************************************
 378 void CInterfaceDDX::CParam::restoreCFGPreset(uint presetVal)
 379 {
 380         if (Type != ConfigFile) return;
 381
 382         if (Widget == BoolButton)
 383         {
 384                 // try to get the preset from cfg
 385                 CConfigFile::CVar *varPtr = ClientCfg.ConfigFile.getVarPtr(Link+"_ps"+toString(presetVal));
 386                 if(varPtr)
 387                 {
 388                         bool bVal = varPtr->asInt() != 0;
 389                         CCtrlBaseButton *pBut = dynamic_cast<CCtrlBaseButton*>(Elt.getPtr());
 390                         if (pBut != NULL)
 391                         {
 392                                 pBut->setPushed(bVal);
 393                         }
 394                 }
 395         }
 396         else if (Widget == ScrollBarInt)
 397         {
 398                 // try to get the preset from cfg
 399                 CConfigFile::CVar *varPtr = ClientCfg.ConfigFile.getVarPtr(Link+"_ps"+toString(presetVal));
 400                 if(varPtr)
 401                 {
 402                         sint32 nVal = varPtr->asInt();
 403                         CCtrlScroll *pCS = dynamic_cast<CCtrlScroll*>(Elt.getPtr());
 404                         if (pCS != NULL)
 405                         {
 406                                 pCS->setValue(nVal);
 407                         }
 408                         updateScrollView(nVal);
 409                 }
 410         }
 411         else if (Widget == ScrollBarFloat)
 412         {
 413                 // try to get the preset from cfg
 414                 CConfigFile::CVar *varPtr = ClientCfg.ConfigFile.getVarPtr(Link+"_ps"+toString(presetVal));
 415                 if(varPtr)
 416                 {
 417                         double rVal = varPtr->asDouble();
 418                         tryRound(rVal);
 419                         sint32 nVal = (sint32)(10000*rVal);
 420                         CCtrlScroll *pCS = dynamic_cast<CCtrlScroll*>(Elt.getPtr());
 421                         if (pCS != NULL)
 422                         {
 423                                 pCS->setValue (nVal);
 424                         }
 425                         updateScrollView(rVal);
 426                 }
 427         }
 428 }
 429
 430 // ***************************************************************************
 431 uint32  CInterfaceDDX::CParam::getPresetPossibleBF()
 432 {
 433         if (Type != ConfigFile) return 0;
 434         uint32  ret= 0;
 435
 436         if (Widget == BoolButton)
 437         {
 438                 // get the current value from cfg
 439                 bool    curVal= ClientCfg.readBool(Link);
 440
 441                 // compare to each preset from cfg
 442                 for(uint i=0;i<CInterfaceDDX::NumPreset;i++)
 443                 {
 444                         CConfigFile::CVar *varPtr = ClientCfg.ConfigFile.getVarPtr(Link+"_ps"+toString(i));
 445                         if(varPtr)
 446                         {
 447                                 bool bVal = varPtr->asInt() != 0;
 448                                 // if same value, then the current value is compatible with the preset
 449                                 if(bVal == curVal)
 450                                         ret|= 1<<i;
 451                         }
 452                 }
 453         }
 454         else if (Widget == ScrollBarInt)
 455         {
 456                 // get the current value from cfg
 457                 sint32  curVal= ClientCfg.readInt(Link);
 458
 459                 // compare to each preset from cfg
 460                 for(uint i=0;i<CInterfaceDDX::NumPreset;i++)
 461                 {
 462                         CConfigFile::CVar *varPtr = ClientCfg.ConfigFile.getVarPtr(Link+"_ps"+toString(i));
 463                         if(varPtr)
 464                         {
 465                                 sint32 nVal = varPtr->asInt();
 466                                 // if same value, then the current value is compatible with the preset
 467                                 if(nVal == curVal)
 468                                         ret|= 1<<i;
 469                         }
 470                 }
 471         }
 472         else if (Widget == ScrollBarFloat)
 473         {
 474                 // get the current value from cfg
 475                 double  curVal= ClientCfg.readDouble(Link);
 476                 tryRound(curVal);
 477
 478                 // compare to each preset from cfg
 479                 for(uint i=0;i<CInterfaceDDX::NumPreset;i++)
 480                 {
 481                         CConfigFile::CVar *varPtr = ClientCfg.ConfigFile.getVarPtr(Link+"_ps"+toString(i));
 482                         if(varPtr)
 483                         {
 484                                 double rVal = varPtr->asDouble();
 485                                 tryRound(rVal);
 486                                 // if same value, then the current value is compatible with the preset
 487                                 if(rVal == curVal)
 488                                         ret|= 1<<i;
 489                         }
 490                 }
 491         }
 492
 493         return ret;
 494 }
 495
 496
 497 // ***************************************************************************
 498 // CInterfaceDDX
 499 // ***************************************************************************
 500
 501
 502 // ***************************************************************************
 503 CInterfaceDDX::CInterfaceDDX()
 504 {
 505         _PresetObs.Owner= this;
 506         _ApplyButton= NULL;
 507 }
 508
 509 // ***************************************************************************
 510 CInterfaceDDX::~CInterfaceDDX()
 511 {
 512         // unregister observer
 513         std::set<CCDBNodeLeaf*>::iterator       it;
 514         for(it=_PresetNodes.begin();it!=_PresetNodes.end();it++)
 515         {
 516                 ICDBNode::CTextId       id;
 517                 (*it)->removeObserver(&_PresetObs, id);
 518         }
 519
 520         _Parameters.clear();
 521         _PresetNodes.clear();
 522 }
 523
 524 // ***************************************************************************
 525 bool CInterfaceDDX::parse (xmlNodePtr cur, CInterfaceGroup *parentGroup)
 526 {
 527         CInterfaceManager *pIM = CInterfaceManager::getInstance();
 528         if (!CInterfaceElement::parse(cur, parentGroup))
 529                 return false;
 530
 531
 532 //              bool ok = true;
 533         cur = cur->children;
 534         while (cur)
 535         {
 536                 // Check that this is a param node
 537                 if ( stricmp((char*)cur->name,"param") == 0 )
 538                 {
 539                         CParam p;
 540                         bool bOK = true;
 541
 542                         CXMLAutoPtr ptrUI((const char*)xmlGetProp (cur, (xmlChar*)"ui"));
 543                         p.Elt = _Parent->getId()+":"+string((const char*)ptrUI);
 544                         if (p.Elt == NULL) bOK = false;
 545
 546                         CXMLAutoPtr ptrType((const char*)xmlGetProp (cur, (xmlChar*)"type"));
 547                         if (!ptrType) bOK = false;
 548                         if (stricmp((const char*)ptrType,"db") == 0)
 549                                 p.Type = CParam::DataBase;
 550                         else if (stricmp((const char*)ptrType,"cfg") == 0)
 551                                 p.Type = CParam::ConfigFile;
 552
 553                         CXMLAutoPtr ptrWidget((const char*)xmlGetProp (cur, (xmlChar*)"widget"));
 554                         if (!ptrWidget) bOK = false;
 555                         if (stricmp((const char*)ptrWidget,"colbut") == 0)
 556                                 p.Widget = CParam::ColorButton;
 557                         else if (stricmp((const char*)ptrWidget,"sbfloat") == 0)
 558                                 p.Widget = CParam::ScrollBarFloat;
 559                         else if (stricmp((const char*)ptrWidget,"sbint") == 0)
 560                                 p.Widget = CParam::ScrollBarInt;
 561                         else if (stricmp((const char*)ptrWidget,"boolbut") == 0)
 562                                 p.Widget = CParam::BoolButton;
 563                         else if (stricmp((const char*)ptrWidget,"sbfloat_round") == 0)
 564                         {
 565                                 p.Widget = CParam::ScrollBarFloat;
 566                                 p.RoundMode = true;
 567                         }
 568
 569                         CXMLAutoPtr ptrLink((const char*)xmlGetProp (cur, (xmlChar*)"link"));
 570                         if (!ptrLink) bOK = false;
 571                         else p.Link = (const char*)ptrLink;
 572
 573                         if (p.Widget == CParam::ScrollBarInt)
 574                         {
 575                                 CXMLAutoPtr ptrMin((const char*)xmlGetProp (cur, (xmlChar*)"min"));
 576                                 if (!ptrMin) p.Min = 0;
 577                                 else fromString((const char*)ptrMin, p.Min);
 578                                 CXMLAutoPtr ptrMax((const char*)xmlGetProp (cur, (xmlChar*)"max"));
 579                                 if (!ptrMax) p.Max = 255;
 580                                 else fromString((const char*)ptrMax, p.Max);
 581                         }
 582
 583                         CXMLAutoPtr ptrRealtime((const char*)xmlGetProp (cur, (xmlChar*)"realtime"));
 584                         if (!ptrRealtime) p.RealTimeMode = CParam::RTModeFalse;
 585                         else
 586                         {
 587                                 if( !strcmp((const char*)ptrRealtime, "true"))
 588                                         p.RealTimeMode= CParam::RTModeTrue;
 589                                 else if( !strcmp((const char*)ptrRealtime, "end_scroll"))
 590                                         p.RealTimeMode = CParam::RTModeEndScroll;
 591                                 else
 592                                         p.RealTimeMode = CParam::RTModeFalse;
 593                         }
 594
 595                         // try to get the ui_view related
 596                         CXMLAutoPtr ptrUIView((const char*)xmlGetProp (cur, (xmlChar*)"ui_view"));
 597                         if(ptrUIView)
 598                                 p.ResultView = _Parent->getId()+":"+string((const char*)ptrUIView);
 599                         CXMLAutoPtr ptrUIUnit((const char*)xmlGetProp (cur, (xmlChar*)"ui_unit"));
 600                         if(ptrUIUnit && ((const char*)ptrUIUnit)[0]!=0 )
 601                                 p.ResultUnit = CI18N::get((const char*)ptrUIUnit);
 602                         CXMLAutoPtr ptrUIDecimal((const char*)xmlGetProp (cur, (xmlChar*)"ui_decimal"));
 603                         if(ptrUIDecimal)
 604                                 fromString((const char*)ptrUIDecimal, p.ResultDecimal);
 605
 606                         // try to get the preset db entry
 607                         if(p.Type==CParam::ConfigFile && bOK)
 608                         {
 609                                 CXMLAutoPtr ptrPreset((const char*)xmlGetProp (cur, (xmlChar*)"preset"));
 610                                 if(ptrPreset)
 611                                 {
 612                                         p.PresetDB = NLGUI::CDBManager::getInstance()->getDbProp((const char*)ptrPreset, false);
 613                                         if(p.PresetDB)
 614                                         {
 615                                                 // if not exist in the set, add it and register callback
 616                                                 if(_PresetNodes.insert(p.PresetDB).second)
 617                                                 {
 618                                                         ICDBNode::CTextId       id;
 619                                                         p.PresetDB->addObserver(&_PresetObs, id);
 620                                                 }
 621                                         }
 622                                 }
 623                         }
 624
 625                         // if ok, add this parameter!
 626                         if (bOK)
 627                                 _Parameters.push_back(p);
 628                 }
 629                 // apply node?
 630                 else if( stricmp((char*)cur->name,"apply") == 0 )
 631                 {
 632                         CXMLAutoPtr ptrUI((const char*)xmlGetProp (cur, (xmlChar*)"ui"));
 633                         _ApplyButton = dynamic_cast<CCtrlBaseButton*>(CWidgetManager::getInstance()->getElementFromId(_Parent->getId(),(const char*)ptrUI));
 634                 }
 635
 636                 cur = cur->next;
 637         }
 638
 639         CDDXManager::getInstance()->add(this);
 640
 641         return true;
 642 }
 643
 644 // ***************************************************************************
 645 // Initialize parameters from external stuff (database, client.cfg ...)
 646 void CInterfaceDDX::init()
 647 {
 648         // **** start values from CFG, and backup
 649         for (uint i = 0; i < _Parameters.size(); ++i)
 650         {
 651                 CParam &p = _Parameters[i];
 652
 653                 if (p.Type == CParam::DataBase)
 654                 {
 655                         p.DBToWidget();
 656                         p.backupDB();
 657                 }
 658                 else if (p.Type == CParam::ConfigFile)
 659                 {
 660                         p.CFGToWidget();
 661                         p.backupCFG();
 662                 }
 663         }
 664
 665         // **** initialize the preset
 666         resetPreSet();
 667
 668         // **** Start apply frozen
 669         if(_ApplyButton)
 670         {
 671                 _ApplyButton->setFrozen(true);
 672         }
 673 }
 674
 675 // ***************************************************************************
 676 void CInterfaceDDX::update()
 677 {
 678         for (uint i = 0; i < _Parameters.size(); ++i)
 679         {
 680                 CParam &p = _Parameters[i];
 681                 if (p.Type == CParam::DataBase)
 682                 {
 683                         p.WidgetToDB();
 684                         p.backupDB();
 685                 }
 686                 else if (p.Type == CParam::ConfigFile)
 687                 {
 688                         p.WidgetToCFG();
 689                         p.backupCFG();
 690                 }
 691         }
 692
 693         // Write the modified client.cfg
 694         ClientCfg.IsInvalidated = true;
 695
 696         // **** set apply frozen
 697         if(_ApplyButton)
 698         {
 699                 _ApplyButton->setFrozen(true);
 700         }
 701 }
 702
 703 // ***************************************************************************
 704 void CInterfaceDDX::cancel()
 705 {
 706         // Update scroll bars that are realtime
 707         bool bMustSave = false;
 708         uint i;
 709         for (i = 0; i < _Parameters.size(); ++i)
 710         {
 711                 CParam &p = _Parameters[i];
 712
 713                 if (p.RealTimeMode==CParam::RTModeFalse) continue;
 714
 715                 if (p.Type == CParam::DataBase)
 716                 {
 717                         p.restoreDB();
 718                 }
 719                 else if (p.Type == CParam::ConfigFile)
 720                 {
 721                         bMustSave = true;
 722                         p.restoreCFG();
 723                 }
 724         }
 725
 726         if (bMustSave)
 727         {
 728                 ClientCfg.IsInvalidated = true;
 729         }
 730
 731         for (i = 0; i < _Parameters.size(); ++i)
 732         {
 733                 CParam &p = _Parameters[i];
 734
 735                 if (p.Type == CParam::DataBase)
 736                 {
 737                         p.DBToWidget();
 738                 }
 739                 else if (p.Type == CParam::ConfigFile)
 740                 {
 741                         p.CFGToWidget();
 742                 }
 743         }
 744
 745         // **** reset the preset
 746         resetPreSet();
 747
 748         // **** set apply frozen
 749         if(_ApplyButton)
 750         {
 751                 _ApplyButton->setFrozen(true);
 752         }
 753 }
 754
 755 // ***************************************************************************
 756 void CInterfaceDDX::updateRealtime(CCtrlBase *pSB, bool updateOnScrollEnd)
 757 {
 758         // Update scroll bars that are realtime
 759         bool bMustSave = false;
 760         uint i;
 761         for (i = 0; i < _Parameters.size(); ++i)
 762         {
 763                 CParam &p = _Parameters[i];
 764
 765                 if (p.Elt != pSB) continue;
 766
 767                 if( (!updateOnScrollEnd && p.RealTimeMode==CParam::RTModeTrue) ||
 768                         (updateOnScrollEnd && p.RealTimeMode==CParam::RTModeEndScroll) )
 769                 {
 770                         if (p.Type == CParam::DataBase)
 771                         {
 772                                 p.WidgetToDB();
 773                         }
 774                         else if (p.Type == CParam::ConfigFile)
 775                         {
 776                                 bMustSave = true;
 777                                 p.WidgetToCFG();
 778                         }
 779                 }
 780
 781                 // even if not realtime, if has a preset setuped, set it to custom!
 782                 if(p.PresetDB)
 783                 {
 784                         p.PresetDB->setValue32(CustomPreset);
 785                 }
 786
 787                 // even if not realtime, must update text view
 788                 p.WidgetToResultView();
 789         }
 790
 791         if (bMustSave)
 792         {
 793                 ClientCfg.IsInvalidated = true;
 794         }
 795
 796         IngameDbMngr.flushObserverCalls();
 797         NLGUI::CDBManager::getInstance()->flushObserverCalls();
 798
 799         for (i = 0; i < _Parameters.size(); ++i)
 800         {
 801                 CParam &p = _Parameters[i];
 802
 803                 if( (!updateOnScrollEnd && p.RealTimeMode==CParam::RTModeTrue) ||
 804                         (updateOnScrollEnd && p.RealTimeMode==CParam::RTModeEndScroll) )
 805                 {
 806                         if (p.Type == CParam::DataBase)
 807                         {
 808                                 p.DBToWidget();
 809                         }
 810                         else if (p.Type == CParam::ConfigFile)
 811                         {
 812                                 p.CFGToWidget();
 813                         }
 814                 }
 815         }
 816
 817         // **** something changed, allow apply!
 818         if(_ApplyButton)
 819         {
 820                 _ApplyButton->setFrozen(false);
 821         }
 822 }
 823
 824 // ***************************************************************************
 825 void CInterfaceDDX::updateParamPreset(CCDBNodeLeaf *presetChanged)
 826 {
 827         if(!presetChanged)
 828                 return;
 829         // if not custom or bad id
 830         uint    presetVal= presetChanged->getValue32();
 831         if(presetVal>=NumPreset)
 832                 return;
 833
 834         // **** check each parameter
 835         for(uint i=0;i<_Parameters.size();i++)
 836         {
 837                 CParam  &param= _Parameters[i];
 838
 839                 // if can be set by this preset modified
 840                 if(param.PresetDB == presetChanged)
 841                 {
 842                         // must be a config file param (see parse())
 843                         nlassert(param.Type==CParam::ConfigFile);
 844
 845                         // restore preset
 846                         param.restoreCFGPreset(presetVal);
 847
 848                         // if realTime, then must update CFG
 849                         if (param.RealTimeMode!=CParam::RTModeFalse)
 850                         {
 851                                 param.WidgetToCFG();
 852                                 ClientCfg.IsInvalidated= true;
 853                         }
 854                 }
 855         }
 856
 857         // **** something changed, allow apply!
 858         if(_ApplyButton)
 859         {
 860                 _ApplyButton->setFrozen(false);
 861         }
 862 }
 863
 864 // ***************************************************************************
 865 void CInterfaceDDX::validateApplyButton()
 866 {
 867         if(_ApplyButton)
 868         {
 869                 _ApplyButton->setFrozen(false);
 870         }
 871 }
 872
 873 // ***************************************************************************
 874 void CInterfaceDDX::resetPreSet()
 875 {
 876         nlassert(NumPreset<32);
 877         // for each preset, assign a bitfield, where bit==1 <=> preset possible
 878         std::map<CCDBNodeLeaf*, uint32>         bfPreset;
 879         std::set<CCDBNodeLeaf*>::iterator       itSet;
 880         // init as "preset possible"
 881         for(itSet=_PresetNodes.begin();itSet!=_PresetNodes.end();itSet++)
 882         {
 883                 bfPreset[*itSet]= (1<<NumPreset)-1;
 884         }
 885
 886         // then for each parameter, invalidate preset according to value
 887         for (uint i = 0; i < _Parameters.size(); ++i)
 888         {
 889                 CParam &p = _Parameters[i];
 890
 891                 if (p.Type == CParam::ConfigFile && p.PresetDB)
 892                 {
 893                         std::map<CCDBNodeLeaf*, uint32>::iterator       it= bfPreset.find(p.PresetDB);
 894                         if(it!=bfPreset.end())
 895                         {
 896                                 it->second&= p.getPresetPossibleBF();
 897                         }
 898                 }
 899         }
 900
 901         // for each preset DB, assign the lowest preset possible
 902         std::map<CCDBNodeLeaf*, uint32>::iterator       itMap;
 903         for(itMap= bfPreset.begin();itMap!=bfPreset.end();itMap++)
 904         {
 905                 CCDBNodeLeaf    *node= itMap->first;
 906                 uint32                  bf= itMap->second;
 907
 908                 // if no common preset is possible, then assign custom!
 909                 if(bf==0)
 910                 {
 911                         node->setValue32(CustomPreset);
 912                 }
 913                 // else assign the lowest bit
 914                 else
 915                 {
 916                         uint32  presetId= 0;
 917                         while( (bf&(1<<presetId)) == 0)
 918                                 presetId++;
 919                         node->setValue32(presetId);
 920                 }
 921         }
 922 }
 923
 924 // ***************************************************************************
 925 void CInterfaceDDX::CPresetObs::update(ICDBNode* node)
 926 {
 927         CCDBNodeLeaf    *leaf= dynamic_cast<CCDBNodeLeaf*>(node);
 928         if(leaf)
 929                 Owner->updateParamPreset(leaf);
 930 }
 931
 932 // ***************************************************************************
 933 // CDDXManager
 934 // ***************************************************************************
 935
 936 // ***************************************************************************
 937 CDDXManager* CDDXManager::_Instance = NULL;
 938
 939 // ***************************************************************************
 940 CDDXManager::CDDXManager()
 941 {
 942 }
 943
 944 // ***************************************************************************
 945 void CDDXManager::releaseInstance()
 946 {
 947         if( _Instance )
 948                 delete _Instance;
 949         _Instance = NULL;
 950 }
 951
 952 // ***************************************************************************
 953 void CDDXManager::release()
 954 {
 955         std::map<std::string, CInterfaceDDX*>::iterator ite = _DDXes.begin();
 956         while (ite != _DDXes.end())
 957         {
 958                 delete ite->second;
 959
 960                 ite++;
 961         }
 962         _DDXes.clear();
 963 }
 964
 965 // ***************************************************************************
 966 void CDDXManager::add(CInterfaceDDX *pDDX)
 967 {
 968         _DDXes.insert(pair<string,CInterfaceDDX*>(pDDX->getId(),pDDX));
 969 }
 970
 971 // ***************************************************************************
 972 CInterfaceDDX *CDDXManager::get(const std::string &ddxName)
 973 {
 974         map<string, CInterfaceDDX*>::iterator it = _DDXes.find(ddxName);
 975         if (it == _DDXes.end())
 976         {
 977                 it = _DDXes.find("ui:interface:"+ddxName);
 978         }
 979         if (it != _DDXes.end())
 980         {
 981                 return it->second;
 982         }
 983         return NULL;
 984 }
 985
 986 // ***************************************************************************
 987 CInterfaceDDX *CDDXManager::getFromParent(const std::string &ddxParentName)
 988 {
 989         map<string, CInterfaceDDX*>::iterator it = _DDXes.begin();
 990         while (it != _DDXes.end())
 991         {
 992                 string parentName = it->first;
 993                 parentName = parentName.substr(0,parentName.rfind(":"));
 994                 if (parentName == ddxParentName)
 995                         return it->second;
 996                 it++;
 997         }
 998         return NULL;
 999 }
1000
1001 // ***************************************************************************
1002 // Update database or config file from the parameters (ddx memory zone)
1003 class CHandlerDDXUpdate : public IActionHandler
1004 {
1005 public:
1006         void execute (CCtrlBase * /* pCaller */, const std::string &sParams)
1007         {
1008                 CDDXManager *pDM = CDDXManager::getInstance();
1009                 CInterfaceDDX *pDDX = pDM->get(sParams);
1010                 if (pDDX != NULL)
1011                         pDDX->update();
1012         }
1013 protected:
1014 };
1015 REGISTER_ACTION_HANDLER( CHandlerDDXUpdate, "ddx_update");
1016
1017 // ***************************************************************************
1018 // Update the parameters (ddx mem zone) from database or config file
1019 class CHandlerDDXInit : public IActionHandler
1020 {
1021 public:
1022         void execute (CCtrlBase * /* pCaller */, const std::string &sParams)
1023         {
1024                 CDDXManager *pDM = CDDXManager::getInstance();
1025                 CInterfaceDDX *pDDX = pDM->get(sParams);
1026                 if (pDDX != NULL)
1027                         pDDX->init();
1028         }
1029 protected:
1030 };
1031 REGISTER_ACTION_HANDLER( CHandlerDDXInit, "ddx_init");
1032
1033 // ***************************************************************************
1034 // Cancel all realtime values
1035 class CHandlerDDXCancel : public IActionHandler
1036 {
1037 public:
1038         void execute (CCtrlBase * /* pCaller */, const std::string &sParams)
1039         {
1040                 CDDXManager *pDM = CDDXManager::getInstance();
1041                 CInterfaceDDX *pDDX = pDM->get(sParams);
1042                 if (pDDX != NULL)
1043                         pDDX->cancel();
1044         }
1045 protected:
1046 };
1047 REGISTER_ACTION_HANDLER( CHandlerDDXCancel, "ddx_cancel");
1048
1049 // ***************************************************************************
1050 class CHandlerDDXScroll : public IActionHandler
1051 {
1052 public:
1053         void execute (CCtrlBase *pCaller, const std::string &sParams)
1054         {
1055                 CDDXManager *pDM = CDDXManager::getInstance();
1056                 CInterfaceDDX *pDDX = pDM->get(sParams);
1057                 if (pDDX != NULL)
1058                         pDDX->updateRealtime(pCaller, false);
1059         }
1060 protected:
1061 };
1062 REGISTER_ACTION_HANDLER( CHandlerDDXScroll, "ddx_scroll");
1063
1064 // ***************************************************************************
1065 class CHandlerDDXScrollEnd : public IActionHandler
1066 {
1067 public:
1068         void execute (CCtrlBase *pCaller, const std::string &sParams)
1069         {
1070                 CDDXManager *pDM = CDDXManager::getInstance();
1071                 CInterfaceDDX *pDDX = pDM->get(sParams);
1072                 if (pDDX != NULL)
1073                         pDDX->updateRealtime(pCaller, true);
1074         }
1075 protected:
1076 };
1077 REGISTER_ACTION_HANDLER( CHandlerDDXScrollEnd, "ddx_scroll_end");
1078
1079 // ***************************************************************************
1080 // Automatically search for the ddx and launch an update
1081 class CHandlerDDXColor : public IActionHandler
1082 {
1083 public:
1084         void execute (CCtrlBase *pCaller, const std::string &/* sParams */)
1085         {
1086                 CDDXManager *pDM = CDDXManager::getInstance();
1087                 if (pCaller == NULL) return;
1088                 CInterfaceManager *pIM = CInterfaceManager::getInstance();
1089                 CCtrlBase *pCB = CWidgetManager::getInstance()->getCtrlLaunchingModal();
1090                 // Search for a ddx in the parents
1091                 CInterfaceGroup *pIG = pCB->getParent();
1092                 bool found = false;
1093                 CInterfaceDDX *pDDX = NULL;
1094                 while (!found)
1095                 {
1096                         pDDX = pDM->getFromParent(pIG->getId());
1097                         if (pDDX != NULL) found = true;
1098                         else pIG = pIG->getParent();
1099                         if (pIG == NULL) return;
1100                 }
1101                 if (pDDX != NULL)
1102                         pDDX->updateRealtime(pCB, false);
1103         }
1104 protected:
1105 };
1106 REGISTER_ACTION_HANDLER( CHandlerDDXColor , "ddx_color");
1107
1108
1109 // ***************************************************************************
1110 // Automatically search for the ddx and launch an update
1111 class CHandlerDDXBoolButton : public IActionHandler
1112 {
1113 public:
1114         void execute (CCtrlBase *pCaller, const std::string &/* sParams */)
1115         {
1116                 CDDXManager *pDM = CDDXManager::getInstance();
1117                 if (pCaller == NULL) return;
1118                 // Search for a ddx in the parents
1119                 CInterfaceGroup *pIG = pCaller->getParent();
1120                 bool found = false;
1121                 CInterfaceDDX *pDDX = NULL;
1122                 while (!found)
1123                 {
1124                         pDDX = pDM->getFromParent(pIG->getId());
1125                         if (pDDX != NULL) found = true;
1126                         else pIG = pIG->getParent();
1127                         if (pIG == NULL) return;
1128                 }
1129                 if (pDDX != NULL)
1130                         pDDX->updateRealtime(pCaller, false);
1131         }
1132 protected:
1133 };
1134 REGISTER_ACTION_HANDLER( CHandlerDDXBoolButton , "ddx_bool_button");