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