aleajactaest/khanat-opennel-code
1
0
Fork 0
mirror of https://port.numenaute.org/aleajactaest/khanat-opennel-code.git synced 2024-11-19 13:46:13 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions
khanat-opennel-code/code/nel/src/gui/group_paragraph.cpp
dfighter1985 27fe95904a Quelled some compiler compliants. 
--HG--
branch : gsoc2014-dfighter
2014-06-29 03:01:43 +02:00

1477 lines
36 KiB
C++
Raw Blame History

// 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/group_paragraph.h"
#include "nel/gui/group_html.h"
#include "nel/gui/widget_manager.h"
#include "nel/gui/interface_element.h"
#include "nel/gui/view_pointer_base.h"
#include "nel/gui/view_bitmap.h"
#include "nel/gui/view_text_id.h"
#include "nel/gui/group_container.h"
#include "nel/misc/i_xml.h"
#include "nel/misc/i18n.h"
#include "nel/misc/xml_auto_ptr.h"
using namespace std;
using namespace NLMISC;
NLMISC_REGISTER_OBJECT(CViewBase, CCtrlLink, std::string, "button_link");
namespace NLGUI
{
// ----------------------------------------------------------------------------
CGroupParagraph::CGroupParagraph(const TCtorParam &param)
: CInterfaceGroup(param),
_Templ(TCtorParam())
{
_IdCounter = 0;
_AddElt = Bottom;
_Align = Left;
_Space = 0;
_MinW= 0;
_MinH= 0;
_Over = false;
_OverColor = CRGBA(255,255,255,32);
_OverElt = -1;
_LastW = 0;
invalidateContent();
_TopSpace = 0;
_Indent = 0;
_FirstViewIndentView = false;
_BrowseGroup = NULL;
_TextId = 0;
}
// ----------------------------------------------------------------------------
void CGroupParagraph::addChild (CViewBase* child, bool deleteOnRemove)
{
if (!child)
{
nlwarning("<CGroupParagraph::addChild> : tried to add a NULL view");
return;
}
// add child at last index
addChildAtIndex(child, (uint)_Elements.size(), deleteOnRemove);
if (_Elements.size() >= 2)
{
setOrder((uint)_Elements.size() - 1, getOrder((uint)_Elements.size() - 2) + 1);
}
invalidateContent();
}
// ----------------------------------------------------------------------------
CGroupParagraph::~CGroupParagraph()
{
deleteAllChildren();
}
// ----------------------------------------------------------------------------
// Set Hotspot of the first element in reference to the group
/*void CGroupParagraph::setHSGroup (CViewBase *child, EAlign addElt, EAlign align)
{
switch (addElt)
{
case Bottom:
if (align == Left)
{
child->_ParentPosRef = Hotspot_TL;
child->_PosRef = Hotspot_TL;
}
else // align == Right
{
child->_ParentPosRef = Hotspot_TR;
child->_PosRef = Hotspot_TR;
}
break;
case Left:
if (align == Top)
{
child->_ParentPosRef = Hotspot_TR;
child->_PosRef = Hotspot_TR;
}
else // align == Bottom
{
child->_ParentPosRef = Hotspot_BR;
child->_PosRef = Hotspot_BR;
}
break;
case Top:
if (align == Left)
{
child->_ParentPosRef = Hotspot_BL;
child->_PosRef = Hotspot_BL;
}
else // align == Right
{
child->_ParentPosRef = Hotspot_BR;
child->_PosRef = Hotspot_BR;
}
break;
case Right:
if (align == Top)
{
child->_ParentPosRef = Hotspot_TL;
child->_PosRef = Hotspot_TL;
}
else // align == Bottom
{
child->_ParentPosRef = Hotspot_BL;
child->_PosRef = Hotspot_BL;
}
break;
default:
nlassert(false);
break;
}
}*/
// ----------------------------------------------------------------------------
/** align an element towards its parent in the group
*/
/*void CGroupParagraph::setHSParent(CViewBase *view, EAlign addElt, EAlign align, uint space)
{
if ((addElt == Top) || (addElt == Bottom))
{
if (addElt == Bottom)
{
if (_Align == Left)
view->_ParentPosRef = Hotspot_BL;
else // align == Right
view->_ParentPosRef = Hotspot_BR;
view->_Y = -abs(space);
}
else if (addElt == Top)
{
if (_Align == Left)
view->_ParentPosRef = Hotspot_TL;
else // align == Right
view->_ParentPosRef = Hotspot_TR;
view->_Y = abs(space);
}
}
else
{
if (addElt == Left)
{
if (_Align == Top)
view->_ParentPosRef = Hotspot_TL;
else // align == Bottom
view->_ParentPosRef = Hotspot_BL;
view->_X = -abs(space);
}
else if (addElt == Right)
{
if (_Align == Top)
view->_ParentPosRef = Hotspot_TR;
else // align == Bottom
view->_ParentPosRef = Hotspot_BR;
view->_X = abs(space);
}
}
}*/
std::string CGroupParagraph::getProperty( const std::string &name ) const
{
if( name == "addelt" )
{
switch( _AddElt )
{
case Top:
return "T";
case Left:
return "L";
case Right:
return "R";
case Bottom:
return "B";
}
nlassert(false);
return "";
}
else
if( name == "align" )
{
switch( _Align )
{
case Top:
return "T";
case Left:
return "L";
case Right:
return "R";
case Bottom:
return "B";
}
nlassert(false);
return "";
}
else
if( name == "space" )
{
return toString( _Space );
}
else
if( name == "over" )
{
return toString( _Over );
}
else
if( name == "col_over" )
{
return toString( _OverColor );
}
else
if( name == "hardtext" )
{
return _HardText;
}
else
if( name == "textid" )
{
return toString( _TextId );
}
else
return CInterfaceGroup::getProperty( name );
}
void CGroupParagraph::setProperty( const std::string &name, const std::string &value )
{
if( name == "addelt" )
{
if( value == "T" )
_AddElt = Top;
else
if( value == "L" )
_AddElt = Left;
else
if( value == "R" )
_AddElt = Right;
else
if( value == "B" )
_AddElt = Bottom;
setupSizes();
return;
}
else
if( name == "align" )
{
if( value == "T" )
_Align = Top;
else
if( value == "L" )
_Align = Left;
else
if( value == "R" )
_Align = Right;
else
if( value == "B" )
_Align = Bottom;
return;
}
else
if( name == "space" )
{
sint32 i;
if( fromString( value, i ) )
_Space = i;
return;
}
else
if( name == "over" )
{
bool b;
if( fromString( value, b ) )
_Over = b;
return;
}
else
if( name == "col_over" )
{
CRGBA c;
if( fromString( value, c ) )
_OverColor = c;
return;
}
if( name == "hardtext" )
{
_HardText = value;
_TextId = 0;
onTextChanged();
return;
}
else
if( name == "textid" )
{
uint32 i;
if( fromString( value, i ) )
{
_TextId = i;
_HardText = "";
}
onTextChanged();
return;
}
else
CInterfaceGroup::setProperty( name, value );
}
xmlNodePtr CGroupParagraph::serialize( xmlNodePtr parentNode, const char *type ) const
{
xmlNodePtr node = CInterfaceGroup::serialize( parentNode, type );
if( node == NULL )
return NULL;
std::string addelt;
std::string align;
switch( _AddElt )
{
case Top:
addelt = "T";
break;
case Left:
addelt = "L";
break;
case Right:
addelt = "R";
break;
default:
addelt = "B";
break;
}
switch( _Align )
{
case Top:
align = "T";
break;
case Left:
align = "L";
break;
case Right:
align = "R";
break;
default:
align = "B";
break;
}
xmlSetProp( node, BAD_CAST "addelt", BAD_CAST addelt.c_str() );
xmlSetProp( node, BAD_CAST "align", BAD_CAST align.c_str() );
xmlSetProp( node, BAD_CAST "space", BAD_CAST toString( _Space ).c_str() );
xmlSetProp( node, BAD_CAST "over", BAD_CAST toString( _Over ).c_str() );
xmlSetProp( node, BAD_CAST "col_over", BAD_CAST toString( _OverColor ).c_str() );
xmlSetProp( node, BAD_CAST "hardtext", BAD_CAST _HardText.c_str() );
xmlSetProp( node, BAD_CAST "textid", BAD_CAST toString( _TextId ).c_str() );
return node;
}
// ----------------------------------------------------------------------------
bool CGroupParagraph::parse (xmlNodePtr cur, CInterfaceGroup * parentGroup)
{
if (!CInterfaceGroup::parse(cur,parentGroup))
return false;
// Parse location. If these properties are not specified, set them to 0
CXMLAutoPtr ptr((const char*) xmlGetProp( cur, (xmlChar*)"addelt" ));
_AddElt = Bottom;
if (ptr)
{
if (stricmp(ptr,"B") == 0)
_AddElt = Bottom;
else if (stricmp(ptr,"T") == 0)
_AddElt = Top;
else if (stricmp(ptr,"L") == 0)
_AddElt = Left;
else if (stricmp(ptr,"R") == 0)
_AddElt = Right;
}
ptr = (char*) xmlGetProp( cur, (xmlChar*)"align" );
_Align = Left;
if (ptr)
{
if (stricmp(ptr,"B") == 0)
_Align = Bottom;
else if (stricmp(ptr,"T") == 0)
_Align = Top;
else if (stricmp(ptr,"L") == 0)
_Align = Left;
else if (stricmp(ptr,"R") == 0)
_Align = Right;
}
setupSizes();
ptr = (char*) xmlGetProp( cur, (xmlChar*)"space" );
_Space = 0;
if (ptr)
fromString((const char*)ptr, _Space);
ptr = (char*) xmlGetProp( cur, (xmlChar*)"over" );
_Over = false;
if (ptr) _Over = convertBool(ptr);
ptr = (char*) xmlGetProp( cur, (xmlChar*)"col_over" );
_OverColor = CRGBA(255,255,255,32);
if (ptr) _OverColor = convertColor(ptr);
// TEMPLATE TEXT SETUP
// justification parameters
_Templ.parseTextOptions (cur);
// initial text
ptr = (char*) xmlGetProp( cur, (xmlChar*)"hardtext" );
if (ptr)
{
_HardText = std::string( (const char*)ptr );
const char *propPtr = ptr;
ucstring Text = ucstring(propPtr);
if ((strlen(propPtr)>2) && (propPtr[0] == 'u') && (propPtr[1] == 'i'))
Text = CI18N::get (propPtr);
addTextChild(Text);
}
else
{
ptr = (char*) xmlGetProp( cur, (xmlChar*)"textid" );
if (ptr)
{
fromString((const char*)ptr, _TextId );
addTextChildID( _TextId );
}
}
return true;
}
// ----------------------------------------------------------------------------
void CGroupParagraph::addTextChild(const ucstring& line, bool multiLine /*= true*/)
{
const string elid = _Id + ":el" + toString(_IdCounter); ++_IdCounter;
CViewText *view= new CViewText (elid, string(""), _Templ.getFontSize(), _Templ.getColor(), _Templ.getShadow());
view->_Parent = this;
view->setMultiLine (multiLine);
view->setTextMode(_Templ.getTextMode());
if (multiLine) view->setMultiLineSpace (_Space);
view->setText (line);
// Herit global-coloring
view->setModulateGlobalColor(getModulateGlobalColor());
addChild (view);
invalidateCoords();
}
// ----------------------------------------------------------------------------
void CGroupParagraph::addTextChild(const ucstring& line, const CRGBA& textColor, bool multiLine /*= true*/)
{
const string elid = _Id + ":el" + toString(_IdCounter); ++_IdCounter;
CViewText *view= new CViewText (elid, string(""), _Templ.getFontSize(), _Templ.getColor(), _Templ.getShadow());
view->_Parent = this;
view->setMultiLine (multiLine);
if (multiLine) view->setMultiLineSpace (_Space);
view->setText (line);
view->setColor (textColor);
// Herit global-coloring
view->setModulateGlobalColor(getModulateGlobalColor());
addChild (view);
invalidateCoords();
}
// ----------------------------------------------------------------------------
void CGroupParagraph::addTextChildID (uint32 nID, bool multiLine)
{
const string elid = _Id + ":el" + toString(_IdCounter); ++_IdCounter;
CViewTextID *view= new CViewTextID (elid, nID, _Templ.getFontSize(), _Templ.getColor(), _Templ.getShadow());
view->_Parent = this;
view->setMultiLine (multiLine);
if (multiLine) view->setMultiLineSpace (_Space);
// Herit global-coloring
view->setModulateGlobalColor(getModulateGlobalColor());
addChild (view);
invalidateCoords();
}
// ----------------------------------------------------------------------------
void CGroupParagraph::addTextChildID(const std::string &dbPath,bool multiLine /*=true*/)
{
const string elid = _Id + ":el" + toString(_IdCounter); ++_IdCounter;
CViewTextID *view= new CViewTextID (elid, dbPath, _Templ.getFontSize(), _Templ.getColor(), _Templ.getShadow());
view->_Parent = this;
view->setMultiLine (multiLine);
if (multiLine) view->setMultiLineSpace (_Space);
// Herit global-coloring
view->setModulateGlobalColor(getModulateGlobalColor());
addChild (view);
invalidateCoords();
}
// ----------------------------------------------------------------------------
void CGroupParagraph::delChild (CViewBase* childToDel)
{
// Look for child
uint posChildToDel = 0;
for (posChildToDel = 0; posChildToDel < _Elements.size(); ++posChildToDel)
{
CElementInfo rEI = _Elements[posChildToDel];
if (rEI.Element == childToDel)
break;
}
if (posChildToDel == _Elements.size())
{
nlwarning("Can't del child %s, it does not exist in the list", childToDel->getId().c_str());
return;
}
delChild(posChildToDel);
}
// ----------------------------------------------------------------------------
void CGroupParagraph::delChild(uint posChildToDel)
{
if (posChildToDel >= (uint) _Elements.size())
{
nlwarning("<CGroupParagraph::delChild> bad index");
return;
}
CViewBase* childToDel = _Elements[posChildToDel].Element;
bool ElementMustBeDeleted = _Elements[posChildToDel].EltDeleteOnRemove;
_Elements.erase (_Elements.begin()+posChildToDel);
// Remove from drawing
if (dynamic_cast<CInterfaceGroup *>(childToDel)) delGroup(static_cast<CInterfaceGroup *>(childToDel), !ElementMustBeDeleted);
else if (dynamic_cast<CCtrlBase *>(childToDel)) delCtrl(static_cast<CCtrlBase *>(childToDel), !ElementMustBeDeleted);
else delView(childToDel, !ElementMustBeDeleted);
// Bind the new first element
if (posChildToDel < _Elements.size())
{
CViewBase *pVB = _Elements[posChildToDel].Element;
if (posChildToDel == 0)
{
pVB->_ParentPos = NULL;
// setHSGroup (pVB, _AddElt, _Align);
if ((_AddElt == Top) || (_AddElt == Bottom))
pVB->setY (0);
else
pVB->setX (0);
}
else
pVB->_ParentPos = _Elements[posChildToDel-1].Element;
}
}
// ----------------------------------------------------------------------------
/*void CGroupParagraph::removeHead ()
{
if (_Elements.empty())
{
nlwarning("<CGroupParagraph::removeHead> Can't remove head, list is empty");
return;
}
delChild (_Elements.begin()->Element);*/
/*CViewBase *pVB = _Elements.begin()->Element;
if ((_AddElt == Top) || (_AddElt == Bottom))
{
sint32 shift = _H - (pVB->getH() + _Space);
_H = shift;
}
else
{
sint32 shift = _W - (pVB->getW() + _Space);
_W = shift;
}
bool FirstElementMustBeDeleted = _Elements.begin()->EltDeleteOnRemove;
if (FirstElementMustBeDeleted)
delete pVB;
_Elements.erase (_Elements.begin());
// Remove from drawing
for (vector<CInterfaceGroup*>::iterator itg = _ChildrenGroups.begin(); itg != _ChildrenGroups.end(); itg++)
if(*itg == pVB)
{
_ChildrenGroups.erase (itg);
break;
}
for (vector<CCtrlBase*>::iterator itc = _Controls.begin(); itc != _Controls.end(); itc++)
if(*itc == pVB)
{
_Controls.erase (itc);
break;
}
for (vector<CViewBase*>::iterator itv = _Views.begin(); itv != _Views.end(); itv++)
if(*itv == pVB)
{
_Views.erase (itv);
break;
}
delEltOrder (pVB);
// Bind the new first element
pVB = _Elements.begin()->Element;
pVB->_ParentPos = NULL;
setHSGroup (pVB, _AddElt, _Align);
if ((_AddElt == Top) || (_AddElt == Bottom))
pVB->setY (0);
else
pVB->setX (0);*/
//}
// ----------------------------------------------------------------------------
void CGroupParagraph::setTextTemplate(const CViewText& templ)
{
_Templ = templ;
}
// ----------------------------------------------------------------------------
void CGroupParagraph::updateCoords()
{
if (_Parent)
{
if (!_ContentValidated)
{
// Update W
CInterfaceElement::updateCoords();
// Current X and Y
sint32 x=_Indent;
sint32 y=-(sint32)_TopSpace;
// Current W
sint width = std::min(getMaxWReal(), getWReal());
// For each elements, place them
uint firstElementOnLine = 0;
const uint elmCount = (uint)_Elements.size();
uint i;
for (i = 0; i < elmCount+1; ++i)
{
// Force flush for the last element
bool changeLine = (i == elmCount);
uint lastLineElement = i+1;
// Not the end of the element
if (i < elmCount)
{
// Active element ?
if (_Elements[i].Element->getActive())
{
_Elements[i].Element->updateCoords();
// Is a view text ?
CViewText *viewText = dynamic_cast<CViewText*>(_Elements[i].Element);
if (viewText)
{
viewText->setFirstLineX(x + ((i==0)?_FirstViewIndentView:0));
viewText->setX(0);
viewText->updateTextContext();
}
else
{
_Elements[i].Element->setX(x + ((i==0)?_FirstViewIndentView:0));
}
_Elements[i].Element->setPosRef(Hotspot_TL);
_Elements[i].Element->setParentPosRef(Hotspot_TL);
// Update coords for this element
_Elements[i].Element->updateCoords();
// Does we balance the last line height ?
if (viewText)
{
changeLine = viewText->getNumLine() > 1;
if (!viewText->getText().empty() && *(viewText->getText().rbegin()) == (ucchar) '\n')
{
changeLine = true;
}
}
else
{
// If this element is too big for the line, place it next time
if ((i!=firstElementOnLine) && ((_Elements[i].Element->getX() + _Elements[i].Element->getW()) > width))
{
lastLineElement--;
changeLine = true;
i--;
}
}
// New x coordinate
x = _Elements[i].Element->getX() + _Elements[i].Element->getWReal();
}
}
else
lastLineElement = i;
// Balance line height
if (changeLine)
{
// Eval line height
uint j;
uint lineHeight = 0;
uint multiLineHeight = 0;
uint legHeight = 0;
uint lastLineWidth = _Indent;
for (j=firstElementOnLine; j<lastLineElement; j++)
{
// Is a view text ?
uint newHeight;
CViewText *viewTextOnLine = dynamic_cast<CViewText*>(_Elements[j].Element);
// Element height
if (viewTextOnLine)
{
// Height is just under the first line letter
newHeight = viewTextOnLine->getFontHeight() - viewTextOnLine->getFontLegHeight();
// Leg height for this view
legHeight = std::max(legHeight, viewTextOnLine->getFontLegHeight());
// Last element is a text multi line
if (j==(lastLineElement-1))
{
const uint numLine = viewTextOnLine->getNumLine();
if (numLine>1)
{
multiLineHeight = (numLine-2) * viewTextOnLine->getFontHeight() + (numLine-1) * viewTextOnLine->getMultiLineSpace();
lastLineWidth = _Indent + viewTextOnLine->getLastLineW ();
}
}
}
else
{
newHeight = _Elements[j].Element->getH();
CGroupHTMLInputOffset *inputOffset = dynamic_cast<CGroupHTMLInputOffset *>(_Elements[j].Element);
if (inputOffset && inputOffset->Offset < 0)
{
newHeight += inputOffset->Offset;
legHeight = max(-(inputOffset->Offset), sint32(legHeight));
}
}
if (lineHeight < newHeight)
lineHeight = newHeight;
}
// Repos element on the line
for (j=firstElementOnLine; j<lastLineElement; j++)
{
// Is a view text ?
uint newHeight;
CViewText *viewTextOnLine = dynamic_cast<CViewText*>(_Elements[j].Element);
sint32 offsetY=0;
CGroupHTMLInputOffset *inputOffset = dynamic_cast<CGroupHTMLInputOffset *>(_Elements[j].Element);
if (inputOffset)
offsetY = inputOffset->Offset;
// Element height
if (viewTextOnLine)
newHeight = viewTextOnLine->getFontHeight() - viewTextOnLine->getFontLegHeight() - offsetY;
else
newHeight = _Elements[j].Element->getH();
sint32 posY = y-lineHeight+newHeight+offsetY;
_Elements[j].Element->setY(posY);
}
if (i < elmCount)
{
nlassert(lastLineElement>0);
nlassert(lastLineElement-1<elmCount);
x = lastLineWidth;
// Next line
y -= lineHeight + multiLineHeight + legHeight;
}
// New first element
firstElementOnLine = lastLineElement;
}
}
// Update control view
for (i = 0; i<_Links.size(); ++i)
{
// Link
CLink &link = _Links[i];
// Number of link needed
uint links = std::min((uint)3, link.Link->getNumLine());
// Number of line..
uint j;
for (j=0; j<3; j++)
{
if (j<links)
{
// Create the control ?
CCtrlLink *ctrl = link.CtrlLink[j];
if (ctrl == NULL)
{
// Control button
ctrl = new CCtrlLink(CViewBase::TCtorParam());
link.CtrlLink[j] = ctrl;
ctrl->setId(getId()+":"+"links"+toString(i)+"-"+toString(j));
ctrl->setParent (this);
ctrl->setParentSize (this);
ctrl->setParentPos (this);
ctrl->setParentPosRef (Hotspot_TL);
ctrl->setPosRef (Hotspot_TL);
ctrl->setActive(true);
if (_BrowseGroup)
{
ctrl->setActionOnLeftClick("browse");
ctrl->setParamsOnLeftClick("name="+_BrowseGroup->getId()+"|url="+link.Link->Link);
}
ctrl->setScale(true);
addCtrl(ctrl);
}
// Pos the links
int x, y, width, height;
int fontSize = link.Link->getFontHeight();
int fontLineSpace = link.Link->getMultiLineSpace();
// X
x = (j == 0) ? link.Link->getFirstLineX() : link.Link->getX();
// Y
if (j < 2)
y = link.Link->getY() - (fontSize+fontLineSpace) * j;
else
y = link.Link->getY() - ((fontSize+fontLineSpace) * (link.Link->getNumLine()-1));
// Width
// Last line ?
if (j == (links-1))
width = link.Link->getLastLineW ();
else
{
width = link.Link->getW();
// First line ?
if (j == 0)
width -= (link.Link->getFirstLineX() - link.Link->getX());
}
if ((j == 1) && (links==3))
height = (fontSize+fontLineSpace)*(link.Link->getNumLine()-2);
else
height = fontSize;
ctrl->setX(x);
ctrl->setY(y);
ctrl->setW(width);
ctrl->setH(height);
}
else
{
if (link.CtrlLink[j])
{
delCtrl (link.CtrlLink[j]);
link.CtrlLink[j] = NULL;
}
}
}
}
}
}
CInterfaceGroup::updateCoords();
// Validated
_ContentValidated = true;
}
// ----------------------------------------------------------------------------
void CGroupParagraph::checkCoords ()
{
if (_Parent != NULL)
{
sint parentWidth = std::min(_Parent->getMaxWReal(), _Parent->getWReal());
if (_LastW != (sint) parentWidth)
{
CCtrlBase *pCB = CWidgetManager::getInstance()->getCapturePointerLeft();
if (pCB != NULL)
{
CCtrlResizer *pCR = dynamic_cast<CCtrlResizer*>(pCB);
if (pCR != NULL)
{
// We are resizing !!!!
}
else
{
_LastW = parentWidth;
invalidateContent();
}
}
else
{
_LastW = parentWidth;
invalidateContent();
}
}
}
CInterfaceGroup::checkCoords();
}
// ----------------------------------------------------------------------------
void CGroupParagraph::draw ()
{
// TEMP TEMP
//CViewRenderer &rVR = *CViewRenderer::getInstance();
//rVR.drawRotFlipBitmap _RenderLayer, (_XReal, _YReal, _WReal, _HReal, 0, false, rVR.getBlankTextureId(), CRGBA(0,255,0,255) );
if (_Over)
{
CViewRenderer &rVR = *CViewRenderer::getInstance();
if (CWidgetManager::getInstance()->getModalWindow() == NULL)
{
sint32 x = CWidgetManager::getInstance()->getPointer()->getX();
sint32 y = CWidgetManager::getInstance()->getPointer()->getY();
CInterfaceGroup *pIG = CWidgetManager::getInstance()->getWindowUnder(x,y);
CInterfaceGroup *pParent = this;
bool bFound = false;
while (pParent != NULL)
{
if (pParent == pIG)
{
bFound = true;
break;
}
pParent = pParent->getParent();
}
sint32 clipx,clipy,clipw,cliph;
getClip(clipx,clipy,clipw,cliph);
if ((x < clipx) ||
(x > (clipx + clipw)) ||
(y < clipy) ||
(y > (clipy + cliph)) || !bFound)
{
_OverElt = -1;
}
else
{
for (uint32 i = 0; i < _Elements.size(); ++i)
if (_Elements[i].Element->getActive())
{
CViewBase *pVB = _Elements[i].Element;
if ((x >= pVB->getXReal()) &&
(x < (pVB->getXReal() + pVB->getWReal()))&&
(y >= pVB->getYReal()) &&
(y < (pVB->getYReal() + pVB->getHReal())))
{
_OverElt = i;
}
}
}
}
if (_OverElt != -1)
{
CViewBase *pVB = _Elements[_OverElt].Element;
CRGBA col = _OverColor;
if(getModulateGlobalColor())
{
col.modulateFromColor (_OverColor, CWidgetManager::getInstance()->getGlobalColorForContent());
}
else
{
col= _OverColor;
col.A = (uint8)(((sint32)col.A*((sint32)CWidgetManager::getInstance()->getGlobalColorForContent().A+1))>>8);
}
rVR.drawRotFlipBitmap (_RenderLayer, pVB->getXReal(), pVB->getYReal(),
pVB->getWReal(), pVB->getHReal(), 0, false, rVR.getBlankTextureId(),
col );
}
}
CInterfaceGroup::draw ();
}
// ----------------------------------------------------------------------------
bool CGroupParagraph::handleEvent (const NLGUI::CEventDescriptor& event)
{
if (!_Active)
return false;
bool bReturn = CInterfaceGroup::handleEvent(event);
if (event.getType() == NLGUI::CEventDescriptor::mouse)
{
const NLGUI::CEventDescriptorMouse &eventDesc = (const NLGUI::CEventDescriptorMouse &)event;
_OverElt = -1;
if (!isIn(eventDesc.getX(), eventDesc.getY()))
return false;
for (uint32 i = 0; i < _Elements.size(); ++i)
if (_Elements[i].Element->getActive())
{
CViewBase *pVB = _Elements[i].Element;
if ((eventDesc.getX() >= pVB->getXReal()) &&
(eventDesc.getX() < (pVB->getXReal() + pVB->getWReal()))&&
(eventDesc.getY() >= pVB->getYReal()) &&
(eventDesc.getY() < (pVB->getYReal() + pVB->getHReal())))
{
_OverElt = i;
}
}
}
return bReturn;
}
// predicate to remove a view from the list of element
struct CRemoveViewPred
{
bool operator()(const CGroupParagraph::CElementInfo &info) const { return dynamic_cast<CViewBase *>(info.Element) != NULL; }
};
// predicate to remove a ctrl from the list of element
struct CRemoveCtrlPred
{
bool operator()(const CGroupParagraph::CElementInfo &info) const { return dynamic_cast<CCtrlBase *>(info.Element) != NULL; }
};
// predicate to remove a group from the list of element
struct CRemoveGroupPred
{
bool operator()(const CGroupParagraph::CElementInfo &info) const { return dynamic_cast<CInterfaceGroup *>(info.Element) != NULL; }
};
// ----------------------------------------------------------------------------
void CGroupParagraph::clearViews()
{
_IdCounter = 0;
// remove views from the list of elements
_Elements.erase(std::remove_if(_Elements.begin(), _Elements.end(), CRemoveViewPred()), _Elements.end());
CInterfaceGroup::clearViews();
updateCoords();
}
// ----------------------------------------------------------------------------
void CGroupParagraph::clearControls()
{
_IdCounter = 0;
// remove views from the list of elements
_Elements.erase(std::remove_if(_Elements.begin(), _Elements.end(), CRemoveCtrlPred()), _Elements.end());
CInterfaceGroup::clearControls();
updateCoords();
}
// ----------------------------------------------------------------------------
void CGroupParagraph::clearGroups()
{
_IdCounter = 0;
// remove views from the list of elements
_Elements.erase(std::remove_if(_Elements.begin(), _Elements.end(), CRemoveGroupPred()), _Elements.end());
CInterfaceGroup::clearGroups();
updateCoords();
}
// ----------------------------------------------------------------------------
void CGroupParagraph::forceSizeW (sint32 newSizeW)
{
_W = newSizeW;
for (uint32 i = 0; i < _Elements.size(); ++i)
{
_Elements[i].Element->setW (_W);
_Elements[i].Element->CInterfaceElement::updateCoords();
}
}
// ----------------------------------------------------------------------------
void CGroupParagraph::forceSizeH (sint32 newSizeH)
{
_H = newSizeH;
for (uint32 i = 0; i < _Elements.size(); ++i)
{
_Elements[i].Element->setH (_H);
_Elements[i].Element->CInterfaceElement::updateCoords();
}
}
// ----------------------------------------------------------------------------
void CGroupParagraph::setMinW(sint32 minW)
{
_MinW= minW;
invalidateCoords();
}
// ----------------------------------------------------------------------------
void CGroupParagraph::setMinH(sint32 minH)
{
_MinH= minH;
invalidateCoords();
}
// ----------------------------------------------------------------------------
bool CGroupParagraph::addChildAtIndex(CViewBase *child, uint index, bool deleteOnRemove /*=true*/)
{
if (!child)
{
nlwarning("<CGroupParagraph::addChild> : tried to add a NULL view");
return false;
}
if (index > _Elements.size())
{
return false;
}
child->_Parent = this;
child->_ParentPos = NULL;
child->_Active = true;
child->_X = 0;
child->_Y = 0;
child->_RenderLayer = this->_RenderLayer;
// Can't have sizeref on the coordinate corresponding to alignement
switch(_AddElt)
{
case Top:
case Bottom:
child->_SizeRef &= 1; // sizeref on w is permitted
break;
case Left:
case Right:
child->_SizeRef &= 2; // sizeref on h is permitted
break;
default:
nlwarning("<CGroupParagraph::addChild> bad align");
child->_SizeRef = 0;
break;
}
child->_SizeDivW = 10;
child->_SizeDivH = 10;
// Position the element according to the list alignement
// setHSGroup (child, _AddElt, _Align);
// update coords of the element (it may use child_resize_h or w)
//child->updateCoords();
child->invalidateCoords();
// Update size
if ((_AddElt == Top) || (_AddElt == Bottom))
{
// update the list size
sint32 newH = _H + child->getH();
if (_Elements.size() > 0)
newH += _Space;
_H = newH;
if ((_SizeRef&1) == 0) // No parent size reference in W
{
sint32 newW = max (_W, child->getW());
_W = newW;
}
}
else
{
// Update the list coords
sint32 newW = _W + child->getW();
if (_Elements.size() > 0)
newW += _Space;
_W = newW;
if ((_SizeRef&2) == 0) // No parent size reference in H
{
sint32 newH = max (_H, child->getH());
_H = newH;
}
}
CElementInfo ei;
ei.Element = child;
ei.EltDeleteOnRemove = deleteOnRemove;
ei.Order = 0;
if (index != 0)
{
// update alignement
// setHSParent(child, _AddElt, _Align, _Space);
// child->_ParentPos = _Elements[index - 1].Element;
}
_Elements.insert(_Elements.begin() + index, ei);
// link next element to this one
if (index < _Elements.size() - 1)
{
// _Elements[index + 1].Element->_ParentPos = child;
// setHSParent(_Elements[index + 1].Element, _AddElt, _Align, _Space);
}
// Add this element for drawing
{
CInterfaceGroup *pIG = dynamic_cast<CInterfaceGroup*>(child);
if (pIG != NULL)
{
addGroup (pIG, (sint) index);
return true;
}
CCtrlBase *pCB = dynamic_cast<CCtrlBase*>(child);
if (pCB != NULL)
{
addCtrl (pCB, (sint) index);
return true;
}
CViewBase *pVB = dynamic_cast<CViewBase*>(child);
if (pVB != NULL)
{
addView (pVB, (sint) index);
return true;
}
nlstop;
return false;
}
return false;
}
// ----------------------------------------------------------------------------
sint32 CGroupParagraph::getElementIndex(CViewBase* child) const
{
for(uint k = 0; k < _Elements.size(); ++k)
{
if (_Elements[k].Element == child) return k;
}
return -1;
}
// ----------------------------------------------------------------------------
/*void CGroupParagraph::swapChildren(uint index1, uint index2)
{
if (index1 >= _Elements.size()
|| index2 >= _Elements.size())
{
nlwarning("<CGroupParagraph::swapChildren> bad indexes");
return;
}
// prevent elements from being deleted
bool oldMustDelete1 = _Elements[index1].EltDeleteOnRemove;
bool oldMustDelete2 = _Elements[index2].EltDeleteOnRemove;
uint order1 = _Elements[index1].Order;
uint order2 = _Elements[index2].Order;
_Elements[index1].EltDeleteOnRemove = false;
_Elements[index2].EltDeleteOnRemove = false;
CViewBase *v1 = _Elements[index1].Element;
CViewBase *v2 = _Elements[index2].Element;
if (index1 < index2)
{
delChild(index2);
delChild(index1);
addChildAtIndex(v2, index1, oldMustDelete2);
setOrder(index1, order2);
addChildAtIndex(v1, index2, oldMustDelete1);
setOrder(index2, order1);
}
else
{
delChild(index1);
delChild(index2);
addChildAtIndex(v1, index2, oldMustDelete1);
setOrder(index2, order1);
addChildAtIndex(v2, index1, oldMustDelete2);
setOrder(index1, order2);
}
}*/
// ----------------------------------------------------------------------------
void CGroupParagraph::deleteAllChildren()
{
uint numChildren = getNbElement();
for(uint k = 0; k < numChildren; ++k)
{
delChild(numChildren - 1 - k); // delete in reverse order to avoid unnecessary vector copies
}
}
// ----------------------------------------------------------------------------
uint CGroupParagraph::getNumActiveChildren() const
{
uint numChildren = 0;
for(uint k = 0; k < _Elements.size(); ++k)
{
if (_Elements[k].Element->getActive()) ++numChildren;
}
return numChildren;
}
// ----------------------------------------------------------------------------
void CGroupParagraph::setDelOnRemove(uint index, bool delOnRemove)
{
if (index >= _Elements.size())
{
nlwarning("bad index");
return;
}
_Elements[index].EltDeleteOnRemove = delOnRemove;
}
// ----------------------------------------------------------------------------
bool CGroupParagraph::getDelOnRemove(uint index) const
{
if (index >= _Elements.size())
{
nlwarning("bad index");
return false;
}
return _Elements[index].EltDeleteOnRemove;
}
// ----------------------------------------------------------------------------
void CGroupParagraph::addChildLink (CViewLink* child, bool deleteOnRemove)
{
// Add the child
addChild (child, deleteOnRemove);
// Add the link
_Links.push_back (CLink(child));
}
// ----------------------------------------------------------------------------
CGroupParagraph::CLink::CLink (CViewLink *link)
{
Link = link;
CtrlLink[0] = NULL;
CtrlLink[1] = NULL;
CtrlLink[2] = NULL;
}
// ----------------------------------------------------------------------------
void CGroupParagraph::onInvalidateContent()
{
_ContentValidated = false;
invalidateCoords();
}
// ----------------------------------------------------------------------------
sint32 CGroupParagraph::getMaxUsedW() const
{
// The paragraph max is the sum of the components max
sint maxWidth = 0;
for (uint k = 0; k < _Elements.size(); ++k)
{
// Get the child width
maxWidth += _Elements[k].Element->getMaxUsedW();
}
return maxWidth;
}
// ----------------------------------------------------------------------------
sint32 CGroupParagraph::getMinUsedW() const
{
// The paragraph min is the max of the components min
sint32 minWidth = 0;
for (uint k = 0; k < _Elements.size(); ++k)
{
// Get the child width
sint32 width = _Elements[k].Element->getMinUsedW();
if (width > minWidth)
minWidth = width;
}
return minWidth;
}
void CGroupParagraph::setupSizes()
{
EAlign addElt = _AddElt;
_GroupSizeRef = _SizeRef;
if ((addElt == Top) || (addElt == Bottom))
{
setMaxW (_W);
setMaxH(_H);
_H = 0;
_SizeRef = _SizeRef&(~2);
}
else
{
setMaxW (_W);
setMaxH (_H);
_W = 0;
_SizeRef = _SizeRef&(~1);
}
}
void CGroupParagraph::onTextChanged()
{
if( _Elements.size() == 0 )
return;
CElementInfo &e = _Elements[ 0 ];
CViewText *t = dynamic_cast< CViewText* >( e.Element );
if( t != NULL )
{
t->setText( _HardText );
return;
}
else
{
CViewTextID *ti = dynamic_cast< CViewTextID* >( e.Element );
if( ti != NULL )
{
ti->setTextId( _TextId );
}
}
}
}
Reference in a new issue View git blame Copy permalink