mirror of
https://port.numenaute.org/aleajactaest/khanat-opennel-code.git
synced 2024-11-23 07:36:16 +00:00
494 lines
12 KiB
C++
494 lines
12 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/>.
|
|
|
|
/* Copyright, 2000 Nevrax Ltd.
|
|
*
|
|
* This file is part of NEVRAX NEL.
|
|
* NEVRAX NEL is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation; either version 2, or (at your option)
|
|
* any later version.
|
|
|
|
* NEVRAX NEL 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
|
|
* General Public License for more details.
|
|
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with NEVRAX NEL; see the file COPYING. If not, write to the
|
|
* Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
|
|
* MA 02111-1307, USA.
|
|
*/
|
|
|
|
#include "stdgeorgesconvert.h"
|
|
#include "item.h"
|
|
#include "georges_loader.h"
|
|
#include "mold_elt_define.h"
|
|
#include "mold_elt_type.h"
|
|
#include "item_elt_atom.h"
|
|
#include "item_elt_struct.h"
|
|
#include "item_elt_list.h"
|
|
#include "common.h"
|
|
|
|
namespace NLOLDGEORGES
|
|
{
|
|
|
|
//////////////////////////////////////////////////////////////////////
|
|
// Construction/Destruction
|
|
//////////////////////////////////////////////////////////////////////
|
|
|
|
CItem:: CItem()
|
|
{
|
|
pitemes = 0;
|
|
// pitemelparents = 0;
|
|
// pitemeacomments = 0;
|
|
}
|
|
|
|
CItem::~CItem()
|
|
{
|
|
Clear();
|
|
}
|
|
|
|
void CItem::Clear()
|
|
{
|
|
if( pitemes )
|
|
delete( pitemes );
|
|
pitemes = 0;
|
|
vsxparents.clear();
|
|
/*
|
|
if( pitemelparents )
|
|
delete( pitemelparents );
|
|
pitemes = 0;
|
|
if( pitemeacomments )
|
|
delete( pitemeacomments );
|
|
pitemes = 0;
|
|
*/
|
|
}
|
|
|
|
void CItem::SetLoader( CLoader* const _pl )
|
|
{
|
|
nlassert( _pl );
|
|
pl = _pl;
|
|
}
|
|
|
|
void CItem::Load( const CStringEx& _sxfullname )
|
|
{
|
|
Clear();
|
|
|
|
// Load the form
|
|
CForm form, formcurrent, formparent;
|
|
pl->LoadForm( formcurrent, _sxfullname );
|
|
|
|
// Load Parents
|
|
unsigned int i = 0;
|
|
CStringEx sxparent = formcurrent.GetParent( 0 );
|
|
CStringEx sxactivity = formcurrent.GetActivity( 0 );
|
|
while( !sxparent.empty() )
|
|
{
|
|
vsxparents.push_back( std::make_pair( sxactivity, sxparent ) );
|
|
if( sxactivity == "true" )
|
|
{
|
|
pl->LoadSearchForm( form, sxparent );
|
|
formparent += form;
|
|
}
|
|
i++;
|
|
sxparent = formcurrent.GetParent( i );
|
|
sxactivity = formcurrent.GetActivity( i );
|
|
}
|
|
|
|
// Find the name of the dfn file
|
|
int ipos = _sxfullname.reverse_find('.');
|
|
if( ipos == -1 )
|
|
return;
|
|
moldfilename = _sxfullname.get_right(_sxfullname.length()-ipos-1);
|
|
moldfilename += ".dfn";
|
|
|
|
// Load the mold and build the item's tree
|
|
CMoldElt* pme = pl->LoadMold( moldfilename );
|
|
CMoldEltDefine* pmed = dynamic_cast< CMoldEltDefine* >( pme );
|
|
nlassert( pmed );
|
|
pitemes = new CItemEltStruct( pl );
|
|
pitemes->BuildItem( pmed );
|
|
|
|
// Fill the tree with parents' form fields
|
|
pitemes->FillParent( formparent.GetBody() );
|
|
|
|
// Fill the tree with current's form
|
|
pitemes->FillCurrent( formcurrent.GetBody() );
|
|
}
|
|
|
|
// Convert CItem to a CForm (in is this)
|
|
void CItem::MakeForm (CForm &out)
|
|
{
|
|
if( !pitemes )
|
|
return;
|
|
pitemes->BuildForm( out.GetBody(), vsxparents );
|
|
}
|
|
|
|
// Convert CForm to CItem (out is this)
|
|
void CItem::MakeItem (CForm &in)
|
|
{
|
|
CForm form, formparent;
|
|
|
|
Clear();
|
|
unsigned int i = 0;
|
|
CStringEx sxparent = in.GetParent( 0 );
|
|
CStringEx sxactivity = in.GetActivity( 0 );
|
|
while( !sxparent.empty() )
|
|
{
|
|
vsxparents.push_back( std::make_pair( sxactivity, sxparent ) );
|
|
if( sxactivity == "true" )
|
|
{
|
|
pl->LoadSearchForm( form, sxparent );
|
|
formparent += form;
|
|
}
|
|
i++;
|
|
sxparent = in.GetParent( i );
|
|
sxactivity = in.GetActivity( i );
|
|
}
|
|
|
|
CMoldElt* pme = pl->LoadMold( moldfilename );
|
|
CMoldEltDefine* pmed = dynamic_cast< CMoldEltDefine* >( pme );
|
|
nlassert( pmed );
|
|
pitemes = new CItemEltStruct( pl );
|
|
pitemes->BuildItem( pmed );
|
|
|
|
pitemes->FillParent( formparent.GetBody() );
|
|
pitemes->FillCurrent( in.GetBody() );
|
|
}
|
|
|
|
void CItem::VirtualSaveLoad()
|
|
{
|
|
//-------save
|
|
if( !pitemes )
|
|
return;
|
|
CForm form, formcurrent, formparent;
|
|
pitemes->BuildForm( formcurrent.GetBody(), vsxparents );
|
|
//------load
|
|
Clear();
|
|
unsigned int i = 0;
|
|
CStringEx sxparent = formcurrent.GetParent( 0 );
|
|
CStringEx sxactivity = formcurrent.GetActivity( 0 );
|
|
while( !sxparent.empty() )
|
|
{
|
|
vsxparents.push_back( std::make_pair( sxactivity, sxparent ) );
|
|
if( sxactivity == "true" )
|
|
{
|
|
pl->LoadSearchForm( form, sxparent );
|
|
formparent += form;
|
|
}
|
|
i++;
|
|
sxparent = formcurrent.GetParent( i );
|
|
sxactivity = formcurrent.GetActivity( i );
|
|
}
|
|
|
|
CMoldElt* pme = pl->LoadMold( moldfilename );
|
|
CMoldEltDefine* pmed = dynamic_cast< CMoldEltDefine* >( pme );
|
|
nlassert( pmed );
|
|
pitemes = new CItemEltStruct( pl );
|
|
pitemes->BuildItem( pmed );
|
|
|
|
pitemes->FillParent( formparent.GetBody() );
|
|
pitemes->FillCurrent( formcurrent.GetBody() );
|
|
}
|
|
|
|
void CItem::New( const CStringEx& _sxdfnfilename )
|
|
{
|
|
Clear();
|
|
|
|
moldfilename = _sxdfnfilename;
|
|
|
|
CMoldElt* pme = pl->LoadMold( _sxdfnfilename );
|
|
CMoldEltDefine* pmed = dynamic_cast< CMoldEltDefine* >( pme );
|
|
nlassert( pmed );
|
|
pitemes = new CItemEltStruct( pl );
|
|
pitemes->BuildItem( pmed );
|
|
}
|
|
|
|
void CItem::Load( const CStringEx& _sxfilename, const CStringEx _sxdate )
|
|
{
|
|
}
|
|
|
|
void CItem::Save( const CStringEx& _sxfilename )
|
|
{
|
|
if( !pitemes )
|
|
return;
|
|
CForm form;
|
|
pitemes->BuildForm( form.GetBody(), vsxparents );
|
|
pl->SaveForm( form, _sxfilename );
|
|
}
|
|
|
|
CItemElt* CItem::GetElt( const unsigned int _index ) const
|
|
{
|
|
if( pitemes )
|
|
return( pitemes->GetElt( _index ) );
|
|
return( 0 );
|
|
}
|
|
|
|
CItemElt* CItem::GetElt( const CStringEx _sxname ) const
|
|
{
|
|
if( pitemes )
|
|
return( pitemes->GetElt( _sxname ) );
|
|
return( 0 );
|
|
}
|
|
|
|
void CItem::SetCurrentValue( const unsigned int _index, const CStringEx s )
|
|
{
|
|
CItemElt* pie = GetElt( _index );
|
|
if( !pie )
|
|
return;
|
|
pie->SetCurrentValue( s );
|
|
pitemes->SetModified( _index );
|
|
}
|
|
|
|
unsigned int CItem::GetNbElt() const
|
|
{
|
|
if( pitemes )
|
|
return( pitemes->GetNbElt() );
|
|
return( 0 );
|
|
}
|
|
|
|
unsigned int CItem::GetNbParents() const
|
|
{
|
|
return( vsxparents.size() );
|
|
}
|
|
|
|
unsigned int CItem::GetNbElt( const unsigned int _index ) const
|
|
{
|
|
CItemElt* pie = GetElt( _index );
|
|
if( !pie )
|
|
return( 0 );
|
|
return( pie->GetNbElt() );
|
|
}
|
|
|
|
unsigned int CItem::GetInfos( const unsigned int _index ) const
|
|
{
|
|
CItemElt* pie = GetElt( _index );
|
|
if( !pie )
|
|
return( 0 );
|
|
return( pie->GetInfos() );
|
|
}
|
|
|
|
CStringEx CItem::GetName( const unsigned int _index ) const
|
|
{
|
|
|
|
CItemElt* pie = GetElt( _index );
|
|
if( !pie )
|
|
{
|
|
CStringEx object;
|
|
return( object );
|
|
}
|
|
return( pie->GetName() );
|
|
}
|
|
|
|
CStringEx CItem::GetCurrentResult( const unsigned int _index ) const
|
|
{
|
|
CItemElt* pie = GetElt( _index );
|
|
if( !pie )
|
|
{
|
|
CStringEx object;
|
|
return( object );
|
|
}
|
|
return( pie->GetCurrentResult() );
|
|
}
|
|
|
|
CStringEx CItem::GetCurrentValue( const unsigned int _index ) const
|
|
{
|
|
CItemElt* pie = GetElt( _index );
|
|
if( !pie )
|
|
{
|
|
CStringEx object;
|
|
return( object );
|
|
}
|
|
return( pie->GetCurrentValue() );
|
|
}
|
|
|
|
bool CItem::Update()
|
|
{
|
|
if( !pitemes )
|
|
return false;
|
|
bool b = false;
|
|
unsigned int i = 0;
|
|
CItemElt* pie = pitemes->GetElt( i++ );
|
|
while( pie )
|
|
{
|
|
CStringEx sxold = pie->GetCurrentValue();
|
|
pie->SetParentValue( pie->GetParentValue() );
|
|
pie->SetCurrentValue( pie->GetCurrentValue() );
|
|
b |= ( sxold != pie->GetCurrentValue() );
|
|
pie = pitemes->GetElt( i++ );
|
|
}
|
|
return b;
|
|
}
|
|
|
|
CStringEx CItem::GetFormula( const unsigned int _index ) const
|
|
{
|
|
CItemElt* pie = GetElt( _index );
|
|
if( !pie )
|
|
{
|
|
CStringEx object;
|
|
return( object );
|
|
}
|
|
return( pie->GetFormula() );
|
|
}
|
|
|
|
bool CItem::IsEnum( const unsigned int _index ) const
|
|
{
|
|
CItemElt* pie = GetElt( _index );
|
|
if( !pie )
|
|
return( false );
|
|
return( ( pie->GetInfos() & ITEM_ISENUM ) != 0 );
|
|
}
|
|
|
|
bool CItem::IsPredef( const unsigned int _index ) const
|
|
{
|
|
CItemElt* pie = GetElt( _index );
|
|
if( !pie )
|
|
return( false );
|
|
CItemEltAtom* piea = dynamic_cast< CItemEltAtom* >( pie );
|
|
if( !piea )
|
|
return( false );
|
|
CMoldEltType* pmet = piea->GetMoldType();
|
|
CStringEx sx = pmet->GetPredefDesignation( 0 );
|
|
return( !sx.empty() );
|
|
}
|
|
|
|
bool CItem::CanEdit( const unsigned int _index ) const
|
|
{
|
|
CItemElt* pie = GetElt( _index );
|
|
if( !pie )
|
|
return( false );
|
|
CItemEltAtom* piea = dynamic_cast< CItemEltAtom* >( pie );
|
|
if( !piea )
|
|
return( false );
|
|
return( !( pie->GetInfos() & ITEM_ISENUM ) );
|
|
}
|
|
|
|
void CItem::GetListPredef( const unsigned int _index, std::vector< CStringEx >& _vsx ) const
|
|
{
|
|
CItemElt* pie = GetElt( _index );
|
|
if( !pie )
|
|
return;
|
|
CItemEltAtom* piea = dynamic_cast< CItemEltAtom* >( pie );
|
|
if( !piea )
|
|
return;
|
|
|
|
CMoldEltType* pmet = piea->GetMoldType();
|
|
|
|
unsigned int i = 0;
|
|
CStringEx sx = pmet->GetPredefDesignation( i++ );
|
|
while( !sx.empty() )
|
|
{
|
|
_vsx.push_back( sx );
|
|
sx = pmet->GetPredefDesignation( i++ );
|
|
}
|
|
}
|
|
|
|
CStringEx CItem::GetParent( const unsigned int _index ) const
|
|
{
|
|
if( _index >= vsxparents.size() )
|
|
{
|
|
CStringEx object;
|
|
return( object );
|
|
}
|
|
return( vsxparents[_index].second );
|
|
}
|
|
|
|
void CItem::SetParent( const unsigned int _index, const CStringEx _sx )
|
|
{
|
|
if( _index >= vsxparents.size() )
|
|
return;
|
|
vsxparents[_index].second = _sx;
|
|
}
|
|
|
|
CStringEx CItem::GetActivity( const unsigned int _index ) const
|
|
{
|
|
if( _index >= vsxparents.size() )
|
|
{
|
|
CStringEx object;
|
|
return( object );
|
|
}
|
|
return( vsxparents[_index].first );
|
|
}
|
|
|
|
void CItem::SetActivity( const unsigned int _index, const CStringEx _sx )
|
|
{
|
|
if( _index >= vsxparents.size() )
|
|
return;
|
|
vsxparents[_index].first = _sx;
|
|
}
|
|
|
|
void CItem::AddList( const unsigned int _index ) const
|
|
{
|
|
CItemElt* pie = GetElt( _index );
|
|
if( !pie )
|
|
return;
|
|
CItemEltList* piel = dynamic_cast< CItemEltList* >( pie );
|
|
if( !piel )
|
|
return;
|
|
piel->NewElt();
|
|
}
|
|
/*
|
|
void CItem::AddListChild( const unsigned int _index ) const
|
|
{
|
|
CItemElt* pie = GetElt( _index );
|
|
if( !pie )
|
|
return;
|
|
CItemElt* piep = pie->GetListParent();
|
|
if( !piep )
|
|
return;
|
|
CItemEltList* piel = dynamic_cast< CItemEltList* >( piep );
|
|
if( !piel )
|
|
return;
|
|
piel->AddElt( pie );
|
|
}
|
|
*/
|
|
void CItem::DelListChild( const unsigned int _index ) const
|
|
{
|
|
CItemElt* pie = GetElt( _index );
|
|
if( !pie )
|
|
return;
|
|
CItemElt* piep = pie->GetListParent();
|
|
if( !piep )
|
|
return;
|
|
CItemEltList* piel = dynamic_cast< CItemEltList* >( piep );
|
|
if( !piel )
|
|
return;
|
|
piel->DelElt( pie );
|
|
}
|
|
|
|
void CItem::AddParent( const unsigned int _index )
|
|
{
|
|
vsxparents.push_back( std::make_pair( CStringEx("false"), CStringEx("filename.extension") ) );
|
|
}
|
|
|
|
void CItem::DelParent( const unsigned int _index )
|
|
{
|
|
unsigned int i = 0;
|
|
for( std::vector< std::pair< CStringEx, CStringEx > >::iterator it = vsxparents.begin(); it != vsxparents.end(); ++it )
|
|
if( i++ == _index )
|
|
{
|
|
vsxparents.erase( it );
|
|
return;
|
|
}
|
|
}
|
|
|
|
void CItem::ClearParents ()
|
|
{
|
|
vsxparents.clear();
|
|
}
|
|
|
|
}
|