nel/src/gui/group_paragraph.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-2014  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 #include "stdpch.h"
  23 #include "nel/gui/group_paragraph.h"
  24 #include "nel/gui/group_html.h"
  25 #include "nel/gui/widget_manager.h"
  26 #include "nel/gui/interface_element.h"
  27 #include "nel/gui/view_pointer_base.h"
  28 #include "nel/gui/view_bitmap.h"
  29 #include "nel/gui/view_text_id.h"
  30 #include "nel/gui/group_container.h"
  31 #include "nel/misc/i_xml.h"
  32 #include "nel/misc/i18n.h"
  33 #include "nel/misc/xml_auto_ptr.h"
  34
  35 using namespace std;
  36 using namespace NLMISC;
  37
  38 #ifdef DEBUG_NEW
  39 #define new DEBUG_NEW
  40 #endif
  41
  42 NLMISC_REGISTER_OBJECT(CViewBase, CCtrlLink, std::string, "button_link");
  43
  44 namespace NLGUI
  45 {
  46
  47         // ----------------------------------------------------------------------------
  48         CGroupParagraph::CGroupParagraph(const TCtorParam &param)
  49         :       CInterfaceGroup(param),
  50                 _Templ(TCtorParam())
  51         {
  52                 _IdCounter = 0;
  53                 _AddElt = Bottom;
  54                 _Align = Left;
  55                 _Space = 0;
  56                 _MinW= 0;
  57                 _MinH= 0;
  58                 _Over = false;
  59                 _TempOver = false;
  60                 _OverColor = CRGBA(255,255,255,32);
  61                 _OverElt = -1;
  62                 _LastW = 0;
  63                 invalidateContent();
  64                 _TopSpace = 0;
  65                 _Indent = 0;
  66                 _FirstViewIndentView = false;
  67                 _TextId = 0;
  68                 _TextAlign = AlignLeft;
  69         }
  70
  71         // ----------------------------------------------------------------------------
  72         void CGroupParagraph::addChild (CViewBase* child, bool deleteOnRemove)
  73         {
  74                 if (!child)
  75                 {
  76                         nlwarning("<CGroupParagraph::addChild> : tried to add a NULL view");
  77                         return;
  78                 }
  79
  80                 // add child at last index
  81                 addChildAtIndex(child, (uint)_Elements.size(), deleteOnRemove);
  82                 if (_Elements.size() >= 2)
  83                 {
  84                         setOrder((uint)_Elements.size() - 1, getOrder((uint)_Elements.size() - 2) + 1);
  85                 }
  86                 invalidateContent();
  87         }
  88
  89         // ----------------------------------------------------------------------------
  90         CGroupParagraph::~CGroupParagraph()
  91         {
  92                 deleteAllChildren();
  93         }
  94
  95         // ----------------------------------------------------------------------------
  96         // Set Hotspot of the first element in reference to the group
  97         /*void CGroupParagraph::setHSGroup (CViewBase *child, EAlign addElt, EAlign align)
  98         {
  99                 switch (addElt)
 100                 {
 101                         case Bottom:
 102                                 if (align == Left)
 103                                 {
 104                                         child->_ParentPosRef = Hotspot_TL;
 105                                         child->_PosRef = Hotspot_TL;
 106                                 }
 107                                 else // align == Right
 108                                 {
 109                                         child->_ParentPosRef = Hotspot_TR;
 110                                         child->_PosRef = Hotspot_TR;
 111                                 }
 112                         break;
 113                         case Left:
 114                                 if (align == Top)
 115                                 {
 116                                         child->_ParentPosRef = Hotspot_TR;
 117                                         child->_PosRef = Hotspot_TR;
 118                                 }
 119                                 else // align == Bottom
 120                                 {
 121                                         child->_ParentPosRef = Hotspot_BR;
 122                                         child->_PosRef = Hotspot_BR;
 123                                 }
 124                         break;
 125                         case Top:
 126                                 if (align == Left)
 127                                 {
 128                                         child->_ParentPosRef = Hotspot_BL;
 129                                         child->_PosRef = Hotspot_BL;
 130                                 }
 131                                 else // align == Right
 132                                 {
 133                                         child->_ParentPosRef = Hotspot_BR;
 134                                         child->_PosRef = Hotspot_BR;
 135                                 }
 136                         break;
 137                         case Right:
 138                                 if (align == Top)
 139                                 {
 140                                         child->_ParentPosRef = Hotspot_TL;
 141                                         child->_PosRef = Hotspot_TL;
 142                                 }
 143                                 else // align == Bottom
 144                                 {
 145                                         child->_ParentPosRef = Hotspot_BL;
 146                                         child->_PosRef = Hotspot_BL;
 147                                 }
 148                         break;
 149                         default:
 150                                 nlassert(false);
 151                         break;
 152                 }
 153         }*/
 154
 155         // ----------------------------------------------------------------------------
 156         /** align an element towards its parent in the group
 157           */
 158         /*void CGroupParagraph::setHSParent(CViewBase *view, EAlign addElt, EAlign align, uint space)
 159         {
 160                 if ((addElt == Top) || (addElt == Bottom))
 161                 {
 162                         if (addElt == Bottom)
 163                         {
 164                                 if (_Align == Left)
 165                                         view->_ParentPosRef = Hotspot_BL;
 166                                 else // align == Right
 167                                         view->_ParentPosRef = Hotspot_BR;
 168                                 view->_Y = -abs(space);
 169                         }
 170                         else if (addElt == Top)
 171                         {
 172                                 if (_Align == Left)
 173                                         view->_ParentPosRef = Hotspot_TL;
 174                                 else // align == Right
 175                                         view->_ParentPosRef = Hotspot_TR;
 176                                 view->_Y = abs(space);
 177                         }
 178                 }
 179                 else
 180                 {
 181                         if (addElt == Left)
 182                         {
 183                                 if (_Align == Top)
 184                                         view->_ParentPosRef = Hotspot_TL;
 185                                 else // align == Bottom
 186                                         view->_ParentPosRef = Hotspot_BL;
 187                                 view->_X = -abs(space);
 188                         }
 189                         else if (addElt == Right)
 190                         {
 191                                 if (_Align == Top)
 192                                         view->_ParentPosRef = Hotspot_TR;
 193                                 else // align == Bottom
 194                                         view->_ParentPosRef = Hotspot_BR;
 195                                 view->_X = abs(space);
 196                         }
 197                 }
 198         }*/
 199
 200
 201         std::string CGroupParagraph::getProperty( const std::string &name ) const
 202         {
 203                 if( name == "addelt" )
 204                 {
 205                         switch( _AddElt )
 206                         {
 207                         case Top:
 208                                 return "T";
 209
 210                         case Left:
 211                                 return "L";
 212
 213                         case Right:
 214                                 return "R";
 215
 216                         case Bottom:
 217                                 return "B";
 218                         }
 219
 220                         nlassert(false);
 221
 222                         return "";
 223                 }
 224                 else
 225                 if( name == "align" )
 226                 {
 227                         switch( _Align )
 228                         {
 229                         case Top:
 230                                 return "T";
 231
 232                         case Left:
 233                                 return "L";
 234
 235                         case Right:
 236                                 return "R";
 237
 238                         case Bottom:
 239                                 return "B";
 240                         }
 241
 242                         nlassert(false);
 243
 244                         return "";
 245                 }
 246                 else
 247                 if( name == "space" )
 248                 {
 249                         return toString( _Space );
 250                 }
 251                 else
 252                 if( name == "over" )
 253                 {
 254                         return toString( _Over );
 255                 }
 256                 else
 257                 if( name == "col_over" )
 258                 {
 259                         return toString( _OverColor );
 260                 }
 261                 else
 262                 if( name == "hardtext" )
 263                 {
 264                         return _HardText;
 265                 }
 266                 else
 267                 if( name == "textid" )
 268                 {
 269                         return toString( _TextId );
 270                 }
 271                 else
 272                 return CInterfaceGroup::getProperty( name );
 273         }
 274
 275         void CGroupParagraph::setProperty( const std::string &name, const std::string &value )
 276         {
 277                 if( name == "addelt" )
 278                 {
 279                         if( value == "T" )
 280                                 _AddElt = Top;
 281                         else
 282                         if( value == "L" )
 283                                 _AddElt = Left;
 284                         else
 285                         if( value == "R" )
 286                                 _AddElt = Right;
 287                         else
 288                         if( value == "B" )
 289                                 _AddElt = Bottom;
 290
 291                         setupSizes();
 292                         return;
 293                 }
 294                 else
 295                 if( name == "align" )
 296                 {
 297                         if( value == "T" )
 298                                 _Align = Top;
 299                         else
 300                         if( value == "L" )
 301                                 _Align = Left;
 302                         else
 303                         if( value == "R" )
 304                                 _Align = Right;
 305                         else
 306                         if( value == "B" )
 307                                 _Align = Bottom;
 308
 309                         return;
 310                 }
 311                 else
 312                 if( name == "space" )
 313                 {
 314                         sint32 i;
 315                         if( fromString( value, i ) )
 316                                 _Space = i;
 317                         return;
 318                 }
 319                 else
 320                 if( name == "over" )
 321                 {
 322                         bool b;
 323                         if( fromString( value, b ) )
 324                                 _Over = b;
 325                         return;
 326                 }
 327                 else
 328                 if( name == "col_over" )
 329                 {
 330                         CRGBA c;
 331                         if( fromString( value, c ) )
 332                                 _OverColor = c;
 333                         return;
 334                 }
 335                 if( name == "hardtext" )
 336                 {
 337                         _HardText = value;
 338                         _TextId = 0;
 339                         onTextChanged();
 340                         return;
 341                 }
 342                 else
 343                 if( name == "textid" )
 344                 {
 345                         uint32 i;
 346                         if( fromString( value, i ) )
 347                         {
 348                                 _TextId = i;
 349                                 _HardText.clear();
 350                         }
 351                         onTextChanged();
 352                         return;
 353
 354                 }
 355                 else
 356                         CInterfaceGroup::setProperty( name, value );
 357         }
 358
 359
 360         xmlNodePtr CGroupParagraph::serialize( xmlNodePtr parentNode, const char *type ) const
 361         {
 362                 xmlNodePtr node = CInterfaceGroup::serialize( parentNode, type );
 363                 if( node == NULL )
 364                         return NULL;
 365
 366                 std::string addelt;
 367                 std::string align;
 368
 369                 switch( _AddElt )
 370                 {
 371                 case Top:
 372                         addelt = "T";
 373                         break;
 374
 375                 case Left:
 376                         addelt = "L";
 377                         break;
 378
 379                 case Right:
 380                         addelt = "R";
 381                         break;
 382
 383                 default:
 384                         addelt = "B";
 385                         break;
 386                 }
 387
 388                 switch( _Align )
 389                 {
 390                 case Top:
 391                         align = "T";
 392                         break;
 393
 394                 case Left:
 395                         align = "L";
 396                         break;
 397
 398                 case Right:
 399                         align = "R";
 400                         break;
 401
 402                 default:
 403                         align = "B";
 404                         break;
 405                 }
 406
 407                 xmlSetProp( node, BAD_CAST "addelt", BAD_CAST addelt.c_str() );
 408                 xmlSetProp( node, BAD_CAST "align", BAD_CAST align.c_str() );
 409                 xmlSetProp( node, BAD_CAST "space", BAD_CAST toString( _Space ).c_str() );
 410                 xmlSetProp( node, BAD_CAST "over", BAD_CAST toString( _Over ).c_str() );
 411                 xmlSetProp( node, BAD_CAST "col_over", BAD_CAST toString( _OverColor ).c_str() );
 412                 xmlSetProp( node, BAD_CAST "hardtext", BAD_CAST _HardText.c_str() );
 413                 xmlSetProp( node, BAD_CAST "textid", BAD_CAST toString( _TextId ).c_str() );
 414
 415                 return node;
 416         }
 417
 418         // ----------------------------------------------------------------------------
 419         bool CGroupParagraph::parse (xmlNodePtr cur, CInterfaceGroup * parentGroup)
 420         {
 421                 if (!CInterfaceGroup::parse(cur,parentGroup))
 422                         return false;
 423
 424                 // Parse location. If these properties are not specified, set them to 0
 425
 426                 CXMLAutoPtr ptr((const char*) xmlGetProp( cur, (xmlChar*)"addelt" ));
 427                 _AddElt = Bottom;
 428                 if (ptr)
 429                 {
 430                         if (stricmp(ptr,"B") == 0)
 431                                 _AddElt = Bottom;
 432                         else if (stricmp(ptr,"T") == 0)
 433                                 _AddElt = Top;
 434                         else if (stricmp(ptr,"L") == 0)
 435                                 _AddElt = Left;
 436                         else if (stricmp(ptr,"R") == 0)
 437                                 _AddElt = Right;
 438                 }
 439
 440                 ptr = (char*) xmlGetProp( cur, (xmlChar*)"align" );
 441                 _Align = Left;
 442                 if (ptr)
 443                 {
 444                         if (stricmp(ptr,"B") == 0)
 445                                 _Align = Bottom;
 446                         else if (stricmp(ptr,"T") == 0)
 447                                 _Align = Top;
 448                         else if (stricmp(ptr,"L") == 0)
 449                                 _Align = Left;
 450                         else if (stricmp(ptr,"R") == 0)
 451                                 _Align = Right;
 452                 }
 453
 454                 setupSizes();
 455
 456                 ptr = (char*) xmlGetProp( cur, (xmlChar*)"space" );
 457                 _Space = 0;
 458                 if (ptr)
 459                         fromString((const char*)ptr, _Space);
 460
 461                 ptr = (char*) xmlGetProp( cur, (xmlChar*)"over" );
 462                 _Over = false;
 463                 if (ptr) _Over = convertBool(ptr);
 464
 465                 ptr = (char*) xmlGetProp( cur, (xmlChar*)"col_over" );
 466                 _OverColor = CRGBA(255,255,255,32);
 467                 if (ptr) _OverColor = convertColor(ptr);
 468
 469
 470                 // TEMPLATE TEXT SETUP
 471
 472                 // justification parameters
 473                 _Templ.parseTextOptions (cur);
 474
 475                 // initial text
 476                 ptr = (char*) xmlGetProp( cur, (xmlChar*)"hardtext" );
 477                 if (ptr)
 478                 {
 479                         _HardText = std::string( (const char*)ptr );
 480                         const char *propPtr = ptr;
 481                         if (NLMISC::startsWith(propPtr, "ui"))
 482                                 addTextChild(CI18N::get(propPtr));
 483                         else
 484                                 addTextChild(propPtr);
 485                 }
 486                 else
 487                 {
 488                         ptr = (char*) xmlGetProp( cur, (xmlChar*)"textid" );
 489                         if (ptr)
 490                         {
 491                                 fromString((const char*)ptr, _TextId );
 492                                 addTextChildID( _TextId );
 493                         }
 494                 }
 495
 496                 return true;
 497         }
 498
 499         // ----------------------------------------------------------------------------
 500         void CGroupParagraph::addTextChild(const std::string& line, bool multiLine /*= true*/)
 501         {
 502                 const string elid = _Id + ":el" + toString(_IdCounter); ++_IdCounter;
 503                 CViewText *view= new CViewText (elid, string(""), _Templ.getFontSize(), _Templ.getColor(), _Templ.getShadow());
 504                 view->_Parent = this;
 505                 view->setMultiLine (multiLine);
 506                 view->setTextMode(_Templ.getTextMode());
 507                 if (multiLine) view->setMultiLineSpace (_Space);
 508                 view->setText (line);
 509                 // Herit global-coloring
 510                 view->setModulateGlobalColor(getModulateGlobalColor());
 511                 addChild (view);
 512                 invalidateCoords();
 513         }
 514
 515
 516
 517         // ----------------------------------------------------------------------------
 518         void CGroupParagraph::addTextChild(const std::string& line, const CRGBA& textColor, bool multiLine /*= true*/)
 519         {
 520                 const string elid = _Id + ":el" + toString(_IdCounter); ++_IdCounter;
 521                 CViewText *view= new CViewText (elid, string(""), _Templ.getFontSize(), _Templ.getColor(), _Templ.getShadow());
 522                 view->_Parent = this;
 523                 view->setMultiLine (multiLine);
 524                 if (multiLine) view->setMultiLineSpace (_Space);
 525                 view->setText (line);
 526                 view->setColor (textColor);
 527                 // Herit global-coloring
 528                 view->setModulateGlobalColor(getModulateGlobalColor());
 529                 addChild (view);
 530                 invalidateCoords();
 531         }
 532
 533         // ----------------------------------------------------------------------------
 534         void CGroupParagraph::addTextChildID (uint32 nID, bool multiLine)
 535         {
 536                 const string elid = _Id + ":el" + toString(_IdCounter); ++_IdCounter;
 537                 CViewTextID *view= new CViewTextID (elid, nID, _Templ.getFontSize(), _Templ.getColor(), _Templ.getShadow());
 538                 view->_Parent = this;
 539                 view->setMultiLine (multiLine);
 540                 if (multiLine) view->setMultiLineSpace (_Space);
 541                 // Herit global-coloring
 542                 view->setModulateGlobalColor(getModulateGlobalColor());
 543                 addChild (view);
 544                 invalidateCoords();
 545         }
 546
 547         // ----------------------------------------------------------------------------
 548         void CGroupParagraph::addTextChildID(const std::string &dbPath,bool multiLine /*=true*/)
 549         {
 550                 const string elid = _Id + ":el" + toString(_IdCounter); ++_IdCounter;
 551                 CViewTextID *view= new CViewTextID (elid, dbPath, _Templ.getFontSize(), _Templ.getColor(), _Templ.getShadow());
 552                 view->_Parent = this;
 553                 view->setMultiLine (multiLine);
 554                 if (multiLine) view->setMultiLineSpace (_Space);
 555                 // Herit global-coloring
 556                 view->setModulateGlobalColor(getModulateGlobalColor());
 557                 addChild (view);
 558                 invalidateCoords();
 559         }
 560
 561         // ----------------------------------------------------------------------------
 562         void CGroupParagraph::delChild (CViewBase* childToDel)
 563         {
 564                 // Look for child
 565                 uint posChildToDel = 0;
 566                 for (posChildToDel = 0; posChildToDel < _Elements.size(); ++posChildToDel)
 567                 {
 568                         CElementInfo rEI = _Elements[posChildToDel];
 569                         if (rEI.Element == childToDel)
 570                                 break;
 571                 }
 572
 573                 if (posChildToDel == _Elements.size())
 574                 {
 575                         nlwarning("Can't del child %s, it does not exist in the list", childToDel->getId().c_str());
 576                         return;
 577                 }
 578                 delChild(posChildToDel);
 579         }
 580
 581         // ----------------------------------------------------------------------------
 582         void CGroupParagraph::delChild(uint posChildToDel)
 583         {
 584                 if (posChildToDel >= (uint) _Elements.size())
 585                 {
 586                         nlwarning("<CGroupParagraph::delChild> bad index");
 587                         return;
 588                 }
 589
 590                 CViewBase* childToDel = _Elements[posChildToDel].Element;
 591                 bool ElementMustBeDeleted = _Elements[posChildToDel].EltDeleteOnRemove;
 592                 _Elements.erase (_Elements.begin()+posChildToDel);
 593                 // Remove from drawing
 594                 if (dynamic_cast<CInterfaceGroup *>(childToDel)) delGroup(static_cast<CInterfaceGroup *>(childToDel), !ElementMustBeDeleted);
 595                 else if (dynamic_cast<CCtrlBase *>(childToDel)) delCtrl(static_cast<CCtrlBase *>(childToDel), !ElementMustBeDeleted);
 596                 else delView(childToDel, !ElementMustBeDeleted);
 597
 598                 // Bind the new first element
 599                 if (posChildToDel < _Elements.size())
 600                 {
 601                         CViewBase *pVB = _Elements[posChildToDel].Element;
 602                         if (posChildToDel == 0)
 603                         {
 604                                 pVB->_ParentPos = NULL;
 605                                 // setHSGroup (pVB, _AddElt, _Align);
 606                                 if ((_AddElt == Top) || (_AddElt == Bottom))
 607                                         pVB->setY (0);
 608                                 else
 609                                         pVB->setX (0);
 610                         }
 611                         else
 612                                 pVB->_ParentPos = _Elements[posChildToDel-1].Element;
 613                 }
 614         }
 615
 616         // ----------------------------------------------------------------------------
 617         /*void CGroupParagraph::removeHead ()
 618         {
 619                 if (_Elements.empty())
 620                 {
 621                         nlwarning("<CGroupParagraph::removeHead> Can't remove head, list is empty");
 622                         return;
 623                 }
 624                 delChild (_Elements.begin()->Element);*/
 625                 /*CViewBase *pVB = _Elements.begin()->Element;
 626                 if ((_AddElt == Top) || (_AddElt == Bottom))
 627                 {
 628                         sint32 shift = _H - (pVB->getH() + _Space);
 629                         _H = shift;
 630                 }
 631                 else
 632                 {
 633                         sint32 shift = _W - (pVB->getW() + _Space);
 634                         _W = shift;
 635                 }
 636
 637                 bool FirstElementMustBeDeleted = _Elements.begin()->EltDeleteOnRemove;
 638                 if (FirstElementMustBeDeleted)
 639                         delete pVB;
 640                 _Elements.erase (_Elements.begin());
 641                 // Remove from drawing
 642                 for (vector<CInterfaceGroup*>::iterator itg = _ChildrenGroups.begin(); itg != _ChildrenGroups.end(); itg++)
 643                         if(*itg == pVB)
 644                         {
 645                                 _ChildrenGroups.erase (itg);
 646                                 break;
 647                         }
 648                 for (vector<CCtrlBase*>::iterator itc = _Controls.begin(); itc != _Controls.end(); itc++)
 649                         if(*itc == pVB)
 650                         {
 651                                 _Controls.erase (itc);
 652                                 break;
 653                         }
 654                 for (vector<CViewBase*>::iterator itv = _Views.begin(); itv != _Views.end(); itv++)
 655                         if(*itv == pVB)
 656                         {
 657                                 _Views.erase (itv);
 658                                 break;
 659                         }
 660                 delEltOrder (pVB);
 661
 662                 // Bind the new first element
 663                 pVB = _Elements.begin()->Element;
 664                 pVB->_ParentPos = NULL;
 665                 setHSGroup (pVB, _AddElt, _Align);
 666                 if ((_AddElt == Top) || (_AddElt == Bottom))
 667                         pVB->setY (0);
 668                 else
 669                         pVB->setX (0);*/
 670         //}
 671
 672         // ----------------------------------------------------------------------------
 673         void CGroupParagraph::setTextTemplate(const CViewText& templ)
 674         {
 675                 _Templ = templ;
 676         }
 677
 678
 679         // ----------------------------------------------------------------------------
 680         void CGroupParagraph::updateCoords()
 681         {
 682                 if (_Parent)
 683                 {
 684                         if (!_ContentValidated)
 685                         {
 686                                 // Update W
 687                                 CInterfaceElement::updateCoords();
 688
 689                                 // Current X and Y
 690                                 sint32 x=_Indent;
 691                                 sint32 y=-(sint32)_TopSpace;
 692
 693                                 // Current W
 694                                 sint width = std::min(getMaxWReal(), getWReal());
 695
 696                                 // For each elements, place them
 697                                 uint firstElementOnLine = 0;
 698                                 const uint elmCount = (uint)_Elements.size();
 699                                 uint i;
 700                                 for (i = 0; i < elmCount+1; ++i)
 701                                 {
 702                                         // Force flush for the last element
 703                                         bool changeLine = (i == elmCount);
 704                                         uint lastLineElement = i+1;
 705
 706                                         // Not the end of the element
 707                                         if (i < elmCount)
 708                                         {
 709                                                 // Active element ?
 710                                                 if (_Elements[i].Element->getActive())
 711                                                 {
 712                                                         _Elements[i].Element->updateCoords();
 713                                                         // Is a view text ?
 714                                                         CViewText *viewText = dynamic_cast<CViewText*>(_Elements[i].Element);
 715                                                         if (viewText)
 716                                                         {
 717                                                                 // FIXME: this does not work with multiple view text on same line
 718                                                                 if (_TextAlign == AlignCenter && elmCount == 1)
 719                                                                         viewText->setTextMode(CViewText::Centered);
 720
 721                                                                 viewText->setFirstLineX(x + ((i==0)?_FirstViewIndentView:0));
 722                                                                 viewText->setX(0);
 723                                                                 viewText->updateTextContext();
 724                                                         }
 725                                                         else
 726                                                         {
 727                                                                 _Elements[i].Element->setX(x + ((i==0)?_FirstViewIndentView:0));
 728                                                         }
 729                                                         _Elements[i].Element->setPosRef(Hotspot_TL);
 730                                                         _Elements[i].Element->setParentPosRef(Hotspot_TL);
 731
 732                                                         // Update coords for this element
 733                                                         _Elements[i].Element->updateCoords();
 734
 735                                                         // Does we balance the last line height ?
 736                                                         if (viewText)
 737                                                         {
 738                                                                 if (_TextAlign == AlignCenter && elmCount == 1)
 739                                                                 {
 740                                                                         sint pad =  width - viewText->getWReal();
 741                                                                         viewText->setX(pad/2);
 742                                                                 }
 743
 744                                                                 changeLine = viewText->getNumLine() > 1;
 745                                                                 if (!viewText->getText().empty() && *(viewText->getText().rbegin()) == '\n')
 746                                                                 {
 747                                                                         changeLine = true;
 748                                                                 }
 749                                                         }
 750                                                         else
 751                                                         {
 752                                                                 // If this element is too big for the line, place it next time
 753                                                                 if ((i!=firstElementOnLine) && ((_Elements[i].Element->getX() + _Elements[i].Element->getW()) > width))
 754                                                                 {
 755                                                                         lastLineElement--;
 756                                                                         changeLine = true;
 757                                                                         i--;
 758                                                                 }
 759                                                         }
 760
 761
 762                                                         // New x coordinate
 763                                                         x = _Elements[i].Element->getX() + _Elements[i].Element->getWReal();
 764                                                 }
 765                                         }
 766                                         else
 767                                                 lastLineElement = i;
 768
 769                                         // Balance line height
 770                                         if (changeLine)
 771                                         {
 772                                                 // Eval line height
 773                                                 uint j;
 774                                                 uint lineHeight = 0;
 775                                                 uint multiLineHeight = 0;
 776                                                 uint legHeight = 0;
 777                                                 uint lastLineWidth = _Indent;
 778
 779                                                 for (j=firstElementOnLine; j<lastLineElement; j++)
 780                                                 {
 781                                                         // Is a view text ?
 782                                                         uint newHeight;
 783                                                         CViewText *viewTextOnLine = dynamic_cast<CViewText*>(_Elements[j].Element);
 784
 785                                                         // Element height
 786                                                         if (viewTextOnLine)
 787                                                         {
 788                                                                 // Height is just under the first line letter
 789                                                                 newHeight = viewTextOnLine->getFontHeight() - viewTextOnLine->getFontLegHeight();
 790
 791                                                                 // Leg height for this view
 792                                                                 legHeight = std::max(legHeight, viewTextOnLine->getFontLegHeight());
 793
 794                                                                 // Last element is a text multi line
 795                                                                 if (j==(lastLineElement-1))
 796                                                                 {
 797                                                                         const uint numLine = viewTextOnLine->getNumLine();
 798                                                                         if (numLine>1)
 799                                                                         {
 800                                                                                 multiLineHeight = (numLine-2) * viewTextOnLine->getFontHeight() + (numLine-1) * viewTextOnLine->getMultiLineSpace();
 801                                                                                 lastLineWidth = _Indent + viewTextOnLine->getLastLineW ();
 802                                                                         }
 803                                                                 }
 804                                                         }
 805                                                         else
 806                                                         {
 807                                                                 newHeight = _Elements[j].Element->getH();
 808                                                                 CGroupHTMLInputOffset *inputOffset = dynamic_cast<CGroupHTMLInputOffset *>(_Elements[j].Element);
 809                                                                 if (inputOffset && inputOffset->Offset < 0)
 810                                                                 {
 811                                                                         newHeight += inputOffset->Offset;
 812                                                                         legHeight = max(-(inputOffset->Offset), sint32(legHeight));
 813                                                                 }
 814                                                         }
 815
 816                                                         if (lineHeight < newHeight)
 817                                                                 lineHeight = newHeight;
 818                                                 }
 819
 820                                                 // Repos element on the line
 821                                                 for (j=firstElementOnLine; j<lastLineElement; j++)
 822                                                 {
 823                                                         // Is a view text ?
 824                                                         uint newHeight;
 825                                                         CViewText *viewTextOnLine = dynamic_cast<CViewText*>(_Elements[j].Element);
 826
 827                                                         sint32 offsetY=0;
 828                                                         CGroupHTMLInputOffset *inputOffset = dynamic_cast<CGroupHTMLInputOffset *>(_Elements[j].Element);
 829                                                         if (inputOffset)
 830                                                                 offsetY = inputOffset->Offset;
 831                                                                 // Element height
 832                                                         if (viewTextOnLine)
 833                                                                 newHeight = viewTextOnLine->getFontHeight() - viewTextOnLine->getFontLegHeight() - offsetY;
 834                                                         else
 835                                                                 newHeight = _Elements[j].Element->getH();
 836
 837                                                         sint32 posY = y-lineHeight+newHeight+offsetY;
 838                                                         _Elements[j].Element->setY(posY);
 839                                                 }
 840
 841                                                 if (i < elmCount)
 842                                                 {
 843                                                         nlassert(lastLineElement>0);
 844                                                         nlassert(lastLineElement-1<elmCount);
 845                                                         x = lastLineWidth;
 846
 847                                                         // Next line
 848                                                         y -= lineHeight + multiLineHeight + legHeight;
 849                                                 }
 850
 851                                                 // New first element
 852                                                 firstElementOnLine = lastLineElement;
 853                                         }
 854                                 }
 855
 856                                 // Update control view
 857                                 for (i = 0; i<_Links.size(); ++i)
 858                                 {
 859                                         // Link
 860                                         CLink &link = _Links[i];
 861
 862                                         // Number of link needed
 863                                         uint links = std::min((uint)3, link.Link->getNumLine());
 864
 865                                         // Number of line..
 866                                         uint j;
 867                                         for (j=0; j<3; j++)
 868                                         {
 869                                                 if (j<links)
 870                                                 {
 871                                                         // Create the control ?
 872                                                         CCtrlLink *ctrl = link.CtrlLink[j];
 873                                                         if (ctrl == NULL)
 874                                                         {
 875                                                                 // Control button
 876                                                                 ctrl = new CCtrlLink(CViewBase::TCtorParam());
 877                                                                 link.CtrlLink[j] = ctrl;
 878                                                                 ctrl->setId(getId()+":"+"links"+toString(i)+"-"+toString(j));
 879                                                                 ctrl->setParent (this);
 880                                                                 ctrl->setParentSize (this);
 881                                                                 ctrl->setParentPos (this);
 882                                                                 ctrl->setParentPosRef (Hotspot_TL);
 883                                                                 ctrl->setPosRef (Hotspot_TL);
 884                                                                 ctrl->setActive(true);
 885                                                                 ctrl->setActionOnLeftClick(link.Link->getActionOnLeftClick());
 886                                                                 ctrl->setParamsOnLeftClick(link.Link->getParamsOnLeftClick());
 887                                                                 ctrl->setScale(true);
 888                                                                 addCtrl(ctrl);
 889                                                         }
 890
 891                                                         // Pos the links
 892                                                         int x, y, width, height;
 893                                                         int fontSize = link.Link->getFontHeight();
 894                                                         int fontLineSpace = link.Link->getMultiLineSpace();
 895
 896                                                         // X
 897                                                         x = (j == 0) ? link.Link->getFirstLineX() : link.Link->getX();
 898
 899                                                         // Y
 900                                                         if (j < 2)
 901                                                                 y = link.Link->getY() - (fontSize+fontLineSpace) * j;
 902                                                         else
 903                                                                 y = link.Link->getY() - ((fontSize+fontLineSpace) * (link.Link->getNumLine()-1));
 904
 905                                                         // Width
 906
 907                                                         // Last line ?
 908                                                         if (j == (links-1))
 909                                                                 width = link.Link->getLastLineW ();
 910                                                         else
 911                                                         {
 912                                                                 width = link.Link->getW();
 913
 914                                                                 // First line ?
 915                                                                 if (j == 0)
 916                                                                         width -= (link.Link->getFirstLineX() - link.Link->getX());
 917                                                         }
 918
 919                                                         if ((j == 1) && (links==3))
 920                                                                 height = (fontSize+fontLineSpace)*(link.Link->getNumLine()-2);
 921                                                         else
 922                                                                 height = fontSize;
 923
 924                                                         ctrl->setX(x);
 925                                                         ctrl->setY(y);
 926                                                         ctrl->setW(width);
 927                                                         ctrl->setH(height);
 928                                                 }
 929                                                 else
 930                                                 {
 931                                                         if (link.CtrlLink[j])
 932                                                         {
 933                                                                 delCtrl (link.CtrlLink[j]);
 934                                                                 link.CtrlLink[j] = NULL;
 935                                                         }
 936                                                 }
 937                                         }
 938                                 }
 939                         }
 940                 }
 941                 CInterfaceGroup::updateCoords();
 942
 943                 // Validated
 944                 _ContentValidated = true;
 945         }
 946
 947         // ----------------------------------------------------------------------------
 948         void CGroupParagraph::checkCoords ()
 949         {
 950                 if (_Parent != NULL)
 951                 {
 952                         sint parentWidth = std::min(_Parent->getMaxWReal(), _Parent->getWReal());
 953                         if (_LastW != (sint) parentWidth)
 954                         {
 955                                 CCtrlBase *pCB = CWidgetManager::getInstance()->getCapturePointerLeft();
 956                                 if (pCB != NULL)
 957                                 {
 958                                         CCtrlResizer *pCR = dynamic_cast<CCtrlResizer*>(pCB);
 959                                         if (pCR != NULL)
 960                                         {
 961                                                 // We are resizing !!!!
 962                                         }
 963                                         else
 964                                         {
 965                                                 _LastW = parentWidth;
 966                                                  invalidateContent();
 967                                         }
 968                                 }
 969                                 else
 970                                 {
 971                                         _LastW = parentWidth;
 972                                         invalidateContent();
 973                                 }
 974                         }
 975                 }
 976                 CInterfaceGroup::checkCoords();
 977         }
 978
 979         // ----------------------------------------------------------------------------
 980         void CGroupParagraph::draw ()
 981         {
 982                 // TEMP TEMP
 983                 //CViewRenderer &rVR = *CViewRenderer::getInstance();
 984                 //rVR.drawRotFlipBitmap _RenderLayer, (_XReal, _YReal, _WReal, _HReal, 0, false, rVR.getBlankTextureId(), CRGBA(0,255,0,255) );
 985                 if (_Over || _TempOver)
 986                 {
 987                         CViewRenderer &rVR = *CViewRenderer::getInstance();
 988
 989                         if (CWidgetManager::getInstance()->getModalWindow() == NULL)
 990                         {
 991                                 sint32 x = CWidgetManager::getInstance()->getPointer()->getX();
 992                                 sint32 y = CWidgetManager::getInstance()->getPointer()->getY();
 993
 994                                 CInterfaceGroup *pIG = CWidgetManager::getInstance()->getWindowUnder(x,y);
 995                                 CInterfaceGroup *pParent = this;
 996                                 bool bFound = false;
 997                                 while (pParent != NULL)
 998                                 {
 999                                         if (pParent == pIG)
1000                                         {
1001                                                 bFound = true;
1002                                                 break;
1003                                         }
1004                                         pParent = pParent->getParent();
1005                                 }
1006
1007                                 sint32 clipx,clipy,clipw,cliph;
1008                                 getClip(clipx,clipy,clipw,cliph);
1009                                 if ((x < clipx) ||
1010                                         (x > (clipx + clipw)) ||
1011                                         (y < clipy) ||
1012                                         (y > (clipy + cliph)) || !bFound)
1013                                 {
1014                                         _OverElt = -1;
1015                                 }
1016                                 else
1017                                 {
1018                                         for (uint32 i = 0; i < _Elements.size(); ++i)
1019                                         if (_Elements[i].Element->getActive())
1020                                         {
1021                                                 CViewBase *pVB = _Elements[i].Element;
1022                                                 if ((x >= pVB->getXReal()) &&
1023                                                         (x < (pVB->getXReal() + pVB->getWReal()))&&
1024                                                         (y >= pVB->getYReal()) &&
1025                                                         (y < (pVB->getYReal() + pVB->getHReal())))
1026                                                 {
1027                                                         _OverElt = i;
1028                                                 }
1029                                         }
1030                                 }
1031                         }
1032
1033                         if (_OverElt != -1)
1034                         {
1035                                 CViewBase *pVB = _Elements[_OverElt].Element;
1036                                 CRGBA col = _OverColor;
1037                                 if(getModulateGlobalColor())
1038                                 {
1039                                         col.modulateFromColor (_OverColor, CWidgetManager::getInstance()->getGlobalColorForContent());
1040                                 }
1041                                 else
1042                                 {
1043                                         col= _OverColor;
1044                                         col.A = (uint8)(((sint32)col.A*((sint32)CWidgetManager::getInstance()->getGlobalColorForContent().A+1))>>8);
1045                                 }
1046                                 rVR.drawRotFlipBitmap (_RenderLayer, pVB->getXReal(), pVB->getYReal(),
1047                                                                                 pVB->getWReal(), pVB->getHReal(), 0, false, rVR.getBlankTextureId(),
1048                                                                                 col );
1049
1050                         }
1051                 }
1052
1053                 CInterfaceGroup::draw ();
1054         }
1055
1056         // ----------------------------------------------------------------------------
1057         bool CGroupParagraph::handleEvent (const NLGUI::CEventDescriptor& event)
1058         {
1059                 if (!_Active)
1060                         return false;
1061
1062                 bool bReturn = CInterfaceGroup::handleEvent(event);
1063
1064                 if (event.getType() == NLGUI::CEventDescriptor::mouse)
1065                 {
1066                         const NLGUI::CEventDescriptorMouse &eventDesc = (const NLGUI::CEventDescriptorMouse &)event;
1067
1068                         _OverElt = -1;
1069                         if (!isIn(eventDesc.getX(), eventDesc.getY()))
1070                         {
1071                                 _TempOver = false;
1072                                 return false;
1073                         }
1074
1075                         for (uint32 i = 0; i < _Elements.size(); ++i)
1076                         if (_Elements[i].Element->getActive())
1077                         {
1078                                 CViewBase *pVB = _Elements[i].Element;
1079                                 if ((eventDesc.getX() >= pVB->getXReal()) &&
1080                                         (eventDesc.getX() < (pVB->getXReal() + pVB->getWReal()))&&
1081                                         (eventDesc.getY() >= pVB->getYReal()) &&
1082                                         (eventDesc.getY() < (pVB->getYReal() + pVB->getHReal())))
1083                                 {
1084                                         _OverElt = i;
1085                                 }
1086                         }
1087                 }
1088
1089                 return bReturn;
1090         }
1091
1092
1093
1094         // predicate to remove a view from the list of element
1095         struct CRemoveViewPred
1096         {
1097                 bool operator()(const CGroupParagraph::CElementInfo &info) const { return dynamic_cast<CViewBase *>(info.Element) != NULL; }
1098         };
1099
1100         // predicate to remove a ctrl from the list of element
1101         struct CRemoveCtrlPred
1102         {
1103                 bool operator()(const CGroupParagraph::CElementInfo &info)  const { return dynamic_cast<CCtrlBase *>(info.Element) != NULL; }
1104         };
1105
1106         // predicate to remove a group from the list of element
1107         struct CRemoveGroupPred
1108         {
1109                 bool operator()(const CGroupParagraph::CElementInfo &info)  const { return dynamic_cast<CInterfaceGroup *>(info.Element) != NULL; }
1110         };
1111
1112
1113         // ----------------------------------------------------------------------------
1114         void CGroupParagraph::clearViews()
1115         {
1116                 _IdCounter = 0;
1117                 // remove views from the list of elements
1118                 _Elements.erase(std::remove_if(_Elements.begin(), _Elements.end(), CRemoveViewPred()), _Elements.end());
1119                 CInterfaceGroup::clearViews();
1120                 updateCoords();
1121         }
1122
1123         // ----------------------------------------------------------------------------
1124         void CGroupParagraph::clearControls()
1125         {
1126                 _IdCounter = 0;
1127                 // remove views from the list of elements
1128                 _Elements.erase(std::remove_if(_Elements.begin(), _Elements.end(), CRemoveCtrlPred()), _Elements.end());
1129                 CInterfaceGroup::clearControls();
1130                 updateCoords();
1131         }
1132
1133         // ----------------------------------------------------------------------------
1134         void CGroupParagraph::clearGroups()
1135         {
1136                 _IdCounter = 0;
1137                 // remove views from the list of elements
1138                 _Elements.erase(std::remove_if(_Elements.begin(), _Elements.end(), CRemoveGroupPred()), _Elements.end());
1139                 CInterfaceGroup::clearGroups();
1140                 updateCoords();
1141         }
1142
1143         // ----------------------------------------------------------------------------
1144         void CGroupParagraph::forceSizeW (sint32 newSizeW)
1145         {
1146                 _W = newSizeW;
1147                 for (uint32 i = 0; i < _Elements.size(); ++i)
1148                 {
1149                         _Elements[i].Element->setW (_W);
1150                         _Elements[i].Element->CInterfaceElement::updateCoords();
1151                 }
1152         }
1153
1154         // ----------------------------------------------------------------------------
1155         void CGroupParagraph::forceSizeH (sint32 newSizeH)
1156         {
1157                 _H = newSizeH;
1158                 for (uint32 i = 0; i < _Elements.size(); ++i)
1159                 {
1160                         _Elements[i].Element->setH (_H);
1161                         _Elements[i].Element->CInterfaceElement::updateCoords();
1162                 }
1163         }
1164
1165         // ----------------------------------------------------------------------------
1166         void    CGroupParagraph::setMinW(sint32 minW)
1167         {
1168                 _MinW= minW;
1169                 invalidateCoords();
1170         }
1171
1172         // ----------------------------------------------------------------------------
1173         void    CGroupParagraph::setMinH(sint32 minH)
1174         {
1175                 _MinH= minH;
1176                 invalidateCoords();
1177         }
1178
1179         // ----------------------------------------------------------------------------
1180         bool CGroupParagraph::addChildAtIndex(CViewBase *child, uint index, bool deleteOnRemove /*=true*/)
1181         {
1182                 if (!child)
1183                 {
1184                         nlwarning("<CGroupParagraph::addChild> : tried to add a NULL view");
1185                         return false;
1186                 }
1187                 if (index > _Elements.size())
1188                 {
1189                         return false;
1190                 }
1191                 child->_Parent = this;
1192                 child->_ParentPos = NULL;
1193                 child->_Active = true;
1194                 child->_X = 0;
1195                 child->_Y = 0;
1196                 child->_RenderLayer = this->_RenderLayer;
1197                 // Can't have sizeref on the coordinate corresponding to alignement
1198                 switch(_AddElt)
1199                 {
1200                         case Top:
1201                         case Bottom:
1202                                 child->_SizeRef &= 1; // sizeref on w is permitted
1203                         break;
1204                         case Left:
1205                         case Right:
1206                                 child->_SizeRef &= 2; // sizeref on h is permitted
1207                         break;
1208                         default:
1209                                 nlwarning("<CGroupParagraph::addChild> bad align");
1210                                 child->_SizeRef = 0;
1211                         break;
1212                 }
1213
1214                 child->_SizeDivW = 10;
1215                 child->_SizeDivH = 10;
1216
1217                 // Position the element according to the list alignement
1218                 // setHSGroup (child, _AddElt, _Align);
1219
1220                 // update coords of the element (it may use child_resize_h or w)
1221                 //child->updateCoords();
1222                 child->invalidateCoords();
1223
1224                 // Update size
1225                 if ((_AddElt == Top) || (_AddElt == Bottom))
1226                 {
1227                         // update the list size
1228                         sint32 newH = _H + child->getH();
1229                         if (!_Elements.empty())
1230                                 newH += _Space;
1231                         _H = newH;
1232
1233                         if ((_SizeRef&1) == 0) // No parent size reference in W
1234                         {
1235                                 sint32 newW = max (_W, child->getW());
1236                                 _W = newW;
1237                         }
1238                 }
1239                 else
1240                 {
1241                         // Update the list coords
1242                         sint32 newW = _W + child->getW();
1243                         if (!_Elements.empty())
1244                                 newW += _Space;
1245                         _W = newW;
1246
1247                         if ((_SizeRef&2) == 0) // No parent size reference in H
1248                         {
1249                                 sint32 newH = max (_H, child->getH());
1250                                 _H = newH;
1251                         }
1252                 }
1253
1254                 CElementInfo ei;
1255                 ei.Element = child;
1256                 ei.EltDeleteOnRemove = deleteOnRemove;
1257                 ei.Order = 0;
1258
1259                 if (index != 0)
1260                 {
1261                         // update alignement
1262                         // setHSParent(child, _AddElt, _Align, _Space);
1263                         // child->_ParentPos = _Elements[index - 1].Element;
1264                 }
1265                 _Elements.insert(_Elements.begin() + index, ei);
1266                 // link next element to this one
1267                 if (index < _Elements.size() - 1)
1268                 {
1269                         // _Elements[index + 1].Element->_ParentPos = child;
1270                         // setHSParent(_Elements[index + 1].Element, _AddElt, _Align, _Space);
1271                 }
1272
1273                 // Add this element for drawing
1274                 {
1275                         CInterfaceGroup *pIG = dynamic_cast<CInterfaceGroup*>(child);
1276                         if (pIG != NULL)
1277                         {
1278                                 addGroup (pIG, (sint) index);
1279                                 return true;
1280                         }
1281                         CCtrlBase *pCB = dynamic_cast<CCtrlBase*>(child);
1282                         if (pCB != NULL)
1283                         {
1284                                 addCtrl (pCB, (sint) index);
1285                                 return true;
1286                         }
1287                         CViewBase *pVB = dynamic_cast<CViewBase*>(child);
1288                         if (pVB != NULL)
1289                         {
1290                                 addView (pVB, (sint) index);
1291                                 return true;
1292                         }
1293                         nlstop;
1294                         return false;
1295                 }
1296                 return false;
1297         }
1298
1299         // ----------------------------------------------------------------------------
1300         sint32 CGroupParagraph::getElementIndex(CViewBase* child) const
1301         {
1302                 for(uint k = 0; k < _Elements.size(); ++k)
1303                 {
1304                         if (_Elements[k].Element == child) return k;
1305                 }
1306                 return -1;
1307         }
1308
1309         // ----------------------------------------------------------------------------
1310         /*void CGroupParagraph::swapChildren(uint index1, uint index2)
1311         {
1312                 if (index1 >= _Elements.size()
1313                         || index2 >= _Elements.size())
1314                 {
1315                         nlwarning("<CGroupParagraph::swapChildren> bad indexes");
1316                         return;
1317                 }
1318                 // prevent elements from being deleted
1319                 bool oldMustDelete1 = _Elements[index1].EltDeleteOnRemove;
1320                 bool oldMustDelete2 = _Elements[index2].EltDeleteOnRemove;
1321
1322                 uint order1 = _Elements[index1].Order;
1323                 uint order2 = _Elements[index2].Order;
1324
1325                 _Elements[index1].EltDeleteOnRemove = false;
1326                 _Elements[index2].EltDeleteOnRemove = false;
1327
1328                 CViewBase *v1 = _Elements[index1].Element;
1329                 CViewBase *v2 = _Elements[index2].Element;
1330
1331
1332                 if (index1 < index2)
1333                 {
1334                         delChild(index2);
1335                         delChild(index1);
1336                         addChildAtIndex(v2, index1, oldMustDelete2);
1337                         setOrder(index1, order2);
1338                         addChildAtIndex(v1, index2, oldMustDelete1);
1339                         setOrder(index2, order1);
1340                 }
1341                 else
1342                 {
1343                         delChild(index1);
1344                         delChild(index2);
1345                         addChildAtIndex(v1, index2, oldMustDelete1);
1346                         setOrder(index2, order1);
1347                         addChildAtIndex(v2, index1, oldMustDelete2);
1348                         setOrder(index1, order2);
1349                 }
1350         }*/
1351
1352         // ----------------------------------------------------------------------------
1353         void CGroupParagraph::deleteAllChildren()
1354         {
1355                 uint numChildren = getNbElement();
1356                 for(uint k = 0; k < numChildren; ++k)
1357                 {
1358                         delChild(numChildren - 1 - k); // delete in reverse order to avoid unnecessary vector copies
1359                 }
1360         }
1361
1362         // ----------------------------------------------------------------------------
1363         uint CGroupParagraph::getNumActiveChildren() const
1364         {
1365                 uint numChildren = 0;
1366                 for(uint k = 0; k < _Elements.size(); ++k)
1367                 {
1368                         if (_Elements[k].Element->getActive()) ++numChildren;
1369                 }
1370                 return numChildren;
1371         }
1372
1373         // ----------------------------------------------------------------------------
1374         void CGroupParagraph::setDelOnRemove(uint index, bool delOnRemove)
1375         {
1376                 if (index >= _Elements.size())
1377                 {
1378                         nlwarning("bad index");
1379                         return;
1380                 }
1381                 _Elements[index].EltDeleteOnRemove = delOnRemove;
1382         }
1383
1384         // ----------------------------------------------------------------------------
1385         bool CGroupParagraph::getDelOnRemove(uint index) const
1386         {
1387                 if (index >= _Elements.size())
1388                 {
1389                         nlwarning("bad index");
1390                         return false;
1391                 }
1392                 return _Elements[index].EltDeleteOnRemove;
1393         }
1394
1395         // ----------------------------------------------------------------------------
1396         void CGroupParagraph::addChildLink (CViewLink* child, bool deleteOnRemove)
1397         {
1398                 // Add the child
1399                 addChild (child, deleteOnRemove);
1400
1401                 // Add the link
1402                 _Links.push_back (CLink(child));
1403         }
1404
1405         // ----------------------------------------------------------------------------
1406         CGroupParagraph::CLink::CLink (CViewLink *link)
1407         {
1408                 Link = link;
1409                 CtrlLink[0] = NULL;
1410                 CtrlLink[1] = NULL;
1411                 CtrlLink[2] = NULL;
1412         }
1413
1414         // ----------------------------------------------------------------------------
1415         void CGroupParagraph::onInvalidateContent()
1416         {
1417                 _ContentValidated = false;
1418                 invalidateCoords();
1419         }
1420
1421         // ----------------------------------------------------------------------------
1422         sint32 CGroupParagraph::getMaxUsedW() const
1423         {
1424                 // The paragraph max is the sum of the components max
1425                 sint maxWidth = 0;
1426                 for (uint k = 0; k < _Elements.size(); ++k)
1427                 {
1428                         // Get the child width
1429                         maxWidth += _Elements[k].Element->getMaxUsedW();
1430                 }
1431                 return maxWidth + _MarginLeft;
1432         }
1433
1434         // ----------------------------------------------------------------------------
1435         sint32 CGroupParagraph::getMinUsedW() const
1436         {
1437                 // The paragraph min is the max of the components min
1438                 sint32 minWidth = 0;
1439                 for (uint k = 0; k < _Elements.size(); ++k)
1440                 {
1441                         // Get the child width
1442                         sint32 width = _Elements[k].Element->getMinUsedW();
1443                         if (width > minWidth)
1444                                 minWidth = width;
1445                 }
1446                 return minWidth + _MarginLeft;
1447         }
1448
1449
1450         void CGroupParagraph::setupSizes()
1451         {
1452                 EAlign addElt = _AddElt;
1453                 _GroupSizeRef = _SizeRef;
1454                 if ((addElt == Top) || (addElt == Bottom))
1455                 {
1456                         setMaxW (_W);
1457                         setMaxH(_H);
1458                         _H = 0;
1459                         _SizeRef = _SizeRef&(~2);
1460                 }
1461                 else
1462                 {
1463                         setMaxW (_W);
1464                         setMaxH (_H);
1465                         _W = 0;
1466                         _SizeRef = _SizeRef&(~1);
1467                 }
1468         }
1469
1470
1471         void CGroupParagraph::onTextChanged()
1472         {
1473                 if( _Elements.empty() )
1474                         return;
1475
1476                 CElementInfo &e = _Elements[ 0 ];
1477
1478                 CViewText *t = dynamic_cast< CViewText* >( e.Element );
1479                 if( t != NULL )
1480                 {
1481                         t->setText( _HardText );
1482                         return;
1483                 }
1484                 else
1485                 {
1486                         CViewTextID *ti = dynamic_cast< CViewTextID* >( e.Element );
1487                         if( ti != NULL )
1488                         {
1489                                 ti->setTextId( _TextId );
1490                         }
1491                 }
1492         }
1493
1494 }
1495