forms/source/xforms/model_ui.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: model_ui.cxx,v $
  10  * $Revision: 1.7 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_forms.hxx"
  33
  34 #include "model.hxx"
  35 #include "model_helper.hxx"
  36 #include "mip.hxx"
  37 #include "evaluationcontext.hxx"
  38 #include "unohelper.hxx"
  39 #include "submission/serialization_app_xml.hxx"
  40 #include "resourcehelper.hxx"
  41 #include "xmlhelper.hxx"
  42 #include "convert.hxx"
  43
  44 #include <rtl/ustring.hxx>
  45 #include <rtl/ustrbuf.hxx>
  46 #include <tools/debug.hxx>
  47
  48 // UNO classes
  49 #include <com/sun/star/xml/dom/XNode.hpp>
  50 #include <com/sun/star/xml/dom/XDocumentBuilder.hpp>
  51 #include <com/sun/star/xml/dom/XDocumentFragment.hpp>
  52 #include <com/sun/star/xml/dom/XNamedNodeMap.hpp>
  53 #include <com/sun/star/xml/xpath/XXPathObject.hpp>
  54 #include <com/sun/star/xml/xpath/XPathObjectType.hpp>
  55 #include <com/sun/star/beans/PropertyValue.hpp>
  56 #include <com/sun/star/io/XInputStream.hpp>
  57 #include <com/sun/star/io/XActiveDataSink.hpp>
  58 #include <com/sun/star/io/XTextInputStream.hpp>
  59 #include <com/sun/star/container/XEnumeration.hpp>
  60 #include <com/sun/star/container/XNameContainer.hpp>
  61 #include <com/sun/star/frame/XModel.hpp>
  62 #include <com/sun/star/xforms/XFormsSupplier.hpp>
  63 #include <com/sun/star/xforms/XDataTypeRepository.hpp>
  64 #include <com/sun/star/xsd/XDataType.hpp>
  65 #include <com/sun/star/xsd/DataTypeClass.hpp>
  66
  67
  68 using rtl::OUString;
  69 using rtl::OUStringBuffer;
  70 using com::sun::star::beans::PropertyValue;
  71 using com::sun::star::io::XInputStream;
  72 using com::sun::star::io::XActiveDataSink;
  73 using com::sun::star::io::XTextInputStream;
  74 using com::sun::star::container::XEnumeration;
  75 using com::sun::star::container::XNameContainer;
  76 using com::sun::star::xforms::XFormsSupplier;
  77
  78 using namespace xforms;
  79 using namespace com::sun::star::uno;
  80 using namespace com::sun::star::xml::dom;
  81 using namespace com::sun::star::xml::xpath;
  82
  83
  84
  85 //
  86 // implement XFormsUIHelper1
  87 //
  88
  89 OUString Model::getDefaultServiceNameForNode( const XNode_t& xNode )
  90     throw( RuntimeException )
  91 {
  92     // determine service for control. string/text field is default.
  93     OUString sService = OUSTRING("com.sun.star.form.component.TextField");
  94
  95     // query repository for suitable type
  96     OSL_ENSURE( mxDataTypes.is(), "no type repository?" );
  97     OUString sTypeName = queryMIP( xNode ).getTypeName();
  98     if( mxDataTypes->hasByName( sTypeName ) )
  99     {
 100         OSL_ENSURE( mxDataTypes->getDataType( sTypeName ).is(),
 101                     "has or has not?" );
 102
 103         switch( mxDataTypes->getDataType( sTypeName )->getTypeClass() )
 104         {
 105         case com::sun::star::xsd::DataTypeClass::BOOLEAN:
 106             sService = OUSTRING("com.sun.star.form.component.CheckBox");
 107             break;
 108         case com::sun::star::xsd::DataTypeClass::DOUBLE:
 109         case com::sun::star::xsd::DataTypeClass::DECIMAL:
 110         case com::sun::star::xsd::DataTypeClass::FLOAT:
 111             sService = OUSTRING("com.sun.star.form.component.NumericField");
 112             break;
 113
 114         case com::sun::star::xsd::DataTypeClass::STRING:
 115         case com::sun::star::xsd::DataTypeClass::DURATION:
 116         case com::sun::star::xsd::DataTypeClass::DATETIME:
 117         case com::sun::star::xsd::DataTypeClass::TIME:
 118         case com::sun::star::xsd::DataTypeClass::DATE:
 119         case com::sun::star::xsd::DataTypeClass::gYearMonth:
 120         case com::sun::star::xsd::DataTypeClass::gYear:
 121         case com::sun::star::xsd::DataTypeClass::gMonthDay:
 122         case com::sun::star::xsd::DataTypeClass::gDay:
 123         case com::sun::star::xsd::DataTypeClass::gMonth:
 124         case com::sun::star::xsd::DataTypeClass::hexBinary:
 125         case com::sun::star::xsd::DataTypeClass::base64Binary:
 126         case com::sun::star::xsd::DataTypeClass::anyURI:
 127         case com::sun::star::xsd::DataTypeClass::QName:
 128         case com::sun::star::xsd::DataTypeClass::NOTATION:
 129         default:
 130             // keep default
 131             break;
 132         }
 133     }
 134
 135     return sService;
 136 }
 137
 138
 139 void lcl_OutPosition( OUStringBuffer& rBuffer,
 140                       const Reference<XNode>& xNode )
 141 {
 142     OSL_ENSURE( xNode->getParentNode().is(), "need parent" );
 143
 144     // count # of occurences of this node
 145     sal_Int32 nFound = 0;
 146     sal_Int32 nPosition = -1;
 147     if( xNode->getParentNode().is() )
 148     {
 149         for( Reference<XNode> xIter = xNode->getParentNode()->getFirstChild();
 150              xIter != NULL;
 151              xIter = xIter->getNextSibling() )
 152         {
 153             if( xIter->getNodeType() == xNode->getNodeType() &&
 154                 xIter->getNodeName() == xNode->getNodeName() &&
 155                 xIter->getNamespaceURI() == xNode->getNamespaceURI() )
 156             {
 157                 nFound++;
 158                 if( xIter == xNode )
 159                     nPosition = nFound;
 160             }
 161         }
 162     }
 163     OSL_ENSURE( nFound > 0  &&  nPosition > 0, "node not found???" );
 164
 165     // output position (if necessary)
 166     if( nFound > 1 )
 167     {
 168         rBuffer.insert( 0, sal_Unicode(']') );
 169         rBuffer.insert( 0, nPosition );
 170         rBuffer.insert( 0, sal_Unicode('[') );
 171     }
 172 }
 173
 174 void lcl_OutName( OUStringBuffer& rBuffer,
 175                   const Reference<XNode>& xNode )
 176 {
 177     rBuffer.insert( 0, xNode->getNodeName() );
 178     OUString sPrefix = xNode->getPrefix();
 179     if( sPrefix.getLength() > 0 )
 180     {
 181         rBuffer.insert( 0, sal_Unicode(':') );
 182         rBuffer.insert( 0, sPrefix );
 183     }
 184 }
 185
 186 void lcl_OutInstance( OUStringBuffer& rBuffer,
 187                       const Reference<XNode>& xNode,
 188                       Model* pModel )
 189 {
 190     Reference<XDocument> xDoc = xNode->getOwnerDocument();
 191
 192     if( xDoc != pModel->getDefaultInstance() )
 193     {
 194         rBuffer.insert( 0, OUSTRING("')") );
 195
 196         // iterate over instances, and find the right one
 197         OUString sInstanceName;
 198         Reference<XEnumeration> xEnum =
 199             pModel->getInstances()->createEnumeration();
 200         while( ( sInstanceName.getLength() == 0 ) && xEnum->hasMoreElements() )
 201         {
 202             Sequence<PropertyValue> aValues;
 203             xEnum->nextElement() >>= aValues;
 204
 205             // get ID and instance
 206             OUString sId;
 207             Reference<XDocument> xInstance;
 208             getInstanceData( aValues, &sId, &xInstance, NULL, NULL );
 209
 210             // now check whether this was our instance:
 211             if( xInstance == xDoc )
 212                 sInstanceName = sId;
 213         }
 214
 215         rBuffer.insert( 0, sInstanceName );
 216         rBuffer.insert( 0, OUSTRING("instance('") );
 217     }
 218 }
 219
 220 OUString Model::getDefaultBindingExpressionForNode(
 221     const XNode_t& xNode,
 222     const EvaluationContext& rContext)
 223 {
 224     OSL_ENSURE( xNode.is(), "need node" );
 225
 226     // iterate upwards and put sections into the expression buffer.
 227     // Stop iteration either at context node (relative expression) or
 228     // at document root, whichever occurs first.
 229     OUStringBuffer aBuffer;
 230     for( Reference<XNode> xCurrent = xNode;
 231          xCurrent.is()  &&  xCurrent != rContext.mxContextNode;
 232          xCurrent = xCurrent->getParentNode() )
 233     {
 234         // insert a '/' for every step except the first
 235         if( aBuffer.getLength() > 0 )
 236             aBuffer.insert( 0, sal_Unicode('/') );
 237
 238         switch( xCurrent->getNodeType() )
 239         {
 240         case NodeType_ELEMENT_NODE:
 241             lcl_OutPosition( aBuffer, xCurrent );
 242             lcl_OutName( aBuffer, xCurrent );
 243             break;
 244
 245         case NodeType_TEXT_NODE:
 246             lcl_OutPosition( aBuffer, xCurrent );
 247             aBuffer.insert( 0, OUSTRING("text()") );
 248             break;
 249
 250         case NodeType_ATTRIBUTE_NODE:
 251             lcl_OutName( aBuffer, xCurrent );
 252             aBuffer.insert( 0, sal_Unicode('@') );
 253             break;
 254
 255         case NodeType_DOCUMENT_NODE:
 256             // check for which instance we have
 257             lcl_OutInstance( aBuffer, xCurrent, this );
 258             break;
 259
 260         default:
 261             // unknown type? fail!
 262             OSL_ENSURE( false, "unknown node type!" );
 263             xCurrent.set( NULL );
 264             aBuffer.makeStringAndClear();
 265             // we'll remove the slash below
 266             aBuffer.insert( 0, sal_Unicode('/') );
 267             break;
 268         }
 269     }
 270
 271     return aBuffer.makeStringAndClear();
 272 }
 273
 274
 275
 276 OUString Model::getDefaultBindingExpressionForNode( const XNode_t& xNode )
 277     throw( RuntimeException )
 278 {
 279     return getDefaultBindingExpressionForNode( xNode, getEvaluationContext() );
 280 }
 281
 282 bool lcl_isWhitespace( const OUString& rString )
 283 {
 284     sal_Int32 nLength = rString.getLength();
 285     const sal_Unicode* pStr = rString.getStr();
 286
 287     bool bWhitespace = true;
 288     for( sal_Int32 i = 0; bWhitespace && ( i < nLength ); i++ )
 289     {
 290         sal_Unicode c = pStr[i];
 291         bWhitespace = ( c == sal_Unicode(0x09) ||
 292                         c == sal_Unicode(0x0A) ||
 293                         c == sal_Unicode(0x0D) ||
 294                         c == sal_Unicode(0x20) );
 295     }
 296     return bWhitespace;
 297 }
 298
 299 OUString Model::getNodeDisplayName( const XNode_t& xNode,
 300                                     sal_Bool bDetail )
 301     throw( RuntimeException )
 302 {
 303     OUStringBuffer aBuffer;
 304
 305     switch( xNode->getNodeType() )
 306     {
 307     case NodeType_ELEMENT_NODE:
 308         lcl_OutName( aBuffer, xNode );
 309         break;
 310
 311     case NodeType_TEXT_NODE:
 312         {
 313             OUString sContent = xNode->getNodeValue();
 314             if( bDetail || ! lcl_isWhitespace( sContent ) )
 315             {
 316                 aBuffer.append( sal_Unicode('"') );
 317                 aBuffer.append( Convert::collapseWhitespace( sContent ) );
 318                 aBuffer.append( sal_Unicode('"') );
 319             }
 320         }
 321         break;
 322
 323     case NodeType_ATTRIBUTE_NODE:
 324         lcl_OutName( aBuffer, xNode );
 325         aBuffer.insert( 0, sal_Unicode('@') );
 326         break;
 327
 328     case NodeType_DOCUMENT_NODE:
 329         if( xNode == getDefaultInstance() )
 330             aBuffer.append( sal_Unicode('/') );
 331         else
 332             lcl_OutInstance( aBuffer, xNode, this );
 333         break;
 334
 335     default:
 336         // unknown type? fail!
 337         OSL_ENSURE( false, "unknown node type!" );
 338         break;
 339     }
 340
 341     return aBuffer.makeStringAndClear();
 342 }
 343
 344 OUString Model::getNodeName( const XNode_t& xNode )
 345     throw( RuntimeException )
 346 {
 347     OUStringBuffer aBuffer;
 348
 349     switch( xNode->getNodeType() )
 350     {
 351     case NodeType_ELEMENT_NODE:
 352     case NodeType_ATTRIBUTE_NODE:
 353         lcl_OutName( aBuffer, xNode );
 354         break;
 355
 356     case NodeType_TEXT_NODE:
 357     case NodeType_DOCUMENT_NODE:
 358     default:
 359         // unknown type? fail!
 360         OSL_ENSURE( false, "no name for this node type!" );
 361         break;
 362     }
 363
 364     return aBuffer.makeStringAndClear();
 365 }
 366
 367 OUString Model::getBindingName( const XPropertySet_t& xBinding,
 368                                 sal_Bool /*bDetail*/ )
 369     throw( RuntimeException )
 370 {
 371     OUString sID;
 372     xBinding->getPropertyValue( OUSTRING("BindingID" ) ) >>= sID;
 373     OUString sExpression;
 374     xBinding->getPropertyValue( OUSTRING("BindingExpression" ) ) >>= sExpression;
 375
 376     OUStringBuffer aBuffer;
 377     if( sID.getLength() > 0 )
 378     {
 379         aBuffer.append( sID );
 380         aBuffer.append( OUSTRING(" (" ));
 381         aBuffer.append( sExpression );
 382         aBuffer.append( OUSTRING(")" ));
 383     }
 384     else
 385         aBuffer.append( sExpression );
 386
 387     return aBuffer.makeStringAndClear();
 388 }
 389
 390 OUString Model::getSubmissionName( const XPropertySet_t& xSubmission,
 391                                    sal_Bool /*bDetail*/ )
 392     throw( RuntimeException )
 393 {
 394     OUString sID;
 395     xSubmission->getPropertyValue( OUSTRING("ID") ) >>= sID;
 396     return sID;
 397 }
 398
 399 Model::XPropertySet_t Model::cloneBindingAsGhost( const XPropertySet_t &xBinding )
 400     throw( RuntimeException )
 401 {
 402     // Create a new binding instance first...
 403     Binding *pBinding = new Binding();
 404
 405     // ...and bump up the "defered notification counter"
 406     // to prevent this binding from contributing to the
 407     // MIPs table...
 408     pBinding->deferNotifications(true);
 409
 410     // Copy the propertyset and return result...
 411     XPropertySet_t xNewBinding(pBinding);
 412     copy( xBinding, xNewBinding );
 413     return xNewBinding;
 414 }
 415
 416 void Model::removeBindingIfUseless( const XPropertySet_t& xBinding )
 417     throw( RuntimeException )
 418 {
 419     Binding* pBinding = Binding::getBinding( xBinding );
 420     if( pBinding != NULL )
 421     {
 422         if( ! pBinding->isUseful() )
 423             mpBindings->removeItem( pBinding );
 424     }
 425 }
 426
 427 Model::XDocument_t Model::newInstance( const rtl::OUString& sName,
 428                          const rtl::OUString& sURL,
 429                          sal_Bool bURLOnce )
 430     throw( RuntimeException )
 431 {
 432     // create a default instance with <instanceData> element
 433     XDocument_t xInstance = getDocumentBuilder()->newDocument();
 434     DBG_ASSERT( xInstance.is(), "failed to create DOM instance" );
 435
 436     Reference<XNode>( xInstance, UNO_QUERY_THROW )->appendChild(
 437         Reference<XNode>( xInstance->createElement( OUSTRING("instanceData") ),
 438                           UNO_QUERY_THROW ) );
 439
 440     Sequence<PropertyValue> aSequence;
 441     bool bOnce = bURLOnce; // bool, so we can take address in setInstanceData
 442     setInstanceData( aSequence, &sName, &xInstance, &sURL, &bOnce );
 443     sal_Int32 nInstance = mpInstances->addItem( aSequence );
 444     loadInstance( nInstance );
 445
 446     return xInstance;
 447 }
 448
 449 sal_Int32 lcl_findProp( const PropertyValue* pValues,
 450                         sal_Int32 nLength,
 451                         const rtl::OUString& rName )
 452 {
 453     bool bFound = false;
 454     sal_Int32 n = 0;
 455     for( ; !bFound && n < nLength; n++ )
 456     {
 457         bFound = ( pValues[n].Name == rName );
 458     }
 459     return bFound ? ( n - 1) : -1;
 460 }
 461
 462 sal_Int32 xforms::lcl_findInstance( const InstanceCollection* pInstances,
 463                                     const rtl::OUString& rName )
 464 {
 465     sal_Int32 nLength = pInstances->countItems();
 466     sal_Int32 n = 0;
 467     bool bFound = false;
 468     for( ; !bFound  &&  n < nLength; n++ )
 469     {
 470         OUString sName;
 471         getInstanceData( pInstances->getItem( n ), &sName, NULL, NULL, NULL );
 472         bFound = ( sName == rName );
 473     }
 474     return bFound ? ( n - 1 ) : -1;
 475 }
 476
 477 void Model::renameInstance( const rtl::OUString& sFrom,
 478                             const rtl::OUString& sTo,
 479                             const rtl::OUString& sURL,
 480                             sal_Bool bURLOnce )
 481     throw( RuntimeException )
 482 {
 483     sal_Int32 nPos = lcl_findInstance( mpInstances, sFrom );
 484     if( nPos != -1 )
 485     {
 486         Sequence<PropertyValue> aSeq = mpInstances->getItem( nPos );
 487         PropertyValue* pSeq = aSeq.getArray();
 488         sal_Int32 nLength = aSeq.getLength();
 489
 490         sal_Int32 nProp = lcl_findProp( pSeq, nLength, OUSTRING("ID") );
 491         if( nProp == -1 )
 492         {
 493             // add name property
 494             aSeq.realloc( nLength + 1 );
 495             pSeq = aSeq.getArray();
 496             pSeq[ nLength ].Name = OUSTRING("ID");
 497             nProp = nLength;
 498         }
 499
 500         // change name
 501         pSeq[ nProp ].Value <<= sTo;
 502
 503         // change url
 504         nProp = lcl_findProp( pSeq, nLength, OUSTRING("URL") );
 505         if(nProp != -1)
 506             pSeq[ nProp ].Value <<= sURL;
 507
 508         // change urlonce
 509         nProp = lcl_findProp( pSeq, nLength, OUSTRING("URLOnce") );
 510         if(nProp != -1)
 511             pSeq[ nProp ].Value <<= bURLOnce;
 512
 513         // set instance
 514         mpInstances->setItem( nPos, aSeq );
 515     }
 516 }
 517
 518 void Model::removeInstance( const rtl::OUString& sName )
 519     throw( RuntimeException )
 520 {
 521     sal_Int32 nPos = lcl_findInstance( mpInstances, sName );
 522     if( nPos != -1 )
 523         mpInstances->removeItem( mpInstances->getItem( nPos ) );
 524 }
 525
 526 Reference<XNameContainer> lcl_getModels(
 527     const Reference<com::sun::star::frame::XModel>& xComponent )
 528 {
 529     Reference<XNameContainer> xRet;
 530     Reference<XFormsSupplier> xSupplier( xComponent, UNO_QUERY );
 531     if( xSupplier.is() )
 532     {
 533         xRet = xSupplier->getXForms();
 534     }
 535     return xRet;
 536 }
 537
 538 Model::XModel_t Model::newModel( const Reference<com::sun::star::frame::XModel>& xCmp,
 539                                  const OUString& sName )
 540     throw( RuntimeException )
 541 {
 542     Model::XModel_t xModel;
 543     Reference<XNameContainer> xModels = lcl_getModels( xCmp );
 544     if( xModels.is()
 545         && ! xModels->hasByName( sName ) )
 546     {
 547         Model* pModel = new Model();
 548         xModel.set( pModel );
 549
 550         pModel->setID( sName );
 551         pModel->newInstance( OUString(), OUString(), sal_False );
 552         pModel->initialize();
 553         xModels->insertByName( sName, makeAny( xModel ) );
 554     }
 555
 556     return xModel;
 557 }
 558
 559 void Model::renameModel( const Reference<com::sun::star::frame::XModel>& xCmp,
 560                          const OUString& sFrom,
 561                          const OUString& sTo )
 562     throw( RuntimeException )
 563 {
 564     Reference<XNameContainer> xModels = lcl_getModels( xCmp );
 565     if( xModels.is()
 566         && xModels->hasByName( sFrom )
 567         && ! xModels->hasByName( sTo ) )
 568     {
 569         Reference<XModel> xModel( xModels->getByName( sFrom ), UNO_QUERY );
 570         xModel->setID( sTo );
 571         xModels->insertByName( sTo, makeAny( xModel ) );
 572         xModels->removeByName( sFrom );
 573     }
 574 }
 575
 576 void Model::removeModel( const Reference<com::sun::star::frame::XModel>& xCmp,
 577                          const OUString& sName )
 578     throw( RuntimeException )
 579 {
 580     Reference<XNameContainer> xModels = lcl_getModels( xCmp );
 581     if( xModels.is()
 582         && xModels->hasByName( sName ) )
 583     {
 584         xModels->removeByName( sName );
 585     }
 586 }
 587
 588 Model::XNode_t Model::createElement( const XNode_t& xParent,
 589                                      const OUString& sName )
 590     throw( RuntimeException )
 591 {
 592     Reference<XNode> xNode;
 593     if( xParent.is()
 594         && isValidXMLName( sName ) )
 595     {
 596         // TODO: implement proper namespace handling
 597         xNode.set( xParent->getOwnerDocument()->createElement( sName ),
 598                    UNO_QUERY );
 599     }
 600     return xNode;
 601 }
 602
 603 Model::XNode_t Model::createAttribute( const XNode_t& xParent,
 604                                        const OUString& sName )
 605     throw( RuntimeException )
 606 {
 607     Reference<XNode> xNode;
 608     Reference<XElement> xElement( xParent, UNO_QUERY );
 609     if( xParent.is()
 610         && xElement.is()
 611         && isValidXMLName( sName ) )
 612     {
 613         // handle case where attribute already exists
 614         sal_Int32 nCount = 0;
 615         OUString sUniqueName = sName;
 616         while( xElement->hasAttribute( sUniqueName ) )
 617         {
 618             nCount++;
 619             sUniqueName = sName + OUString::valueOf( nCount );
 620         }
 621
 622         // TODO: implement proper namespace handling
 623         xNode.set( xParent->getOwnerDocument()->createAttribute( sUniqueName ),
 624                    UNO_QUERY );
 625     }
 626     return xNode;
 627 }
 628
 629 Model::XNode_t Model::renameNode( const XNode_t& xNode,
 630                                   const rtl::OUString& sName )
 631     throw( RuntimeException )
 632 {
 633     // early out if we don't have to change the name
 634     if( xNode->getNodeName() == sName )
 635         return xNode;
 636
 637     // refuse to change name if its an attribute, and the name is already used
 638     if( xNode->getNodeType() == NodeType_ATTRIBUTE_NODE
 639         && xNode->getParentNode().is()
 640         && Reference<XElement>(xNode->getParentNode(), UNO_QUERY_THROW)->hasAttribute( sName ) )
 641         return xNode;
 642
 643     // note old binding expression so we can adjust bindings below
 644     OUString sOldDefaultBindingExpression =
 645         getDefaultBindingExpressionForNode( xNode );
 646
 647     Reference<XDocument> xDoc = xNode->getOwnerDocument();
 648     Reference<XNode> xNew;
 649     if( xNode->getNodeType() == NodeType_ELEMENT_NODE )
 650     {
 651         Reference<XElement> xElem = xDoc->createElement( sName );
 652         xNew.set( xElem, UNO_QUERY );
 653
 654         // iterate over all attributes and append them to the new element
 655         Reference<XElement> xOldElem( xNode, UNO_QUERY );
 656         OSL_ENSURE( xNode.is(), "no element?" );
 657
 658         Reference<XNamedNodeMap> xMap = xNode->getAttributes();
 659         sal_Int32 nLength = xMap.is() ? xMap->getLength() : 0;
 660         for( sal_Int32 n = 0; n < nLength; n++ )
 661         {
 662             Reference<XAttr> xAttr( xMap->item(n), UNO_QUERY );
 663             xElem->setAttributeNode( xOldElem->removeAttributeNode( xAttr ) );
 664         }
 665
 666         // iterate over all children and append them to the new element
 667         for( Reference<XNode> xCurrent = xNode->getFirstChild();
 668              xCurrent.is();
 669              xCurrent = xNode->getFirstChild() )
 670         {
 671             xNew->appendChild( xNode->removeChild( xCurrent ) );
 672         }
 673
 674         xNode->getParentNode()->replaceChild( xNew, xNode );
 675     }
 676     else if( xNode->getNodeType() == NodeType_ATTRIBUTE_NODE )
 677     {
 678         // create new attribute
 679         Reference<XAttr> xAttr = xDoc->createAttribute( sName );
 680         xAttr->setValue( xNode->getNodeValue() );
 681
 682         // replace node
 683         Reference<XNode> xParent = xNode->getParentNode();
 684         xParent->removeChild( xNode );
 685         xNew = xParent->appendChild( Reference<XNode>( xAttr, UNO_QUERY ) );
 686     }
 687     else
 688     {
 689         OSL_ENSURE( false, "can't rename this node type" );
 690     }
 691
 692     // adjust bindings (if necessary):
 693     if( xNew.is() )
 694     {
 695         // iterate over bindings and replace default expressions
 696         OUString sNewDefaultBindingExpression =
 697             getDefaultBindingExpressionForNode( xNew );
 698         for( sal_Int32 n = 0; n < mpBindings->countItems(); n++ )
 699         {
 700             Binding* pBinding = Binding::getBinding(
 701                 mpBindings->Collection<XPropertySet_t>::getItem( n ) );
 702
 703             if( pBinding->getBindingExpression()
 704                     == sOldDefaultBindingExpression )
 705                 pBinding->setBindingExpression( sNewDefaultBindingExpression );
 706         }
 707     }
 708
 709     // return node; return old node if renaming failed
 710     return xNew.is() ? xNew : xNode;
 711 }
 712
 713 Model::XPropertySet_t Model::getBindingForNode( const XNode_t& xNode,
 714                                                 sal_Bool bCreate )
 715     throw( RuntimeException )
 716 {
 717     OSL_ENSURE( xNode.is(), "no node?" );
 718
 719     // We will iterate over all bindings and determine the
 720     // appropriateness of the respective binding for this node. The
 721     // best one will be used. If we don't find any and bCreate is set,
 722     // then we will create a suitable binding.
 723     Binding* pBestBinding = NULL;
 724     sal_Int32 nBestScore = 0;
 725
 726     for( sal_Int32 n = 0; n < mpBindings->countItems(); n++ )
 727     {
 728         Binding* pBinding = Binding::getBinding(
 729             mpBindings->Collection<XPropertySet_t>::getItem( n ) );
 730
 731         OSL_ENSURE( pBinding != NULL, "no binding?" );
 732         Reference<XNodeList> xNodeList = pBinding->getXNodeList();
 733
 734         sal_Int32 nNodes = xNodeList.is() ? xNodeList->getLength() : 0;
 735         if( nNodes > 0  &&  xNodeList->item( 0 ) == xNode )
 736         {
 737             // allright, we found a suitable node. Let's determine how
 738             // well it fits. Score:
 739             // - bind to exactly this node is better than whole nodeset
 740             // - simple binding expressions is better than complex ones
 741             sal_Int32 nScore = 0;
 742             if( nNodes == 1 )
 743                 nScore ++;
 744             if( pBinding->isSimpleBindingExpression() )
 745                 nScore ++;
 746
 747             // if we found a better binding, remember it
 748             if( nScore > nBestScore )
 749             {
 750                 pBestBinding = pBinding;
 751                 nBestScore = nScore;
 752             }
 753         }
 754     }
 755
 756     // create binding, if none was found and bCreate is set
 757     OSL_ENSURE( ( nBestScore == 0 ) == ( pBestBinding == NULL ),
 758                 "score != binding?" );
 759     if( bCreate  &&  pBestBinding == NULL )
 760     {
 761         pBestBinding = new Binding();
 762         pBestBinding->setBindingExpression(
 763             getDefaultBindingExpressionForNode( xNode ) );
 764         mpBindings->addItem( pBestBinding );
 765     }
 766
 767     return pBestBinding;
 768 }
 769
 770 void Model::removeBindingForNode( const XNode_t& )
 771     throw( RuntimeException )
 772 {
 773     // determine whether suitable binding is still used
 774 }
 775
 776 OUString lcl_serializeForDisplay( const Reference< XAttr >& _rxAttrNode )
 777 {
 778     ::rtl::OUString sResult;
 779     OSL_ENSURE( _rxAttrNode.is(), "lcl_serializeForDisplay( attr ): invalid argument!" );
 780     if ( _rxAttrNode.is() )
 781     {
 782         ::rtl::OUStringBuffer aBuffer;
 783         aBuffer.append( _rxAttrNode->getName() );
 784         aBuffer.appendAscii( "=" );
 785         ::rtl::OUString sValue = _rxAttrNode->getValue();
 786         sal_Unicode nQuote = '"';
 787         if ( sValue.indexOf( nQuote ) >= 0 )
 788             nQuote = '\'';
 789         aBuffer.append( nQuote );
 790         aBuffer.append( sValue );
 791         aBuffer.append( nQuote );
 792         aBuffer.append( (sal_Unicode)' ' );
 793         sResult = aBuffer.makeStringAndClear();
 794     }
 795     return sResult;
 796 }
 797
 798 OUString lcl_serializeForDisplay( const Reference<XNodeList>& xNodes )
 799 {
 800     ::rtl::OUString sResult;
 801
 802     // create document fragment
 803     Reference<XDocument> xDocument( getDocumentBuilder()->newDocument() );
 804     Reference<XDocumentFragment> xFragment(
 805         xDocument->createDocumentFragment() );
 806     Reference<XNode> xNode( xFragment, UNO_QUERY );
 807     OSL_ENSURE( xFragment.is(), "xFragment" );
 808     OSL_ENSURE( xNode.is(), "xNode" );
 809
 810     sal_Int32 nAttributeNodes = 0;
 811
 812     // attach nodelist to fragment
 813     sal_Int32 nLength = xNodes->getLength();
 814     for( sal_Int32 i = 0; i < nLength; i++ )
 815     {
 816         Reference<XNode> xCurrent = xNodes->item( i );
 817
 818         switch ( xCurrent->getNodeType() )
 819         {
 820         case NodeType_DOCUMENT_NODE:
 821             // special-case documents: use top-level element instead
 822             xCurrent = xCurrent->getFirstChild();
 823             break;
 824         case NodeType_ATTRIBUTE_NODE:
 825         {
 826             Reference< XAttr > xAttr( xCurrent, UNO_QUERY );
 827             if ( xAttr.is() )
 828             {
 829                 sResult += lcl_serializeForDisplay( xAttr );
 830                 ++nAttributeNodes;
 831             }
 832         }
 833         continue;
 834
 835         default:
 836             break;
 837         }
 838
 839         // append node
 840         xNode->appendChild( xDocument->importNode( xCurrent, sal_True ) );
 841     }
 842     OSL_ENSURE( ( nAttributeNodes == 0 ) || ( nAttributeNodes == nLength ),
 843         "lcl_serializeForDisplay: mixed attribute and non-attribute nodes?" );
 844     if ( nAttributeNodes )
 845         // had only attribute nodes
 846         return sResult;
 847
 848     // serialize fragment
 849     CSerializationAppXML aSerialization;
 850     aSerialization.setSource( xFragment );
 851     aSerialization.serialize();
 852
 853     // copy stream into buffer
 854     Reference<XTextInputStream> xTextInputStream(
 855         createInstance( OUSTRING("com.sun.star.io.TextInputStream") ),
 856         UNO_QUERY );
 857     Reference<XActiveDataSink>( xTextInputStream, UNO_QUERY_THROW )
 858         ->setInputStream( aSerialization.getInputStream() );
 859
 860     /* WORK AROUND for problem in serialization: currently, multiple
 861       XML delarations (<?xml...?>) are being written out and we don't
 862       want them. When this is fixed, the code below is nice and
 863       simple. The current code filters out the declarations.
 864     OUString sResult = xTextInputStream->readString( Sequence<sal_Unicode>(),
 865                                                      sal_True );
 866     */
 867
 868     // well, the serialization prepends XML header(s) that we need to
 869     // remove first.
 870     OUStringBuffer aBuffer;
 871     while( ! xTextInputStream->isEOF() )
 872     {
 873         OUString sLine = xTextInputStream->readLine();
 874         if( sLine.getLength() > 0
 875             && sLine.compareToAscii( "<?xml", 5 ) != 0 )
 876         {
 877             aBuffer.append( sLine );
 878             aBuffer.append( sal_Unicode('\n') );
 879         }
 880     }
 881     sResult = aBuffer.makeStringAndClear();
 882
 883     return sResult;
 884 }
 885
 886 OUString lcl_serializeForDisplay( const Reference<XXPathObject>& xResult )
 887 {
 888     // error handling first
 889     if( ! xResult.is() )
 890         return getResource( RID_STR_XFORMS_CANT_EVALUATE );
 891
 892
 893     // TODO: localize
 894     OUStringBuffer aBuffer;
 895
 896     switch( xResult->getObjectType() )
 897     {
 898     case XPathObjectType_XPATH_BOOLEAN:
 899         aBuffer.append( xResult->getBoolean()
 900                         ? OUSTRING("true")
 901                         : OUSTRING("false") );
 902         break;
 903
 904     case XPathObjectType_XPATH_STRING:
 905         aBuffer.append( sal_Unicode('"') );
 906         aBuffer.append( xResult->getString() );
 907         aBuffer.append( sal_Unicode('"') );
 908         break;
 909
 910     case XPathObjectType_XPATH_NODESET:
 911         aBuffer.append( lcl_serializeForDisplay( xResult->getNodeList() ) );
 912         break;
 913
 914     case XPathObjectType_XPATH_NUMBER:
 915         aBuffer.append( xResult->getDouble() );
 916         break;
 917
 918     case XPathObjectType_XPATH_UNDEFINED:
 919     case XPathObjectType_XPATH_POINT:
 920     case XPathObjectType_XPATH_RANGE:
 921     case XPathObjectType_XPATH_LOCATIONSET:
 922     case XPathObjectType_XPATH_USERS:
 923     case XPathObjectType_XPATH_XSLT_TREE:
 924     default:
 925         // TODO: localized error message?
 926         break;
 927     }
 928
 929     return aBuffer.makeStringAndClear();
 930 }
 931
 932 OUString Model::getResultForExpression(
 933     const XPropertySet_t& xBinding,
 934     sal_Bool bIsBindingExpression,
 935     const OUString& sExpression )
 936     throw( RuntimeException )
 937 {
 938     Binding* pBinding = Binding::getBinding( xBinding );
 939     if( pBinding == NULL )
 940         throw RuntimeException();
 941
 942     // prepare & evaluate expression
 943     OUStringBuffer aBuffer;
 944     ComputedExpression aExpression;
 945     aExpression.setExpression( sExpression );
 946     if( bIsBindingExpression )
 947     {
 948         // binding: use binding context and evaluation
 949         aExpression.evaluate( pBinding->getEvaluationContext() );
 950         aBuffer.append( lcl_serializeForDisplay( aExpression.getXPath() ) );
 951     }
 952     else
 953     {
 954         // MIP (not binding): iterate over bindings contexts
 955         std::vector<EvaluationContext> aContext =
 956             pBinding->getMIPEvaluationContexts();
 957         for( std::vector<EvaluationContext>::iterator aIter = aContext.begin();
 958              aIter != aContext.end();
 959              aIter ++ )
 960         {
 961             aExpression.evaluate( *aIter );
 962             aBuffer.append( lcl_serializeForDisplay(aExpression.getXPath()) );
 963             aBuffer.append( sal_Unicode('\n') );
 964         }
 965     }
 966     return aBuffer.makeStringAndClear();
 967 }
 968
 969 sal_Bool Model::isValidXMLName( const OUString& sName )
 970     throw( RuntimeException )
 971 {
 972     return isValidQName( sName, NULL );
 973 }
 974
 975 sal_Bool Model::isValidPrefixName( const OUString& sName )
 976     throw( RuntimeException )
 977 {
 978     return ::isValidPrefixName( sName, NULL );
 979 }
 980
 981 void Model::setNodeValue(
 982     const XNode_t& xNode,
 983     const rtl::OUString& sValue )
 984     throw( RuntimeException )
 985 {
 986     setSimpleContent( xNode, sValue );
 987 }
 988
 989
 990 //
 991 // helper functions from model_helper.hxx
 992 //
 993
 994 void xforms::getInstanceData(
 995     const Sequence<PropertyValue>& aValues,
 996     OUString* pID,
 997     Reference<XDocument>* pInstance,
 998     OUString* pURL,
 999     bool* pURLOnce )
