nel/src/gui/ctrl_button.cpp

   1 // Ryzom - MMORPG Framework <http://dev.ryzom.com/projects/ryzom/>
   2 // Copyright (C) 2010-2016  Winch Gate Property Limited
   3 //
   4 // This source file has been modified by the following contributors:
   5 // Copyright (C) 2013  Laszlo KIS-ADAM (dfighter) <dfighter1985@gmail.com>
   6 // Copyright (C) 2020  Jan BOON (Kaetemi) <jan.boon@kaetemi.be>
   7 //
   8 // This program is free software: you can redistribute it and/or modify
   9 // it under the terms of the GNU Affero General Public License as
  10 // published by the Free Software Foundation, either version 3 of the
  11 // License, or (at your option) any later version.
  12 //
  13 // This program is distributed in the hope that it will be useful,
  14 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 // GNU Affero General Public License for more details.
  17 //
  18 // You should have received a copy of the GNU Affero General Public License
  19 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
  20
  21
  22 #include "stdpch.h"
  23 #include "nel/gui/ctrl_button.h"
  24 #include "nel/misc/xml_auto_ptr.h"
  25 #include "nel/gui/widget_manager.h"
  26 #include "nel/gui/interface_group.h"
  27
  28 // ----------------------------------------------------------------------------
  29 using namespace std;
  30 using namespace NLMISC;
  31 using namespace NL3D;
  32
  33 #ifdef DEBUG_NEW
  34 #define new DEBUG_NEW
  35 #endif
  36
  37 NLMISC_REGISTER_OBJECT(CViewBase, CCtrlButton, std::string, "button");
  38
  39 namespace NLGUI
  40 {
  41
  42         void CCtrlButton::setAlignFromString( const std::string &s )
  43         {
  44                 _Align = 0;
  45
  46                 std::string::size_type i;
  47                 for( i = 0; i < s.size(); i++ )
  48                 {
  49                         char c = toLower( s[ i ] );
  50
  51                         switch( c )
  52                         {
  53                                 case 'l':
  54                                         _Align &= ~1;
  55                                         break;
  56
  57                                 case 'r':
  58                                         _Align |= 1;
  59                                         break;
  60
  61                                 case 'b':
  62                                         _Align &= ~2;
  63                                         break;
  64
  65                                 case 't':
  66                                         _Align |= 2;
  67                                         break;
  68                         }
  69                 }
  70         }
  71
  72         std::string CCtrlButton::getProperty( const std::string &name ) const
  73         {
  74                 if( name == "tx_normal" )
  75                 {
  76                         return CViewRenderer::getInstance()->getTextureNameFromId( _TextureIdNormal );
  77                 }
  78                 else
  79                 if( name == "tx_pushed" )
  80                 {
  81                         return CViewRenderer::getInstance()->getTextureNameFromId( _TextureIdPushed );
  82                 }
  83                 else
  84                 if( name == "tx_over" )
  85                 {
  86                         return CViewRenderer::getInstance()->getTextureNameFromId( _TextureIdOver );
  87                 }
  88                 else
  89                 if( name == "scale" )
  90                 {
  91                         return toString( _Scale );
  92                 }
  93                 else
  94                 if( name == "align" )
  95                 {
  96                         std::string align;
  97                         if( ( _Align & 1 ) != 0 )
  98                                 align = "r";
  99                         else
 100                                 align = "l";
 101                         if( ( _Align & 2 ) != 0 )
 102                                 align += "t";
 103                         else
 104                                 align += "b";
 105                         return align;
 106                 }
 107                 else
 108                         return CCtrlBaseButton::getProperty( name );
 109         }
 110
 111         void CCtrlButton::setProperty( const std::string &name, const std::string &value )
 112         {
 113                 if( name == "tx_normal" )
 114                 {
 115                         std::string s = CViewRenderer::getInstance()->getTextureNameFromId( _TextureIdNormal );
 116                         if( !_TextureIdNormal.setTexture( value.c_str() ) )
 117                         {
 118                                 _TextureIdNormal.setTexture( s.c_str() );
 119                         }
 120                         return;
 121                 }
 122                 else
 123                 if( name == "tx_pushed" )
 124                 {
 125                         std::string s = CViewRenderer::getInstance()->getTextureNameFromId( _TextureIdPushed );
 126                         if( !_TextureIdPushed.setTexture( value.c_str() ) )
 127                         {
 128                                 _TextureIdPushed.setTexture( s.c_str() );
 129                         }
 130                         return;
 131                 }
 132                 else
 133                 if( name == "tx_over" )
 134                 {
 135                         std::string s = CViewRenderer::getInstance()->getTextureNameFromId( _TextureIdOver );
 136                         if( !_TextureIdOver.setTexture( value.c_str() ) )
 137                         {
 138                                 _TextureIdOver.setTexture( s.c_str() );
 139                         }
 140                         return;
 141                 }
 142                 else
 143                 if( name == "scale" )
 144                 {
 145                         bool b;
 146                         if( fromString( value, b ) )
 147                                 _Scale = b;
 148                         return;
 149                 }
 150                 else
 151                 if( name == "align" )
 152                 {
 153                         setAlignFromString( value );
 154                         return;
 155                 }
 156                 else
 157                         CCtrlBaseButton::setProperty( name, value );
 158         }
 159
 160
 161         xmlNodePtr CCtrlButton::serialize( xmlNodePtr parentNode, const char *type ) const
 162         {
 163                 xmlNodePtr node = CCtrlBaseButton::serialize( parentNode, type );
 164                 if( node == NULL )
 165                         return NULL;
 166
 167                 xmlSetProp( node, BAD_CAST "type", BAD_CAST "button" );
 168
 169                 xmlNewProp( node, BAD_CAST "tx_normal",
 170                         BAD_CAST CViewRenderer::getInstance()->getTextureNameFromId( _TextureIdNormal ).c_str() );
 171
 172                 xmlNewProp( node, BAD_CAST "tx_pushed",
 173                         BAD_CAST CViewRenderer::getInstance()->getTextureNameFromId( _TextureIdPushed ).c_str() );
 174
 175                 xmlNewProp( node, BAD_CAST "tx_over",
 176                         BAD_CAST CViewRenderer::getInstance()->getTextureNameFromId( _TextureIdOver ).c_str() );
 177
 178                 xmlNewProp( node, BAD_CAST "scale", BAD_CAST toString( _Scale ).c_str() );
 179
 180                 std::string align;
 181                 if( ( _Align & 1 ) != 0 )
 182                         align = "r";
 183                 else
 184                         align = "l";
 185                 if( ( _Align & 2 ) != 0 )
 186                         align += "t";
 187                 else
 188                         align += "b";
 189
 190                 xmlNewProp( node, BAD_CAST "align", BAD_CAST align.c_str() );
 191
 192                 return node;
 193         }
 194
 195         // ----------------------------------------------------------------------------
 196         bool CCtrlButton::parse(xmlNodePtr cur, CInterfaceGroup * parentGroup)
 197         {
 198                 CXMLAutoPtr prop;
 199                 //try to get props that can be inherited from groups
 200                 //if a property is not defined, try to find it in the parent group.
 201                 //if it is undefined, set it to zero
 202                 if (! CCtrlBaseButton::parse(cur,parentGroup) )
 203                 {
 204                         string tmp = "cannot parse view:"+getId()+", parent:"+parentGroup->getId();
 205                         nlinfo(tmp.c_str());
 206                         return false;
 207                 }
 208
 209
 210                 // *** Read Textures
 211                 prop = (char*) xmlGetProp( cur, (xmlChar*)"tx_normal" );
 212                 if (prop)
 213                 {
 214                         string TxName = NLMISC::toLowerAscii((const char *) prop);
 215                         _TextureIdNormal.setTexture(TxName.c_str());
 216                 }
 217
 218                 prop = (char*) xmlGetProp( cur, (xmlChar*)"tx_pushed" );
 219                 if (prop)
 220                 {
 221                         string TxName = NLMISC::toLowerAscii((const char *) prop);
 222                         _TextureIdPushed.setTexture(TxName.c_str());
 223                 }
 224
 225                 prop = (char*) xmlGetProp( cur, (xmlChar*)"tx_over" );
 226                 if (prop)
 227                 {
 228                         string TxName = NLMISC::toLowerAscii((const char *) prop);
 229                         _TextureIdOver.setTexture(TxName.c_str());
 230                 }
 231
 232                 // *** Misc.
 233                 prop = (char*) xmlGetProp( cur, (xmlChar*)"scale" );
 234                 _Scale = false;
 235                 if (prop)
 236                         _Scale = convertBool(prop);
 237
 238
 239                 prop = (char*) xmlGetProp (cur, (xmlChar*)"align");
 240                 if (prop)
 241                 {
 242                         setAlignFromString( std::string( (const char*)prop ) );
 243                 }
 244
 245
 246                 return true;
 247         }
 248
 249         // ----------------------------------------------------------------------------
 250         void CCtrlButton::draw ()
 251         {
 252                 sint32 nTxId = -1;
 253                 CRGBA  color;
 254
 255                 CViewRenderer &rVR = *CViewRenderer::getInstance();
 256                 CRGBA  globalColor= CWidgetManager::getInstance()->getGlobalColorForContent();
 257
 258                 // *** Detect Over
 259                 bool    lastOver = false;
 260
 261                 updateOver(lastOver);
 262
 263
 264                 sint32 x = _XReal;
 265                 sint32 y = _YReal;
 266                 sint32 txw, txh;
 267                 // the pointer is over the button
 268                 if (_Scale)
 269                 {
 270                         x = _XReal;
 271                         y = _YReal;
 272                         txw = _WReal;
 273                         txh = _HReal;
 274                 }
 275                 else
 276                 {
 277                         x = _XReal;
 278                         y = _YReal;
 279                 }
 280
 281                 switch(_Type)
 282                 {
 283                         case ToggleButton:
 284                         {
 285                                 if (_Pushed && !editorMode )
 286                                 {
 287                                         nTxId = _TextureIdPushed;
 288                                         color  = getCurrentColorPushed(globalColor);
 289                                 }
 290                                 else
 291                                 {
 292                                         nTxId = _TextureIdNormal;
 293                                         color  = getCurrentColorNormal(globalColor);
 294                                 }
 295                         }
 296                         break;
 297                         case RadioButton:
 298                         {
 299         //                      CViewPointer &rIP = *CInterfaceManager::getInstance()->getPointer();
 300                                 // Init the radio button
 301                                 initRBRef();
 302
 303                                 if (*_RBRef == this)
 304                                 {
 305                                         // if it is equal to the ref value, then the button must appear pushed
 306                                         nTxId = _TextureIdPushed;
 307                                         color  = getCurrentColorPushed(globalColor);
 308                                 }
 309                                 else
 310                                 {
 311                                         if ( (_Over) && (CWidgetManager::getInstance()->getCapturePointerLeft() == this) && !editorMode )
 312                                         {
 313                                                 nTxId = _TextureIdPushed;
 314                                                 color  = getCurrentColorPushed(globalColor);
 315                                         }
 316                                         else
 317                                         {
 318                                                 nTxId = _TextureIdNormal;
 319                                                 color     = getCurrentColorNormal(globalColor);
 320                                                 _Pushed = false;
 321                                         }
 322                                 }
 323                         }
 324                         break;
 325                         case PushButton:
 326                         {
 327                                 if ( _Over && (CWidgetManager::getInstance()->getCapturePointerLeft() == this) && !editorMode )
 328                                 {
 329                                         nTxId = _TextureIdPushed;
 330                                         color  = getCurrentColorPushed(globalColor);
 331                                 }
 332                                 else
 333                                 {
 334                                         nTxId = _TextureIdNormal;
 335                                         color     = getCurrentColorNormal(globalColor);
 336                                         _Pushed = false;
 337                                 }
 338                         }
 339                         break;
 340                         default:
 341                         break;
 342                 }
 343
 344                 color.A = (uint8)(((sint32)color.A*((sint32)globalColor.A+1))>>8);
 345
 346                 // Fromzen ?
 347                 if (getFrozen() && getFrozenHalfTone())
 348                         color.A >>= 2;
 349
 350                 if (!_Scale)
 351                 {
 352                         CViewRenderer::getInstance()->getTextureSizeFromId (nTxId, txw, txh);
 353                         if (_Align&1)
 354                                 x = x + _WReal - txw;
 355                         if (_Align&2)
 356                                 y = y + _HReal - txh;
 357                 }
 358                 rVR.drawRotFlipBitmap ( _RenderLayer, x, y, txw, txh,
 359                                                                 0, false,
 360                                                                 nTxId,
 361                                                                 color );
 362
 363                 if ((_OverWhenPushed == false) && (_Pushed == true || (CWidgetManager::getInstance()->getCapturePointerLeft() == this)))
 364                         return;
 365
 366
 367
 368                 if ( ( _Over && !editorMode ) )
 369                 {
 370
 371                         if( !editorMode && (lastOver == false) && (_AHOnOver != NULL))
 372                                 CAHManager::getInstance()->runActionHandler (_AHOnOver, this, _AHOverParams);
 373
 374                         // the pointer is over the button
 375                         color= getCurrentColorOver(globalColor);
 376                         color.A = (uint8)(((sint32)color.A*((sint32)globalColor.A+1))>>8);
 377
 378                         // Frozen ?
 379                         if (getFrozen())
 380                                 color.A >>= 2;
 381
 382                         // draw the over. force upper layer to avoid problem with DXTC/tga
 383                         rVR.drawRotFlipBitmap ( _RenderLayer+1, x, y, txw, txh,
 384                                                                         0, false,
 385                                                                         _TextureIdOver,
 386                                                                         color );
 387                 }
 388         }
 389
 390
 391         // ----------------------------------------------------------------------------
 392         void CCtrlButton::updateCoords()
 393         {
 394                 if (!_Scale)
 395                 {
 396                         CViewRenderer &rVR = *CViewRenderer::getInstance();
 397                         sint32 txw, txh;
 398                         rVR.getTextureSizeFromId (_TextureIdNormal, txw, txh);
 399                         _W = txw;
 400                         _H = txh;
 401                 }
 402                 CViewBase::updateCoords();
 403         }
 404
 405         // ----------------------------------------------------------------------------
 406         void CCtrlButton::setTexture(const std::string&name)
 407         {
 408         //      CInterfaceManager *pIM = CInterfaceManager::getInstance();
 409         //      CViewRenderer &rVR = *CViewRenderer::getInstance();
 410                 _TextureIdNormal.setTexture(name.c_str (), 0, 0, -1, -1, false);
 411         }
 412
 413         // ----------------------------------------------------------------------------
 414         void CCtrlButton::setTexturePushed(const std::string&name)
 415         {
 416         //      CInterfaceManager *pIM = CInterfaceManager::getInstance();
 417         //      CViewRenderer &rVR = *CViewRenderer::getInstance();
 418                 _TextureIdPushed.setTexture(name.c_str (), 0, 0, -1, -1, false);
 419         }
 420
 421         // ----------------------------------------------------------------------------
 422         void CCtrlButton::setTextureOver(const std::string&name)
 423         {
 424         //      CInterfaceManager *pIM = CInterfaceManager::getInstance();
 425         //      CViewRenderer &rVR = *CViewRenderer::getInstance();
 426                 _TextureIdOver.setTexture(name.c_str (), 0, 0, -1, -1, false);
 427         }
 428
 429         // ----------------------------------------------------------------------------
 430         std::string CCtrlButton::getTexture() const
 431         {
 432                 CViewRenderer &rVR = *CViewRenderer::getInstance();
 433                 return rVR.getTextureNameFromId(_TextureIdNormal);
 434         }
 435
 436         // ----------------------------------------------------------------------------
 437         std::string CCtrlButton::getTexturePushed() const
 438         {
 439                 CViewRenderer &rVR = *CViewRenderer::getInstance();
 440                 return rVR.getTextureNameFromId(_TextureIdPushed);
 441         }
 442
 443         // ----------------------------------------------------------------------------
 444         std::string CCtrlButton::getTextureOver() const
 445         {
 446                 CViewRenderer &rVR = *CViewRenderer::getInstance();
 447                 return rVR.getTextureNameFromId(_TextureIdOver);
 448         }
 449
 450         // ***************************************************************************
 451         sint32  CCtrlButton::getMaxUsedW() const
 452         {
 453                 if (_Scale)
 454                         return _WReal;
 455
 456                 sint32 txw, txh;
 457                 CViewRenderer &rVR = *CViewRenderer::getInstance();
 458                 rVR.getTextureSizeFromId (_TextureIdNormal, txw, txh);
 459                 return txw;
 460         }
 461
 462         // ***************************************************************************
 463         sint32  CCtrlButton::getMinUsedW() const
 464         {
 465                 return getMaxUsedW();
 466         }
 467
 468         // ***************************************************************************
 469         void CCtrlButton::fitTexture()
 470         {
 471                 CViewRenderer &rVR = *CViewRenderer::getInstance();
 472                 sint32 w, h;
 473                 rVR.getTextureSizeFromId(_TextureIdNormal, w, h);
 474                 setW(w);
 475                 setH(h);
 476         }
 477
 478         // ***************************************************************************
 479         bool CCtrlButton::getMouseOverShape(string &texName, uint8 &rot, CRGBA &col)
 480         {
 481                 if (_AHOnLeftClickString == "browse")
 482                 {
 483                         if (!_AHOnLeftClickStringParams.empty())
 484                         {
 485                                 texName = "@curs_pick.tga@"+_AHOnLeftClickStringParams;
 486                         }
 487                         else
 488                         {
 489                                 texName = "curs_pick.tga";
 490                         }
 491                         rot= 0;
 492                         col = CRGBA::White;
 493                         return true;
 494                 }
 495
 496                 return false;
 497         }
 498
 499 }
 500