mirror of
https://port.numenaute.org/aleajactaest/khanat-opennel-code.git
synced 2024-09-20 19:50:32 +00:00
405 lines
10 KiB
C++
405 lines
10 KiB
C++
// Ryzom - MMORPG Framework <http://dev.ryzom.com/projects/ryzom/>
|
|
// Copyright (C) 2010 Winch Gate Property Limited
|
|
//
|
|
// This program is free software: you can redistribute it and/or modify
|
|
// it under the terms of the GNU Affero General Public License as
|
|
// published by the Free Software Foundation, either version 3 of the
|
|
// License, or (at your option) any later version.
|
|
//
|
|
// This program is distributed in the hope that it will be useful,
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
// GNU Affero General Public License for more details.
|
|
//
|
|
// You should have received a copy of the GNU Affero General Public License
|
|
// along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
|
|
#include "stdpch.h"
|
|
#include "nel/gui/dbview_bar.h"
|
|
#include "nel/misc/xml_auto_ptr.h"
|
|
#include "nel/gui/interface_group.h"
|
|
#include "nel/gui/widget_manager.h"
|
|
#include "nel/gui/db_manager.h"
|
|
|
|
using namespace std;
|
|
using namespace NL3D;
|
|
using namespace NLMISC;
|
|
|
|
NLMISC_REGISTER_OBJECT(CViewBase, CDBViewBar, std::string, "bar");
|
|
|
|
namespace NLGUI
|
|
{
|
|
|
|
// ----------------------------------------------------------------------------
|
|
void CDBViewBar::parseValProp(xmlNodePtr cur, CInterfaceProperty &dbProp, sint32 &intProp, const char *name)
|
|
{
|
|
CXMLAutoPtr prop((const char*) xmlGetProp( cur, (xmlChar*)name ));
|
|
if (prop)
|
|
{
|
|
if ( isdigit(*prop.getDatas()) || *(prop.getDatas())=='-')
|
|
fromString((const char*)prop, intProp);
|
|
else
|
|
dbProp.link(prop);
|
|
}
|
|
}
|
|
|
|
std::string CDBViewBar::getProperty( const std::string &name ) const
|
|
{
|
|
if( name == "value" )
|
|
{
|
|
if( _Value.getNodePtr() != NULL )
|
|
return _Value.getNodePtr()->getFullName();
|
|
else
|
|
return toString( _ValueInt );
|
|
}
|
|
else
|
|
if( name == "range" )
|
|
{
|
|
if( _Range.getNodePtr() != NULL )
|
|
return _Range.getNodePtr()->getFullName();
|
|
else
|
|
return toString( _RangeInt );
|
|
}
|
|
else
|
|
if( name == "reference" )
|
|
{
|
|
if( _Reference.getNodePtr() != NULL )
|
|
return _Reference.getNodePtr()->getFullName();
|
|
else
|
|
return toString( _ReferenceInt );
|
|
}
|
|
else
|
|
if( name == "color_negative" )
|
|
{
|
|
return toString( _ColorNegative );
|
|
}
|
|
else
|
|
if( name == "mini" )
|
|
{
|
|
if( _Type == ViewBar_Mini )
|
|
return "true";
|
|
else
|
|
return "false";
|
|
}
|
|
else
|
|
if( name == "ultra_mini" )
|
|
{
|
|
if( _Type == ViewBar_UltraMini )
|
|
return "true";
|
|
else
|
|
return "false";
|
|
}
|
|
else
|
|
if( name == "mini_thick" )
|
|
{
|
|
if( _Type == ViewBar_MiniThick )
|
|
return "true";
|
|
else
|
|
return "false";
|
|
}
|
|
else
|
|
return CViewBitmap::getProperty( name );
|
|
}
|
|
|
|
void CDBViewBar::setProperty( const std::string &name, const std::string &value )
|
|
{
|
|
if( name == "value" )
|
|
{
|
|
sint32 i;
|
|
if( fromString( value, i ) )
|
|
_ValueInt = i;
|
|
else
|
|
_Value.link( value.c_str() );
|
|
return;
|
|
}
|
|
else
|
|
if( name == "range" )
|
|
{
|
|
sint32 i;
|
|
if( fromString( value, i ) )
|
|
_RangeInt = i;
|
|
else
|
|
_Range.link( value.c_str() );
|
|
return;
|
|
}
|
|
else
|
|
if( name == "reference" )
|
|
{
|
|
sint32 i;
|
|
if( fromString( value, i ) )
|
|
_ReferenceInt = i;
|
|
else
|
|
_Reference.link( value.c_str() );
|
|
return;
|
|
}
|
|
else
|
|
if( name == "color_negative" )
|
|
{
|
|
CRGBA c;
|
|
if( fromString( value, c ) )
|
|
_ColorNegative = c;
|
|
return;
|
|
}
|
|
else
|
|
if( name == "mini" )
|
|
{
|
|
bool b;
|
|
if( fromString( value, b ) )
|
|
if( b )
|
|
_Type = ViewBar_Mini;
|
|
return;
|
|
}
|
|
else
|
|
if( name == "ultra_mini" )
|
|
{
|
|
bool b;
|
|
if( fromString( value, b ) )
|
|
if( b )
|
|
_Type = ViewBar_UltraMini;
|
|
return;
|
|
}
|
|
else
|
|
if( name == "mini_thick" )
|
|
{
|
|
bool b;
|
|
if( fromString( value, b ) )
|
|
if( b )
|
|
_Type = ViewBar_MiniThick;
|
|
return;
|
|
}
|
|
else
|
|
CViewBitmap::setProperty( name, value );
|
|
}
|
|
|
|
|
|
xmlNodePtr CDBViewBar::serialize( xmlNodePtr parentNode, const char *type ) const
|
|
{
|
|
xmlNodePtr node = CViewBitmap::serialize( parentNode, type );
|
|
if( node == NULL )
|
|
return NULL;
|
|
|
|
xmlSetProp( node, BAD_CAST "type", BAD_CAST "bar" );
|
|
|
|
if( _Value.getNodePtr() != NULL )
|
|
xmlSetProp( node, BAD_CAST "value", BAD_CAST _Value.getNodePtr()->getFullName().c_str() );
|
|
else
|
|
xmlSetProp( node, BAD_CAST "value", BAD_CAST toString( _RangeInt ).c_str() );
|
|
|
|
if( _Range.getNodePtr() != NULL )
|
|
xmlSetProp( node, BAD_CAST "range", BAD_CAST _Range.getNodePtr()->getFullName().c_str() );
|
|
else
|
|
xmlSetProp( node, BAD_CAST "range", BAD_CAST toString( _RangeInt ).c_str() );
|
|
|
|
if( _Reference.getNodePtr() != NULL )
|
|
xmlSetProp( node, BAD_CAST "reference", BAD_CAST _Reference.getNodePtr()->getFullName().c_str() );
|
|
else
|
|
xmlSetProp( node, BAD_CAST "reference", BAD_CAST toString( _ReferenceInt ).c_str() );
|
|
|
|
xmlSetProp( node, BAD_CAST "color_negative", BAD_CAST toString( _ColorNegative ).c_str() );
|
|
|
|
if( _Type == ViewBar_Mini )
|
|
xmlSetProp( node, BAD_CAST "mini", BAD_CAST "true" );
|
|
else
|
|
xmlSetProp( node, BAD_CAST "mini", BAD_CAST "false" );
|
|
|
|
if( _Type == ViewBar_UltraMini )
|
|
xmlSetProp( node, BAD_CAST "ultra_mini", BAD_CAST "true" );
|
|
else
|
|
xmlSetProp( node, BAD_CAST "ultra_mini", BAD_CAST "false" );
|
|
|
|
if( _Type == ViewBar_MiniThick )
|
|
xmlSetProp( node, BAD_CAST "mini_thick", BAD_CAST "true" );
|
|
else
|
|
xmlSetProp( node, BAD_CAST "mini_thick", BAD_CAST "false" );
|
|
|
|
return node;
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
bool CDBViewBar::parse (xmlNodePtr cur, CInterfaceGroup * parentGroup)
|
|
{
|
|
if (!CViewBitmap::parse(cur, parentGroup))
|
|
{
|
|
string tmp = "cannot parse view:"+getId()+", parent:"+parentGroup->getId();
|
|
nlinfo(tmp.c_str());
|
|
return false;
|
|
}
|
|
|
|
CXMLAutoPtr prop;
|
|
|
|
// read value, range and reference
|
|
parseValProp(cur, _Value, _ValueInt, "value");
|
|
parseValProp(cur, _Range, _RangeInt, "range");
|
|
parseValProp(cur, _Reference, _ReferenceInt, "reference");
|
|
|
|
// Get Visual props
|
|
prop= (char*) xmlGetProp( cur, (xmlChar*)"color_negative" );
|
|
_ColorNegative = CRGBA(0,0,0,0);
|
|
if (prop)
|
|
_ColorNegative = convertColor (prop);
|
|
|
|
// Bar Type
|
|
_Type = ViewBar_Normal;
|
|
|
|
prop = (char*) xmlGetProp( cur, (xmlChar*)"mini" );
|
|
if (prop)
|
|
if (convertBool(prop))
|
|
setType(ViewBar_Mini);
|
|
|
|
prop = (char*) xmlGetProp( cur, (xmlChar*)"ultra_mini" );
|
|
if (prop)
|
|
if (convertBool(prop))
|
|
setType(ViewBar_UltraMini);
|
|
|
|
prop = (char*) xmlGetProp( cur, (xmlChar*)"mini_thick" );
|
|
if (prop)
|
|
if (convertBool(prop))
|
|
setType(ViewBar_MiniThick);
|
|
|
|
if (_Type == ViewBar_Normal)
|
|
setType(ViewBar_Normal);
|
|
|
|
return true;
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
void CDBViewBar::setType (TViewBar vb)
|
|
{
|
|
_Type = vb;
|
|
switch(_Type)
|
|
{
|
|
case ViewBar_Normal: _Slot.setTexture ("w_slot_jauge_1.tga"); break;
|
|
case ViewBar_Mini: _Slot.setTexture ("w_slot_jauge_1_mini.tga"); break;
|
|
case ViewBar_UltraMini: _Slot.setTexture ("w_slot_jauge_1_umin.tga"); break;
|
|
case ViewBar_MiniThick: _Slot.setTexture ("w_slot_jauge_1_tmin.tga"); break;
|
|
}
|
|
|
|
_Slot.setPosRef (_PosRef);
|
|
_Slot.setParentPosRef (_ParentPosRef);
|
|
_Slot.setX (_X);
|
|
_Slot.setY (_Y);
|
|
|
|
_Scale = true;
|
|
switch(_Type)
|
|
{
|
|
case ViewBar_Normal: setTexture ("w_jauge_fill.tga"); break;
|
|
case ViewBar_Mini: setTexture ("w_jauge_fill_mini.tga"); break;
|
|
case ViewBar_UltraMini: setTexture ("w_jauge_fill_umin.tga"); break;
|
|
case ViewBar_MiniThick: setTexture ("w_jauge_fill_tmin.tga"); break;
|
|
}
|
|
|
|
// Get the Height Size.
|
|
sint32 wBar;
|
|
CViewRenderer::getInstance()->getTextureSizeFromId(_TextureId, wBar, _HBar);
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
void CDBViewBar::updateCoords ()
|
|
{
|
|
if (_ParentPos == NULL)
|
|
_Slot.setParentPos (_Parent);
|
|
else
|
|
_Slot.setParentPos (_ParentPos);
|
|
_Slot.updateCoords();
|
|
_W = _Slot.getW();
|
|
_H = _Slot.getH();
|
|
CViewBitmap::updateCoords();
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
sint64 CDBViewBar::getCurrentValProp(const CInterfaceProperty &dbProp, sint32 intProp)
|
|
{
|
|
if(dbProp.getNodePtr())
|
|
return dbProp.getSInt64();
|
|
else
|
|
return intProp;
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
void CDBViewBar::draw ()
|
|
{
|
|
float wBar = (float)(_Slot.getWReal()-4);
|
|
|
|
sint64 value= getCurrentValProp(_Value, _ValueInt);
|
|
sint64 range= getCurrentValProp(_Range, _RangeInt);
|
|
sint64 reference= getCurrentValProp(_Reference, _ReferenceInt);
|
|
|
|
// remove the reference
|
|
value-= reference;
|
|
range-= reference;
|
|
|
|
// draw the bar
|
|
CRGBA color = _Color;
|
|
|
|
if (range > 0)
|
|
{
|
|
float ratio= (float)value / range;
|
|
if (_ColorNegative.A != 0 && ratio < 0.0f)
|
|
{
|
|
ratio = - ratio;
|
|
color = _ColorNegative;
|
|
}
|
|
NLMISC::clamp(ratio, 0.f, 1.f);
|
|
wBar *= ratio;
|
|
}
|
|
else
|
|
wBar = 0;
|
|
|
|
_WReal = (sint32)wBar;
|
|
|
|
_Slot.draw();
|
|
|
|
CViewRenderer &rVR = *CViewRenderer::getInstance();
|
|
|
|
color.A = (uint8)(((sint32)color.A*((sint32)CWidgetManager::getInstance()->getGlobalColorForContent().A+1))>>8);
|
|
|
|
// compute the DeltaY: mean of dif.
|
|
sint32 deltaY= (_H-_HBar)/2;
|
|
rVR.drawRotFlipBitmap (_RenderLayer, _XReal+2, _YReal+deltaY, _WReal, _HBar, 0, false, _TextureId, color);
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
void CDBViewBar::setValueDbLink (const std::string &r)
|
|
{
|
|
CCDBNodeLeaf *pNL = NLGUI::CDBManager::getInstance()->getDbProp(r,false);
|
|
if (pNL != NULL) _Value.setNodePtr(pNL);
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
void CDBViewBar::setRangeDbLink (const std::string &r)
|
|
{
|
|
CCDBNodeLeaf *pNL = NLGUI::CDBManager::getInstance()->getDbProp(r,false);
|
|
if (pNL != NULL) _Range.setNodePtr(pNL);
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
void CDBViewBar::setReferenceDbLink (const std::string &r)
|
|
{
|
|
CCDBNodeLeaf *pNL = NLGUI::CDBManager::getInstance()->getDbProp(r,false);
|
|
if (pNL != NULL) _Reference.setNodePtr(pNL);
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
string CDBViewBar::getValueDbLink () const
|
|
{
|
|
if (_Value.getNodePtr() == NULL) return "";
|
|
return _Value.getNodePtr()->getFullName();
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
string CDBViewBar::getRangeDbLink () const
|
|
{
|
|
if (_Range.getNodePtr() == NULL) return "";
|
|
return _Range.getNodePtr()->getFullName();
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
string CDBViewBar::getReferenceDbLink () const
|
|
{
|
|
if (_Reference.getNodePtr() == NULL) return "";
|
|
return _Reference.getNodePtr()->getFullName();
|
|
}
|
|
|
|
}
|
|
|