1000 {
1001     sal_Int32 nValues = aValues.getLength();
1002     const PropertyValue* pValues = aValues.getConstArray();
1003     for( sal_Int32 n = 0; n < nValues; n++ )
1004     {
1005         const PropertyValue& rValue = pValues[n];
1006 #define PROP(NAME) \
1007         if( p##NAME != NULL && \
1008             rValue.Name.equalsAsciiL(RTL_CONSTASCII_STRINGPARAM(#NAME)) ) \
1009             rValue.Value >>= (*p##NAME)
1010         PROP(ID);
1011         PROP(Instance);
1012         PROP(URL);
1013         PROP(URLOnce);
1014 #undef PROP
1015     }
1016 }
1017
1018 void xforms::setInstanceData(
1019     Sequence<PropertyValue>& aSequence,
1020     const OUString* _pID,
1021     const Reference<XDocument>* _pInstance,
1022     const OUString* _pURL,
1023     const bool* _pURLOnce )
1024 {
1025     // get old instance data
1026     OUString sID;
1027     Reference<XDocument> xInstance;
1028     OUString sURL;
1029     bool bURLOnce = false;
1030     getInstanceData( aSequence, &sID, &xInstance, &sURL, &bURLOnce );
1031     const OUString* pID = ( sID.getLength() > 0 ) ? &sID : NULL;
1032     const Reference<XDocument>* pInstance = xInstance.is() ? &xInstance : NULL;
1033     const OUString* pURL = ( sURL.getLength() > 0 ) ? &sURL : NULL;
1034     const bool* pURLOnce = ( bURLOnce && pURL != NULL ) ? &bURLOnce : NULL;
1035
1036     // determine new instance data
1037 #define PROP(NAME) if( _p##NAME != NULL ) p##NAME = _p##NAME
1038     PROP(ID);
1039     PROP(Instance);
1040     PROP(URL);
1041     PROP(URLOnce);
1042 #undef PROP
1043
1044     // count # of values we want to set
1045     sal_Int32 nCount = 0;
1046 #define PROP(NAME) if( p##NAME != NULL ) nCount++
1047     PROP(ID);
1048     PROP(Instance);
1049     PROP(URL);
1050     PROP(URLOnce);
1051 #undef PROP
1052
1053     // realloc sequence and enter values;
1054     aSequence.realloc( nCount );
1055     PropertyValue* pSequence = aSequence.getArray();
1056     sal_Int32 nIndex = 0;
1057 #define PROP(NAME) \
1058     if( p##NAME != NULL ) \
1059     { \
1060         pSequence[ nIndex ].Name = OUSTRING(#NAME); \
1061         pSequence[ nIndex ].Value <<= *p##NAME; \
1062         nIndex++; \
1063     }
1064     PROP(ID);
1065     PROP(Instance);
1066     PROP(URL);
1067     PROP(URLOnce);
1068 #undef PROP
1069 }