path: root/part/qdom_add.cpp

/***************************************************************************
                          qdom_add.cpp  -  description
                             -------------------
    begin                : Wed Nov 21 2001
    copyright            : (C) 2001, 2002, 2003 by The KXMLEditor Team
    email                : [email protected]
 ***************************************************************************/

/***************************************************************************
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 ***************************************************************************/

/** This file contains useful datatypes and functions in addition to the TQt DOM classes. */

#include "qdom_add.h"

#include <kiconloader.h>
#include <kdebug.h>

#include <tqtextstream.h>

#include "kxmleditorfactory.h"
#include "kxesearchdialog.h"

TQPixmap g_iconElement( UserIcon("xml_element",KXMLEditorFactory::instance()) );
TQPixmap g_iconText( UserIcon("xml_text",KXMLEditorFactory::instance()) );
TQPixmap g_iconComment( UserIcon("xml_comment",KXMLEditorFactory::instance()) );
TQPixmap g_iconCDATASection( UserIcon("xml_cdata",KXMLEditorFactory::instance()) );
TQPixmap g_iconProcessingInstruction( UserIcon("xml_procinstr",KXMLEditorFactory::instance()) );
TQPixmap g_iconElement_b( UserIcon("xml_element_b",KXMLEditorFactory::instance()) );
TQPixmap g_iconText_b( UserIcon("xml_text_b",KXMLEditorFactory::instance()) );
TQPixmap g_iconComment_b( UserIcon("xml_comment_b",KXMLEditorFactory::instance()) );
TQPixmap g_iconCDATASection_b( UserIcon("xml_cdata_b",KXMLEditorFactory::instance()) );
TQPixmap g_iconProcessingInstruction_b( UserIcon("xml_procinstr_b",KXMLEditorFactory::instance()) );
TQPixmap g_iconUnknown;

const TQPixmap & domTool_getIconForNodeType( TQDomNode::NodeType type, bool bBookmarked )
{
	if(!bBookmarked)
    { switch(type)
	      { case  TQDomNode::ElementNode: return g_iconElement; break;
		      case	TQDomNode::TextNode: return g_iconText; break;
		      case	TQDomNode::CDATASectionNode: return g_iconCDATASection; break;
		      case	TQDomNode::CommentNode: return g_iconComment; break;
		      case	TQDomNode::ProcessingInstructionNode: return g_iconProcessingInstruction; break;

		      default:
			      kdDebug() << "domTool_getIconForNodeType: unknown node type (" << type << ")" << endl;
	      }
    }
  else
    { switch(type)
	      { case  TQDomNode::ElementNode: return g_iconElement_b; break;
		      case	TQDomNode::TextNode: return g_iconText_b; break;
		      case	TQDomNode::CDATASectionNode: return g_iconCDATASection_b; break;
		      case	TQDomNode::CommentNode: return g_iconComment_b; break;
		      case	TQDomNode::ProcessingInstructionNode: return g_iconProcessingInstruction_b; break;

		      default:
			      kdDebug() << "domTool_getIconForNodeType: unknown node type (" << type << ")" << endl;
	      }
    }
	return g_iconUnknown;
}

// Obtain XPath for all nodes, instead of elements
TQString domTool_getPath( const TQDomNode & node )
{
	if ( node.isNull() )
	{
		kdDebug() << "domTool_getPath: elelent given" << endl;
		return TQString();
	}

  if(node.isElement())
		{
      kdDebug() << "use domTool_getPath( const TQDomElement & domElement ) for elements" << endl;
    }
    
	TQString strReturn;

  TQDomNode parentNode = node.parentNode();
	if ( (!parentNode.isNull()) && (!parentNode.isDocument()) )
	{
    strReturn = domTool_getPath( parentNode.toElement() ); // get the parent's path
    strReturn += "/"; // append slash
    strReturn += node.nodeName(); // append the given node's name
  }
	else
		strReturn = node.nodeName(); // set the given node's name (must be root element)

	return strReturn;
}

// Obtain XPath for elements
TQString domTool_getPath( const TQDomElement & domElement )
{
	if ( domElement.isNull() )
	{
		kdDebug() << "domTool_getPath: no node given" << endl;
		return TQString();
	}

	TQString strReturn;
	TQDomNode parentNode = domElement.parentNode();
	if ( (!parentNode.isNull()) && (!parentNode.isDocument()) )
	{
		// calculate index - only for elements with the same name
		int i = 0;
    bool bUseIndex = false; // index is used only when exist sibling(s) with the same name

    // traverse previous sibling elements with same name and calculate index
    TQDomNode tmpNode = domElement.previousSibling();
    while ( ! tmpNode.isNull() )
    {
      if(tmpNode.isElement())
      {
        TQDomElement domSiblingElement = tmpNode.toElement();

        if(domElement.tagName() == domSiblingElement.tagName())
          { i++; bUseIndex = true;
          }
      }
      tmpNode = tmpNode.previousSibling();
    }

    if(bUseIndex == false)
    {
      // traverse next sibling elements with same name
      // and decide, if index is necessary
      TQDomNode tmpNode = domElement.nextSibling();
      while ( ! tmpNode.isNull() )
      {
        if(tmpNode.isElement())
        {
          TQDomElement domSiblingElement = tmpNode.toElement();

          if(domElement.tagName() == domSiblingElement.tagName())
            bUseIndex = true;
        }

        tmpNode = tmpNode.nextSibling();
        
      }
    }    
		
		strReturn = domTool_getPath( parentNode.toElement() ); // get the parent's path
		strReturn += "/"; // append slash
		strReturn += domElement.nodeName(); // append the given node's name

    if(bUseIndex)
      {
        TQString strIndex;
        strIndex.setNum(i+1);
        strReturn += "[" + strIndex + "]"; // append the index
      }
	}
	else
		strReturn = domElement.nodeName(); // set the given node's name (must be root element)

	return strReturn;
}

