1*cdf0e10cSrcweir /************************************************************************* 2*cdf0e10cSrcweir * 3*cdf0e10cSrcweir * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 4*cdf0e10cSrcweir * 5*cdf0e10cSrcweir * Copyright 2000, 2010 Oracle and/or its affiliates. 6*cdf0e10cSrcweir * 7*cdf0e10cSrcweir * OpenOffice.org - a multi-platform office productivity suite 8*cdf0e10cSrcweir * 9*cdf0e10cSrcweir * This file is part of OpenOffice.org. 10*cdf0e10cSrcweir * 11*cdf0e10cSrcweir * OpenOffice.org is free software: you can redistribute it and/or modify 12*cdf0e10cSrcweir * it under the terms of the GNU Lesser General Public License version 3 13*cdf0e10cSrcweir * only, as published by the Free Software Foundation. 14*cdf0e10cSrcweir * 15*cdf0e10cSrcweir * OpenOffice.org is distributed in the hope that it will be useful, 16*cdf0e10cSrcweir * but WITHOUT ANY WARRANTY; without even the implied warranty of 17*cdf0e10cSrcweir * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 18*cdf0e10cSrcweir * GNU Lesser General Public License version 3 for more details 19*cdf0e10cSrcweir * (a copy is included in the LICENSE file that accompanied this code). 20*cdf0e10cSrcweir * 21*cdf0e10cSrcweir * You should have received a copy of the GNU Lesser General Public License 22*cdf0e10cSrcweir * version 3 along with OpenOffice.org. If not, see 23*cdf0e10cSrcweir * <http://www.openoffice.org/license.html> 24*cdf0e10cSrcweir * for a copy of the LGPLv3 License. 25*cdf0e10cSrcweir * 26*cdf0e10cSrcweir ************************************************************************/ 27*cdf0e10cSrcweir 28*cdf0e10cSrcweir // MARKER(update_precomp.py): autogen include statement, do not remove 29*cdf0e10cSrcweir #include "precompiled_xmlsecurity.hxx" 30*cdf0e10cSrcweir 31*cdf0e10cSrcweir #include "saxeventkeeperimpl.hxx" 32*cdf0e10cSrcweir #include <com/sun/star/lang/XMultiServiceFactory.hpp> 33*cdf0e10cSrcweir #include <com/sun/star/xml/sax/XDocumentHandler.hpp> 34*cdf0e10cSrcweir #include <com/sun/star/xml/crypto/sax/ConstOfSecurityId.hpp> 35*cdf0e10cSrcweir 36*cdf0e10cSrcweir namespace cssu = com::sun::star::uno; 37*cdf0e10cSrcweir namespace cssl = com::sun::star::lang; 38*cdf0e10cSrcweir namespace cssxc = com::sun::star::xml::crypto; 39*cdf0e10cSrcweir namespace cssxcsax = com::sun::star::xml::csax; 40*cdf0e10cSrcweir namespace cssxw = com::sun::star::xml::wrapper; 41*cdf0e10cSrcweir namespace cssxs = com::sun::star::xml::sax; 42*cdf0e10cSrcweir 43*cdf0e10cSrcweir #define SERVICE_NAME "com.sun.star.xml.crypto.sax.SAXEventKeeper" 44*cdf0e10cSrcweir #define IMPLEMENTATION_NAME "com.sun.star.xml.security.framework.SAXEventKeeperImpl" 45*cdf0e10cSrcweir 46*cdf0e10cSrcweir #define _USECOMPRESSEDDOCUMENTHANDLER 47*cdf0e10cSrcweir 48*cdf0e10cSrcweir SAXEventKeeperImpl::SAXEventKeeperImpl( ) 49*cdf0e10cSrcweir :m_pRootBufferNode(NULL), 50*cdf0e10cSrcweir m_pCurrentBufferNode(NULL), 51*cdf0e10cSrcweir m_nNextElementMarkId(1), 52*cdf0e10cSrcweir m_pNewBlocker(NULL), 53*cdf0e10cSrcweir m_pCurrentBlockingBufferNode(NULL), 54*cdf0e10cSrcweir m_bIsReleasing(false), 55*cdf0e10cSrcweir m_bIsForwarding(false) 56*cdf0e10cSrcweir { 57*cdf0e10cSrcweir m_vElementMarkBuffers.reserve(2); 58*cdf0e10cSrcweir m_vNewElementCollectors.reserve(2); 59*cdf0e10cSrcweir m_vReleasedElementMarkBuffers.reserve(2); 60*cdf0e10cSrcweir } 61*cdf0e10cSrcweir 62*cdf0e10cSrcweir SAXEventKeeperImpl::~SAXEventKeeperImpl() 63*cdf0e10cSrcweir { 64*cdf0e10cSrcweir /* 65*cdf0e10cSrcweir * delete the BufferNode tree 66*cdf0e10cSrcweir */ 67*cdf0e10cSrcweir if (m_pRootBufferNode != NULL) 68*cdf0e10cSrcweir { 69*cdf0e10cSrcweir m_pRootBufferNode->freeAllChildren(); 70*cdf0e10cSrcweir delete m_pRootBufferNode; 71*cdf0e10cSrcweir } 72*cdf0e10cSrcweir 73*cdf0e10cSrcweir m_pRootBufferNode = m_pCurrentBufferNode = m_pCurrentBlockingBufferNode = NULL; 74*cdf0e10cSrcweir 75*cdf0e10cSrcweir /* 76*cdf0e10cSrcweir * delete all unfreed ElementMarks 77*cdf0e10cSrcweir */ 78*cdf0e10cSrcweir m_vNewElementCollectors.clear(); 79*cdf0e10cSrcweir m_pNewBlocker = NULL; 80*cdf0e10cSrcweir 81*cdf0e10cSrcweir std::vector< const ElementMark* >::const_iterator ii = m_vElementMarkBuffers.begin(); 82*cdf0e10cSrcweir for( ; ii != m_vElementMarkBuffers.end(); ++ii ) 83*cdf0e10cSrcweir { 84*cdf0e10cSrcweir delete (*ii); 85*cdf0e10cSrcweir } 86*cdf0e10cSrcweir m_vElementMarkBuffers.clear(); 87*cdf0e10cSrcweir } 88*cdf0e10cSrcweir 89*cdf0e10cSrcweir void SAXEventKeeperImpl::setCurrentBufferNode(BufferNode* pBufferNode) 90*cdf0e10cSrcweir /****** SAXEventKeeperImpl/setCurrentBufferNode ****************************** 91*cdf0e10cSrcweir * 92*cdf0e10cSrcweir * NAME 93*cdf0e10cSrcweir * setCurrentBufferNode -- set a new active BufferNode. 94*cdf0e10cSrcweir * 95*cdf0e10cSrcweir * SYNOPSIS 96*cdf0e10cSrcweir * setCurrentBufferNode( pBufferNode ); 97*cdf0e10cSrcweir * 98*cdf0e10cSrcweir * FUNCTION 99*cdf0e10cSrcweir * connects this BufferNode into the BufferNode tree as a child of the 100*cdf0e10cSrcweir * current active BufferNode. Then makes this BufferNode as the current 101*cdf0e10cSrcweir * active BufferNode. 102*cdf0e10cSrcweir * If the previous active BufferNode points to the root 103*cdf0e10cSrcweir * BufferNode, which means that no buffering operation was proceeding, 104*cdf0e10cSrcweir * then notifies the status change listener that buffering operation 105*cdf0e10cSrcweir * will begin at once. 106*cdf0e10cSrcweir * 107*cdf0e10cSrcweir * INPUTS 108*cdf0e10cSrcweir * pBufferNode - a BufferNode which will be the new active BufferNode 109*cdf0e10cSrcweir * 110*cdf0e10cSrcweir * RESULT 111*cdf0e10cSrcweir * empty 112*cdf0e10cSrcweir * 113*cdf0e10cSrcweir * HISTORY 114*cdf0e10cSrcweir * 05.01.2004 - implemented 115*cdf0e10cSrcweir * 116*cdf0e10cSrcweir * AUTHOR 117*cdf0e10cSrcweir * Michael Mi 118*cdf0e10cSrcweir * Email: michael.mi@sun.com 119*cdf0e10cSrcweir ******************************************************************************/ 120*cdf0e10cSrcweir { 121*cdf0e10cSrcweir if (pBufferNode != m_pCurrentBufferNode) 122*cdf0e10cSrcweir { 123*cdf0e10cSrcweir if ( m_pCurrentBufferNode == m_pRootBufferNode && 124*cdf0e10cSrcweir m_xSAXEventKeeperStatusChangeListener.is()) 125*cdf0e10cSrcweir { 126*cdf0e10cSrcweir m_xSAXEventKeeperStatusChangeListener->collectionStatusChanged(sal_True); 127*cdf0e10cSrcweir } 128*cdf0e10cSrcweir 129*cdf0e10cSrcweir if (pBufferNode->getParent() == NULL) 130*cdf0e10cSrcweir { 131*cdf0e10cSrcweir m_pCurrentBufferNode->addChild(pBufferNode); 132*cdf0e10cSrcweir pBufferNode->setParent(m_pCurrentBufferNode); 133*cdf0e10cSrcweir } 134*cdf0e10cSrcweir 135*cdf0e10cSrcweir m_pCurrentBufferNode = pBufferNode; 136*cdf0e10cSrcweir } 137*cdf0e10cSrcweir } 138*cdf0e10cSrcweir 139*cdf0e10cSrcweir BufferNode* SAXEventKeeperImpl::addNewElementMarkBuffers() 140*cdf0e10cSrcweir /****** SAXEventKeeperImpl/addNewElementMarkBuffers ************************** 141*cdf0e10cSrcweir * 142*cdf0e10cSrcweir * NAME 143*cdf0e10cSrcweir * addNewElementMarkBuffers -- add new ElementCollectors and new Blocker. 144*cdf0e10cSrcweir * 145*cdf0e10cSrcweir * SYNOPSIS 146*cdf0e10cSrcweir * pBufferNode = addNewElementMarkBuffers( ); 147*cdf0e10cSrcweir * 148*cdf0e10cSrcweir * FUNCTION 149*cdf0e10cSrcweir * if there are new ElementCollector or new Blocker to be added, then 150*cdf0e10cSrcweir * connect all of them with the current BufferNode. In case of the 151*cdf0e10cSrcweir * current BufferNode doesn't exist, creates one. 152*cdf0e10cSrcweir * Clears up the new ElementCollector list and the new Blocker pointer. 153*cdf0e10cSrcweir * 154*cdf0e10cSrcweir * INPUTS 155*cdf0e10cSrcweir * empty 156*cdf0e10cSrcweir * 157*cdf0e10cSrcweir * RESULT 158*cdf0e10cSrcweir * pBufferNode - the BufferNode that has been connected with both new 159*cdf0e10cSrcweir * ElementCollectors and new Blocker. 160*cdf0e10cSrcweir * 161*cdf0e10cSrcweir * HISTORY 162*cdf0e10cSrcweir * 05.01.2004 - implemented 163*cdf0e10cSrcweir * 164*cdf0e10cSrcweir * AUTHOR 165*cdf0e10cSrcweir * Michael Mi 166*cdf0e10cSrcweir * Email: michael.mi@sun.com 167*cdf0e10cSrcweir ******************************************************************************/ 168*cdf0e10cSrcweir { 169*cdf0e10cSrcweir BufferNode* pBufferNode = NULL; 170*cdf0e10cSrcweir 171*cdf0e10cSrcweir if ( (m_vNewElementCollectors.size()>0) || 172*cdf0e10cSrcweir (m_pNewBlocker != NULL)) 173*cdf0e10cSrcweir { 174*cdf0e10cSrcweir /* 175*cdf0e10cSrcweir * When the current BufferNode is right pointing to the current 176*cdf0e10cSrcweir * working element in the XMLDocumentWrapper component, then 177*cdf0e10cSrcweir * no new BufferNode is needed to create. 178*cdf0e10cSrcweir * This situation can only happen in the "Forwarding" mode. 179*cdf0e10cSrcweir */ 180*cdf0e10cSrcweir if ( (m_pCurrentBufferNode != NULL) && 181*cdf0e10cSrcweir (m_xXMLDocument->isCurrent(m_pCurrentBufferNode->getXMLElement()))) 182*cdf0e10cSrcweir { 183*cdf0e10cSrcweir pBufferNode = m_pCurrentBufferNode; 184*cdf0e10cSrcweir } 185*cdf0e10cSrcweir else 186*cdf0e10cSrcweir { 187*cdf0e10cSrcweir pBufferNode = new BufferNode(m_xXMLDocument->getCurrentElement()); 188*cdf0e10cSrcweir } 189*cdf0e10cSrcweir 190*cdf0e10cSrcweir if (m_pNewBlocker != NULL) 191*cdf0e10cSrcweir { 192*cdf0e10cSrcweir pBufferNode->setBlocker(m_pNewBlocker); 193*cdf0e10cSrcweir 194*cdf0e10cSrcweir /* 195*cdf0e10cSrcweir * If no blocking before, then notify the status change listener that 196*cdf0e10cSrcweir * the SAXEventKeeper has entered "blocking" status, during which, no 197*cdf0e10cSrcweir * SAX events will be forwarded to the next document handler. 198*cdf0e10cSrcweir */ 199*cdf0e10cSrcweir if (m_pCurrentBlockingBufferNode == NULL) 200*cdf0e10cSrcweir { 201*cdf0e10cSrcweir m_pCurrentBlockingBufferNode = pBufferNode; 202*cdf0e10cSrcweir 203*cdf0e10cSrcweir if (m_xSAXEventKeeperStatusChangeListener.is()) 204*cdf0e10cSrcweir { 205*cdf0e10cSrcweir m_xSAXEventKeeperStatusChangeListener->blockingStatusChanged(sal_True); 206*cdf0e10cSrcweir } 207*cdf0e10cSrcweir } 208*cdf0e10cSrcweir 209*cdf0e10cSrcweir m_pNewBlocker = NULL; 210*cdf0e10cSrcweir } 211*cdf0e10cSrcweir 212*cdf0e10cSrcweir if (m_vNewElementCollectors.size()>0) 213*cdf0e10cSrcweir { 214*cdf0e10cSrcweir std::vector< const ElementCollector* >::const_iterator ii = m_vNewElementCollectors.begin(); 215*cdf0e10cSrcweir 216*cdf0e10cSrcweir for( ; ii != m_vNewElementCollectors.end(); ++ii ) 217*cdf0e10cSrcweir { 218*cdf0e10cSrcweir pBufferNode->addElementCollector(*ii); 219*cdf0e10cSrcweir } 220*cdf0e10cSrcweir 221*cdf0e10cSrcweir m_vNewElementCollectors.clear(); 222*cdf0e10cSrcweir } 223*cdf0e10cSrcweir } 224*cdf0e10cSrcweir 225*cdf0e10cSrcweir return pBufferNode; 226*cdf0e10cSrcweir } 227*cdf0e10cSrcweir 228*cdf0e10cSrcweir ElementMark* SAXEventKeeperImpl::findElementMarkBuffer(sal_Int32 nId) const 229*cdf0e10cSrcweir /****** SAXEventKeeperImpl/findElementMarkBuffer ***************************** 230*cdf0e10cSrcweir * 231*cdf0e10cSrcweir * NAME 232*cdf0e10cSrcweir * findElementMarkBuffer -- finds an ElementMark. 233*cdf0e10cSrcweir * 234*cdf0e10cSrcweir * SYNOPSIS 235*cdf0e10cSrcweir * pElementMark = findElementMarkBuffer( nId ); 236*cdf0e10cSrcweir * 237*cdf0e10cSrcweir * FUNCTION 238*cdf0e10cSrcweir * searches an ElementMark with the particular Id in the ElementMark 239*cdf0e10cSrcweir * list. 240*cdf0e10cSrcweir * 241*cdf0e10cSrcweir * INPUTS 242*cdf0e10cSrcweir * nId - the Id of the ElementMark to be searched. 243*cdf0e10cSrcweir * 244*cdf0e10cSrcweir * RESULT 245*cdf0e10cSrcweir * pElementMark - the ElementMark with the particular Id, or NULL when 246*cdf0e10cSrcweir * no such Id exists. 247*cdf0e10cSrcweir * 248*cdf0e10cSrcweir * HISTORY 249*cdf0e10cSrcweir * 05.01.2004 - implemented 250*cdf0e10cSrcweir * 251*cdf0e10cSrcweir * AUTHOR 252*cdf0e10cSrcweir * Michael Mi 253*cdf0e10cSrcweir * Email: michael.mi@sun.com 254*cdf0e10cSrcweir ******************************************************************************/ 255*cdf0e10cSrcweir { 256*cdf0e10cSrcweir ElementMark* pElementMark = NULL; 257*cdf0e10cSrcweir 258*cdf0e10cSrcweir std::vector< const ElementMark* >::const_iterator ii = m_vElementMarkBuffers.begin(); 259*cdf0e10cSrcweir 260*cdf0e10cSrcweir for( ; ii != m_vElementMarkBuffers.end(); ++ii ) 261*cdf0e10cSrcweir { 262*cdf0e10cSrcweir if ( nId == (*ii)->getBufferId()) 263*cdf0e10cSrcweir { 264*cdf0e10cSrcweir pElementMark = (ElementMark*)*ii; 265*cdf0e10cSrcweir break; 266*cdf0e10cSrcweir } 267*cdf0e10cSrcweir } 268*cdf0e10cSrcweir 269*cdf0e10cSrcweir return pElementMark; 270*cdf0e10cSrcweir } 271*cdf0e10cSrcweir 272*cdf0e10cSrcweir void SAXEventKeeperImpl::removeElementMarkBuffer(sal_Int32 nId) 273*cdf0e10cSrcweir /****** SAXEventKeeperImpl/removeElementMarkBuffer *************************** 274*cdf0e10cSrcweir * 275*cdf0e10cSrcweir * NAME 276*cdf0e10cSrcweir * removeElementMarkBuffer -- removes an ElementMark 277*cdf0e10cSrcweir * 278*cdf0e10cSrcweir * SYNOPSIS 279*cdf0e10cSrcweir * removeElementMarkBuffer( nId ); 280*cdf0e10cSrcweir * 281*cdf0e10cSrcweir * FUNCTION 282*cdf0e10cSrcweir * removes an ElementMark with the particular Id in the ElementMark list. 283*cdf0e10cSrcweir * 284*cdf0e10cSrcweir * INPUTS 285*cdf0e10cSrcweir * nId - the Id of the ElementMark to be removed. 286*cdf0e10cSrcweir * 287*cdf0e10cSrcweir * RESULT 288*cdf0e10cSrcweir * empty 289*cdf0e10cSrcweir * 290*cdf0e10cSrcweir * HISTORY 291*cdf0e10cSrcweir * 05.01.2004 - implemented 292*cdf0e10cSrcweir * 293*cdf0e10cSrcweir * AUTHOR 294*cdf0e10cSrcweir * Michael Mi 295*cdf0e10cSrcweir * Email: michael.mi@sun.com 296*cdf0e10cSrcweir ******************************************************************************/ 297*cdf0e10cSrcweir { 298*cdf0e10cSrcweir std::vector< const ElementMark* >::iterator ii = m_vElementMarkBuffers.begin(); 299*cdf0e10cSrcweir 300*cdf0e10cSrcweir for( ; ii != m_vElementMarkBuffers.end(); ++ii ) 301*cdf0e10cSrcweir { 302*cdf0e10cSrcweir if ( nId == (*ii)->getBufferId()) 303*cdf0e10cSrcweir { 304*cdf0e10cSrcweir /* 305*cdf0e10cSrcweir * checks whether this ElementMark still in the new ElementCollect array 306*cdf0e10cSrcweir */ 307*cdf0e10cSrcweir std::vector< const ElementCollector* >::iterator jj = m_vNewElementCollectors.begin(); 308*cdf0e10cSrcweir for( ; jj != m_vNewElementCollectors.end(); ++jj ) 309*cdf0e10cSrcweir { 310*cdf0e10cSrcweir if ((*ii) == (*jj)) 311*cdf0e10cSrcweir { 312*cdf0e10cSrcweir m_vNewElementCollectors.erase(jj); 313*cdf0e10cSrcweir break; 314*cdf0e10cSrcweir } 315*cdf0e10cSrcweir } 316*cdf0e10cSrcweir 317*cdf0e10cSrcweir /* 318*cdf0e10cSrcweir * checks whether this ElementMark is the new Blocker 319*cdf0e10cSrcweir */ 320*cdf0e10cSrcweir if ((*ii) == m_pNewBlocker) 321*cdf0e10cSrcweir { 322*cdf0e10cSrcweir m_pNewBlocker = NULL; 323*cdf0e10cSrcweir } 324*cdf0e10cSrcweir 325*cdf0e10cSrcweir /* 326*cdf0e10cSrcweir * destory the ElementMark 327*cdf0e10cSrcweir */ 328*cdf0e10cSrcweir delete (*ii); 329*cdf0e10cSrcweir 330*cdf0e10cSrcweir m_vElementMarkBuffers.erase( ii ); 331*cdf0e10cSrcweir break; 332*cdf0e10cSrcweir } 333*cdf0e10cSrcweir } 334*cdf0e10cSrcweir } 335*cdf0e10cSrcweir 336*cdf0e10cSrcweir rtl::OUString SAXEventKeeperImpl::printBufferNode( 337*cdf0e10cSrcweir BufferNode* pBufferNode, sal_Int32 nIndent) const 338*cdf0e10cSrcweir /****** SAXEventKeeperImpl/printBufferNode *********************************** 339*cdf0e10cSrcweir * 340*cdf0e10cSrcweir * NAME 341*cdf0e10cSrcweir * printBufferNode -- retrieves the information of a BufferNode and its 342*cdf0e10cSrcweir * branch. 343*cdf0e10cSrcweir * 344*cdf0e10cSrcweir * SYNOPSIS 345*cdf0e10cSrcweir * info = printBufferNode( pBufferNode, nIndent ); 346*cdf0e10cSrcweir * 347*cdf0e10cSrcweir * FUNCTION 348*cdf0e10cSrcweir * all retrieved information includes: 349*cdf0e10cSrcweir * 1. whether it is the current BufferNode; 350*cdf0e10cSrcweir * 2. whether it is the current blocking BufferNode; 351*cdf0e10cSrcweir * 3. the name of the parent element; 352*cdf0e10cSrcweir * 4. the name of this element; 353*cdf0e10cSrcweir * 5. all ElementCollectors working on this BufferNode; 354*cdf0e10cSrcweir * 6. the Blocker working on this BufferNode; 355*cdf0e10cSrcweir * 7. all child BufferNodes' information. 356*cdf0e10cSrcweir * 357*cdf0e10cSrcweir * INPUTS 358*cdf0e10cSrcweir * pBufferNode - the BufferNode from where information will be retrieved. 359*cdf0e10cSrcweir * nIndent - how many space characters prefixed before the output 360*cdf0e10cSrcweir * message. 361*cdf0e10cSrcweir * 362*cdf0e10cSrcweir * RESULT 363*cdf0e10cSrcweir * info - the information string 364*cdf0e10cSrcweir * 365*cdf0e10cSrcweir * HISTORY 366*cdf0e10cSrcweir * 05.01.2004 - implemented 367*cdf0e10cSrcweir * 368*cdf0e10cSrcweir * AUTHOR 369*cdf0e10cSrcweir * Michael Mi 370*cdf0e10cSrcweir * Email: michael.mi@sun.com 371*cdf0e10cSrcweir ******************************************************************************/ 372*cdf0e10cSrcweir { 373*cdf0e10cSrcweir rtl::OUString rc; 374*cdf0e10cSrcweir 375*cdf0e10cSrcweir for ( int i=0; i<nIndent; ++i ) 376*cdf0e10cSrcweir { 377*cdf0e10cSrcweir rc += rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( " " )); 378*cdf0e10cSrcweir } 379*cdf0e10cSrcweir 380*cdf0e10cSrcweir if (pBufferNode == m_pCurrentBufferNode) 381*cdf0e10cSrcweir { 382*cdf0e10cSrcweir rc += rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "[%]" )); 383*cdf0e10cSrcweir } 384*cdf0e10cSrcweir 385*cdf0e10cSrcweir if (pBufferNode == m_pCurrentBlockingBufferNode) 386*cdf0e10cSrcweir { 387*cdf0e10cSrcweir rc += rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "[B]" )); 388*cdf0e10cSrcweir } 389*cdf0e10cSrcweir 390*cdf0e10cSrcweir rc += rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( " " )); 391*cdf0e10cSrcweir rc += m_xXMLDocument->getNodeName(pBufferNode->getXMLElement()); 392*cdf0e10cSrcweir 393*cdf0e10cSrcweir BufferNode* pParent = (BufferNode*)pBufferNode->getParent(); 394*cdf0e10cSrcweir if (pParent != NULL) 395*cdf0e10cSrcweir { 396*cdf0e10cSrcweir rc += rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "[" )); 397*cdf0e10cSrcweir rc += m_xXMLDocument->getNodeName(pParent->getXMLElement()); 398*cdf0e10cSrcweir rc += rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "]" )); 399*cdf0e10cSrcweir } 400*cdf0e10cSrcweir 401*cdf0e10cSrcweir rc += rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( ":EC=" )); 402*cdf0e10cSrcweir rc += pBufferNode->printChildren(); 403*cdf0e10cSrcweir rc += rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( " BR=" )); 404*cdf0e10cSrcweir 405*cdf0e10cSrcweir ElementMark * pBlocker = pBufferNode->getBlocker(); 406*cdf0e10cSrcweir if (pBlocker != NULL) 407*cdf0e10cSrcweir { 408*cdf0e10cSrcweir rc += rtl::OUString::valueOf( pBlocker->getBufferId() ); 409*cdf0e10cSrcweir rc += rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "(SecId=" )); 410*cdf0e10cSrcweir rc += rtl::OUString::valueOf( pBlocker->getSecurityId() ); 411*cdf0e10cSrcweir rc += rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( ")" )); 412*cdf0e10cSrcweir rc += rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( " " )); 413*cdf0e10cSrcweir } 414*cdf0e10cSrcweir rc += rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "\n" )); 415*cdf0e10cSrcweir 416*cdf0e10cSrcweir std::vector< const BufferNode* >* vChildren = pBufferNode->getChildren(); 417*cdf0e10cSrcweir std::vector< const BufferNode* >::const_iterator jj = vChildren->begin(); 418*cdf0e10cSrcweir for( ; jj != vChildren->end(); ++jj ) 419*cdf0e10cSrcweir { 420*cdf0e10cSrcweir rc += printBufferNode((BufferNode *)*jj, nIndent+4); 421*cdf0e10cSrcweir } 422*cdf0e10cSrcweir 423*cdf0e10cSrcweir delete vChildren; 424*cdf0e10cSrcweir 425*cdf0e10cSrcweir return rc; 426*cdf0e10cSrcweir } 427*cdf0e10cSrcweir 428*cdf0e10cSrcweir cssu::Sequence< cssu::Reference< cssxw::XXMLElementWrapper > > 429*cdf0e10cSrcweir SAXEventKeeperImpl::collectChildWorkingElement(BufferNode* pBufferNode) const 430*cdf0e10cSrcweir /****** SAXEventKeeperImpl/collectChildWorkingElement ************************ 431*cdf0e10cSrcweir * 432*cdf0e10cSrcweir * NAME 433*cdf0e10cSrcweir * collectChildWorkingElement -- collects a BufferNode's all child 434*cdf0e10cSrcweir * Elements. 435*cdf0e10cSrcweir * 436*cdf0e10cSrcweir * SYNOPSIS 437*cdf0e10cSrcweir * list = collectChildWorkingElement( pBufferNode ); 438*cdf0e10cSrcweir * 439*cdf0e10cSrcweir * FUNCTION 440*cdf0e10cSrcweir * see NAME. 441*cdf0e10cSrcweir * 442*cdf0e10cSrcweir * INPUTS 443*cdf0e10cSrcweir * pBufferNode - the BufferNode whose child Elements will be collected. 444*cdf0e10cSrcweir * 445*cdf0e10cSrcweir * RESULT 446*cdf0e10cSrcweir * list - the child Elements list. 447*cdf0e10cSrcweir * 448*cdf0e10cSrcweir * HISTORY 449*cdf0e10cSrcweir * 05.01.2004 - implemented 450*cdf0e10cSrcweir * 451*cdf0e10cSrcweir * AUTHOR 452*cdf0e10cSrcweir * Michael Mi 453*cdf0e10cSrcweir * Email: michael.mi@sun.com 454*cdf0e10cSrcweir ******************************************************************************/ 455*cdf0e10cSrcweir { 456*cdf0e10cSrcweir std::vector< const BufferNode* >* vChildren = pBufferNode->getChildren(); 457*cdf0e10cSrcweir 458*cdf0e10cSrcweir cssu::Sequence < cssu::Reference< 459*cdf0e10cSrcweir cssxw::XXMLElementWrapper > > aChildrenCollection ( vChildren->size()); 460*cdf0e10cSrcweir 461*cdf0e10cSrcweir std::vector< const BufferNode* >::const_iterator ii = vChildren->begin(); 462*cdf0e10cSrcweir 463*cdf0e10cSrcweir sal_Int32 nIndex = 0; 464*cdf0e10cSrcweir for( ; ii != vChildren->end(); ++ii ) 465*cdf0e10cSrcweir { 466*cdf0e10cSrcweir aChildrenCollection[nIndex] = (*ii)->getXMLElement(); 467*cdf0e10cSrcweir nIndex++; 468*cdf0e10cSrcweir } 469*cdf0e10cSrcweir 470*cdf0e10cSrcweir delete vChildren; 471*cdf0e10cSrcweir 472*cdf0e10cSrcweir return aChildrenCollection; 473*cdf0e10cSrcweir } 474*cdf0e10cSrcweir 475*cdf0e10cSrcweir void SAXEventKeeperImpl::smashBufferNode( 476*cdf0e10cSrcweir BufferNode* pBufferNode, bool bClearRoot) const 477*cdf0e10cSrcweir /****** SAXEventKeeperImpl/smashBufferNode *********************************** 478*cdf0e10cSrcweir * 479*cdf0e10cSrcweir * NAME 480*cdf0e10cSrcweir * smashBufferNode -- removes a BufferNode along with its working 481*cdf0e10cSrcweir * element. 482*cdf0e10cSrcweir * 483*cdf0e10cSrcweir * SYNOPSIS 484*cdf0e10cSrcweir * smashBufferNode( pBufferNode, bClearRoot ); 485*cdf0e10cSrcweir * 486*cdf0e10cSrcweir * FUNCTION 487*cdf0e10cSrcweir * removes the BufferNode's working element from the DOM document, while 488*cdf0e10cSrcweir * reserves all ancestor paths for its child BufferNodes. 489*cdf0e10cSrcweir * when any of the BufferNode's ancestor element is useless, removes it 490*cdf0e10cSrcweir * too. 491*cdf0e10cSrcweir * removes the BufferNode from the BufferNode tree. 492*cdf0e10cSrcweir * 493*cdf0e10cSrcweir * INPUTS 494*cdf0e10cSrcweir * pBufferNode - the BufferNode to be removed 495*cdf0e10cSrcweir * bClearRoot - whether the root element also needs to be cleared up. 496*cdf0e10cSrcweir * 497*cdf0e10cSrcweir * RESULT 498*cdf0e10cSrcweir * empty 499*cdf0e10cSrcweir * 500*cdf0e10cSrcweir * NOTES 501*cdf0e10cSrcweir * when removeing a Blocker's BufferNode, the bClearRoot flag should be 502*cdf0e10cSrcweir * true. Because a Blocker can buffer many SAX events which are not used 503*cdf0e10cSrcweir * by any other ElementCollector or Blocker. 504*cdf0e10cSrcweir * When the bClearRoot is set to true, the root BufferNode will be first 505*cdf0e10cSrcweir * cleared, with a stop flag seting at the next Blocking BufferNode. This 506*cdf0e10cSrcweir * operation can delete all useless bufferred SAX events which are only 507*cdf0e10cSrcweir * needed by the Blocker to be deleted. 508*cdf0e10cSrcweir * 509*cdf0e10cSrcweir * HISTORY 510*cdf0e10cSrcweir * 05.01.2004 - implemented 511*cdf0e10cSrcweir * 512*cdf0e10cSrcweir * AUTHOR 513*cdf0e10cSrcweir * Michael Mi 514*cdf0e10cSrcweir * Email: michael.mi@sun.com 515*cdf0e10cSrcweir ******************************************************************************/ 516*cdf0e10cSrcweir { 517*cdf0e10cSrcweir if (!pBufferNode->hasAnything()) 518*cdf0e10cSrcweir { 519*cdf0e10cSrcweir BufferNode* pParent = (BufferNode*)pBufferNode->getParent(); 520*cdf0e10cSrcweir 521*cdf0e10cSrcweir /* 522*cdf0e10cSrcweir * delete the XML data 523*cdf0e10cSrcweir */ 524*cdf0e10cSrcweir if (pParent == m_pRootBufferNode) 525*cdf0e10cSrcweir { 526*cdf0e10cSrcweir bool bIsNotBlocking = (m_pCurrentBlockingBufferNode == NULL); 527*cdf0e10cSrcweir bool bIsBlockInside = false; 528*cdf0e10cSrcweir bool bIsBlockingAfterward = false; 529*cdf0e10cSrcweir 530*cdf0e10cSrcweir /* 531*cdf0e10cSrcweir * If this is a blocker, then remove any out-element data 532*cdf0e10cSrcweir * which caused by blocking. The removal process will stop 533*cdf0e10cSrcweir * at the next blokcer to avoid removing any useful data. 534*cdf0e10cSrcweir */ 535*cdf0e10cSrcweir if (bClearRoot) 536*cdf0e10cSrcweir { 537*cdf0e10cSrcweir cssu::Sequence< cssu::Reference< cssxw::XXMLElementWrapper > > 538*cdf0e10cSrcweir aChildElements = collectChildWorkingElement(m_pRootBufferNode); 539*cdf0e10cSrcweir 540*cdf0e10cSrcweir /* 541*cdf0e10cSrcweir * the clearUselessData only clearup the content in the 542*cdf0e10cSrcweir * node, not the node itself. 543*cdf0e10cSrcweir */ 544*cdf0e10cSrcweir m_xXMLDocument->clearUselessData(m_pRootBufferNode->getXMLElement(), 545*cdf0e10cSrcweir aChildElements, 546*cdf0e10cSrcweir bIsNotBlocking?(NULL): 547*cdf0e10cSrcweir (m_pCurrentBlockingBufferNode->getXMLElement())); 548*cdf0e10cSrcweir 549*cdf0e10cSrcweir /* 550*cdf0e10cSrcweir * remove the node if it is empty, then if its parent is also 551*cdf0e10cSrcweir * empty, remove it, then if the next parent is also empty, 552*cdf0e10cSrcweir * remove it,..., until parent become null. 553*cdf0e10cSrcweir */ 554*cdf0e10cSrcweir m_xXMLDocument->collapse( m_pRootBufferNode->getXMLElement() ); 555*cdf0e10cSrcweir } 556*cdf0e10cSrcweir 557*cdf0e10cSrcweir /* 558*cdf0e10cSrcweir * if blocking, check the relationship between this BufferNode and 559*cdf0e10cSrcweir * the current blocking BufferNode. 560*cdf0e10cSrcweir */ 561*cdf0e10cSrcweir if ( !bIsNotBlocking ) 562*cdf0e10cSrcweir { 563*cdf0e10cSrcweir /* 564*cdf0e10cSrcweir * the current blocking BufferNode is a descendant of this BufferNode. 565*cdf0e10cSrcweir */ 566*cdf0e10cSrcweir bIsBlockInside = (NULL != pBufferNode->isAncestor(m_pCurrentBlockingBufferNode)); 567*cdf0e10cSrcweir 568*cdf0e10cSrcweir /* 569*cdf0e10cSrcweir * the current blocking BufferNode locates behind this BufferNode in tree 570*cdf0e10cSrcweir * order. 571*cdf0e10cSrcweir */ 572*cdf0e10cSrcweir bIsBlockingAfterward = pBufferNode->isPrevious(m_pCurrentBlockingBufferNode); 573*cdf0e10cSrcweir } 574*cdf0e10cSrcweir 575*cdf0e10cSrcweir /* 576*cdf0e10cSrcweir * this BufferNode's working element needs to be deleted only when 577*cdf0e10cSrcweir * 1. there is no blocking, or 578*cdf0e10cSrcweir * 2. the current blocking BufferNode is a descendant of this BufferNode, 579*cdf0e10cSrcweir * (then in the BufferNode's working element, the useless data before the blocking 580*cdf0e10cSrcweir * element should be deleted.) or 581*cdf0e10cSrcweir * 3. the current blocking BufferNode is locates behind this BufferNode in tree, 582*cdf0e10cSrcweir * (then the useless data between the blocking element and the working element 583*cdf0e10cSrcweir * should be deleted.). 584*cdf0e10cSrcweir * Otherwise, this working element should not be deleted. 585*cdf0e10cSrcweir */ 586*cdf0e10cSrcweir if ( bIsNotBlocking || bIsBlockInside || bIsBlockingAfterward ) 587*cdf0e10cSrcweir { 588*cdf0e10cSrcweir cssu::Sequence< cssu::Reference< cssxw::XXMLElementWrapper > > 589*cdf0e10cSrcweir aChildElements = collectChildWorkingElement(pBufferNode); 590*cdf0e10cSrcweir 591*cdf0e10cSrcweir /* 592*cdf0e10cSrcweir * the clearUselessData only clearup the content in the 593*cdf0e10cSrcweir * node, not the node itself. 594*cdf0e10cSrcweir */ 595*cdf0e10cSrcweir m_xXMLDocument->clearUselessData(pBufferNode->getXMLElement(), 596*cdf0e10cSrcweir aChildElements, 597*cdf0e10cSrcweir bIsBlockInside?(m_pCurrentBlockingBufferNode->getXMLElement()): 598*cdf0e10cSrcweir (NULL)); 599*cdf0e10cSrcweir 600*cdf0e10cSrcweir /* 601*cdf0e10cSrcweir * remove the node if it is empty, then if its parent is also 602*cdf0e10cSrcweir * empty, remove it, then if the next parent is also empty, 603*cdf0e10cSrcweir * remove it,..., until parent become null. 604*cdf0e10cSrcweir */ 605*cdf0e10cSrcweir m_xXMLDocument->collapse( pBufferNode->getXMLElement() ); 606*cdf0e10cSrcweir } 607*cdf0e10cSrcweir } 608*cdf0e10cSrcweir 609*cdf0e10cSrcweir sal_Int32 nIndex = pParent->indexOfChild(pBufferNode); 610*cdf0e10cSrcweir 611*cdf0e10cSrcweir std::vector< const BufferNode* >* vChildren = pBufferNode->getChildren(); 612*cdf0e10cSrcweir pParent->removeChild(pBufferNode); 613*cdf0e10cSrcweir pBufferNode->setParent(NULL); 614*cdf0e10cSrcweir 615*cdf0e10cSrcweir std::vector< const BufferNode * >::const_iterator ii = vChildren->begin(); 616*cdf0e10cSrcweir for( ; ii != vChildren->end(); ++ii ) 617*cdf0e10cSrcweir { 618*cdf0e10cSrcweir ((BufferNode *)(*ii))->setParent(pParent); 619*cdf0e10cSrcweir pParent->addChild(*ii, nIndex); 620*cdf0e10cSrcweir nIndex++; 621*cdf0e10cSrcweir } 622*cdf0e10cSrcweir 623*cdf0e10cSrcweir delete vChildren; 624*cdf0e10cSrcweir 625*cdf0e10cSrcweir /* 626*cdf0e10cSrcweir * delete the BufferNode 627*cdf0e10cSrcweir */ 628*cdf0e10cSrcweir delete pBufferNode; 629*cdf0e10cSrcweir } 630*cdf0e10cSrcweir } 631*cdf0e10cSrcweir 632*cdf0e10cSrcweir BufferNode* SAXEventKeeperImpl::findNextBlockingBufferNode( 633*cdf0e10cSrcweir BufferNode* pStartBufferNode) const 634*cdf0e10cSrcweir /****** SAXEventKeeperImpl/findNextBlockingBufferNode ************************ 635*cdf0e10cSrcweir * 636*cdf0e10cSrcweir * NAME 637*cdf0e10cSrcweir * findNextBlockingBufferNode -- finds the next blocking BufferNode 638*cdf0e10cSrcweir * behind the particular BufferNode. 639*cdf0e10cSrcweir * 640*cdf0e10cSrcweir * SYNOPSIS 641*cdf0e10cSrcweir * pBufferNode = findNextBlockingBufferNode( pStartBufferNode ); 642*cdf0e10cSrcweir * 643*cdf0e10cSrcweir * FUNCTION 644*cdf0e10cSrcweir * see NAME. 645*cdf0e10cSrcweir * 646*cdf0e10cSrcweir * INPUTS 647*cdf0e10cSrcweir * pStartBufferNode - the BufferNode from where to search the next 648*cdf0e10cSrcweir * blocking BufferNode. 649*cdf0e10cSrcweir * 650*cdf0e10cSrcweir * RESULT 651*cdf0e10cSrcweir * pBufferNode - the next blocking BufferNode, or NULL if no such 652*cdf0e10cSrcweir * BufferNode exists. 653*cdf0e10cSrcweir * 654*cdf0e10cSrcweir * HISTORY 655*cdf0e10cSrcweir * 05.01.2004 - implemented 656*cdf0e10cSrcweir * 657*cdf0e10cSrcweir * AUTHOR 658*cdf0e10cSrcweir * Michael Mi 659*cdf0e10cSrcweir * Email: michael.mi@sun.com 660*cdf0e10cSrcweir ******************************************************************************/ 661*cdf0e10cSrcweir { 662*cdf0e10cSrcweir BufferNode* pNext = NULL; 663*cdf0e10cSrcweir 664*cdf0e10cSrcweir if (pStartBufferNode != NULL) 665*cdf0e10cSrcweir { 666*cdf0e10cSrcweir pNext = pStartBufferNode; 667*cdf0e10cSrcweir 668*cdf0e10cSrcweir while (NULL != (pNext = (BufferNode*)pNext->getNextNodeByTreeOrder())) 669*cdf0e10cSrcweir { 670*cdf0e10cSrcweir if (pNext->getBlocker() != NULL) 671*cdf0e10cSrcweir { 672*cdf0e10cSrcweir break; 673*cdf0e10cSrcweir } 674*cdf0e10cSrcweir } 675*cdf0e10cSrcweir } 676*cdf0e10cSrcweir 677*cdf0e10cSrcweir return pNext; 678*cdf0e10cSrcweir } 679*cdf0e10cSrcweir 680*cdf0e10cSrcweir void SAXEventKeeperImpl::diffuse(BufferNode* pBufferNode) const 681*cdf0e10cSrcweir /****** SAXEventKeeperImpl/diffuse ******************************************* 682*cdf0e10cSrcweir * 683*cdf0e10cSrcweir * NAME 684*cdf0e10cSrcweir * diffuse -- diffuse the notification. 685*cdf0e10cSrcweir * 686*cdf0e10cSrcweir * SYNOPSIS 687*cdf0e10cSrcweir * diffuse( pBufferNode ); 688*cdf0e10cSrcweir * 689*cdf0e10cSrcweir * FUNCTION 690*cdf0e10cSrcweir * diffuse the collecting completion notification from the specific 691*cdf0e10cSrcweir * BufferNode along its parent link, until an ancestor which is not 692*cdf0e10cSrcweir * completely received is met. 693*cdf0e10cSrcweir * 694*cdf0e10cSrcweir * INPUTS 695*cdf0e10cSrcweir * pBufferNode - the BufferNode from which the notification will be 696*cdf0e10cSrcweir * diffused. 697*cdf0e10cSrcweir * 698*cdf0e10cSrcweir * RESULT 699*cdf0e10cSrcweir * empty 700*cdf0e10cSrcweir * 701*cdf0e10cSrcweir * HISTORY 702*cdf0e10cSrcweir * 05.01.2004 - implemented 703*cdf0e10cSrcweir * 704*cdf0e10cSrcweir * AUTHOR 705*cdf0e10cSrcweir * Michael Mi 706*cdf0e10cSrcweir * Email: michael.mi@sun.com 707*cdf0e10cSrcweir ******************************************************************************/ 708*cdf0e10cSrcweir { 709*cdf0e10cSrcweir BufferNode* pParent = pBufferNode; 710*cdf0e10cSrcweir 711*cdf0e10cSrcweir while(pParent->isAllReceived()) 712*cdf0e10cSrcweir { 713*cdf0e10cSrcweir pParent->elementCollectorNotify(); 714*cdf0e10cSrcweir pParent = (BufferNode*)pParent->getParent(); 715*cdf0e10cSrcweir } 716*cdf0e10cSrcweir } 717*cdf0e10cSrcweir 718*cdf0e10cSrcweir void SAXEventKeeperImpl::releaseElementMarkBuffer() 719*cdf0e10cSrcweir /****** SAXEventKeeperImpl/releaseElementMarkBuffer ************************** 720*cdf0e10cSrcweir * 721*cdf0e10cSrcweir * NAME 722*cdf0e10cSrcweir * releaseElementMarkBuffer -- releases useless ElementMarks 723*cdf0e10cSrcweir * 724*cdf0e10cSrcweir * SYNOPSIS 725*cdf0e10cSrcweir * releaseElementMarkBuffer( ); 726*cdf0e10cSrcweir * 727*cdf0e10cSrcweir * FUNCTION 728*cdf0e10cSrcweir * releases each ElementMark in the releasing list 729*cdf0e10cSrcweir * m_vReleasedElementMarkBuffers. 730*cdf0e10cSrcweir * The operation differs between an ElementCollector and a Blocker. 731*cdf0e10cSrcweir * 732*cdf0e10cSrcweir * INPUTS 733*cdf0e10cSrcweir * empty 734*cdf0e10cSrcweir * 735*cdf0e10cSrcweir * RESULT 736*cdf0e10cSrcweir * empty 737*cdf0e10cSrcweir * 738*cdf0e10cSrcweir * HISTORY 739*cdf0e10cSrcweir * 05.01.2004 - implemented 740*cdf0e10cSrcweir * 741*cdf0e10cSrcweir * AUTHOR 742*cdf0e10cSrcweir * Michael Mi 743*cdf0e10cSrcweir * Email: michael.mi@sun.com 744*cdf0e10cSrcweir ******************************************************************************/ 745*cdf0e10cSrcweir { 746*cdf0e10cSrcweir m_bIsReleasing = true; 747*cdf0e10cSrcweir while (m_vReleasedElementMarkBuffers.size()>0) 748*cdf0e10cSrcweir { 749*cdf0e10cSrcweir std::vector< sal_Int32 >::iterator pId = m_vReleasedElementMarkBuffers.begin(); 750*cdf0e10cSrcweir sal_Int32 nId = *pId; 751*cdf0e10cSrcweir m_vReleasedElementMarkBuffers.erase( pId ); 752*cdf0e10cSrcweir 753*cdf0e10cSrcweir ElementMark* pElementMark = findElementMarkBuffer(nId); 754*cdf0e10cSrcweir 755*cdf0e10cSrcweir if (pElementMark != NULL) 756*cdf0e10cSrcweir { 757*cdf0e10cSrcweir if (cssxc::sax::ElementMarkType_ELEMENTCOLLECTOR 758*cdf0e10cSrcweir == pElementMark->getType()) 759*cdf0e10cSrcweir /* 760*cdf0e10cSrcweir * it is a EC 761*cdf0e10cSrcweir */ 762*cdf0e10cSrcweir { 763*cdf0e10cSrcweir ElementCollector* pElementCollector = (ElementCollector*)pElementMark; 764*cdf0e10cSrcweir 765*cdf0e10cSrcweir cssxc::sax::ElementMarkPriority nPriority = pElementCollector->getPriority(); 766*cdf0e10cSrcweir bool bToModify = pElementCollector->getModify(); 767*cdf0e10cSrcweir 768*cdf0e10cSrcweir /* 769*cdf0e10cSrcweir * Delete the EC from the buffer node. 770*cdf0e10cSrcweir */ 771*cdf0e10cSrcweir BufferNode* pBufferNode = pElementCollector->getBufferNode(); 772*cdf0e10cSrcweir pBufferNode->removeElementCollector(pElementCollector); 773*cdf0e10cSrcweir 774*cdf0e10cSrcweir if ( nPriority == cssxc::sax::ElementMarkPriority_BEFOREMODIFY) 775*cdf0e10cSrcweir { 776*cdf0e10cSrcweir pBufferNode->notifyBranch(); 777*cdf0e10cSrcweir } 778*cdf0e10cSrcweir 779*cdf0e10cSrcweir if (bToModify) 780*cdf0e10cSrcweir { 781*cdf0e10cSrcweir pBufferNode->notifyAncestor(); 782*cdf0e10cSrcweir } 783*cdf0e10cSrcweir 784*cdf0e10cSrcweir /* 785*cdf0e10cSrcweir * delete the ElementMark 786*cdf0e10cSrcweir */ 787*cdf0e10cSrcweir pElementCollector = NULL; 788*cdf0e10cSrcweir pElementMark = NULL; 789*cdf0e10cSrcweir removeElementMarkBuffer(nId); 790*cdf0e10cSrcweir 791*cdf0e10cSrcweir /* 792*cdf0e10cSrcweir * delete the BufferNode 793*cdf0e10cSrcweir */ 794*cdf0e10cSrcweir diffuse(pBufferNode); 795*cdf0e10cSrcweir smashBufferNode(pBufferNode, false); 796*cdf0e10cSrcweir } 797*cdf0e10cSrcweir else 798*cdf0e10cSrcweir /* 799*cdf0e10cSrcweir * it is a Blocker 800*cdf0e10cSrcweir */ 801*cdf0e10cSrcweir { 802*cdf0e10cSrcweir /* 803*cdf0e10cSrcweir * Delete the TH from the buffer node. 804*cdf0e10cSrcweir */ 805*cdf0e10cSrcweir BufferNode *pBufferNode = pElementMark->getBufferNode(); 806*cdf0e10cSrcweir pBufferNode->setBlocker(NULL); 807*cdf0e10cSrcweir 808*cdf0e10cSrcweir /* 809*cdf0e10cSrcweir * If there is a following handler and no blocking now, then 810*cdf0e10cSrcweir * forward this event 811*cdf0e10cSrcweir */ 812*cdf0e10cSrcweir if (m_pCurrentBlockingBufferNode == pBufferNode) 813*cdf0e10cSrcweir { 814*cdf0e10cSrcweir /* 815*cdf0e10cSrcweir * Before forwarding, the next blocking point needs to be 816*cdf0e10cSrcweir * found. 817*cdf0e10cSrcweir */ 818*cdf0e10cSrcweir m_pCurrentBlockingBufferNode = findNextBlockingBufferNode(pBufferNode); 819*cdf0e10cSrcweir 820*cdf0e10cSrcweir /* 821*cdf0e10cSrcweir * Forward the blocked events between these two STHs. 822*cdf0e10cSrcweir */ 823*cdf0e10cSrcweir if (m_xNextHandler.is()) 824*cdf0e10cSrcweir { 825*cdf0e10cSrcweir BufferNode* pTempCurrentBufferNode = m_pCurrentBufferNode; 826*cdf0e10cSrcweir BufferNode* pTempCurrentBlockingBufferNode = m_pCurrentBlockingBufferNode; 827*cdf0e10cSrcweir 828*cdf0e10cSrcweir m_pCurrentBufferNode = pBufferNode; 829*cdf0e10cSrcweir m_pCurrentBlockingBufferNode = NULL; 830*cdf0e10cSrcweir 831*cdf0e10cSrcweir m_bIsForwarding = true; 832*cdf0e10cSrcweir 833*cdf0e10cSrcweir m_xXMLDocument->generateSAXEvents( 834*cdf0e10cSrcweir m_xNextHandler, 835*cdf0e10cSrcweir this, 836*cdf0e10cSrcweir pBufferNode->getXMLElement(), 837*cdf0e10cSrcweir (pTempCurrentBlockingBufferNode == NULL)?NULL:(pTempCurrentBlockingBufferNode->getXMLElement())); 838*cdf0e10cSrcweir 839*cdf0e10cSrcweir m_bIsForwarding = false; 840*cdf0e10cSrcweir 841*cdf0e10cSrcweir m_pCurrentBufferNode = pTempCurrentBufferNode; 842*cdf0e10cSrcweir if (m_pCurrentBlockingBufferNode == NULL) 843*cdf0e10cSrcweir { 844*cdf0e10cSrcweir m_pCurrentBlockingBufferNode = pTempCurrentBlockingBufferNode; 845*cdf0e10cSrcweir } 846*cdf0e10cSrcweir } 847*cdf0e10cSrcweir 848*cdf0e10cSrcweir if (m_pCurrentBlockingBufferNode == NULL && 849*cdf0e10cSrcweir m_xSAXEventKeeperStatusChangeListener.is()) 850*cdf0e10cSrcweir { 851*cdf0e10cSrcweir m_xSAXEventKeeperStatusChangeListener->blockingStatusChanged(sal_False); 852*cdf0e10cSrcweir } 853*cdf0e10cSrcweir } 854*cdf0e10cSrcweir 855*cdf0e10cSrcweir /* 856*cdf0e10cSrcweir * delete the ElementMark 857*cdf0e10cSrcweir */ 858*cdf0e10cSrcweir pElementMark = NULL; 859*cdf0e10cSrcweir removeElementMarkBuffer(nId); 860*cdf0e10cSrcweir 861*cdf0e10cSrcweir /* 862*cdf0e10cSrcweir * delete the BufferNode 863*cdf0e10cSrcweir */ 864*cdf0e10cSrcweir diffuse(pBufferNode); 865*cdf0e10cSrcweir smashBufferNode(pBufferNode, true); 866*cdf0e10cSrcweir } 867*cdf0e10cSrcweir } 868*cdf0e10cSrcweir } 869*cdf0e10cSrcweir 870*cdf0e10cSrcweir m_bIsReleasing = false; 871*cdf0e10cSrcweir 872*cdf0e10cSrcweir if (!m_pRootBufferNode->hasAnything() && 873*cdf0e10cSrcweir !m_pRootBufferNode->hasChildren() && 874*cdf0e10cSrcweir m_xSAXEventKeeperStatusChangeListener.is()) 875*cdf0e10cSrcweir { 876*cdf0e10cSrcweir m_xSAXEventKeeperStatusChangeListener->bufferStatusChanged(sal_True); 877*cdf0e10cSrcweir } 878*cdf0e10cSrcweir } 879*cdf0e10cSrcweir 880*cdf0e10cSrcweir void SAXEventKeeperImpl::markElementMarkBuffer(sal_Int32 nId) 881*cdf0e10cSrcweir /****** SAXEventKeeperImpl/markElementMarkBuffer ***************************** 882*cdf0e10cSrcweir * 883*cdf0e10cSrcweir * NAME 884*cdf0e10cSrcweir * markElementMarkBuffer -- marks an ElementMark to be released 885*cdf0e10cSrcweir * 886*cdf0e10cSrcweir * SYNOPSIS 887*cdf0e10cSrcweir * markElementMarkBuffer( nId ); 888*cdf0e10cSrcweir * 889*cdf0e10cSrcweir * FUNCTION 890*cdf0e10cSrcweir * puts the ElementMark with the particular Id into the releasing list, 891*cdf0e10cSrcweir * checks whether the releasing process is runing, if not then launch 892*cdf0e10cSrcweir * this process. 893*cdf0e10cSrcweir * 894*cdf0e10cSrcweir * INPUTS 895*cdf0e10cSrcweir * nId - the Id of the ElementMark which will be released 896*cdf0e10cSrcweir * 897*cdf0e10cSrcweir * RESULT 898*cdf0e10cSrcweir * empty 899*cdf0e10cSrcweir * 900*cdf0e10cSrcweir * HISTORY 901*cdf0e10cSrcweir * 05.01.2004 - implemented 902*cdf0e10cSrcweir * 903*cdf0e10cSrcweir * AUTHOR 904*cdf0e10cSrcweir * Michael Mi 905*cdf0e10cSrcweir * Email: michael.mi@sun.com 906*cdf0e10cSrcweir ******************************************************************************/ 907*cdf0e10cSrcweir { 908*cdf0e10cSrcweir m_vReleasedElementMarkBuffers.push_back( nId ); 909*cdf0e10cSrcweir if ( !m_bIsReleasing ) 910*cdf0e10cSrcweir { 911*cdf0e10cSrcweir releaseElementMarkBuffer(); 912*cdf0e10cSrcweir } 913*cdf0e10cSrcweir } 914*cdf0e10cSrcweir 915*cdf0e10cSrcweir sal_Int32 SAXEventKeeperImpl::createElementCollector( 916*cdf0e10cSrcweir sal_Int32 nSecurityId, 917*cdf0e10cSrcweir cssxc::sax::ElementMarkPriority nPriority, 918*cdf0e10cSrcweir bool bModifyElement, 919*cdf0e10cSrcweir const cssu::Reference< cssxc::sax::XReferenceResolvedListener >& xReferenceResolvedListener) 920*cdf0e10cSrcweir /****** SAXEventKeeperImpl/createElementCollector **************************** 921*cdf0e10cSrcweir * 922*cdf0e10cSrcweir * NAME 923*cdf0e10cSrcweir * createElementCollector -- creates a new ElementCollector on the 924*cdf0e10cSrcweir * incoming element. 925*cdf0e10cSrcweir * 926*cdf0e10cSrcweir * SYNOPSIS 927*cdf0e10cSrcweir * nId = createElementCollector( nSecurityId, nPriority, 928*cdf0e10cSrcweir * bModifyElement, 929*cdf0e10cSrcweir * xReferenceResolvedListener ); 930*cdf0e10cSrcweir * 931*cdf0e10cSrcweir * FUNCTION 932*cdf0e10cSrcweir * allocs a new Id, then create an ElementCollector with this Id value. 933*cdf0e10cSrcweir * Add the new created ElementCollector to the new ElementCollecotor list. 934*cdf0e10cSrcweir * 935*cdf0e10cSrcweir * INPUTS 936*cdf0e10cSrcweir * nSecurityId - the security Id of the new ElementCollector 937*cdf0e10cSrcweir * nPriority - the prirority of the new ElementCollector 938*cdf0e10cSrcweir * bModifyElement -whether this BufferNode will modify the content of 939*cdf0e10cSrcweir * the corresponding element it works on 940*cdf0e10cSrcweir * xReferenceResolvedListener - the listener for the new ElementCollector. 941*cdf0e10cSrcweir * 942*cdf0e10cSrcweir * RESULT 943*cdf0e10cSrcweir * nId - the Id of the new ElementCollector 944*cdf0e10cSrcweir * 945*cdf0e10cSrcweir * HISTORY 946*cdf0e10cSrcweir * 05.01.2004 - implemented 947*cdf0e10cSrcweir * 948*cdf0e10cSrcweir * AUTHOR 949*cdf0e10cSrcweir * Michael Mi 950*cdf0e10cSrcweir * Email: michael.mi@sun.com 951*cdf0e10cSrcweir ******************************************************************************/ 952*cdf0e10cSrcweir { 953*cdf0e10cSrcweir sal_Int32 nId = m_nNextElementMarkId; 954*cdf0e10cSrcweir m_nNextElementMarkId ++; 955*cdf0e10cSrcweir 956*cdf0e10cSrcweir ElementCollector* pElementCollector 957*cdf0e10cSrcweir = new ElementCollector( 958*cdf0e10cSrcweir nSecurityId, 959*cdf0e10cSrcweir nId, 960*cdf0e10cSrcweir nPriority, 961*cdf0e10cSrcweir bModifyElement, 962*cdf0e10cSrcweir xReferenceResolvedListener); 963*cdf0e10cSrcweir 964*cdf0e10cSrcweir m_vElementMarkBuffers.push_back( pElementCollector ); 965*cdf0e10cSrcweir 966*cdf0e10cSrcweir /* 967*cdf0e10cSrcweir * All the new EC to initial EC array. 968*cdf0e10cSrcweir */ 969*cdf0e10cSrcweir m_vNewElementCollectors.push_back( pElementCollector ); 970*cdf0e10cSrcweir 971*cdf0e10cSrcweir return nId; 972*cdf0e10cSrcweir } 973*cdf0e10cSrcweir 974*cdf0e10cSrcweir 975*cdf0e10cSrcweir sal_Int32 SAXEventKeeperImpl::createBlocker(sal_Int32 nSecurityId) 976*cdf0e10cSrcweir /****** SAXEventKeeperImpl/createBlocker ************************************* 977*cdf0e10cSrcweir * 978*cdf0e10cSrcweir * NAME 979*cdf0e10cSrcweir * createBlocker -- creates a new Blocker on the incoming element. 980*cdf0e10cSrcweir * 981*cdf0e10cSrcweir * SYNOPSIS 982*cdf0e10cSrcweir * nId = createBlocker( nSecurityId ); 983*cdf0e10cSrcweir * 984*cdf0e10cSrcweir * FUNCTION 985*cdf0e10cSrcweir * see NAME. 986*cdf0e10cSrcweir * 987*cdf0e10cSrcweir * INPUTS 988*cdf0e10cSrcweir * nSecurityId - the security Id of the new Blocker 989*cdf0e10cSrcweir * 990*cdf0e10cSrcweir * RESULT 991*cdf0e10cSrcweir * nId - the Id of the new Blocker 992*cdf0e10cSrcweir * 993*cdf0e10cSrcweir * HISTORY 994*cdf0e10cSrcweir * 05.01.2004 - implemented 995*cdf0e10cSrcweir * 996*cdf0e10cSrcweir * AUTHOR 997*cdf0e10cSrcweir * Michael Mi 998*cdf0e10cSrcweir * Email: michael.mi@sun.com 999*cdf0e10cSrcweir ******************************************************************************/ 1000*cdf0e10cSrcweir { 1001*cdf0e10cSrcweir sal_Int32 nId = m_nNextElementMarkId; 1002*cdf0e10cSrcweir m_nNextElementMarkId ++; 1003*cdf0e10cSrcweir 1004*cdf0e10cSrcweir OSL_ASSERT(m_pNewBlocker == NULL); 1005*cdf0e10cSrcweir 1006*cdf0e10cSrcweir m_pNewBlocker = new ElementMark(nSecurityId, nId); 1007*cdf0e10cSrcweir m_vElementMarkBuffers.push_back( m_pNewBlocker ); 1008*cdf0e10cSrcweir 1009*cdf0e10cSrcweir return nId; 1010*cdf0e10cSrcweir } 1011*cdf0e10cSrcweir 1012*cdf0e10cSrcweir /* XSAXEventKeeper */ 1013*cdf0e10cSrcweir sal_Int32 SAL_CALL SAXEventKeeperImpl::addElementCollector( ) 1014*cdf0e10cSrcweir throw (cssu::RuntimeException) 1015*cdf0e10cSrcweir { 1016*cdf0e10cSrcweir return createElementCollector( 1017*cdf0e10cSrcweir cssxc::sax::ConstOfSecurityId::UNDEFINEDSECURITYID, 1018*cdf0e10cSrcweir cssxc::sax::ElementMarkPriority_AFTERMODIFY, 1019*cdf0e10cSrcweir false, 1020*cdf0e10cSrcweir NULL); 1021*cdf0e10cSrcweir } 1022*cdf0e10cSrcweir 1023*cdf0e10cSrcweir void SAL_CALL SAXEventKeeperImpl::removeElementCollector( sal_Int32 id ) 1024*cdf0e10cSrcweir throw (cssu::RuntimeException) 1025*cdf0e10cSrcweir { 1026*cdf0e10cSrcweir markElementMarkBuffer(id); 1027*cdf0e10cSrcweir } 1028*cdf0e10cSrcweir 1029*cdf0e10cSrcweir sal_Int32 SAL_CALL SAXEventKeeperImpl::addBlocker( ) 1030*cdf0e10cSrcweir throw (cssu::RuntimeException) 1031*cdf0e10cSrcweir { 1032*cdf0e10cSrcweir return createBlocker(cssxc::sax::ConstOfSecurityId::UNDEFINEDSECURITYID); 1033*cdf0e10cSrcweir } 1034*cdf0e10cSrcweir 1035*cdf0e10cSrcweir void SAL_CALL SAXEventKeeperImpl::removeBlocker( sal_Int32 id ) 1036*cdf0e10cSrcweir throw (cssu::RuntimeException) 1037*cdf0e10cSrcweir { 1038*cdf0e10cSrcweir markElementMarkBuffer(id); 1039*cdf0e10cSrcweir } 1040*cdf0e10cSrcweir 1041*cdf0e10cSrcweir sal_Bool SAL_CALL SAXEventKeeperImpl::isBlocking( ) 1042*cdf0e10cSrcweir throw (cssu::RuntimeException) 1043*cdf0e10cSrcweir { 1044*cdf0e10cSrcweir return (m_pCurrentBlockingBufferNode != NULL); 1045*cdf0e10cSrcweir } 1046*cdf0e10cSrcweir 1047*cdf0e10cSrcweir cssu::Reference< cssxw::XXMLElementWrapper > SAL_CALL 1048*cdf0e10cSrcweir SAXEventKeeperImpl::getElement( sal_Int32 id ) 1049*cdf0e10cSrcweir throw (cssu::RuntimeException) 1050*cdf0e10cSrcweir { 1051*cdf0e10cSrcweir cssu::Reference< cssxw::XXMLElementWrapper > rc; 1052*cdf0e10cSrcweir 1053*cdf0e10cSrcweir ElementMark* pElementMark = findElementMarkBuffer(id); 1054*cdf0e10cSrcweir if (pElementMark != NULL) 1055*cdf0e10cSrcweir { 1056*cdf0e10cSrcweir rc = pElementMark->getBufferNode()->getXMLElement(); 1057*cdf0e10cSrcweir } 1058*cdf0e10cSrcweir 1059*cdf0e10cSrcweir return rc; 1060*cdf0e10cSrcweir } 1061*cdf0e10cSrcweir 1062*cdf0e10cSrcweir void SAL_CALL SAXEventKeeperImpl::setElement( 1063*cdf0e10cSrcweir sal_Int32 id, 1064*cdf0e10cSrcweir const cssu::Reference< cssxw::XXMLElementWrapper >& aElement ) 1065*cdf0e10cSrcweir throw (cssu::RuntimeException) 1066*cdf0e10cSrcweir { 1067*cdf0e10cSrcweir if (aElement.is()) 1068*cdf0e10cSrcweir { 1069*cdf0e10cSrcweir m_xXMLDocument->rebuildIDLink(aElement); 1070*cdf0e10cSrcweir 1071*cdf0e10cSrcweir ElementMark* pElementMark = findElementMarkBuffer(id); 1072*cdf0e10cSrcweir 1073*cdf0e10cSrcweir if (pElementMark != NULL) 1074*cdf0e10cSrcweir { 1075*cdf0e10cSrcweir BufferNode* pBufferNode = pElementMark->getBufferNode(); 1076*cdf0e10cSrcweir if (pBufferNode != NULL) 1077*cdf0e10cSrcweir { 1078*cdf0e10cSrcweir bool bIsCurrent = m_xXMLDocument->isCurrent(pBufferNode->getXMLElement()); 1079*cdf0e10cSrcweir pBufferNode->setXMLElement(aElement); 1080*cdf0e10cSrcweir 1081*cdf0e10cSrcweir if (bIsCurrent) 1082*cdf0e10cSrcweir { 1083*cdf0e10cSrcweir m_xXMLDocument->setCurrentElement(aElement); 1084*cdf0e10cSrcweir } 1085*cdf0e10cSrcweir } 1086*cdf0e10cSrcweir } 1087*cdf0e10cSrcweir } 1088*cdf0e10cSrcweir else 1089*cdf0e10cSrcweir { 1090*cdf0e10cSrcweir removeElementCollector( id ); 1091*cdf0e10cSrcweir } 1092*cdf0e10cSrcweir } 1093*cdf0e10cSrcweir 1094*cdf0e10cSrcweir cssu::Reference< cssxs::XDocumentHandler > SAL_CALL SAXEventKeeperImpl::setNextHandler( 1095*cdf0e10cSrcweir const cssu::Reference< cssxs::XDocumentHandler >& xNewHandler ) 1096*cdf0e10cSrcweir throw (cssu::RuntimeException) 1097*cdf0e10cSrcweir { 1098*cdf0e10cSrcweir cssu::Reference< cssxs::XDocumentHandler > xOldHandler = m_xNextHandler; 1099*cdf0e10cSrcweir 1100*cdf0e10cSrcweir m_xNextHandler = xNewHandler; 1101*cdf0e10cSrcweir return xOldHandler; 1102*cdf0e10cSrcweir } 1103*cdf0e10cSrcweir 1104*cdf0e10cSrcweir rtl::OUString SAL_CALL SAXEventKeeperImpl::printBufferNodeTree() 1105*cdf0e10cSrcweir throw (cssu::RuntimeException) 1106*cdf0e10cSrcweir { 1107*cdf0e10cSrcweir rtl::OUString rc; 1108*cdf0e10cSrcweir 1109*cdf0e10cSrcweir rc += rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "ElementMarkBuffers: size = " )); 1110*cdf0e10cSrcweir rc += rtl::OUString::valueOf((sal_Int32)m_vElementMarkBuffers.size()); 1111*cdf0e10cSrcweir rc += rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "\nCurrentBufferNode: " )); 1112*cdf0e10cSrcweir rc += m_xXMLDocument->getNodeName(m_pCurrentBufferNode->getXMLElement()); 1113*cdf0e10cSrcweir rc += rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "\n" )); 1114*cdf0e10cSrcweir rc += printBufferNode(m_pRootBufferNode, 0); 1115*cdf0e10cSrcweir 1116*cdf0e10cSrcweir return rc; 1117*cdf0e10cSrcweir } 1118*cdf0e10cSrcweir 1119*cdf0e10cSrcweir cssu::Reference< cssxw::XXMLElementWrapper > SAL_CALL SAXEventKeeperImpl::getCurrentBlockingNode() 1120*cdf0e10cSrcweir throw (cssu::RuntimeException) 1121*cdf0e10cSrcweir { 1122*cdf0e10cSrcweir cssu::Reference< cssxw::XXMLElementWrapper > rc; 1123*cdf0e10cSrcweir 1124*cdf0e10cSrcweir if (m_pCurrentBlockingBufferNode != NULL) 1125*cdf0e10cSrcweir { 1126*cdf0e10cSrcweir rc = m_pCurrentBlockingBufferNode->getXMLElement(); 1127*cdf0e10cSrcweir } 1128*cdf0e10cSrcweir 1129*cdf0e10cSrcweir return rc; 1130*cdf0e10cSrcweir } 1131*cdf0e10cSrcweir 1132*cdf0e10cSrcweir /* XSecuritySAXEventKeeper */ 1133*cdf0e10cSrcweir sal_Int32 SAL_CALL SAXEventKeeperImpl::addSecurityElementCollector( 1134*cdf0e10cSrcweir cssxc::sax::ElementMarkPriority priority, 1135*cdf0e10cSrcweir sal_Bool modifyElement ) 1136*cdf0e10cSrcweir throw (cssu::RuntimeException) 1137*cdf0e10cSrcweir { 1138*cdf0e10cSrcweir return createElementCollector( 1139*cdf0e10cSrcweir cssxc::sax::ConstOfSecurityId::UNDEFINEDSECURITYID, 1140*cdf0e10cSrcweir priority, 1141*cdf0e10cSrcweir modifyElement, 1142*cdf0e10cSrcweir NULL); 1143*cdf0e10cSrcweir } 1144*cdf0e10cSrcweir 1145*cdf0e10cSrcweir sal_Int32 SAL_CALL SAXEventKeeperImpl::cloneElementCollector( 1146*cdf0e10cSrcweir sal_Int32 referenceId, 1147*cdf0e10cSrcweir cssxc::sax::ElementMarkPriority priority ) 1148*cdf0e10cSrcweir throw (cssu::RuntimeException) 1149*cdf0e10cSrcweir { 1150*cdf0e10cSrcweir sal_Int32 nId = -1; 1151*cdf0e10cSrcweir 1152*cdf0e10cSrcweir ElementCollector* pElementCollector = (ElementCollector*)findElementMarkBuffer(referenceId); 1153*cdf0e10cSrcweir if (pElementCollector != NULL) 1154*cdf0e10cSrcweir { 1155*cdf0e10cSrcweir nId = m_nNextElementMarkId; 1156*cdf0e10cSrcweir m_nNextElementMarkId ++; 1157*cdf0e10cSrcweir 1158*cdf0e10cSrcweir ElementCollector* pClonedOne 1159*cdf0e10cSrcweir = pElementCollector->clone(nId, priority); 1160*cdf0e10cSrcweir 1161*cdf0e10cSrcweir /* 1162*cdf0e10cSrcweir * add this EC into the security data buffer array. 1163*cdf0e10cSrcweir */ 1164*cdf0e10cSrcweir m_vElementMarkBuffers.push_back(pClonedOne); 1165*cdf0e10cSrcweir 1166*cdf0e10cSrcweir /* 1167*cdf0e10cSrcweir * If the reference EC is still in initial EC array, add 1168*cdf0e10cSrcweir * this cloned one into the initial EC array too. 1169*cdf0e10cSrcweir */ 1170*cdf0e10cSrcweir if (pElementCollector->getBufferNode() == NULL) 1171*cdf0e10cSrcweir { 1172*cdf0e10cSrcweir m_vNewElementCollectors.push_back(pClonedOne); 1173*cdf0e10cSrcweir } 1174*cdf0e10cSrcweir } 1175*cdf0e10cSrcweir 1176*cdf0e10cSrcweir return nId; 1177*cdf0e10cSrcweir } 1178*cdf0e10cSrcweir 1179*cdf0e10cSrcweir void SAL_CALL SAXEventKeeperImpl::setSecurityId( sal_Int32 id, sal_Int32 securityId ) 1180*cdf0e10cSrcweir throw (cssu::RuntimeException) 1181*cdf0e10cSrcweir { 1182*cdf0e10cSrcweir ElementMark* pElementMark = findElementMarkBuffer(id); 1183*cdf0e10cSrcweir if (pElementMark != NULL) 1184*cdf0e10cSrcweir { 1185*cdf0e10cSrcweir pElementMark->setSecurityId(securityId); 1186*cdf0e10cSrcweir } 1187*cdf0e10cSrcweir } 1188*cdf0e10cSrcweir 1189*cdf0e10cSrcweir 1190*cdf0e10cSrcweir /* XReferenceResolvedBroadcaster */ 1191*cdf0e10cSrcweir void SAL_CALL SAXEventKeeperImpl::addReferenceResolvedListener( 1192*cdf0e10cSrcweir sal_Int32 referenceId, 1193*cdf0e10cSrcweir const cssu::Reference< cssxc::sax::XReferenceResolvedListener >& listener ) 1194*cdf0e10cSrcweir throw (cssu::RuntimeException) 1195*cdf0e10cSrcweir { 1196*cdf0e10cSrcweir ElementCollector* pElementCollector = (ElementCollector*)findElementMarkBuffer(referenceId); 1197*cdf0e10cSrcweir if (pElementCollector != NULL) 1198*cdf0e10cSrcweir { 1199*cdf0e10cSrcweir pElementCollector->setReferenceResolvedListener(listener); 1200*cdf0e10cSrcweir } 1201*cdf0e10cSrcweir } 1202*cdf0e10cSrcweir 1203*cdf0e10cSrcweir void SAL_CALL SAXEventKeeperImpl::removeReferenceResolvedListener( 1204*cdf0e10cSrcweir sal_Int32 /*referenceId*/, 1205*cdf0e10cSrcweir const cssu::Reference< cssxc::sax::XReferenceResolvedListener >&) 1206*cdf0e10cSrcweir throw (cssu::RuntimeException) 1207*cdf0e10cSrcweir { 1208*cdf0e10cSrcweir } 1209*cdf0e10cSrcweir 1210*cdf0e10cSrcweir /* XSAXEventKeeperStatusChangeBroadcaster */ 1211*cdf0e10cSrcweir void SAL_CALL SAXEventKeeperImpl::addSAXEventKeeperStatusChangeListener( 1212*cdf0e10cSrcweir const cssu::Reference< cssxc::sax::XSAXEventKeeperStatusChangeListener >& listener ) 1213*cdf0e10cSrcweir throw (cssu::RuntimeException) 1214*cdf0e10cSrcweir { 1215*cdf0e10cSrcweir m_xSAXEventKeeperStatusChangeListener = listener; 1216*cdf0e10cSrcweir } 1217*cdf0e10cSrcweir 1218*cdf0e10cSrcweir void SAL_CALL SAXEventKeeperImpl::removeSAXEventKeeperStatusChangeListener( 1219*cdf0e10cSrcweir const cssu::Reference< cssxc::sax::XSAXEventKeeperStatusChangeListener >&) 1220*cdf0e10cSrcweir throw (cssu::RuntimeException) 1221*cdf0e10cSrcweir { 1222*cdf0e10cSrcweir } 1223*cdf0e10cSrcweir 1224*cdf0e10cSrcweir /* XDocumentHandler */ 1225*cdf0e10cSrcweir void SAL_CALL SAXEventKeeperImpl::startDocument( ) 1226*cdf0e10cSrcweir throw (cssxs::SAXException, cssu::RuntimeException) 1227*cdf0e10cSrcweir { 1228*cdf0e10cSrcweir if ( m_xNextHandler.is()) 1229*cdf0e10cSrcweir { 1230*cdf0e10cSrcweir m_xNextHandler->startDocument(); 1231*cdf0e10cSrcweir } 1232*cdf0e10cSrcweir } 1233*cdf0e10cSrcweir 1234*cdf0e10cSrcweir void SAL_CALL SAXEventKeeperImpl::endDocument( ) 1235*cdf0e10cSrcweir throw (cssxs::SAXException, cssu::RuntimeException) 1236*cdf0e10cSrcweir { 1237*cdf0e10cSrcweir if ( m_xNextHandler.is()) 1238*cdf0e10cSrcweir { 1239*cdf0e10cSrcweir m_xNextHandler->endDocument(); 1240*cdf0e10cSrcweir } 1241*cdf0e10cSrcweir } 1242*cdf0e10cSrcweir 1243*cdf0e10cSrcweir void SAL_CALL SAXEventKeeperImpl::startElement( 1244*cdf0e10cSrcweir const rtl::OUString& aName, 1245*cdf0e10cSrcweir const cssu::Reference< cssxs::XAttributeList >& xAttribs ) 1246*cdf0e10cSrcweir throw (cssxs::SAXException, cssu::RuntimeException) 1247*cdf0e10cSrcweir { 1248*cdf0e10cSrcweir /* 1249*cdf0e10cSrcweir * If there is a following handler and no blocking now, then 1250*cdf0e10cSrcweir * forward this event 1251*cdf0e10cSrcweir */ 1252*cdf0e10cSrcweir if ((m_pCurrentBlockingBufferNode == NULL) && 1253*cdf0e10cSrcweir (m_xNextHandler.is()) && 1254*cdf0e10cSrcweir (!m_bIsForwarding) && 1255*cdf0e10cSrcweir (m_pNewBlocker == NULL)) 1256*cdf0e10cSrcweir { 1257*cdf0e10cSrcweir m_xNextHandler->startElement(aName, xAttribs); 1258*cdf0e10cSrcweir } 1259*cdf0e10cSrcweir 1260*cdf0e10cSrcweir /* 1261*cdf0e10cSrcweir * If not forwarding, buffer this startElement. 1262*cdf0e10cSrcweir */ 1263*cdf0e10cSrcweir if (!m_bIsForwarding) 1264*cdf0e10cSrcweir { 1265*cdf0e10cSrcweir #ifndef _USECOMPRESSEDDOCUMENTHANDLER 1266*cdf0e10cSrcweir m_xDocumentHandler->startElement(aName, xAttribs); 1267*cdf0e10cSrcweir #else 1268*cdf0e10cSrcweir sal_Int32 nLength = xAttribs->getLength(); 1269*cdf0e10cSrcweir cssu::Sequence< cssxcsax::XMLAttribute > aAttributes (nLength); 1270*cdf0e10cSrcweir 1271*cdf0e10cSrcweir for ( int i = 0; i<nLength; ++i ) 1272*cdf0e10cSrcweir { 1273*cdf0e10cSrcweir aAttributes[i].sName = xAttribs->getNameByIndex((short)i); 1274*cdf0e10cSrcweir aAttributes[i].sValue =xAttribs->getValueByIndex((short)i); 1275*cdf0e10cSrcweir } 1276*cdf0e10cSrcweir 1277*cdf0e10cSrcweir m_xCompressedDocumentHandler->_startElement(aName, aAttributes); 1278*cdf0e10cSrcweir #endif 1279*cdf0e10cSrcweir 1280*cdf0e10cSrcweir } 1281*cdf0e10cSrcweir 1282*cdf0e10cSrcweir BufferNode* pBufferNode = addNewElementMarkBuffers(); 1283*cdf0e10cSrcweir if (pBufferNode != NULL) 1284*cdf0e10cSrcweir { 1285*cdf0e10cSrcweir setCurrentBufferNode(pBufferNode); 1286*cdf0e10cSrcweir } 1287*cdf0e10cSrcweir } 1288*cdf0e10cSrcweir 1289*cdf0e10cSrcweir void SAL_CALL SAXEventKeeperImpl::endElement( const rtl::OUString& aName ) 1290*cdf0e10cSrcweir throw (cssxs::SAXException, cssu::RuntimeException) 1291*cdf0e10cSrcweir { 1292*cdf0e10cSrcweir sal_Bool bIsCurrent = m_xXMLDocument->isCurrent(m_pCurrentBufferNode->getXMLElement()); 1293*cdf0e10cSrcweir 1294*cdf0e10cSrcweir /* 1295*cdf0e10cSrcweir * If there is a following handler and no blocking now, then 1296*cdf0e10cSrcweir * forward this event 1297*cdf0e10cSrcweir */ 1298*cdf0e10cSrcweir if ((m_pCurrentBlockingBufferNode == NULL) && 1299*cdf0e10cSrcweir (m_xNextHandler.is()) && 1300*cdf0e10cSrcweir (!m_bIsForwarding)) 1301*cdf0e10cSrcweir { 1302*cdf0e10cSrcweir m_xNextHandler->endElement(aName); 1303*cdf0e10cSrcweir } 1304*cdf0e10cSrcweir 1305*cdf0e10cSrcweir if ((m_pCurrentBlockingBufferNode != NULL) || 1306*cdf0e10cSrcweir (m_pCurrentBufferNode != m_pRootBufferNode) || 1307*cdf0e10cSrcweir (!m_xXMLDocument->isCurrentElementEmpty())) 1308*cdf0e10cSrcweir { 1309*cdf0e10cSrcweir if (!m_bIsForwarding) 1310*cdf0e10cSrcweir { 1311*cdf0e10cSrcweir #ifndef _USECOMPRESSEDDOCUMENTHANDLER 1312*cdf0e10cSrcweir m_xDocumentHandler->endElement(aName); 1313*cdf0e10cSrcweir #else 1314*cdf0e10cSrcweir m_xCompressedDocumentHandler->_endElement(aName); 1315*cdf0e10cSrcweir #endif 1316*cdf0e10cSrcweir } 1317*cdf0e10cSrcweir 1318*cdf0e10cSrcweir /* 1319*cdf0e10cSrcweir * If the current buffer node has not notified yet, and 1320*cdf0e10cSrcweir * the current buffer node is waiting for the current element, 1321*cdf0e10cSrcweir * then let it notify. 1322*cdf0e10cSrcweir */ 1323*cdf0e10cSrcweir if (bIsCurrent && (m_pCurrentBufferNode != m_pRootBufferNode)) 1324*cdf0e10cSrcweir { 1325*cdf0e10cSrcweir BufferNode* pOldCurrentBufferNode = m_pCurrentBufferNode; 1326*cdf0e10cSrcweir m_pCurrentBufferNode = (BufferNode*)m_pCurrentBufferNode->getParent(); 1327*cdf0e10cSrcweir 1328*cdf0e10cSrcweir pOldCurrentBufferNode->setReceivedAll(); 1329*cdf0e10cSrcweir 1330*cdf0e10cSrcweir if ((m_pCurrentBufferNode == m_pRootBufferNode) && 1331*cdf0e10cSrcweir m_xSAXEventKeeperStatusChangeListener.is()) 1332*cdf0e10cSrcweir { 1333*cdf0e10cSrcweir m_xSAXEventKeeperStatusChangeListener->collectionStatusChanged(sal_False); 1334*cdf0e10cSrcweir } 1335*cdf0e10cSrcweir } 1336*cdf0e10cSrcweir } 1337*cdf0e10cSrcweir else 1338*cdf0e10cSrcweir { 1339*cdf0e10cSrcweir if (!m_bIsForwarding) 1340*cdf0e10cSrcweir { 1341*cdf0e10cSrcweir m_xXMLDocument->removeCurrentElement(); 1342*cdf0e10cSrcweir } 1343*cdf0e10cSrcweir } 1344*cdf0e10cSrcweir } 1345*cdf0e10cSrcweir 1346*cdf0e10cSrcweir void SAL_CALL SAXEventKeeperImpl::characters( const rtl::OUString& aChars ) 1347*cdf0e10cSrcweir throw (cssxs::SAXException, cssu::RuntimeException) 1348*cdf0e10cSrcweir { 1349*cdf0e10cSrcweir if (!m_bIsForwarding) 1350*cdf0e10cSrcweir { 1351*cdf0e10cSrcweir if ((m_pCurrentBlockingBufferNode == NULL) && m_xNextHandler.is()) 1352*cdf0e10cSrcweir { 1353*cdf0e10cSrcweir m_xNextHandler->characters(aChars); 1354*cdf0e10cSrcweir } 1355*cdf0e10cSrcweir 1356*cdf0e10cSrcweir if ((m_pCurrentBlockingBufferNode != NULL) || 1357*cdf0e10cSrcweir (m_pCurrentBufferNode != m_pRootBufferNode)) 1358*cdf0e10cSrcweir { 1359*cdf0e10cSrcweir #ifndef _USECOMPRESSEDDOCUMENTHANDLER 1360*cdf0e10cSrcweir m_xDocumentHandler->characters(aChars); 1361*cdf0e10cSrcweir #else 1362*cdf0e10cSrcweir m_xCompressedDocumentHandler->_characters(aChars); 1363*cdf0e10cSrcweir #endif 1364*cdf0e10cSrcweir } 1365*cdf0e10cSrcweir } 1366*cdf0e10cSrcweir } 1367*cdf0e10cSrcweir 1368*cdf0e10cSrcweir void SAL_CALL SAXEventKeeperImpl::ignorableWhitespace( const rtl::OUString& aWhitespaces ) 1369*cdf0e10cSrcweir throw (cssxs::SAXException, cssu::RuntimeException) 1370*cdf0e10cSrcweir { 1371*cdf0e10cSrcweir characters( aWhitespaces ); 1372*cdf0e10cSrcweir } 1373*cdf0e10cSrcweir 1374*cdf0e10cSrcweir void SAL_CALL SAXEventKeeperImpl::processingInstruction( 1375*cdf0e10cSrcweir const rtl::OUString& aTarget, const rtl::OUString& aData ) 1376*cdf0e10cSrcweir throw (cssxs::SAXException, cssu::RuntimeException) 1377*cdf0e10cSrcweir { 1378*cdf0e10cSrcweir if (!m_bIsForwarding) 1379*cdf0e10cSrcweir { 1380*cdf0e10cSrcweir if ((m_pCurrentBlockingBufferNode == NULL) && m_xNextHandler.is()) 1381*cdf0e10cSrcweir { 1382*cdf0e10cSrcweir m_xNextHandler->processingInstruction(aTarget, aData); 1383*cdf0e10cSrcweir } 1384*cdf0e10cSrcweir 1385*cdf0e10cSrcweir if ((m_pCurrentBlockingBufferNode != NULL) || 1386*cdf0e10cSrcweir (m_pCurrentBufferNode != m_pRootBufferNode)) 1387*cdf0e10cSrcweir { 1388*cdf0e10cSrcweir #ifndef _USECOMPRESSEDDOCUMENTHANDLER 1389*cdf0e10cSrcweir m_xDocumentHandler->processingInstruction(aTarget, aData); 1390*cdf0e10cSrcweir #else 1391*cdf0e10cSrcweir m_xCompressedDocumentHandler->_processingInstruction(aTarget, aData); 1392*cdf0e10cSrcweir #endif 1393*cdf0e10cSrcweir } 1394*cdf0e10cSrcweir } 1395*cdf0e10cSrcweir } 1396*cdf0e10cSrcweir 1397*cdf0e10cSrcweir void SAL_CALL SAXEventKeeperImpl::setDocumentLocator( const cssu::Reference< cssxs::XLocator >&) 1398*cdf0e10cSrcweir throw (cssxs::SAXException, cssu::RuntimeException) 1399*cdf0e10cSrcweir { 1400*cdf0e10cSrcweir } 1401*cdf0e10cSrcweir 1402*cdf0e10cSrcweir /* XInitialization */ 1403*cdf0e10cSrcweir void SAL_CALL SAXEventKeeperImpl::initialize( const cssu::Sequence< cssu::Any >& aArguments ) 1404*cdf0e10cSrcweir throw (cssu::Exception, cssu::RuntimeException) 1405*cdf0e10cSrcweir { 1406*cdf0e10cSrcweir OSL_ASSERT(aArguments.getLength() == 1); 1407*cdf0e10cSrcweir 1408*cdf0e10cSrcweir aArguments[0] >>= m_xXMLDocument; 1409*cdf0e10cSrcweir m_xDocumentHandler = cssu::Reference< cssxs::XDocumentHandler >( 1410*cdf0e10cSrcweir m_xXMLDocument, cssu::UNO_QUERY ); 1411*cdf0e10cSrcweir m_xCompressedDocumentHandler = cssu::Reference< cssxcsax::XCompressedDocumentHandler >( 1412*cdf0e10cSrcweir m_xXMLDocument, cssu::UNO_QUERY ); 1413*cdf0e10cSrcweir 1414*cdf0e10cSrcweir m_pRootBufferNode = new BufferNode(m_xXMLDocument->getCurrentElement()); 1415*cdf0e10cSrcweir m_pCurrentBufferNode = m_pRootBufferNode; 1416*cdf0e10cSrcweir } 1417*cdf0e10cSrcweir 1418*cdf0e10cSrcweir rtl::OUString SAXEventKeeperImpl_getImplementationName () 1419*cdf0e10cSrcweir throw (cssu::RuntimeException) 1420*cdf0e10cSrcweir { 1421*cdf0e10cSrcweir return rtl::OUString ( RTL_CONSTASCII_USTRINGPARAM ( IMPLEMENTATION_NAME ) ); 1422*cdf0e10cSrcweir } 1423*cdf0e10cSrcweir 1424*cdf0e10cSrcweir sal_Bool SAL_CALL SAXEventKeeperImpl_supportsService( const rtl::OUString& ServiceName ) 1425*cdf0e10cSrcweir throw (cssu::RuntimeException) 1426*cdf0e10cSrcweir { 1427*cdf0e10cSrcweir return ServiceName.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM ( SERVICE_NAME )); 1428*cdf0e10cSrcweir } 1429*cdf0e10cSrcweir 1430*cdf0e10cSrcweir cssu::Sequence< rtl::OUString > SAL_CALL SAXEventKeeperImpl_getSupportedServiceNames( ) 1431*cdf0e10cSrcweir throw (cssu::RuntimeException) 1432*cdf0e10cSrcweir { 1433*cdf0e10cSrcweir cssu::Sequence < rtl::OUString > aRet(1); 1434*cdf0e10cSrcweir rtl::OUString* pArray = aRet.getArray(); 1435*cdf0e10cSrcweir pArray[0] = rtl::OUString ( RTL_CONSTASCII_USTRINGPARAM ( SERVICE_NAME ) ); 1436*cdf0e10cSrcweir return aRet; 1437*cdf0e10cSrcweir } 1438*cdf0e10cSrcweir #undef SERVICE_NAME 1439*cdf0e10cSrcweir 1440*cdf0e10cSrcweir cssu::Reference< cssu::XInterface > SAL_CALL SAXEventKeeperImpl_createInstance( 1441*cdf0e10cSrcweir const cssu::Reference< cssl::XMultiServiceFactory > &) 1442*cdf0e10cSrcweir throw( cssu::Exception ) 1443*cdf0e10cSrcweir { 1444*cdf0e10cSrcweir return (cppu::OWeakObject*) new SAXEventKeeperImpl(); 1445*cdf0e10cSrcweir } 1446*cdf0e10cSrcweir 1447*cdf0e10cSrcweir /* XServiceInfo */ 1448*cdf0e10cSrcweir rtl::OUString SAL_CALL SAXEventKeeperImpl::getImplementationName( ) 1449*cdf0e10cSrcweir throw (cssu::RuntimeException) 1450*cdf0e10cSrcweir { 1451*cdf0e10cSrcweir return SAXEventKeeperImpl_getImplementationName(); 1452*cdf0e10cSrcweir } 1453*cdf0e10cSrcweir sal_Bool SAL_CALL SAXEventKeeperImpl::supportsService( const rtl::OUString& rServiceName ) 1454*cdf0e10cSrcweir throw (cssu::RuntimeException) 1455*cdf0e10cSrcweir { 1456*cdf0e10cSrcweir return SAXEventKeeperImpl_supportsService( rServiceName ); 1457*cdf0e10cSrcweir } 1458*cdf0e10cSrcweir cssu::Sequence< rtl::OUString > SAL_CALL SAXEventKeeperImpl::getSupportedServiceNames( ) 1459*cdf0e10cSrcweir throw (cssu::RuntimeException) 1460*cdf0e10cSrcweir { 1461*cdf0e10cSrcweir return SAXEventKeeperImpl_getSupportedServiceNames(); 1462*cdf0e10cSrcweir } 1463*cdf0e10cSrcweir 1464