nel/src/gui/dbgroup_combo_box.cpp

   1 // Ryzom - MMORPG Framework <http://dev.ryzom.com/projects/ryzom/>
   2 // Copyright (C) 2010-2021  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) 2013-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 #include "stdpch.h"
  23 #include "nel/gui/dbgroup_combo_box.h"
  24 #include "nel/gui/group_menu.h"
  25 #include "nel/misc/xml_auto_ptr.h"
  26 #include "nel/gui/ctrl_button.h"
  27 #include "nel/gui/action_handler.h"
  28 #include "nel/gui/lua_ihm.h"
  29 #include "nel/gui/widget_manager.h"
  30 #include "nel/misc/i18n.h"
  31
  32 using namespace std;
  33 using namespace NLMISC;
  34
  35 #ifdef DEBUG_NEW
  36 #define new DEBUG_NEW
  37 #endif
  38
  39 namespace NLGUI
  40 {
  41         NLMISC_REGISTER_OBJECT(CViewBase, CDBGroupComboBox, std::string, "combo_box");
  42
  43         void force_link_dbgroup_combo_box_cpp() { }
  44
  45         // Compare strings
  46         static inline bool lt_text(const std::pair<int,std::string> &s1, const std::pair<int,std::string> &s2)
  47         {
  48                 // return toLower(s1.second) < toLower(s2.second);
  49                 return NLMISC::compareCaseInsensitive(s1.second, s2.second) < 0;
  50         }
  51
  52         std::string CDBGroupComboBox::measureMenu;
  53         std::string CDBGroupComboBox::selectMenu;
  54         std::string CDBGroupComboBox::selectMenuOut;
  55
  56         // ***************************************************************************
  57         CDBGroupComboBox::CDBGroupComboBox(const TCtorParam &param)
  58         :       CInterfaceGroup(param)
  59         {
  60                 _Setuped= false;
  61                 _ViewText= NULL;
  62                 _SelectButton= NULL;
  63                 _LinkedToDB = true;
  64                 _NotLinkedToDBSelection = 0;
  65                 _CallingOnChangeActionHandler = false;
  66                 _IsExternViewText = false;
  67                 dirt();
  68         }
  69
  70         // ***************************************************************************
  71         CDBGroupComboBox::~CDBGroupComboBox()
  72         {
  73         }
  74
  75         // ***************************************************************************
  76         sint32 CDBGroupComboBox::evalContentWidth() const
  77         {
  78                 // get the menu to open.
  79                 CGroupMenu      *groupMenu= dynamic_cast<CGroupMenu*>(CWidgetManager::getInstance()->getElementFromId( CDBGroupComboBox::measureMenu ));
  80                 if( !groupMenu )
  81                 {
  82                         return 0;
  83                 }
  84                 fillMenu(groupMenu);
  85                 groupMenu->setActive(true);
  86                 groupMenu->updateCoords();
  87                 sint32 width = groupMenu->getWReal();
  88                 groupMenu->setActive(false);
  89                 groupMenu->reset();
  90                 // add width for the selection arrow
  91                 return width;
  92         }
  93
  94         std::string CDBGroupComboBox::getProperty( const std::string &name ) const
  95         {
  96                 if( name == "linked_to_db" )
  97                 {
  98                         return toString( _LinkedToDB );
  99                 }
 100                 else
 101                 if( name == "value" )
 102                 {
 103                         if( _Selection.getNodePtr() != NULL )
 104                                 return _Selection.getNodePtr()->getFullName();
 105                         else
 106                                 return "";
 107                 }
 108                 else
 109                         return CInterfaceGroup::getProperty( name );
 110         }
 111
 112         void CDBGroupComboBox::setProperty( const std::string &name, const std::string &value )
 113         {
 114                 if( name == "linked_to_db" )
 115                 {
 116                         bool b;
 117                         if( fromString( value, b ) )
 118                                 _LinkedToDB = b;
 119                         return;
 120                 }
 121                 else
 122                 if( name == "value" )
 123                 {
 124                         _Selection.link( value.c_str() );
 125                         return;
 126                 }
 127                 else
 128                         CInterfaceGroup::setProperty( name, value );
 129         }
 130
 131         xmlNodePtr CDBGroupComboBox::serialize( xmlNodePtr parentNode, const char *type ) const
 132         {
 133                 xmlNodePtr node = CInterfaceGroup::serialize( parentNode, type );
 134                 if( node == NULL )
 135                         return NULL;
 136
 137                 xmlSetProp( node, BAD_CAST "type", BAD_CAST "combo_box" );
 138                 xmlSetProp( node, BAD_CAST "linked_to_db", BAD_CAST toString( _LinkedToDB ).c_str() );
 139
 140                 if( _Selection.getNodePtr() != NULL )
 141                         xmlSetProp( node, BAD_CAST "value", BAD_CAST _Selection.getNodePtr()->getFullName().c_str() );
 142                 else
 143                         xmlSetProp( node, BAD_CAST "value", BAD_CAST "" );
 144
 145
 146                 return node;
 147         }
 148
 149         // ***************************************************************************
 150         bool    CDBGroupComboBox::parse (xmlNodePtr cur, CInterfaceGroup *parentGroup)
 151         {
 152                 if( !CInterfaceGroup::parse(cur, parentGroup) )
 153                         return false;
 154
 155                 CXMLAutoPtr     prop((const char*)xmlGetProp(cur, (xmlChar*)"linked_to_db"));
 156                 if (prop)
 157                 {
 158                         _LinkedToDB = convertBool(prop);
 159                 }
 160
 161                 if (_LinkedToDB)
 162                 {
 163                         // read the selection value
 164                         CXMLAutoPtr     prop((const char*)xmlGetProp(cur, (xmlChar*)"value"));
 165                         if(!prop)
 166                         {
 167                                 nlwarning("'value' not found in %s", _Id.c_str());
 168                                 return false;
 169                         }
 170                         else
 171                         {
 172                                 _Selection.link((const char*)prop);
 173                         }
 174                 }
 175
 176                 // read the sons text
 177                 xmlNodePtr child;
 178                 child = cur->children;
 179                 while (child)
 180                 {
 181                         if (stricmp((char*)child->name,"combo_text") == 0)
 182                         {
 183                                 CXMLAutoPtr name((const char*) xmlGetProp (child, (xmlChar*)"name"));
 184                                 if (name)
 185                                 {
 186                                         const char *propPtr = name;
 187                                         if (NLMISC::startsWith(propPtr, "ui"))
 188                                                 addText(CI18N::get(propPtr));
 189                                         else
 190                                                 addText(propPtr);
 191                                 }
 192                         }
 193                         child = child->next;
 194                 }
 195
 196                 // optional ActionHandler on click
 197                 prop= xmlGetProp(cur, (xmlChar*)"on_select_start");
 198                 if(prop)        _AHOnSelectStart= (const char*)prop;
 199
 200                 // optional ActionHandler on change
 201                 prop= xmlGetProp(cur, (xmlChar*)"on_change");
 202                 if(prop)        _AHOnChange= (const char*)prop;
 203
 204                 prop= xmlGetProp(cur, (xmlChar*)"on_change_params");
 205                 if(prop)        _AHOnChangeParams= (const char*)prop;
 206
 207
 208                 return true;
 209         }
 210
 211         // ***************************************************************************
 212         void    CDBGroupComboBox::checkCoords ()
 213         {
 214                 if(!_ViewText)
 215                         return;
 216                 bool mustUpdate = false;
 217                 if (_LinkedToDB)
 218                 {
 219                         // if some change in texts/selection
 220                         if(_DirtySelection || _CacheSelection!=_Selection.getSInt32())
 221                         {
 222                                 _CacheSelection= _Selection.getSInt32();
 223                                 mustUpdate = true;
 224                         }
 225                 }
 226                 else
 227                 {
 228                         // if some change in texts/selection
 229                         if(_DirtySelection || _CacheSelection != _NotLinkedToDBSelection)
 230                         {
 231                                 _CacheSelection= _NotLinkedToDBSelection;
 232                                 mustUpdate = true;
 233                         }
 234                 }
 235                 if (mustUpdate)
 236                 {
 237                         // change selected text
 238                         if(_CacheSelection<0 || _CacheSelection>=(sint32)_Texts.size() )
 239                         {
 240                                 _ViewText->setText(std::string());
 241                         }
 242                         else if(_IsExternViewText)
 243                         {
 244                                 _ViewText->setText(_ExternViewText);
 245                         }
 246                         else
 247                         {
 248                                 _ViewText->setText(_Texts[_CacheSelection].second);
 249                         }
 250                 }
 251         }
 252
 253         // ***************************************************************************
 254         void    CDBGroupComboBox::updateCoords ()
 255         {
 256                 if(!_Setuped)
 257                         setup();
 258                 CInterfaceGroup::updateCoords();
 259         }
 260
 261
 262         // ***************************************************************************
 263         void    CDBGroupComboBox::dirt()
 264         {
 265                 _DirtySelection= true;
 266         }
 267
 268         // ***************************************************************************
 269         void    CDBGroupComboBox::resetTexts()
 270         {
 271                 dirt();
 272                 _Texts.clear();
 273                 _Textures.clear();
 274                 _Grayed.clear();
 275         }
 276
 277         // ***************************************************************************
 278         void    CDBGroupComboBox::addText(const std::string &text)
 279         {
 280                 dirt();
 281                 _Texts.push_back(make_pair((uint)_Texts.size(), text));
 282                 _Textures.push_back(std::string());
 283                 _Grayed.push_back(false);
 284         }
 285
 286         // ***************************************************************************
 287         void    CDBGroupComboBox::setText(uint i, const std::string &text)
 288         {
 289                 dirt();
 290                 if(i<_Texts.size())
 291                         _Texts[i].second= text;
 292         }
 293
 294         // ***************************************************************************
 295         void    CDBGroupComboBox::insertText(uint i, const std::string &text)
 296         {
 297                 dirt();
 298                 if(i<_Texts.size())
 299                 {
 300                         addText(_Texts[_Texts.size()-1].second);
 301
 302                         for(uint t=i; t<_Texts.size()-1; t++)
 303                         {
 304                                 _Texts[t+1] = _Texts[t];
 305                                 _Textures[t+1] = _Textures[t];
 306                                 _Grayed[t+1] = _Grayed[t];
 307                         }
 308                         _Texts[i] = make_pair(i, text);
 309                         _Textures[i] = std::string();
 310                         _Grayed[i] = false;
 311                 }
 312                 else if(i==_Texts.size())
 313                         addText(text);
 314         }
 315
 316         // ***************************************************************************
 317         void    CDBGroupComboBox::setTexture(uint i, const std::string &texture)
 318         {
 319                 dirt();
 320                 if(i<_Textures.size())
 321                         _Textures[i]= texture;
 322         }
 323
 324         // ***************************************************************************
 325         void    CDBGroupComboBox::setGrayed(uint i, bool g)
 326         {
 327                 dirt();
 328                 if(i<_Grayed.size())
 329                         _Grayed[i] = g;
 330         }
 331
 332         // ***************************************************************************
 333         bool    CDBGroupComboBox::getGrayed(uint i) const
 334         {
 335                 if(i<_Grayed.size())
 336                         return _Grayed[i];
 337                 else
 338                         return false;
 339         }
 340
 341
 342         // ***************************************************************************
 343         void    CDBGroupComboBox::removeText(uint nPos)
 344         {
 345                 dirt();
 346                 if(nPos<_Texts.size())
 347                 {
 348                         _Texts.erase( _Texts.begin()+nPos );
 349                         _Textures.erase( _Textures.begin()+nPos );
 350                         _Grayed.erase ( _Grayed.begin()+nPos );
 351                 }
 352         }
 353
 354         // ***************************************************************************
 355         const std::string &CDBGroupComboBox::getText(uint i) const
 356         {
 357                 static const std::string empty;
 358                 if (i < _Texts.size())
 359                         return _Texts[i].second;
 360                 else
 361                         return empty;
 362         }
 363
 364 #ifdef RYZOM_LUA_UCSTRING
 365         // ***************************************************************************
 366         ucstring CDBGroupComboBox::getTextAsUtf16(uint i) const
 367         {
 368                 return ucstring::makeFromUtf8(getText(i));
 369         }
 370 #endif
 371
 372         // ***************************************************************************
 373         uint CDBGroupComboBox::getTextId(uint i) const
 374         {
 375                 static  uint    null = 0;
 376                 if(i<_Texts.size())
 377                         return _Texts[i].first;
 378                 else
 379                         return null;
 380         }
 381
 382         // ***************************************************************************
 383         uint    CDBGroupComboBox::getTextPos(uint nId) const
 384         {
 385                 for(uint i=0; i<_Texts.size(); i++)
 386                 {
 387                         if(nId == _Texts[i].first) {return i;}
 388                 }
 389                 return 0;
 390         }
 391
 392         // ***************************************************************************
 393         void    CDBGroupComboBox::sortText()
 394         {
 395                 sort(_Texts.begin(), _Texts.end(), lt_text);
 396         }
 397
 398         // ***************************************************************************
 399         const std::string &CDBGroupComboBox::getTexture(uint i) const
 400         {
 401                 static const std::string empty;
 402                 if (i < _Textures.size())
 403                         return _Textures[i];
 404                 else
 405                         return empty;
 406         }
 407
 408 #ifdef RYZOM_LUA_UCSTRING
 409         // ***************************************************************************
 410         ucstring CDBGroupComboBox::getTextureAsUtf16(uint i) const
 411         {
 412                 return ucstring::makeFromUtf8(getTexture(i));
 413         }
 414 #endif
 415
 416         // ***************************************************************************
 417         void            CDBGroupComboBox::setSelection(sint32 val)
 418         {
 419                 _IsExternViewText = false;
 420
 421                 if (_LinkedToDB)
 422                 {
 423                         _Selection.setSInt32(val);
 424                 }
 425                 else
 426                 {
 427                         _NotLinkedToDBSelection = val;
 428                 }
 429                 if (!_AHOnChange.empty())
 430                 {
 431                         if (!_CallingOnChangeActionHandler)
 432                         {
 433                                 _CallingOnChangeActionHandler = true;
 434                                 CAHManager::getInstance()->runActionHandler (_AHOnChange, this, _AHOnChangeParams);
 435                                 _CallingOnChangeActionHandler = false;
 436                         }
 437                 }
 438         }
 439
 440         // ***************************************************************************
 441         void CDBGroupComboBox::setSelectionNoTrigger(sint32 val)
 442         {
 443                 if (_LinkedToDB)
 444                 {
 445                         _Selection.setSInt32(val);
 446                 }
 447                 else
 448                 {
 449                         _NotLinkedToDBSelection = val;
 450                 }
 451         }
 452
 453         // ***************************************************************************
 454         sint32          CDBGroupComboBox::getSelection() const
 455         {
 456                 if (_LinkedToDB)
 457                 {
 458                         return _Selection.getSInt32();
 459                 }
 460                 else
 461                 {
 462                         return _NotLinkedToDBSelection;
 463                 }
 464         }
 465
 466         // ***************************************************************************
 467         void            CDBGroupComboBox::setSelectionText(const std::string & val)
 468         {
 469                 sint32 value;
 470                 for(uint i=0; i<getNumTexts(); i++)
 471                 {
 472                         std::string sText = getText(i);
 473                         if(sText == val)
 474                         {
 475                                 value = i;
 476                                 setSelection(value);
 477                                 break;
 478                         }
 479                 }
 480         }
 481
 482                 // ***************************************************************************
 483         void            CDBGroupComboBox::setOnChange(const std::string & val)
 484         {
 485                 _AHOnChange = "lua";
 486                 _AHOnChangeParams = val;
 487         }
 488
 489         // ***************************************************************************
 490         void CDBGroupComboBox::setViewText(const std::string &text)
 491         {
 492                 _IsExternViewText = true;
 493                 _ExternViewText = text;
 494                 _ViewText->setText(_ExternViewText);
 495         }
 496
 497         // ***************************************************************************
 498         std::string CDBGroupComboBox::getViewText() const
 499         {
 500                 return _ViewText->getText();
 501         }
 502
 503 #ifdef RYZOM_LUA_UCSTRING
 504         // ***************************************************************************
 505         ucstring CDBGroupComboBox::getViewTextAsUtf16() const
 506         {
 507                 return  CUtfStringView(_ViewText->getText()).toUtf16();
 508         }
 509 #endif
 510
 511         // ***************************************************************************
 512         CViewText *CDBGroupComboBox::getViewText()
 513         {
 514                 return  _ViewText;
 515         }
 516
 517         // ***************************************************************************
 518         std::string CDBGroupComboBox::getSelectionText() const
 519         {
 520                 if (_LinkedToDB)
 521                 {
 522                         return getText(_Selection.getSInt32());
 523                 }
 524                 else
 525                 {
 526                         return getText(_NotLinkedToDBSelection);
 527                 }
 528         }
 529
 530 // ***************************************************************************
 531         std::string CDBGroupComboBox::getOnChange() const
 532         {
 533                         return _AHOnChangeParams;
 534         }
 535
 536
 537         // ***************************************************************************
 538         void    CDBGroupComboBox::setup()
 539         {
 540                 _Setuped= true;
 541
 542                 // get the viewText
 543                 _ViewText= dynamic_cast<CViewText*>(CInterfaceGroup::getView("text"));
 544                 // get the button
 545                 _SelectButton= dynamic_cast<CCtrlBaseButton*>(CInterfaceGroup::getCtrl("select"));
 546
 547                 // force the action handler
 548                 if( _SelectButton )
 549                         _SelectButton->setActionOnLeftClick("combo_box_select_start");
 550         }
 551
 552
 553
 554         // ***************************************************************************
 555         int CDBGroupComboBox::luaRemoveSelection(CLuaState &ls)
 556         {
 557                 CLuaIHM::checkArgCount(ls, "removeSelection", 1);
 558                 sint32 value;
 559                 if(CLuaIHM::popSINT32(ls, value))
 560                 {
 561                         removeText(value);
 562                 }
 563                 return 0;
 564         }
 565
 566         // ***************************************************************************
 567         int CDBGroupComboBox::luaRemoveText(CLuaState &ls)
 568         {
 569                 CLuaIHM::checkArgCount(ls, "removeText", 1);
 570                 CLuaIHM::checkArgType(ls, "removeText", 1, LUA_TSTRING);
 571                 std::string text = ls.toString(1);
 572                 sint32 value;
 573                 for(uint i=0; i<getNumTexts(); i++)
 574                 {
 575                         std::string sText = getText(i);
 576                         if(sText == text)
 577                         {
 578                                 value = i;
 579                                 removeText(value);
 580                                 break;
 581                         }
 582                 }
 583                 return 0;
 584         }
 585
 586         // ***************************************************************************
 587         int CDBGroupComboBox::luaResetTexts(CLuaState &ls)
 588         {
 589                 CLuaIHM::checkArgCount(ls, "resetTexts", 0);
 590                 resetTexts();
 591                 return 0;
 592         }
 593
 594         // ***************************************************************************
 595         int CDBGroupComboBox::luaAddText(CLuaState &ls)
 596         {
 597                 const char *funcName = "addText";
 598                 CLuaIHM::checkArgCount(ls, funcName, 1);
 599 #ifdef RYZOM_LUA_UCSTRING
 600                 CLuaIHM::checkArgTypeUCString(ls, funcName, 1);
 601                 ucstring text; // Compatibility
 602                 nlverify(CLuaIHM::pop(ls, text));
 603                 addText(text.toUtf8());
 604 #else
 605                 CLuaIHM::checkArgType(ls, funcName, 1, LUA_TSTRING);
 606                 string text = ls.toString(1);
 607                 addText(text);
 608 #endif
 609                 return 0;
 610         }
 611
 612         // ***************************************************************************
 613         int CDBGroupComboBox::luaSetText(CLuaState &ls)
 614         {
 615                 const char *funcName = "setText";
 616                 CLuaIHM::checkArgCount(ls, funcName, 2);
 617                 CLuaIHM::checkArgType(ls, funcName, 1, LUA_TNUMBER);
 618 #ifdef RYZOM_LUA_UCSTRING
 619                 CLuaIHM::checkArgTypeUCString(ls, funcName, 2);
 620                 ucstring text; // Compatibility
 621                 nlverify(CLuaIHM::pop(ls, text));
 622                 setText((uint) ls.toInteger(1), text.toUtf8());
 623 #else
 624                 CLuaIHM::checkArgType(ls, funcName, 2, LUA_TSTRING);
 625                 string text = ls.toString(2);
 626                 setText((uint)ls.toInteger(1), text);
 627 #endif
 628                 return 0;
 629         }
 630
 631         // ***************************************************************************
 632         int CDBGroupComboBox::luaInsertText(CLuaState &ls)
 633         {
 634                 const char *funcName = "insertText";
 635                 CLuaIHM::checkArgCount(ls, funcName, 2);
 636                 CLuaIHM::checkArgType(ls, funcName, 1, LUA_TNUMBER);
 637 #ifdef RYZOM_LUA_UCSTRING
 638                 CLuaIHM::checkArgTypeUCString(ls, funcName, 2);
 639                 ucstring text;
 640                 nlverify(CLuaIHM::pop(ls, text));
 641                 insertText((uint) ls.toInteger(1), text.toUtf8()); // FIXME: Lua should just do UTF-8!
 642 #else
 643                 CLuaIHM::checkArgType(ls, funcName, 2, LUA_TSTRING);
 644                 string text = ls.toString(2);
 645                 insertText((uint)ls.toInteger(1), text);
 646 #endif
 647                 return 0;
 648         }
 649
 650         // ***************************************************************************
 651         int CDBGroupComboBox::luaSetTexture(CLuaState &ls)
 652         {
 653                 const char *funcName = "setTexture";
 654                 CLuaIHM::checkArgCount(ls, funcName, 2);
 655                 CLuaIHM::checkArgType(ls, funcName, 1, LUA_TNUMBER);
 656 #ifdef RYZOM_LUA_UCSTRING
 657                 CLuaIHM::checkArgTypeUCString(ls, funcName, 2);
 658                 ucstring texture;
 659                 nlverify(CLuaIHM::pop(ls, texture));
 660                 setTexture((uint) ls.toInteger(1), texture.toUtf8()); // FIXME: Lua should just do UTF-8!
 661 #else
 662                 CLuaIHM::checkArgType(ls, funcName, 2, LUA_TSTRING);
 663                 string texture = ls.toString(2);
 664                 setTexture((uint)ls.toInteger(1), texture);
 665 #endif
 666                 return 0;
 667         }
 668
 669         // ***************************************************************************
 670         int CDBGroupComboBox::luaGetText(CLuaState &ls)
 671         {
 672                 const char *funcName = "getText";
 673                 CLuaIHM::checkArgCount(ls, funcName, 1);
 674                 CLuaIHM::checkArgType(ls, funcName, 1, LUA_TNUMBER);
 675 #ifdef RYZOM_LUA_UCSTRING
 676                 CLuaIHM::push(ls, getTextAsUtf16((uint) ls.toInteger(1)));
 677 #else
 678                 ls.push(getText((uint)ls.toInteger(1)));
 679 #endif
 680                 return 1;
 681         }
 682
 683         // ***************************************************************************
 684         int CDBGroupComboBox::luaRemoveTextByIndex(CLuaState &ls)
 685         {
 686                 const char *funcName = "removeText";
 687                 CLuaIHM::checkArgCount(ls, funcName, 1);
 688                 CLuaIHM::checkArgType(ls, funcName, 1, LUA_TNUMBER);
 689                 removeText((uint)ls.toInteger(1));
 690                 return 0;
 691         }
 692
 693         // ***************************************************************************
 694         int CDBGroupComboBox::luaGetNumTexts(CLuaState &ls)
 695         {
 696                 const char *funcName = "getNumTexts";
 697                 CLuaIHM::checkArgCount(ls, funcName, 0);
 698                 ls.push(getNumTexts());
 699                 return 1;
 700         }
 701
 702         // ***************************************************************************
 703         void CDBGroupComboBox::fillMenu(CGroupMenu *groupMenu) const
 704         {
 705                 nlassert(groupMenu);
 706
 707                         if (_ViewText)
 708                                 groupMenu->setFontSize(_ViewText->getFontSize());
 709
 710                         // Setup the menu with combo action.
 711                         groupMenu->reset();
 712                         for(uint i=0; i<getNumTexts(); i++)
 713                         {
 714                                 // set the id as the parameter
 715                                 bool checkable = false;
 716                                 if (getTexture(i) != std::string())
 717                                 {
 718                                         checkable = true;
 719                                 }
 720                                 groupMenu->addLine(getText(i), "combo_box_select_end", toString(i),
 721                                         "", std::string(), getTexture(i), checkable);
 722                                 groupMenu->setGrayedLine(i, getGrayed(i));
 723                         }
 724
 725
 726         }
 727
 728
 729
 730         // ***************************************************************************
 731         class   CHandlerComboBoxSelectStart : public IActionHandler
 732         {
 733         public:
 734                 virtual void execute (CCtrlBase *pCaller, const std::string &/* Params */)
 735                 {
 736                         CDBGroupComboBox *pCB = dynamic_cast<CDBGroupComboBox*>(pCaller->getParent());
 737                         if (pCB == NULL) return;
 738                         // if no choice, return.
 739                         if( pCB->getNumTexts()==0 )
 740                                 return;
 741
 742                         // get the menu to open.
 743                         CGroupMenu      *groupMenu= dynamic_cast<CGroupMenu*>(CWidgetManager::getInstance()->getElementFromId( CDBGroupComboBox::selectMenu ));
 744                         if( !groupMenu )
 745                         {
 746                                 groupMenu= dynamic_cast<CGroupMenu*>(CWidgetManager::getInstance()->getElementFromId( CDBGroupComboBox::selectMenuOut ));
 747                         }
 748                         if( !groupMenu )
 749                                 return;
 750
 751                         pCB->fillMenu(groupMenu);
 752
 753                         groupMenu->setMaxVisibleLine(8);
 754
 755                         // pos and size wisely the menu.
 756                         groupMenu->setMinW(pCB->getWReal());
 757                         groupMenu->setX(pCB->getXReal());
 758                         groupMenu->setBaseX(pCB->getXReal());
 759                         groupMenu->setY(pCB->getYReal());
 760                         groupMenu->setBaseY(pCB->getYReal());
 761
 762                         // Must ensure the combo menu has same windows priority than the combo box window
 763                         CInterfaceGroup         *rootWin= pCB->getRootWindow();
 764                         if(rootWin)
 765                                 groupMenu->setPriority(rootWin->getPriority());
 766
 767                         // After menu init, Call user activation method
 768                         if( !pCB->_AHOnSelectStart.empty() )
 769                         {
 770                                 CAHManager::getInstance()->runActionHandler(pCB->_AHOnSelectStart, pCB);
 771                         }
 772
 773                         // launch the menu
 774                         // if the combo box is in a modal, must do a push, else just replace
 775                         if(dynamic_cast<CGroupModal*>(pCB->getRootWindow()))
 776                         {
 777                                 groupMenu->setCloseSubMenuUsingPopModal(true);
 778                                 CWidgetManager::getInstance()->pushModalWindow(pCB, groupMenu);
 779                         }
 780                         else
 781                         {
 782                                 groupMenu->setCloseSubMenuUsingPopModal(false);
 783                                 CWidgetManager::getInstance()->enableModalWindow (pCB, groupMenu);
 784                         }
 785                 }
 786         };
 787         REGISTER_ACTION_HANDLER (CHandlerComboBoxSelectStart, "combo_box_select_start");
 788
 789
 790
 791
 792         // ***************************************************************************
 793         class   CHandlerComboBoxSelectEnd : public IActionHandler
 794         {
 795         public:
 796                 virtual void execute (CCtrlBase * /* pCaller */, const std::string &Params)
 797                 {
 798                         CDBGroupComboBox *pCB = dynamic_cast<CDBGroupComboBox*>(CWidgetManager::getInstance()->getCtrlLaunchingModal());
 799                         if (pCB == NULL) return;
 800
 801                         // set the selection
 802                         sint32 selection;
 803                         fromString(Params, selection);
 804                         pCB->setSelection(selection);
 805                 }
 806         };
 807         REGISTER_ACTION_HANDLER (CHandlerComboBoxSelectEnd, "combo_box_select_end");
 808
 809 }
 810
 811