You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
779 lines
23 KiB
779 lines
23 KiB
/***************************************************************************
|
|
commands_edit - description
|
|
-------------------
|
|
begin : Wed Nov 26 2003
|
|
copyright : (C) 2003 by The KXMLEditor Team
|
|
email : a_charytoniuk@user.sourceforge.net
|
|
***************************************************************************/
|
|
|
|
/***************************************************************************
|
|
* *
|
|
* 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. *
|
|
* *
|
|
***************************************************************************/
|
|
#include "commands_edit.h"
|
|
|
|
#include <kdebug.h>
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////
|
|
/////////// Cutting element to clipboard //////////
|
|
//////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
KXECutCommand::KXECutCommand(KXEDocument *pDocument, TQDomNode &domNode)
|
|
: KXEDeleteNodeCommand(pDocument, domNode)
|
|
{
|
|
}
|
|
|
|
KXECutCommand::~KXECutCommand()
|
|
{
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////
|
|
/////////// Pasting node from clipboard to document //////////
|
|
//////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
KXEPasteToDocumentCommand::KXEPasteToDocumentCommand(
|
|
KXEDocument *pDocument,
|
|
TQDomDocument *pDomTargetDoc,
|
|
TQDomElement &domSourceElement
|
|
)
|
|
: KXECommand(pDocument)
|
|
{
|
|
if ( pDomTargetDoc == 0 )
|
|
kdError() << "KXEPasteToDocumentCommand::KXEPasteToDocumentCommand the given XML document object is empty." << endl;
|
|
|
|
m_pDomTargetDoc = pDomTargetDoc;
|
|
m_domSourceElement = domSourceElement;
|
|
}
|
|
|
|
KXEPasteToDocumentCommand::~KXEPasteToDocumentCommand()
|
|
{
|
|
}
|
|
|
|
void KXEPasteToDocumentCommand::execute()
|
|
{
|
|
// Insert root element
|
|
TQDomNode newNode = m_pDomTargetDoc->importNode(m_domSourceElement, true);
|
|
m_pDomTargetDoc->appendChild(newNode);
|
|
m_pDocument->updateNodeCreated(newNode);
|
|
}
|
|
|
|
void KXEPasteToDocumentCommand::unexecute()
|
|
{
|
|
TQDomNode removedNode = m_pDomTargetDoc->removeChild( m_pDomTargetDoc->documentElement());
|
|
|
|
if ( removedNode.isNull() )
|
|
kdError() << "KXEPasteToDocumentCommand::unexecute error removing node." << endl;
|
|
else
|
|
{
|
|
m_pDocument->updateNodeDeleted(removedNode);
|
|
}
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////
|
|
/////////// Pasting node from clipboard to element //////////
|
|
//////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
KXEPasteToElementCommand::KXEPasteToElementCommand(
|
|
KXEDocument *pDocument,
|
|
TQDomElement & domTargetElement,
|
|
TQDomNode &domSourceNode
|
|
)
|
|
: KXECommand(pDocument)
|
|
{
|
|
if ( domTargetElement.isNull() )
|
|
kdError() << "KXEPasteCommand::KXEPasteCommand the given XML element object is empty." << endl;
|
|
|
|
m_domTargetElement = domTargetElement;
|
|
m_domSourceNode = domSourceNode;
|
|
}
|
|
|
|
KXEPasteToElementCommand::~KXEPasteToElementCommand()
|
|
{
|
|
}
|
|
|
|
void KXEPasteToElementCommand::execute()
|
|
{
|
|
m_domTargetElement.appendChild(m_domSourceNode);
|
|
m_pDocument->updateNodeCreated(m_domSourceNode);
|
|
}
|
|
|
|
void KXEPasteToElementCommand::unexecute()
|
|
{
|
|
if ( m_domSourceNode.parentNode().removeChild( m_domSourceNode ).isNull() )
|
|
kdError() << "KXEPasteToElementCommand::unexecute error removing the node." << endl;
|
|
else
|
|
{
|
|
m_pDocument->updateNodeDeleted(m_domSourceNode);
|
|
}
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////
|
|
/////////// Pasting proc.instr from clipboard to proc.instr //////////
|
|
//////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
KXEPasteToProcInstrCommand::KXEPasteToProcInstrCommand(
|
|
KXEDocument *pDocument,
|
|
TQDomProcessingInstruction &domTargetProcInstr,
|
|
TQDomProcessingInstruction &domSourceProcInstr
|
|
)
|
|
: KXECommand(pDocument)
|
|
{
|
|
if ( domTargetProcInstr.isNull() )
|
|
kdError() << "KXEPasteToProcInstrCommand::KXEPasteToProcInstrCommand the given object is empty." << endl;
|
|
|
|
if ( domSourceProcInstr.isNull() )
|
|
kdError() << "KXEPasteToProcInstrCommand::KXEPasteToProcInstrCommand the given object is empty." << endl;
|
|
|
|
m_domTargetProcInstr = domTargetProcInstr;
|
|
m_strNewData = domSourceProcInstr.data();
|
|
}
|
|
|
|
KXEPasteToProcInstrCommand::~KXEPasteToProcInstrCommand()
|
|
{
|
|
}
|
|
|
|
void KXEPasteToProcInstrCommand::execute()
|
|
{
|
|
// Replace contents of selected proc. instr.
|
|
m_strOldData = m_domTargetProcInstr.data();
|
|
m_domTargetProcInstr.setData(m_strNewData);
|
|
m_pDocument->updateNodeChanged(m_domTargetProcInstr);
|
|
}
|
|
|
|
void KXEPasteToProcInstrCommand::unexecute()
|
|
{
|
|
// Rverse action.
|
|
m_domTargetProcInstr.setData(m_strOldData);
|
|
m_pDocument->updateNodeChanged(m_domTargetProcInstr);
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////
|
|
/////////// Pasting char. data from clipboard to char. data //////////
|
|
//////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
|
|
KXEPasteToCharDataCommand::KXEPasteToCharDataCommand(
|
|
KXEDocument *pDocument,
|
|
TQDomCharacterData &domTargetCharData,
|
|
TQDomCharacterData &domSourceCharData
|
|
)
|
|
: KXECommand(pDocument)
|
|
{
|
|
if ( domTargetCharData.isNull() )
|
|
kdError() << "KXEPasteToCharDataCommand::KXEPasteToCharDataCommand the given object is empty." << endl;
|
|
|
|
if ( domSourceCharData.isNull() )
|
|
kdError() << "KXEPasteToCharDataCommand::KXEPasteToCharDataCommand the given object is empty." << endl;
|
|
|
|
m_domTargetCharData = domTargetCharData;
|
|
m_strNewData = domSourceCharData.data();
|
|
}
|
|
|
|
KXEPasteToCharDataCommand::~KXEPasteToCharDataCommand()
|
|
{
|
|
}
|
|
|
|
void KXEPasteToCharDataCommand::execute()
|
|
{
|
|
// replace target contents with source
|
|
m_strOldData = m_domTargetCharData.data();
|
|
m_domTargetCharData.setData(m_strNewData);
|
|
m_pDocument->updateNodeChanged(m_domTargetCharData);
|
|
}
|
|
|
|
void KXEPasteToCharDataCommand::unexecute()
|
|
{
|
|
m_domTargetCharData.setData(m_strOldData);
|
|
m_pDocument->updateNodeChanged(m_domTargetCharData);
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////
|
|
/////////// Drag & drop node //////////
|
|
//////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
KXEDragDropMoveCommand::KXEDragDropMoveCommand(
|
|
KXEDocument *pDocument,
|
|
TQDomElement & domTargetElement,
|
|
TQDomNode &domSourceNode
|
|
)
|
|
: KXECommand(pDocument)
|
|
{
|
|
if ( domTargetElement.isNull() )
|
|
kdError() << "KXEDragDropMoveCommand::KXEDragDropMoveCommand the given XML element object is empty." << endl;
|
|
|
|
m_domTargetElement = domTargetElement;
|
|
m_domSourceNode = domSourceNode;
|
|
m_domPreviousParentNode = m_domSourceNode.parentNode();
|
|
}
|
|
|
|
KXEDragDropMoveCommand::~KXEDragDropMoveCommand()
|
|
{
|
|
}
|
|
|
|
void KXEDragDropMoveCommand::execute()
|
|
{
|
|
// 1st, remove source node from its parent
|
|
if( m_domPreviousParentNode.removeChild( m_domSourceNode ).isNull() )
|
|
kdError() << "KXEDocument::slotXmlElementDelete error removing the selected node." << endl;
|
|
else
|
|
m_pDocument->updateNodeDeleted(m_domSourceNode);
|
|
|
|
// 2nd, append moved node to new parent
|
|
m_domTargetElement.appendChild(m_domSourceNode);
|
|
m_pDocument->updateNodeCreated(m_domSourceNode);
|
|
}
|
|
|
|
void KXEDragDropMoveCommand::unexecute()
|
|
{
|
|
// 1st, remove source node from its parent
|
|
if ( m_domTargetElement.removeChild( m_domSourceNode ).isNull() )
|
|
kdError() << "KXEPasteToElementCommand::unexecute error removing the node." << endl;
|
|
else
|
|
{
|
|
m_pDocument->updateNodeDeleted(m_domSourceNode);
|
|
}
|
|
|
|
// 2nd, append moved node to previous parent
|
|
m_domPreviousParentNode.appendChild(m_domSourceNode);
|
|
m_pDocument->updateNodeCreated(m_domSourceNode);
|
|
}
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////
|
|
/////////// Deleting node //////////
|
|
//////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
KXEDeleteNodeCommand::KXEDeleteNodeCommand(KXEDocument *pDocument, TQDomNode &domNode)
|
|
: KXECommand(pDocument)
|
|
{
|
|
m_domNode = domNode;
|
|
m_domParentNode = m_domNode.parentNode();
|
|
m_afterNode = m_domNode.previousSibling();
|
|
|
|
if ( m_domParentNode.isNull() )
|
|
kdError() << "KXEDeleteNodeCommand::KXEDeleteNodeCommand selected nodes parent node is empty." << endl;
|
|
}
|
|
|
|
KXEDeleteNodeCommand::~KXEDeleteNodeCommand()
|
|
{
|
|
}
|
|
|
|
void KXEDeleteNodeCommand::execute()
|
|
{
|
|
if ( m_domParentNode.removeChild( m_domNode ).isNull() )
|
|
kdError() << "KXEDeleteNodeCommand::execute error removing the selected node." << endl;
|
|
else
|
|
{
|
|
m_pDocument->updateNodeDeleted(m_domNode);
|
|
}
|
|
}
|
|
|
|
void KXEDeleteNodeCommand::unexecute()
|
|
{
|
|
if (m_afterNode.isNull())
|
|
m_domParentNode.insertBefore(m_domNode,m_afterNode);
|
|
else
|
|
m_domParentNode.insertAfter( m_domNode,m_afterNode );
|
|
m_pDocument->updateNodeCreated(m_domNode);
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////
|
|
/////////// Deleting one attribute //////////
|
|
//////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
|
|
KXEDeleteAttrCommand::KXEDeleteAttrCommand(
|
|
KXEDocument *pDocument,
|
|
TQDomElement &domOwnerElement,
|
|
TQDomAttr &domAttr
|
|
)
|
|
: KXECommand(pDocument)
|
|
{
|
|
m_domOwnerElement = domOwnerElement;
|
|
m_domAttr = domAttr;
|
|
}
|
|
|
|
KXEDeleteAttrCommand::~KXEDeleteAttrCommand()
|
|
{
|
|
}
|
|
|
|
void KXEDeleteAttrCommand::execute()
|
|
{
|
|
m_domOwnerElement.removeAttributeNode(m_domAttr);
|
|
m_pDocument->updateNodeChanged(m_domOwnerElement);
|
|
}
|
|
|
|
void KXEDeleteAttrCommand::unexecute()
|
|
{
|
|
m_domOwnerElement.setAttributeNode( m_domAttr );
|
|
m_pDocument->updateNodeChanged( m_domOwnerElement ) ;
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////
|
|
/////////// Deleting all attributes //////////
|
|
//////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
KXEDeleteAllAttribCommand::KXEDeleteAllAttribCommand(
|
|
KXEDocument *pDocument,
|
|
TQDomElement &domOwnerElement
|
|
)
|
|
: KXECommand(pDocument)
|
|
{
|
|
m_domOwnerElement = domOwnerElement;
|
|
m_listRemovedAttributes.setAutoDelete( true ); // the list owns the objects
|
|
}
|
|
|
|
KXEDeleteAllAttribCommand::~KXEDeleteAllAttribCommand()
|
|
{
|
|
}
|
|
|
|
void KXEDeleteAllAttribCommand::execute()
|
|
{
|
|
TQDomNamedNodeMap mapAttributes = m_domOwnerElement.attributes();
|
|
uint nAttributes = mapAttributes.count();
|
|
|
|
if( nAttributes == 0 )
|
|
return;
|
|
|
|
for( uint nRow = nAttributes; nRow > 0; nRow-- )
|
|
{
|
|
TQDomNode node = mapAttributes.item(nRow-1);
|
|
if ( node.isAttr() )
|
|
{ TQDomAttr domAttr = node.toAttr();
|
|
|
|
TQDomAttr *pNodeCloned = new TQDomAttr(domAttr.cloneNode(true).toAttr());
|
|
|
|
m_listRemovedAttributes.append(pNodeCloned);
|
|
m_domOwnerElement.removeAttributeNode(node.toAttr());
|
|
}
|
|
else
|
|
kdDebug() << "KXMLEditor " << k_funcinfo << " node is not an attribute (but should be)" << node.nodeName() << endl;
|
|
}
|
|
|
|
m_pDocument->updateNodeChanged(m_domOwnerElement);
|
|
}
|
|
|
|
void KXEDeleteAllAttribCommand::unexecute()
|
|
{
|
|
TQDomNamedNodeMap mapAttributes = m_domOwnerElement.attributes();
|
|
uint nAttributes = m_listRemovedAttributes.count();
|
|
|
|
if ( nAttributes == 0 )
|
|
return;
|
|
|
|
TQDomAttr *pDomAttr;
|
|
for ( pDomAttr = m_listRemovedAttributes.first(); pDomAttr; pDomAttr = m_listRemovedAttributes.next() )
|
|
{
|
|
if(!pDomAttr->namespaceURI().isEmpty())
|
|
m_domOwnerElement.setAttribute(pDomAttr->name(), pDomAttr->value());
|
|
else
|
|
m_domOwnerElement.setAttributeNS(pDomAttr->namespaceURI(), pDomAttr->name(), pDomAttr->value());
|
|
}
|
|
|
|
m_listRemovedAttributes.clear();
|
|
|
|
m_pDocument->updateNodeChanged(m_domOwnerElement);
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////
|
|
/////////// Moving node up //////////
|
|
//////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
KXEUpCommand::KXEUpCommand(KXEDocument *pDocument, TQDomNode &domNode)
|
|
: KXECommand(pDocument)
|
|
{
|
|
m_domNode = domNode;
|
|
m_domParentNode = m_domNode.parentNode();
|
|
|
|
if ( m_domParentNode.isNull() )
|
|
kdError() << "KXEUpCommand::KXEUpCommand selected nodes parent node is empty." << endl;
|
|
}
|
|
|
|
KXEUpCommand::~KXEUpCommand()
|
|
{
|
|
}
|
|
|
|
void KXEUpCommand::execute()
|
|
{
|
|
TQDomNode domPrevSibling = m_domNode.previousSibling();
|
|
if ( domPrevSibling.isNull() )
|
|
{
|
|
kdError() << "KXEUpCommand::execute selected node doesn't seem to have a previous sibling." << endl;
|
|
return;
|
|
}
|
|
|
|
TQDomNode domNode = m_domParentNode.removeChild( m_domNode );
|
|
if ( domNode.isNull() )
|
|
kdError() << "KXEUpCommand::execute can't remove child node." << endl;
|
|
else
|
|
{
|
|
domNode = m_domParentNode.insertBefore( domNode, domPrevSibling );
|
|
if ( domNode.isNull() )
|
|
kdError() << "KXEUpCommand::execute can't insert child node." << endl;
|
|
else
|
|
{
|
|
m_pDocument->updateNodeMoved(domNode);
|
|
}
|
|
}
|
|
}
|
|
|
|
void KXEUpCommand::unexecute()
|
|
{
|
|
TQDomNode domNextSibling = m_domNode.nextSibling();
|
|
if ( domNextSibling.isNull() )
|
|
{
|
|
kdError() << "KXEUpCommand::unexecute selected node doesn't seem to have a next sibling." << endl;
|
|
return;
|
|
}
|
|
|
|
TQDomNode domNode = m_domParentNode.removeChild( m_domNode );
|
|
if ( domNode.isNull() )
|
|
kdError() << "KXEUpCommand::unexecute can't remove child node." << endl;
|
|
else
|
|
{
|
|
domNode = m_domParentNode.insertAfter( domNode, domNextSibling );
|
|
if ( domNode.isNull() )
|
|
kdError() << "KXEUpCommand::unexecute can't insert child node." << endl;
|
|
else
|
|
{
|
|
m_pDocument->updateNodeMoved(domNode);
|
|
}
|
|
}
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////
|
|
/////////// Moving node down //////////
|
|
//////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
KXEDownCommand::KXEDownCommand(KXEDocument *pDocument, TQDomNode &domNode)
|
|
: KXECommand(pDocument)
|
|
{
|
|
m_domNode = domNode;
|
|
m_domParentNode = m_domNode.parentNode();
|
|
|
|
if ( m_domParentNode.isNull() )
|
|
kdError() << "KXEDownCommand::KXEDownCommand selected nodes parent node is empty." << endl;
|
|
}
|
|
|
|
KXEDownCommand::~KXEDownCommand()
|
|
{
|
|
}
|
|
|
|
void KXEDownCommand::execute()
|
|
{
|
|
TQDomNode domNextSibling = m_domNode.nextSibling();
|
|
if ( domNextSibling.isNull() )
|
|
{
|
|
kdError() << "KXEDownCommand::execute selected node doesn't seem to have a next sibling." << endl;
|
|
return;
|
|
}
|
|
|
|
TQDomNode domNode = m_domParentNode.removeChild( m_domNode );
|
|
if ( domNode.isNull() )
|
|
kdError() << "KXEDownCommand::execute can't remove child node." << endl;
|
|
else
|
|
{
|
|
domNode = m_domParentNode.insertAfter( domNode, domNextSibling );
|
|
if ( domNode.isNull() )
|
|
kdError() << "KXEDownCommand::execute can't insert child node." << endl;
|
|
else
|
|
{
|
|
m_pDocument->updateNodeMoved(domNode);
|
|
}
|
|
}
|
|
}
|
|
|
|
void KXEDownCommand::unexecute()
|
|
{
|
|
TQDomNode domPrevSibling = m_domNode.previousSibling();
|
|
if ( domPrevSibling.isNull() )
|
|
{
|
|
kdError() << "KXEDownCommand::unexecute selected node doesn't seem to have a previous sibling." << endl;
|
|
return;
|
|
}
|
|
|
|
TQDomNode domNode = m_domParentNode.removeChild( m_domNode );
|
|
if ( domNode.isNull() )
|
|
kdError() << "KXEDownCommand::unexecute can't remove child node." << endl;
|
|
else
|
|
{
|
|
domNode = m_domParentNode.insertBefore( domNode, domPrevSibling );
|
|
if ( domNode.isNull() )
|
|
kdError() << "KXEDownCommand::unexecute can't insert child node." << endl;
|
|
else
|
|
{
|
|
m_pDocument->updateNodeMoved(domNode);
|
|
}
|
|
}
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////
|
|
/////////// Editing char. data properties //////////
|
|
//////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
KXEEditCharDataCommand::KXEEditCharDataCommand(
|
|
KXEDocument *pDocument,
|
|
TQDomCharacterData &domCharacterData,
|
|
const TQString strNewContents
|
|
)
|
|
: KXECommand(pDocument)
|
|
{
|
|
m_domCharacterData = domCharacterData;
|
|
m_strNewContents = strNewContents;
|
|
}
|
|
|
|
KXEEditCharDataCommand::~KXEEditCharDataCommand()
|
|
{
|
|
}
|
|
|
|
void KXEEditCharDataCommand::execute()
|
|
{
|
|
m_strOldContents = m_domCharacterData.data();
|
|
m_domCharacterData.setData( m_strNewContents );
|
|
m_pDocument->updateNodeChanged( m_domCharacterData );
|
|
}
|
|
|
|
void KXEEditCharDataCommand::unexecute()
|
|
{
|
|
m_domCharacterData.setData( m_strOldContents );
|
|
m_pDocument->updateNodeChanged( m_domCharacterData );
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////
|
|
/////////// Editing proc. instr properties //////////
|
|
//////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
KXEEditProcInstrCommand::KXEEditProcInstrCommand(
|
|
KXEDocument *pDocument,
|
|
TQDomProcessingInstruction &domProcInstr,
|
|
const TQString strNewData
|
|
)
|
|
: KXECommand(pDocument)
|
|
{
|
|
m_domProcInstr = domProcInstr;
|
|
m_strNewData = strNewData;
|
|
}
|
|
|
|
KXEEditProcInstrCommand::~KXEEditProcInstrCommand()
|
|
{
|
|
}
|
|
|
|
void KXEEditProcInstrCommand::execute()
|
|
{
|
|
m_strOldData = m_domProcInstr.data();
|
|
m_domProcInstr.setData( m_strNewData );
|
|
m_pDocument->updateNodeChanged( m_domProcInstr );
|
|
}
|
|
|
|
void KXEEditProcInstrCommand::unexecute()
|
|
{
|
|
m_domProcInstr.setData( m_strOldData );
|
|
m_pDocument->updateNodeChanged( m_domProcInstr );
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////
|
|
/////////// Editing element data properties //////////
|
|
//////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
KXEEditElementCommand::KXEEditElementCommand(
|
|
KXEDocument *pDocument,
|
|
TQDomElement &domElement,
|
|
const TQString strNewPrefix,
|
|
const TQString strNewName
|
|
)
|
|
: KXECommand(pDocument)
|
|
{
|
|
m_domElement = domElement;
|
|
m_strNewPrefix = strNewPrefix;
|
|
m_strNewName = strNewName;
|
|
}
|
|
|
|
KXEEditElementCommand::~KXEEditElementCommand()
|
|
{
|
|
}
|
|
|
|
void KXEEditElementCommand::execute()
|
|
{
|
|
m_strOldPrefix = m_domElement.prefix();
|
|
m_strOldName = m_domElement.tagName();
|
|
|
|
|
|
if ( ! m_domElement.namespaceURI().isNull() )
|
|
m_domElement.setPrefix( m_strNewPrefix );
|
|
|
|
m_domElement.setTagName( m_strNewName );
|
|
|
|
m_pDocument->updateNodeChanged( m_domElement );
|
|
}
|
|
|
|
void KXEEditElementCommand::unexecute()
|
|
{
|
|
if ( ! m_domElement.namespaceURI().isNull() )
|
|
m_domElement.setPrefix( m_strOldPrefix );
|
|
|
|
m_domElement.setTagName( m_strOldName );
|
|
|
|
m_pDocument->updateNodeChanged( m_domElement );
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////
|
|
/////////// Edit attribute value //////////
|
|
//////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
|
|
KXEEditAttrValueCommand::KXEEditAttrValueCommand(
|
|
KXEDocument *pDocument,
|
|
const TQDomAttr &domAttr,
|
|
const TQString strNewValue
|
|
)
|
|
: KXECommand(pDocument)
|
|
{
|
|
m_domAttr = domAttr;
|
|
m_strNewValue = strNewValue;
|
|
}
|
|
|
|
KXEEditAttrValueCommand::~KXEEditAttrValueCommand()
|
|
{
|
|
}
|
|
|
|
void KXEEditAttrValueCommand::execute()
|
|
{
|
|
m_strOldValue = m_domAttr.value();
|
|
m_domAttr.setValue( m_strNewValue );
|
|
|
|
m_pDocument->updateNodeChanged(m_domAttr.ownerElement());
|
|
}
|
|
|
|
void KXEEditAttrValueCommand::unexecute()
|
|
{
|
|
m_domAttr.setValue( m_strOldValue );
|
|
|
|
m_pDocument->updateNodeChanged(m_domAttr.ownerElement());
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////
|
|
/////////// Edit attribute name //////////
|
|
//////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
|
|
KXEEditAttrNameCommand::KXEEditAttrNameCommand(
|
|
KXEDocument *pDocument,
|
|
const TQDomAttr &domOldAttr,
|
|
const TQString strNewName
|
|
)
|
|
: KXECommand(pDocument)
|
|
{
|
|
m_strNewName = strNewName;
|
|
m_strOldName = domOldAttr.name();
|
|
m_strValue = domOldAttr.value();
|
|
|
|
if(!domOldAttr.namespaceURI().isEmpty())
|
|
m_strNamespaceURI = domOldAttr.namespaceURI();
|
|
|
|
m_domOwnerElement = domOldAttr.ownerElement();
|
|
}
|
|
|
|
KXEEditAttrNameCommand::~KXEEditAttrNameCommand()
|
|
{
|
|
}
|
|
|
|
void KXEEditAttrNameCommand::execute()
|
|
{
|
|
// it's not possible to change name. Must delete attribute and create new one
|
|
if(m_strNamespaceURI.isEmpty())
|
|
{
|
|
m_domOwnerElement.setAttribute(m_strNewName, m_strValue);
|
|
m_domOwnerElement.attributes().removeNamedItem(m_strOldName);
|
|
}
|
|
else
|
|
{
|
|
m_domOwnerElement.setAttributeNS( m_strNamespaceURI, m_strNewName, m_strValue);
|
|
m_domOwnerElement.attributes().removeNamedItemNS (m_strNamespaceURI, m_strOldName);
|
|
}
|
|
|
|
m_pDocument->updateNodeChanged(m_domOwnerElement);
|
|
}
|
|
|
|
void KXEEditAttrNameCommand::unexecute()
|
|
{
|
|
// it's not possible to change name. Must delete attribute and create new one
|
|
if(m_strNamespaceURI.isEmpty())
|
|
{
|
|
m_domOwnerElement.setAttribute(m_strOldName, m_strValue);
|
|
m_domOwnerElement.attributes().removeNamedItem(m_strNewName);
|
|
|
|
}
|
|
else
|
|
{
|
|
m_domOwnerElement.setAttributeNS( m_strNamespaceURI, m_strOldName, m_strValue);
|
|
m_domOwnerElement.attributes().removeNamedItemNS (m_strNamespaceURI, m_strNewName);
|
|
}
|
|
|
|
m_pDocument->updateNodeChanged(m_domOwnerElement);
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////
|
|
/////////// Editing element and its subtree as raw XML //////////
|
|
//////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
KXEEditRawXmlCommand::KXEEditRawXmlCommand(
|
|
KXEDocument *pDocument,
|
|
TQDomElement &domOldElement,
|
|
TQDomElement &domNewElement
|
|
)
|
|
: KXECommand(pDocument)
|
|
{
|
|
m_domOldElement = domOldElement;
|
|
m_domNewElement = domNewElement;
|
|
m_domParentNode = domOldElement.parentNode();
|
|
m_afterNode = domOldElement.previousSibling();
|
|
|
|
if ( m_domParentNode.isNull() )
|
|
kdError() << "KXEEditRawXmlCommand::KXEEditRawXmlCommand selected nodes parent node is empty." << endl;
|
|
|
|
}
|
|
|
|
KXEEditRawXmlCommand::~KXEEditRawXmlCommand()
|
|
{
|
|
}
|
|
|
|
void KXEEditRawXmlCommand::execute()
|
|
{
|
|
// first delete node
|
|
if ( m_domParentNode.removeChild( m_domOldElement ).isNull() )
|
|
kdError() << "KXEEditRawXmlCommand::execute error removing the selected node." << endl;
|
|
else
|
|
{
|
|
m_pDocument->updateNodeDeleted(m_domOldElement);
|
|
}
|
|
|
|
// then insert new node
|
|
if (m_afterNode.isNull())
|
|
m_domParentNode.insertBefore(m_domNewElement, m_afterNode);
|
|
else
|
|
m_domParentNode.insertAfter( m_domNewElement, m_afterNode );
|
|
m_pDocument->updateNodeCreated(m_domNewElement);
|
|
}
|
|
|
|
void KXEEditRawXmlCommand::unexecute()
|
|
{
|
|
// first delete node
|
|
if ( m_domParentNode.removeChild( m_domNewElement ).isNull() )
|
|
kdError() << "KXEEditRawXmlCommand::unexecute error removing the selected node." << endl;
|
|
else
|
|
{
|
|
m_pDocument->updateNodeDeleted(m_domNewElement);
|
|
}
|
|
|
|
// then insert new node
|
|
if (m_afterNode.isNull())
|
|
m_domParentNode.insertBefore(m_domOldElement, m_afterNode);
|
|
else
|
|
m_domParentNode.insertAfter( m_domOldElement, m_afterNode );
|
|
m_pDocument->updateNodeCreated(m_domOldElement);
|
|
}
|