Attachment #251 for bug #1541

View | Details | Raw Unified | Return to bug 1541
Collapse All | Expand All




     *  The current node is not consulted or set.
     */
    Node getNextSibling(Node node) {
		return getNextSibling(node, fRoot);
	}

    /** Internal function.
     *  Return the nextSibling Node, from the input node
     *  after applying filter, whatToshow.
	 *  NEVER TRAVERSES ABOVE THE SPECIFIED ROOT NODE. 
     *  The current node is not consulted or set.
     */
    Node getNextSibling(Node node, Node root) {
        
        if (node == null || node == root) return null;
        
        Node newNode = node.getNextSibling();
        if (newNode == null) {
                
            newNode = node.getParentNode();
                
            if (newNode == null || newNode == root)  return null; 
                
            int parentAccept = acceptNode(newNode);
                
            if (parentAccept==NodeFilter.FILTER_SKIP) {
                return getNextSibling(newNode, root);
            }
                
            return null;

            return newNode;
        else 
        if (accept == NodeFilter.FILTER_SKIP) {
            Node fChild = getFirstChild(newNode);
            if (fChild == null) {
                return getNextSibling(newNode, root);
            }
            return fChild;
        }
        else 
        //if (accept == NodeFilter.REJECT_NODE) 
        {
            return getNextSibling(newNode, root);
        }
        
    } // getNextSibling(Node node) {

     *  The current node is not consulted or set.
     */
    Node getPreviousSibling(Node node) {
		return getPreviousSibling(node, fRoot);
	}

    /** Internal function.
     *  Return the previousSibling Node, from the input node
     *  after applying filter, whatToshow.
	 *  NEVER TRAVERSES ABOVE THE SPECIFIED ROOT NODE. 
     *  The current node is not consulted or set.
     */
    Node getPreviousSibling(Node node, Node root) {
        
        if (node == null || node == root) return null;
        
        Node newNode = node.getPreviousSibling();
        if (newNode == null) {
                
            newNode = node.getParentNode();
            if (newNode == null || newNode == root)  return null; 
                
            int parentAccept = acceptNode(newNode);
                
            if (parentAccept==NodeFilter.FILTER_SKIP) {
                return getPreviousSibling(newNode, root);
            }
            
            return null;

        if (accept == NodeFilter.FILTER_SKIP) {
            Node fChild =  getLastChild(newNode);
            if (fChild == null) {
                return getPreviousSibling(newNode, root);
            }
            return fChild;
        }
        else 
        //if (accept == NodeFilter.REJECT_NODE) 
        {
            return getPreviousSibling(newNode, root);
        }
        
    } // getPreviousSibling(Node node) {

     *  The current node is not consulted or set.
     */
    Node getFirstChild(Node node) {
        
        if (node == null) return null;
        
        if ( !fEntityReferenceExpansion
             && node.getNodeType() == Node.ENTITY_REFERENCE_NODE)
            return null;
   
        Node newNode = node.getFirstChild();
        if (newNode == null)  return null;
        
        int accept = acceptNode(newNode);
        

        if (accept == NodeFilter.FILTER_SKIP
            && newNode.hasChildNodes()) 
        {
            Node fChild = getFirstChild(newNode);
            if (fChild == null) {
                return getNextSibling(newNode, node);
            }
            return fChild;
        }
        else 
        //if (accept == NodeFilter.REJECT_NODE) 
        {
            return getNextSibling(newNode, node);
        }
        
        

        if (accept == NodeFilter.FILTER_SKIP
            && newNode.hasChildNodes()) 
        {
            Node lChild = getLastChild(newNode);
            if (lChild == null) {
                return getPreviousSibling(newNode, node);
            }
            return lChild;
        }
        else 
        //if (accept == NodeFilter.REJECT_NODE) 
        {
            return getPreviousSibling(newNode, node);
        }
        
        

Return to bug 1541

Lines 319-338 Link Here

(-)src/org/apache/xerces/dom/TreeWalkerImpl.java (-17 / +48 lines)
319	* The current node is not consulted or set.	319	* The current node is not consulted or set.
320	*/	320	*/
321	Node getNextSibling(Node node) {	321	Node getNextSibling(Node node) {
		322	return getNextSibling(node, fRoot);
		323	}
		324
		325	/** Internal function.
		326	* Return the nextSibling Node, from the input node
		327	* after applying filter, whatToshow.
		328	* NEVER TRAVERSES ABOVE THE SPECIFIED ROOT NODE.
		329	* The current node is not consulted or set.
		330	*/
		331	Node getNextSibling(Node node, Node root) {
322		332
323	if (node == null \|\| node == fRoot) return null;	333	if (node == null \|\| node == root) return null;
324		334
325	Node newNode = node.getNextSibling();	335	Node newNode = node.getNextSibling();
326	if (newNode == null) {	336	if (newNode == null) {
327		337
328	newNode = node.getParentNode();	338	newNode = node.getParentNode();
329		339
330	if (newNode == null \|\| node == fRoot) return null;	340	if (newNode == null \|\| newNode == root) return null;
331		341
332	int parentAccept = acceptNode(newNode);	342	int parentAccept = acceptNode(newNode);
333		343
334	if (parentAccept==NodeFilter.FILTER_SKIP) {	344	if (parentAccept==NodeFilter.FILTER_SKIP) {
335	return getNextSibling(newNode);	345	return getNextSibling(newNode, root);
336	}	346	}
337		347
338	return null;	348	return null;
Lines 344-355 Link Here
344	return newNode;	354	return newNode;
345	else	355	else
346	if (accept == NodeFilter.FILTER_SKIP) {	356	if (accept == NodeFilter.FILTER_SKIP) {
347	return getFirstChild(newNode);	357	Node fChild = getFirstChild(newNode);
		358	if (fChild == null) {
		359	return getNextSibling(newNode, root);
		360	}
		361	return fChild;
348	}	362	}
349	else	363	else
350	//if (accept == NodeFilter.REJECT_NODE)	364	//if (accept == NodeFilter.REJECT_NODE)
351	{	365	{
352	return getNextSibling(newNode);	366	return getNextSibling(newNode, root);
353	}	367	}
354		368
355	} // getNextSibling(Node node) {	369	} // getNextSibling(Node node) {
Lines 360-378 Link Here
360	* The current node is not consulted or set.	374	* The current node is not consulted or set.
361	*/	375	*/
362	Node getPreviousSibling(Node node) {	376	Node getPreviousSibling(Node node) {
		377	return getPreviousSibling(node, fRoot);
		378	}
		379
		380	/** Internal function.
		381	* Return the previousSibling Node, from the input node
		382	* after applying filter, whatToshow.
		383	* NEVER TRAVERSES ABOVE THE SPECIFIED ROOT NODE.
		384	* The current node is not consulted or set.
		385	*/
		386	Node getPreviousSibling(Node node, Node root) {
363		387
364	if (node == null \|\| node == fRoot) return null;	388	if (node == null \|\| node == root) return null;
365		389
366	Node newNode = node.getPreviousSibling();	390	Node newNode = node.getPreviousSibling();
367	if (newNode == null) {	391	if (newNode == null) {
368		392
369	newNode = node.getParentNode();	393	newNode = node.getParentNode();
370	if (newNode == null \|\| node == fRoot) return null;	394	if (newNode == null \|\| newNode == root) return null;
371		395
372	int parentAccept = acceptNode(newNode);	396	int parentAccept = acceptNode(newNode);
373		397
374	if (parentAccept==NodeFilter.FILTER_SKIP) {	398	if (parentAccept==NodeFilter.FILTER_SKIP) {
375	return getPreviousSibling(newNode);	399	return getPreviousSibling(newNode, root);
376	}	400	}
377		401
378	return null;	402	return null;
Lines 386-399 Link Here
386	if (accept == NodeFilter.FILTER_SKIP) {	410	if (accept == NodeFilter.FILTER_SKIP) {
387	Node fChild = getLastChild(newNode);	411	Node fChild = getLastChild(newNode);
388	if (fChild == null) {	412	if (fChild == null) {
389	return getPreviousSibling(newNode);	413	return getPreviousSibling(newNode, root);
390	}	414	}
391	return fChild;	415	return fChild;
392	}	416	}
393	else	417	else
394	//if (accept == NodeFilter.REJECT_NODE)	418	//if (accept == NodeFilter.REJECT_NODE)
395	{	419	{
396	return getPreviousSibling(newNode);	420	return getPreviousSibling(newNode, root);
397	}	421	}
398		422
399	} // getPreviousSibling(Node node) {	423	} // getPreviousSibling(Node node) {
Lines 404-418 Link Here
404	* The current node is not consulted or set.	428	* The current node is not consulted or set.
405	*/	429	*/
406	Node getFirstChild(Node node) {	430	Node getFirstChild(Node node) {
407
408	if (node == null) return null;	431	if (node == null) return null;
409		432
410	if ( !fEntityReferenceExpansion	433	if ( !fEntityReferenceExpansion
411	&& node.getNodeType() == Node.ENTITY_REFERENCE_NODE)	434	&& node.getNodeType() == Node.ENTITY_REFERENCE_NODE)
412	return null;	435	return null;
413		436
414	Node newNode = node.getFirstChild();	437	Node newNode = node.getFirstChild();
415	if (newNode == null) return getNextSibling(node);	438	if (newNode == null) return null;
416		439
417	int accept = acceptNode(newNode);	440	int accept = acceptNode(newNode);
418		441
Lines 422-433 Link Here
422	if (accept == NodeFilter.FILTER_SKIP	445	if (accept == NodeFilter.FILTER_SKIP
423	&& newNode.hasChildNodes())	446	&& newNode.hasChildNodes())
424	{	447	{
425	return getFirstChild(newNode);	448	Node fChild = getFirstChild(newNode);
		449	if (fChild == null) {
		450	return getNextSibling(newNode, node);
		451	}
		452	return fChild;
426	}	453	}
427	else	454	else
428	//if (accept == NodeFilter.REJECT_NODE)	455	//if (accept == NodeFilter.REJECT_NODE)
429	{	456	{
430	return getNextSibling(newNode);	457	return getNextSibling(newNode, node);
431	}	458	}
432		459
433		460
Lines 457-468 Link Here
457	if (accept == NodeFilter.FILTER_SKIP	484	if (accept == NodeFilter.FILTER_SKIP
458	&& newNode.hasChildNodes())	485	&& newNode.hasChildNodes())
459	{	486	{
460	return getLastChild(newNode);	487	Node lChild = getLastChild(newNode);
		488	if (lChild == null) {
		489	return getPreviousSibling(newNode, node);
		490	}
		491	return lChild;
461	}	492	}
462	else	493	else
463	//if (accept == NodeFilter.REJECT_NODE)	494	//if (accept == NodeFilter.REJECT_NODE)
464	{	495	{
465	return getPreviousSibling(newNode);	496	return getPreviousSibling(newNode, node);
466	}	497	}
467		498
468		499