khanat-opennel-code/code/nel/src/gui/view_bitmap_combo.cpp

726 lines
19 KiB
C++
Raw Normal View History

2013-02-14 15:53:06 +00:00
// 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"
2013-02-14 15:53:06 +00:00
#include "nel/gui/view_bitmap_combo.h"
#include "nel/misc/xml_auto_ptr.h"
#include "nel/gui/db_manager.h"
#include "nel/gui/view_renderer.h"
#include "nel/gui/widget_manager.h"
#include "nel/gui/view_pointer_base.h"
#include "nel/gui/interface_group.h"
using namespace NLMISC;
namespace NLGUI
{
//=======================================================================================
bool CComboBoxDesc::parse(xmlNodePtr cur, CInterfaceElement*owner)
{
nlassert(owner);
const std::string &ownerId = owner->getId();
CXMLAutoPtr prop;
//
prop = xmlGetProp(cur, (const xmlChar *) "selected");
if (!prop)
{
nlwarning((ownerId + " : Couldn't read 'selected' field").c_str());
return false;
}
owner->relativeSInt64Read(CurrSelected, "selected", prop, "0");
//
prop = xmlGetProp(cur, (const xmlChar *) "num_row");
owner->relativeSInt64Read(NumRow, "num_row", prop, "1");
//
prop = xmlGetProp(cur, (const xmlChar *) "num_col");
owner->relativeSInt64Read(NumCol, "num_col", prop, "1");
//
prop = xmlGetProp(cur, (const xmlChar *) "itemw");
owner->relativeSInt64Read(ItemWidth, "itemw", prop, "32");
//
prop = xmlGetProp(cur, (const xmlChar *) "itemh");
owner->relativeSInt64Read(ItemHeight, "itemh", prop, "32");
//
prop = xmlGetProp(cur, (const xmlChar *) "unrolled");
owner->relativeBoolRead(Unrolled, "unrolled", prop, "false");
//
prop = xmlGetProp(cur, (xmlChar *) "wgap");
owner->relativeSInt64Read(WGap, "wgap", prop, "0");
//
prop = xmlGetProp(cur, (xmlChar *) "hgap");
owner->relativeSInt64Read(HGap, "hgap", prop, "0");
//
prop = xmlGetProp(cur, (xmlChar *) "wgap_selected");
owner->relativeSInt64Read(WGapSelected, "wgap_selected", prop, "0");
//
prop = xmlGetProp(cur, (xmlChar *) "hgap_selected");
owner->relativeSInt64Read(HGapSelected, "hgap_selected", prop, "0");
//
//
prop = xmlGetProp(cur, (xmlChar *) "num_sel");
owner->relativeSInt64Read(NumSel, "num_sel", prop, "1");
//
prop = (char*) xmlGetProp (cur, (xmlChar*)"align");
Align.readSInt32 ("0", ownerId + ":align");
if (prop)
{
const char *seekPtr = prop.getDatas();
while (*seekPtr != 0)
{
if ((*seekPtr=='l')||(*seekPtr=='L'))
{
Align.setSInt32 (Align.getSInt32()&(~1));
}
if ((*seekPtr=='r')||(*seekPtr=='R'))
{
Align.setSInt32 (Align.getSInt32()|1);
}
if ((*seekPtr=='b')||(*seekPtr=='B'))
{
Align.setSInt32 (Align.getSInt32()&(~2));
}
if ((*seekPtr=='t')||(*seekPtr=='T'))
{
Align.setSInt32 (Align.getSInt32()|2);
}
++seekPtr;
}
}
//
return true;
}
//=========================================================================================
void CComboBoxDesc::addObserver(ICDBNode::IPropertyObserver *obs)
{
// Add observers on dimensions
if (NumRow.getNodePtr())
{
ICDBNode::CTextId textId;
NumRow.getNodePtr()->addObserver(obs, textId);
}
if (NumCol.getNodePtr())
{
ICDBNode::CTextId textId;
NumCol.getNodePtr()->addObserver(obs, textId);
}
if (ItemWidth.getNodePtr())
{
ICDBNode::CTextId textId;
ItemWidth.getNodePtr()->addObserver(obs, textId);
}
if (ItemHeight.getNodePtr())
{
ICDBNode::CTextId textId;
ItemHeight.getNodePtr()->addObserver(obs, textId);
}
if (Unrolled.getNodePtr())
{
ICDBNode::CTextId textId;
Unrolled.getNodePtr()->addObserver(obs, textId);
}
}
//=======================================================================================
void CComboBoxDesc::getGridSize(uint &numRow, uint &numCol) const
{
numRow = NumRow.getSInt32();
numCol = NumCol.getSInt32();
if (numRow == 0 || numCol == 0) return;
if (!Unrolled.getBool())
{
numRow = numCol = 1;
}
}
//=======================================================================================
void CComboBoxDesc::getDimensions(uint &w, uint &h) const
{
uint numRow, numCol;
getGridSize(numRow, numCol);
w = numCol * (ItemWidth.getSInt32() + WGap.getSInt32());
h = numRow * (ItemHeight.getSInt32() + HGap.getSInt32());
//
if (numCol == 1) w -= WGap.getSInt32();
else w += WGapSelected.getSInt32() - WGap.getSInt32();
//
if (numRow == 1) h -= HGap.getSInt32();
else h += HGapSelected.getSInt32() - HGap.getSInt32();
}
//=======================================================================================
NLMISC_REGISTER_OBJECT(CViewBase, CViewBitmapCombo, std::string, "bitmap_combo");
CViewBitmapCombo::CViewBitmapCombo(const TCtorParam &param) : CViewBase(param)
{
}
std::string CViewBitmapCombo::getProperty( const std::string &name ) const
{
if( name == "tx_normal" )
{
std::string normal;
getTexList( _Texs, normal );
return normal;
}
else
if( name == "tx_over" )
{
std::string over;
getTexList( _TexsOver, over );
return over;
}
else
if( name == "tx_pushed" )
{
std::string pushed;
getTexList( _TexsPushed, pushed );
return pushed;
}
else
if( name == "col_normal" )
{
std::string normal;
getColList( _Col, normal );
return normal;
}
else
if( name == "col_over" )
{
std::string over;
getColList( _ColOver, over );
return over;
}
else
if( name == "col_pushed" )
{
std::string pushed;
getColList( _ColPushed, pushed );
return pushed;
}
else
return CViewBase::getProperty( name );
}
void CViewBitmapCombo::setProperty( const std::string &name, const std::string &value )
{
if( name == "tx_normal" )
{
parseTexList( value, _Texs );
return;
}
else
if( name == "tx_over" )
{
parseTexList( value, _TexsOver );
return;
}
else
if( name == "tx_pushed" )
{
parseTexList( value, _TexsPushed );
return;
}
else
if( name == "col_normal" )
{
parseColList( value, _Col );
return;
}
else
if( name == "col_over" )
{
parseColList( value, _ColOver );
return;
}
else
if( name == "col_pushed" )
{
parseColList( value, _ColPushed );
return;
}
else
CViewBase::setProperty( name, value );
}
xmlNodePtr CViewBitmapCombo::serialize( xmlNodePtr parentNode, const char *type ) const
{
xmlNodePtr node = CViewBase::serialize( parentNode, type );
if( node == NULL )
return NULL;
xmlSetProp( node, BAD_CAST "type", BAD_CAST "bitmap_combo" );
std::string normal;
std::string over;
std::string pushed;
getTexList( _Texs, normal );
getTexList( _TexsOver, over );
getTexList( _TexsPushed, pushed );
xmlSetProp( node, BAD_CAST "tx_normal", BAD_CAST normal.c_str() );
xmlSetProp( node, BAD_CAST "tx_over", BAD_CAST over.c_str() );
xmlSetProp( node, BAD_CAST "tx_pushed", BAD_CAST pushed.c_str() );
getColList( _Col, normal );
getColList( _ColOver, over );
getColList( _ColPushed, pushed );
xmlSetProp( node, BAD_CAST "col_normal", BAD_CAST normal.c_str() );
xmlSetProp( node, BAD_CAST "col_over", BAD_CAST over.c_str() );
xmlSetProp( node, BAD_CAST "col_pushed", BAD_CAST pushed.c_str() );
return node;
}
//=======================================================================================
bool CViewBitmapCombo::parse(xmlNodePtr cur, CInterfaceGroup * parentGroup)
{
if (! CViewBase::parse(cur, parentGroup) )
{
parseError(parentGroup);
return false;
}
CXMLAutoPtr prop;
std::string texs;
prop = xmlGetProp(cur, (xmlChar *)"tx_normal");
if (prop) texs = (const char*)prop;
std::string texsOver;
prop = xmlGetProp(cur, (xmlChar *)"tx_over");
if (prop) texsOver = (const char*)prop;
std::string texsPushed;
prop = xmlGetProp(cur, (xmlChar *)"tx_pushed");
if (prop) texsPushed = (const char*)prop;
//
// for colors, an empty strings means all colors are white
//
std::string col;
prop = xmlGetProp(cur, (xmlChar *)"col_normal");
if (prop) col = (const char*)prop;
std::string colOver;
prop = xmlGetProp(cur, (xmlChar *)"col_over");
if (prop) colOver = (const char*)prop;
std::string colPushed;
prop = xmlGetProp(cur, (xmlChar *)"col_pushed");
if (prop) colPushed = (const char*)prop;
/* if (texs.empty() || texsOver.empty() || texsPushed.empty())
{
parseError(parentGroup, "Cannot read tx_normal, tx_over, or tx_pushed");
return false;
}*/
parseTexList(texs, _Texs);
parseTexList(texsOver, _TexsOver);
parseTexList(texsPushed, _TexsPushed);
parseColList(col, _Col);
parseColList(colOver, _ColOver);
parseColList(colPushed, _ColPushed);
//
/* if (_Texs.size() != _TexsOver.size() || _TexsOver.size() != _TexsPushed.size())
{
parseError(parentGroup, "Texture names arrays do not have the same size");
return false;
}
//
uint numCols = NLMISC::maxof(_Col.size(), _ColOver.size(), _ColPushed.size());
if (!
(
(_Col.empty() || _Col.size() == numCols)
&& (_ColOver.empty() || _ColOver.size() == numCols)
&& (_ColPushed.empty() || _ColPushed.size() == numCols)
)
)
{
parseError(parentGroup, "Color names arrays do not have the same size (note an empty array is valid, means all color are 255 255 255");
return false;
}*/
//
if (!_CD.parse(cur, this))
{
return false;
}
//
setupSize();
//
_CD.addObserver(this);
return true;
}
//=======================================================================================
NLMISC::CRGBA CViewBitmapCombo::getCol(const CViewBitmapCombo::TColorArray &array,uint index)
{
if (array.empty()) return CRGBA::White;
return array[index % array.size()];
}
//=======================================================================================
const std::string *CViewBitmapCombo::getTex(const TStringArray &array,uint index)
{
if (array.empty()) return NULL;
return &array[index % array.size()];
}
//=======================================================================================
sint32 CViewBitmapCombo::getTexId(const TIdArray &array, uint index)
{
if (array.empty()) return -1;
return array[index % array.size()];
}
//=======================================================================================
void CViewBitmapCombo::draw()
{
if (_Texs.empty()) return;
uint numRow, numCol;
_CD.getGridSize(numRow, numCol);
if (numRow == 0 || numCol == 0) return;
sint32 mx = 0, my = 0;
CViewRenderer &rVR = *CViewRenderer::getInstance();
const std::vector<CViewBase *> &rVB = CWidgetManager::getInstance()->getViewsUnderPointer();
if (!CWidgetManager::getInstance()->getPointer()) return;
CWidgetManager::getInstance()->getPointer()->getPointerDispPos(mx, my);
bool over = false;
uint32 i;
for (i = 0; i < rVB.size(); ++i)
{
if (rVB[i] == this)
{
over = true;
break;
}
}
if (_TexsId.size() == 0)
{
for (i = 0; i < _Texs.size(); ++i)
_TexsId.push_back(rVR.getTextureIdFromName(_Texs[i]));
for (i = 0; i < _TexsOver.size(); ++i)
_TexsOverId.push_back(rVR.getTextureIdFromName(_TexsOver[i]));
for (i = 0; i < _TexsPushed.size(); ++i)
_TexsPushedId.push_back(rVR.getTextureIdFromName(_TexsPushed[i]));
}
sint32 textId;
CRGBA color;
uint selectedTexIndex = _CD.CurrSelected.getSInt32();
uint itemw = _CD.ItemWidth.getSInt32() + _CD.WGap.getSInt32();
uint itemh = _CD.ItemHeight.getSInt32() + _CD.HGap.getSInt32();
uint counter = 0;
bool overItem = false;
for(uint x = 0; x < numCol; ++x)
{
for(uint y = 0; y < numRow; ++y)
{
uint texIndex = counter;
if (counter != 0)
{
if (counter == selectedTexIndex)
{
texIndex = 0;
}
sint px;
sint py;
// get the right position depending on alignment
if (_CD.Align.getSInt32() & 1) // right align ?
{
px = _XReal + _WReal - (x + 1) * itemw;
}
else
{
px = _XReal + x * itemw;
}
// top align ?
if (_CD.Align.getSInt32() & 2)
{
py = _YReal + _HReal - (y + 1) * itemh;
}
else
{
py = _YReal + y * itemh;
}
if (x != 0)
{
if (_CD.Align.getSInt32() & 1)
px -= _CD.WGapSelected.getSInt32() - _CD.WGap.getSInt32();
else px += _CD.WGapSelected.getSInt32() - _CD.WGap.getSInt32();
}
if (y != 0)
{
if (_CD.Align.getSInt32() & 2)
py -= _CD.HGapSelected.getSInt32() - _CD.HGap.getSInt32();
else py += _CD.HGapSelected.getSInt32() - _CD.HGap.getSInt32();
}
// is the mouse on current item ?
if (over
&& mx >= px
&& my >= py
&& mx < px + (sint32) itemw
&& my < py + (sint32) itemh)
{
overItem = true;
if ( CWidgetManager::getInstance()->getPointer()->getButtonState() & NLMISC::leftButton)
{
textId = getTexId(_TexsPushedId, texIndex);
color = getCol(_ColPushed, texIndex);
}
else
{
textId = getTexId(_TexsOverId, texIndex);
color = getCol(_ColOver, texIndex);
}
}
else
{
textId = getTexId(_TexsId, texIndex);
color = getCol(_Col, texIndex);
}
CViewRenderer::getInstance()->drawRotFlipBitmap (_RenderLayer, px, py, itemw, itemh, 0, false,
textId,
color);
}
++counter;
if ((sint32) counter == _CD.NumSel.getSInt32())
break;
}
}
if ((sint32) selectedTexIndex >= _CD.NumSel.getSInt32())
{
return;
}
// draw current selection
sint32 px;
sint32 py;
//
if (_CD.Align.getSInt32() & 1)
{
px = _XReal + _WReal - itemw;
}
else
{
px = _XReal;
}
//
if (_CD.Align.getSInt32() & 2)
{
py = _YReal + _HReal - itemh;
}
else
{
py = _YReal;
}
//
if (_CD.Unrolled.getBool())
{
if (overItem && CWidgetManager::getInstance()->getPointer()->getButtonState() & NLMISC::leftButton)
{
textId = getTexId(_TexsId, selectedTexIndex);
color = getCol(_Col, selectedTexIndex);
}
else
{
textId = getTexId(_TexsPushedId, selectedTexIndex);
color = getCol(_ColPushed, selectedTexIndex);
}
}
else
{
if (over
&& mx >= px
&& my >= py
&& mx < px + (sint32) itemw
&& my < py + (sint32) itemh
)
{
if ( CWidgetManager::getInstance()->getPointer()->getButtonState() & NLMISC::leftButton)
{
textId = getTexId(_TexsPushedId, selectedTexIndex);
color = getCol(_ColPushed, selectedTexIndex);
}
else
{
textId = getTexId(_TexsOverId, selectedTexIndex);
color = getCol(_ColOver, selectedTexIndex);
}
}
else
{
textId = getTexId(_TexsId, selectedTexIndex);
color = getCol(_Col, selectedTexIndex);
}
}
CViewRenderer::getInstance()->drawRotFlipBitmap (_RenderLayer, px, py, itemw, itemh, 0, false,
textId,
color);
}
//=======================================================================================
void CViewBitmapCombo::parseTexList(const std::string &names, TStringArray &dest)
{
static const char sep[] = " ,\t";
std::string::size_type pos = 0, nextPos;
dest.clear();
do
{
nextPos = names.find_first_of(sep, pos);
if (pos != nextPos)
{
dest.push_back(names.substr(pos, nextPos - pos));
}
pos = names.find_first_not_of(sep, nextPos);
}
while (pos != std::string::npos);
}
//=======================================================================================
void CViewBitmapCombo::parseColList(const std::string &names,TColorArray &dest)
{
static const char sep[] = ",\t";
std::string::size_type pos = 0, nextPos;
dest.clear();
std::string col;
do
{
nextPos = names.find_first_of(sep, pos);
if (pos != nextPos)
{
col = names.substr(pos, nextPos - pos);
int r = 0, g = 0, b = 0, a = 255;
sscanf (col.c_str(), "%d %d %d %d", &r, &g, &b, &a);
NLMISC::clamp (r, 0, 255);
NLMISC::clamp (g, 0, 255);
NLMISC::clamp (b, 0, 255);
NLMISC::clamp (a, 0, 255);
dest.push_back(NLMISC::CRGBA((uint8) r, (uint8) g, (uint8) b, (uint8) a));
}
pos = names.find_first_not_of(sep, nextPos);
}
while (pos != std::string::npos);
}
void CViewBitmapCombo::getTexList( const TStringArray &arr, std::string &dest ) const
{
dest.clear();
TStringArray::const_iterator itr;
for( itr = arr.begin(); itr != arr.end(); ++itr )
{
dest += *itr;
dest += " ";
}
}
void CViewBitmapCombo::getColList( const TColorArray &arr, std::string &dest ) const
{
dest.clear();
TColorArray::const_iterator itr;
for( itr = arr.begin(); itr != arr.end(); ++itr )
{
dest += toString( *itr );
dest += " ";
}
}
//=======================================================================================
void CViewBitmapCombo::setupSize()
{
uint w, h;
_CD.getDimensions(w, h);
setW(w);
setH(h);
invalidateCoords();
}
//=======================================================================================
void CViewBitmapCombo::update(ICDBNode * /* leaf */)
{
setupSize();
}
//=======================================================================================
/** copy an array of char * into an array of strings
*/
static void copyStrArrayFromChar(CViewBitmapCombo::TStringArray &dest, const char * const src[], uint numColor)
{
dest.resize(numColor);
for(uint k = 0; k < numColor; ++k)
{
dest[k] = src[k];
}
}
static void copyRGBAVectorFromRGBAArray(CViewBitmapCombo::TColorArray &dest, const NLMISC::CRGBA src[], uint numColor)
{
dest.resize(numColor);
std::copy(src, src + numColor, dest.begin());
}
//=======================================================================================
void CViewBitmapCombo::setTexs(const char * const tex[], uint numTex)
{
copyStrArrayFromChar(_Texs, tex, numTex);
}
//=======================================================================================
void CViewBitmapCombo::setTexsOver(const char * const tex[], uint numTex)
{
copyStrArrayFromChar(_TexsOver, tex, numTex);
}
//=======================================================================================
void CViewBitmapCombo::setTexsPushed(const char * const tex[], uint numTex)
{
copyStrArrayFromChar(_TexsPushed, tex, numTex);
}
//=======================================================================================
void CViewBitmapCombo::setColors(const NLMISC::CRGBA colors[], uint numColors)
{
copyRGBAVectorFromRGBAArray(_Col, colors, numColors);
}
//=======================================================================================
void CViewBitmapCombo::setColorsOver(const NLMISC::CRGBA colors[], uint numColors)
{
copyRGBAVectorFromRGBAArray(_ColOver, colors, numColors);
}
//=======================================================================================
void CViewBitmapCombo::setColorsPushed(const NLMISC::CRGBA colors[], uint numColors)
{
copyRGBAVectorFromRGBAArray(_ColPushed, colors, numColors);
}
}