unsigned int domTool_getLevel( const TQDomNode & node )
{
	if ( node.isNull() )
	{
		kdDebug() << "domTool_getLevel: internal implementation error - the given node is an empty one" << endl;
		return 0;
	}

	unsigned int iLevel = 0;
	TQDomNode parentNode = node.parentNode();
	while ( ! parentNode.isNull() )
	{
		iLevel++;
		parentNode = parentNode.parentNode();
	}

	return iLevel - 1;
}

TQString domTool_save( const TQDomNode & node, int iIndent )
{
	TQString strXML;
	TQTextStream ts( & strXML, IO_WriteOnly );

  node.save(ts, iIndent);
	return strXML;
}

TQDomNode domTool_prevNode( const TQDomNode & node )
{
	if ( node.isNull() )
	{
		kdDebug() << "domTool_prevNode: internal implementation error - the given node is an empty one" << endl;
		return TQDomNode();
	}

	if ( ! node.previousSibling().isNull() ) // if there is a prev. sibling
	{                                    // return its last grand child (if there is any)
		TQDomNode prevNode = node.previousSibling();
		while ( ! prevNode.lastChild().isNull() )
			prevNode = prevNode.lastChild();
		return prevNode;
	}
	else                        // if there is no prev. sibling, return
		return node.parentNode(); // the nodes parent (if there is any)

}

TQDomNode domTool_nextNode( const TQDomNode & node )
{
	if ( node.isNull() )
	{
		kdDebug() << "domTool_nextNode: internal implementation error - the given node is an empty one" << endl;
		return TQDomNode();
	}

	// checking for a child
	if ( ! node.firstChild().isNull() )
		return node.firstChild();

	// there is no child -> checking for the next sibling
	if ( ! node.nextSibling().isNull() )
		return node.nextSibling();

	// there is no next sibling -> checking for parents' next sibling(s)
	TQDomNode nodeParent = node.parentNode();
	while ( ! nodeParent.isNull() )
	{
		if ( ! nodeParent.nextSibling().isNull() )
			return nodeParent.nextSibling();

		nodeParent = nodeParent.parentNode(); // parent has no sibling - try its parent
	}

	// parent has no parents anymore
	return TQDomNode(); // return empty node
}

TQDomNode domTool_matchingNode( const TQDomNode & node, const TQString & szPath )
{
  if(szPath.length() == 0)
    return TQDomNode(); // return void node

  TQString szNodePath = node.isDocument() ? TQString("") : domTool_getPath(node);
	if ( szPath == szNodePath ) // test if the strings match
		return node;

   /* L.V. those optimalizations disallow find proc. instr. at doc. level

      //  we will find any node in root element subtree
      if ( szPath.length() <= szNodePath.length() ) // the given string must be longer
        return TQDomNode(); // otherwise we don't need to check the childs

      if ( szPath.left(szNodePath.length()) != szNodePath ) // the nodes path must be left part of the given path
        return TQDomNode(); // otherwise we don't need to check the childs
  */   
     
	// recursively check the childs
	TQDomNode nodeChild = node.firstChild();
	TQDomNode nodeTmp;
	while ( ! nodeChild.isNull() )
	{
		nodeTmp = domTool_matchingNode( nodeChild, szPath );
		if ( ! nodeTmp.isNull() )
			return nodeTmp;
		nodeChild = nodeChild.nextSibling();
	}

	return TQDomNode(); // nothing found -> return empty node
}

bool domTool_match( TQDomNode node, const KXESearchDialog * const pConditions )
{
	if ( node.isNull() )
	{
		kdDebug() << "domTool_match: internal implementation error - the given node is an empty one" << endl;
		return false;
	}

	if ( ! pConditions )
	{
		kdDebug() << "domTool_match: internal implementation error - the given pointer is a null pointer" << endl;
		return false;
	}

	switch ( node.nodeType() )
	{
		case TQDomNode::ElementNode: // ----------------------------------------
		{
			if ( pConditions->getInElementNames() )
			{
				if ( node.toElement().tagName().find( pConditions->getSearchString(), 0, pConditions->getMatchCase() ) >= 0 )
					return true;
			}

			if ( ( pConditions->getInAttributeNames() ) || ( pConditions->getInAttributeValues() ) )
			{
				TQDomNamedNodeMap list = node.toElement().attributes();
				unsigned int iLength = list.length();
				if ( iLength <= 0 )
					return false;     // no attributes

				for ( unsigned int iRow = 0; iRow < iLength; iRow++ )
				{
					if ( pConditions->getInAttributeNames() )
						if ( list.item(iRow).toAttr().name().find( pConditions->getSearchString(), 0, pConditions->getMatchCase() ) >= 0 )
							return true;
					if ( pConditions->getInAttributeValues() )
						if ( list.item(iRow).toAttr().value().find( pConditions->getSearchString(), 0, pConditions->getMatchCase() ) >= 0 )
							return true;
				}
				return false;
			}

			return false;
			break;
		}

		case TQDomNode::TextNode: // ----------------------------------------
		case TQDomNode::CDATASectionNode:
		case TQDomNode::CommentNode:
		{
			if ( pConditions->getInContents() )
			{
				if ( node.toCharacterData().data().find( pConditions->getSearchString(), 0, pConditions->getMatchCase() ) >= 0 )
					return true;
				else
					return false;
			}
			else
				return false;

			break;
		}

// TODO implement this for the other node types (eg proc.instr.)

		default:
			kdDebug() << "domTool_match: unknown node type (" << node.nodeType() << ")" << endl;
	}

	return true;
}