int PMInsertRuleSystem::canInsert( const PMObject* parentObject,
const QStringList& list,
const PMObject* after )
{
if( list.size( ) == 1 )
{
// more efficient
if( canInsert( parentObject, list.first( ), after ) )
return 1;
else
return 0;
}
// find rules for target class
QPtrList<PMRuleTargetClass> targetClassList;
PMMetaObject* meta = parentObject->metaObject( );
for( ; meta; meta = meta->superClass( ) )
{
PMRuleTargetClass* tc = m_rulesDict.find( meta->className( ) );
if( tc )
targetClassList.append( tc );
}
if( targetClassList.isEmpty( ) )
return 0; // not rules found
// count already inserted children
QPtrListIterator<PMRuleTargetClass> tit( targetClassList );
for( ; tit.current( ); ++tit ) // ... for all target classes
{
QPtrListIterator<PMRule> rit = tit.current( )->rules( );
for( ; rit.current( ); ++rit ) // ... and all rules
{
rit.current( )->reset( );
bool afterInsertPoint = false;
PMObject* o = parentObject->firstChild( );
if( !after )
afterInsertPoint = true;
for( ; o; o = o->nextSibling( ) )
{
rit.current( )->countChild( o->className( ), afterInsertPoint );
if( o == after )
afterInsertPoint = true;
}
}
}
int number = 0;
QStringList::const_iterator oit;
for( oit = list.begin( ); oit != list.end( ); ++oit )
{
bool possible = false;
for( tit.toFirst( ); tit.current( ) && !possible; ++tit )
{
QPtrListIterator<PMRule> rit = tit.current( )->rules( );
for( ; rit.current( ) && !possible; ++rit )
{
PMRule* rule = rit.current( );
if( rule->matches( *oit ) )
possible = rule->evaluate( parentObject );
}
}
if( possible )
{
// object can be inserted, count it
for( ; tit.current( ); ++tit )
{
QPtrListIterator<PMRule> rit = tit.current( )->rules( );
for( ; rit.current( ); ++rit )
rit.current( )->countChild( *oit, false );
}
number++;
}
}
return number;
}
bool PMInsertRuleSystem::canInsert( const PMObject* parentObject,
const QString& className,
const PMObject* after,
const PMObjectList* objectsBetween )
{
bool possible = false;
// find rules for target class
PMMetaObject* meta = parentObject->metaObject( );
for( ; meta && !possible; meta = meta->superClass( ) )
{
PMRuleTargetClass* tc = m_rulesDict.find( meta->className( ) );
if( tc )
{
// check the exception list
QStringList exceptions = tc->exceptions( );
bool exceptionFound = false;
QStringList::ConstIterator it;
for( it = exceptions.begin( );
it != exceptions.end( ) && !exceptionFound; ++it )
if( parentObject->isA( *it ) )
exceptionFound = true;
if( !exceptionFound )
{
QPtrListIterator<PMRule> rit = tc->rules( );
// find matching rules for class name
for( ; rit.current( ) && !possible; ++rit )
{
PMRule* rule = rit.current( );
if( rule->matches( className ) )
{
// matching rule found
// reset the rule
rit.current( )->reset( );
// count already inserted child objects
bool afterInsertPoint = false;
PMObject* o = parentObject->firstChild( );
if( !after )
afterInsertPoint = true;
for( ; o; o = o->nextSibling( ) )
{
rule->countChild( o->className( ), afterInsertPoint );
if( o == after )
afterInsertPoint = true;
}
if( objectsBetween )
{
PMObjectListIterator it( *objectsBetween );
for( ; it.current( ); ++it )
rule->countChild( it.current( )->type( ), false );
}
// evaluate condition value
possible = rule->evaluate( parentObject );
}
}
}
}
}
return possible;
}