QgsComposition* QgsProjectParser::initComposition( const QString& composerTemplate, QgsMapRenderer* mapRenderer, QList< QgsComposerMap*>& mapList, QList< QgsComposerLabel* >& labelList ) const
{
//Create composition from xml
QDomElement composerElem = composerByName( composerTemplate );
if ( composerElem.isNull() )
{
throw QgsMapServiceException( "Error", "Composer template not found" );
}
QDomElement compositionElem = composerElem.firstChildElement( "Composition" );
if ( compositionElem.isNull() )
{
return 0;
}
QgsComposition* composition = new QgsComposition( mapRenderer ); //set resolution, paper size from composer element attributes
if ( !composition->readXML( compositionElem, *mXMLDoc ) )
{
delete composition;
return 0;
}
//go through all the item elements and add them to the composition (and to the lists)
QDomNodeList itemNodes = composerElem.childNodes();
for ( int i = 0; i < itemNodes.size(); ++i )
{
QDomElement currentElem = itemNodes.at( i ).toElement();
QString elemName = currentElem.tagName();
if ( elemName == "ComposerMap" )
{
QgsComposerMap* map = new QgsComposerMap( composition );
map->readXML( currentElem, *mXMLDoc );
composition->addItem( map );
mapList.push_back( map );
}
else if ( elemName == "ComposerLabel" )
{
QgsComposerLabel* label = new QgsComposerLabel( composition );
label->readXML( currentElem, *mXMLDoc );
composition->addItem( label );
labelList.push_back( label );
}
else if ( elemName == "ComposerLegend" )
{
//legend needs to be loaded indirectly to have generic content
//and to avoid usage of x-server with pixmap icons
//read full legend from xml
QgsComposerLegend* legend = new QgsComposerLegend( composition );
legend->readXML( currentElem, *mXMLDoc );
//dynamic legend (would be interesting in case of layers dynamically defined in SLD)
//legend->_readXML( currentElem.firstChildElement( "ComposerItem" ), *mXMLDoc );
//legend->updateLegend();
composition->addItem( legend );
}
else if ( elemName == "ComposerShape" )
{
QgsComposerShape* shape = new QgsComposerShape( composition );
shape->readXML( currentElem, *mXMLDoc );
composition->addItem( shape );
}
else if ( elemName == "ComposerArrow" )
{
QgsComposerArrow* arrow = new QgsComposerArrow( composition );
arrow->readXML( currentElem, *mXMLDoc );
composition->addItem( arrow );
}
else if ( elemName == "ComposerAttributeTable" )
{
QgsComposerAttributeTable* table = new QgsComposerAttributeTable( composition );
table->readXML( currentElem, *mXMLDoc );
composition->addItem( table );
}
}
//scalebars and pictures need to be loaded after the maps to receive the correct size / rotation
for ( int i = 0; i < itemNodes.size(); ++i )
{
QDomElement currentElem = itemNodes.at( i ).toElement();
QString elemName = currentElem.tagName();
if ( elemName == "ComposerPicture" )
{
QgsComposerPicture* picture = new QgsComposerPicture( composition );
picture->readXML( currentElem, *mXMLDoc );
//qgis mapserver needs an absolute file path
picture->setPictureFile( convertToAbsolutePath( picture->pictureFile() ) );
composition->addItem( picture );
}
else if ( elemName == "ComposerScaleBar" )
{
QgsComposerScaleBar* bar = new QgsComposerScaleBar( composition );
bar->readXML( currentElem, *mXMLDoc );
composition->addItem( bar );
}
}
return composition;
}
void QgsComposition::addItemsFromXML( const QDomElement& elem, const QDomDocument& doc, QMap< QgsComposerMap*, int >* mapsToRestore,
bool addUndoCommands, QPointF* pos )
{
QDomNodeList composerLabelList = elem.elementsByTagName( "ComposerLabel" );
for ( int i = 0; i < composerLabelList.size(); ++i )
{
QDomElement currentComposerLabelElem = composerLabelList.at( i ).toElement();
QgsComposerLabel* newLabel = new QgsComposerLabel( this );
newLabel->readXML( currentComposerLabelElem, doc );
if ( pos )
{
newLabel->setItemPosition( pos->x(), pos->y() );
}
addComposerLabel( newLabel );
if ( addUndoCommands )
{
pushAddRemoveCommand( newLabel, tr( "Label added" ) );
}
}
// map
QDomNodeList composerMapList = elem.elementsByTagName( "ComposerMap" );
for ( int i = 0; i < composerMapList.size(); ++i )
{
QDomElement currentComposerMapElem = composerMapList.at( i ).toElement();
QgsComposerMap* newMap = new QgsComposerMap( this );
newMap->readXML( currentComposerMapElem, doc );
newMap->assignFreeId();
if ( mapsToRestore )
{
mapsToRestore->insert( newMap, ( int )( newMap->previewMode() ) );
newMap->setPreviewMode( QgsComposerMap::Rectangle );
}
addComposerMap( newMap, false );
if ( pos )
{
newMap->setItemPosition( pos->x(), pos->y() );
}
if ( addUndoCommands )
{
pushAddRemoveCommand( newMap, tr( "Map added" ) );
}
}
// arrow
QDomNodeList composerArrowList = elem.elementsByTagName( "ComposerArrow" );
for ( int i = 0; i < composerArrowList.size(); ++i )
{
QDomElement currentComposerArrowElem = composerArrowList.at( i ).toElement();
QgsComposerArrow* newArrow = new QgsComposerArrow( this );
newArrow->readXML( currentComposerArrowElem, doc );
if ( pos )
{
newArrow->setItemPosition( pos->x(), pos->y() );
}
addComposerArrow( newArrow );
if ( addUndoCommands )
{
pushAddRemoveCommand( newArrow, tr( "Arrow added" ) );
}
}
// scalebar
QDomNodeList composerScaleBarList = elem.elementsByTagName( "ComposerScaleBar" );
for ( int i = 0; i < composerScaleBarList.size(); ++i )
{
QDomElement currentComposerScaleBarElem = composerScaleBarList.at( i ).toElement();
QgsComposerScaleBar* newScaleBar = new QgsComposerScaleBar( this );
newScaleBar->readXML( currentComposerScaleBarElem, doc );
if ( pos )
{
newScaleBar->setItemPosition( pos->x(), pos->y() );
}
addComposerScaleBar( newScaleBar );
if ( addUndoCommands )
{
pushAddRemoveCommand( newScaleBar, tr( "Scale bar added" ) );
}
}
// shape
QDomNodeList composerShapeList = elem.elementsByTagName( "ComposerShape" );
for ( int i = 0; i < composerShapeList.size(); ++i )
{
QDomElement currentComposerShapeElem = composerShapeList.at( i ).toElement();
QgsComposerShape* newShape = new QgsComposerShape( this );
newShape->readXML( currentComposerShapeElem, doc );
if ( pos )
{
newShape->setItemPosition( pos->x(), pos->y() );
}
addComposerShape( newShape );
if ( addUndoCommands )
{
pushAddRemoveCommand( newShape, tr( "Shape added" ) );
}
}
// picture
QDomNodeList composerPictureList = elem.elementsByTagName( "ComposerPicture" );
for ( int i = 0; i < composerPictureList.size(); ++i )
{
QDomElement currentComposerPictureElem = composerPictureList.at( i ).toElement();
QgsComposerPicture* newPicture = new QgsComposerPicture( this );
newPicture->readXML( currentComposerPictureElem, doc );
if ( pos )
{
newPicture->setItemPosition( pos->x(), pos->y() );
}
addComposerPicture( newPicture );
if ( addUndoCommands )
{
pushAddRemoveCommand( newPicture, tr( "Picture added" ) );
}
}
// legend
QDomNodeList composerLegendList = elem.elementsByTagName( "ComposerLegend" );
for ( int i = 0; i < composerLegendList.size(); ++i )
{
QDomElement currentComposerLegendElem = composerLegendList.at( i ).toElement();
QgsComposerLegend* newLegend = new QgsComposerLegend( this );
newLegend->readXML( currentComposerLegendElem, doc );
if ( pos )
{
newLegend->setItemPosition( pos->x(), pos->y() );
}
addComposerLegend( newLegend );
if ( addUndoCommands )
{
pushAddRemoveCommand( newLegend, tr( "Legend added" ) );
}
}
// table
QDomNodeList composerTableList = elem.elementsByTagName( "ComposerAttributeTable" );
for ( int i = 0; i < composerTableList.size(); ++i )
{
QDomElement currentComposerTableElem = composerTableList.at( i ).toElement();
QgsComposerAttributeTable* newTable = new QgsComposerAttributeTable( this );
newTable->readXML( currentComposerTableElem, doc );
if ( pos )
{
newTable->setItemPosition( pos->x(), pos->y() );
}
addComposerTable( newTable );
if ( addUndoCommands )
{
pushAddRemoveCommand( newTable, tr( "Table added" ) );
}
}
//html
QDomNodeList composerHtmlList = elem.elementsByTagName( "ComposerHtml" );
for ( int i = 0; i < composerHtmlList.size(); ++i )
{
QDomElement currentHtmlElem = composerHtmlList.at( i ).toElement();
QgsComposerHtml* newHtml = new QgsComposerHtml( this, false );
newHtml->readXML( currentHtmlElem, doc );
newHtml->setCreateUndoCommands( true );
this->addMultiFrame( newHtml );
}
}