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.
tdeaddons/konq-plugins/domtreeviewer/domtreecommands.cpp

563 lines
12 KiB

/* This file is part of the KDE project
*
* Copyright (C) 2005 Leo Savernik <l.savernik@aon.at>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public License
* along with this library; see the file COPYING.LIB. If not, write to
* the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
* Boston, MA 02110-1301, USA.
*/
#include "domtreecommands.h"
#include <dom/dom_doc.h>
#include <dom/dom_exception.h>
#include <tdelocale.h>
#include <tqmap.h>
using namespace domtreeviewer;
static const char * const dom_error_msgs[] = {
I18N_NOOP("No error"),
I18N_NOOP("Index size exceeded"),
I18N_NOOP("DOMString size exceeded"),
I18N_NOOP("Hierarchy request error"),
I18N_NOOP("Wrong document"),
I18N_NOOP("Invalid character"),
I18N_NOOP("No data allowed"),
I18N_NOOP("No modification allowed"),
I18N_NOOP("Not found"),
I18N_NOOP("Not supported"),
I18N_NOOP("Attribute in use"),
I18N_NOOP("Invalid state"),
I18N_NOOP("Syntax error"),
I18N_NOOP("Invalid modification"),
I18N_NOOP("Namespace error"),
I18N_NOOP("Invalid access")
};
// == global functions ==============================================
TQString domtreeviewer::domErrorMessage(int dom_err)
{
if ((unsigned)dom_err > sizeof dom_error_msgs/sizeof dom_error_msgs[0])
return i18n("Unknown Exception %1").arg(dom_err);
else
return i18n(dom_error_msgs[dom_err]);
}
// == ManipulationCommandSignalEmitter ==============================
static ManipulationCommandSignalEmitter *_mcse;
ManipulationCommandSignalEmitter::ManipulationCommandSignalEmitter()
{}
ManipulationCommandSignalEmitter::~ManipulationCommandSignalEmitter()
{}
namespace domtreeviewer {
ManipulationCommandSignalEmitter* ManipulationCommand::mcse()
{
if (!_mcse) _mcse = new ManipulationCommandSignalEmitter;
return _mcse;
}
}
// == ChangedNodeSet ================================================
namespace domtreeviewer {
// collection of nodes for which to emit the nodeChanged signal
inline static bool operator <(const DOM::Node &n1, const DOM::Node &n2)
{
return (long)n1.handle() - (long)n2.handle() < 0;
}
class ChangedNodeSet : public TQMap<DOM::Node, bool>
{
};
}
// == ManipulationCommand ===========================================
ManipulationCommand::ManipulationCommand() : _exception(0), changedNodes(0)
, _reapplied(false) , allow_signals(true)
{
}
ManipulationCommand::~ManipulationCommand()
{
}
void ManipulationCommand::connect(const char *signal, TQObject *recv, const char *slot)
{
TQObject::connect(mcse(), signal, recv, slot);
}
void ManipulationCommand::handleException(DOM::DOMException &ex)
{
_exception = ex;
TQString msg = name() + ": " + domErrorMessage(ex.code);
emit mcse()->error(ex.code, msg);
}
void ManipulationCommand::checkAndEmitSignals()
{
if (allow_signals) {
if (changedNodes) {
ChangedNodeSet::Iterator end = changedNodes->end();
for (ChangedNodeSet::Iterator it = changedNodes->begin(); it != end; ++it) {
emit mcse()->nodeChanged(it.key());
}
}
if (struc_changed) emit mcse()->structureChanged();
}
if (changedNodes) changedNodes->clear();
}
void ManipulationCommand::addChangedNode(const DOM::Node &node)
{
if (!changedNodes) changedNodes = new ChangedNodeSet;
changedNodes->insert(node, true);
}
void ManipulationCommand::execute()
{
if (!isValid()) return;
struc_changed = false;
try {
if (shouldReapply())
reapply();
else
apply();
checkAndEmitSignals();
} catch(DOM::DOMException &ex) {
handleException(ex);
}
_reapplied = true;
}
void ManipulationCommand::unexecute()
{
if (!isValid()) return;
struc_changed = false;
try {
unapply();
checkAndEmitSignals();
} catch(DOM::DOMException &ex) {
handleException(ex);
}
}
void ManipulationCommand::reapply()
{
apply();
}
// == MultiCommand ===========================================
MultiCommand::MultiCommand(const TQString &desc)
: _name(desc)
{
cmds.setAutoDelete(true);
}
MultiCommand::~MultiCommand()
{
}
void MultiCommand::addCommand(ManipulationCommand *cmd)
{
cmd->allow_signals = false;
cmds.append(cmd);
}
void MultiCommand::apply()
{
// apply in forward order
for (TQPtrListIterator<ManipulationCommand> it = cmds; *it; ++it) {
try {
if (shouldReapply()) (*it)->reapply();
else (*it)->apply();
struc_changed |= (*it)->struc_changed;
mergeChangedNodesFrom(*it);
} catch (DOM::DOMException &) {
// rollback
for (--it; *it; --it) {
try {
(*it)->unapply();
} catch(DOM::DOMException &) {
// ignore
}
}
throw;
}
}
}
void MultiCommand::unapply()
{
// unapply in reverse order
TQPtrListIterator<ManipulationCommand> it = cmds;
for (it.toLast(); *it; --it) {
try {
(*it)->unapply();
struc_changed |= (*it)->struc_changed;
mergeChangedNodesFrom(*it);
} catch (DOM::DOMException &) {
// rollback
for (++it; *it; ++it) {
try {
(*it)->reapply();
} catch(DOM::DOMException &) {
// ignore
}
}
throw;
}
}
}
void MultiCommand::mergeChangedNodesFrom(ManipulationCommand *cmd)
{
if (!cmd->changedNodes) return;
ChangedNodeSet::ConstIterator end = cmd->changedNodes->end();
for (ChangedNodeSet::ConstIterator it = cmd->changedNodes->begin(); it != end; ++it) {
addChangedNode(it.key());
}
cmd->changedNodes->clear();
}
TQString MultiCommand::name() const
{
return _name;
}
// == AddAttributeCommand ===========================================
AddAttributeCommand::AddAttributeCommand(const DOM::Element &element, const TQString &attrName, const TQString &attrValue)
: _element(element), attrName(attrName), attrValue(attrValue)
{
if (attrValue.isEmpty()) this->attrValue = "<dummy>";
}
AddAttributeCommand::~AddAttributeCommand()
{
}
void AddAttributeCommand::apply()
{
_element.setAttribute(attrName, attrValue);
addChangedNode(_element);
}
void AddAttributeCommand::unapply()
{
_element.removeAttribute(attrName);
addChangedNode(_element);
}
TQString AddAttributeCommand::name() const
{
return i18n("Add attribute");
}
// == ChangeAttributeValueCommand ====================================
ChangeAttributeValueCommand::ChangeAttributeValueCommand(
const DOM::Element &element, const TQString &attr, const TQString &value)
: _element(element), _attr(attr), new_value(value)
{
}
ChangeAttributeValueCommand::~ChangeAttributeValueCommand()
{
}
void ChangeAttributeValueCommand::apply()
{
if (!shouldReapply()) old_value = _element.getAttribute(_attr);
_element.setAttribute(_attr, new_value);
addChangedNode(_element);
}
void ChangeAttributeValueCommand::unapply()
{
_element.setAttribute(_attr, old_value);
addChangedNode(_element);
}
TQString ChangeAttributeValueCommand::name() const
{
return i18n("Change attribute value");
}
// == RemoveAttributeCommand ========================================
RemoveAttributeCommand::RemoveAttributeCommand(const DOM::Element &element, const TQString &attrName)
: _element(element), attrName(attrName)
{
}
RemoveAttributeCommand::~RemoveAttributeCommand()
{
}
void RemoveAttributeCommand::apply()
{
// kdDebug(90180) << k_funcinfo << _element.nodeName().string() << ": " << attrName.string() << endl;
if (!shouldReapply())
oldAttrValue = _element.getAttribute(attrName);
_element.removeAttribute(attrName);
addChangedNode(_element);
}
void RemoveAttributeCommand::unapply()
{
_element.setAttribute(attrName, oldAttrValue);
addChangedNode(_element);
}
TQString RemoveAttributeCommand::name() const
{
return i18n("Remove attribute");
}
// == RenameAttributeCommand ========================================
RenameAttributeCommand::RenameAttributeCommand(const DOM::Element &element, const TQString &attrOldName, const TQString &attrNewName)
: _element(element), attrOldName(attrOldName), attrNewName(attrNewName)
{
}
RenameAttributeCommand::~RenameAttributeCommand()
{
}
void RenameAttributeCommand::apply()
{
if (!shouldReapply())
attrValue = _element.getAttribute(attrOldName);
_element.removeAttribute(attrOldName);
_element.setAttribute(attrNewName, attrValue);
addChangedNode(_element);
}
void RenameAttributeCommand::unapply()
{
_element.removeAttribute(attrNewName);
_element.setAttribute(attrOldName, attrValue);
addChangedNode(_element);
}
TQString RenameAttributeCommand::name() const
{
return i18n("Rename attribute");
}
// == ChangeCDataCommand ========================================
ChangeCDataCommand::ChangeCDataCommand(const DOM::CharacterData &cdata, const TQString &value)
: cdata(cdata), value(value), has_newlines(false)
{
}
ChangeCDataCommand::~ChangeCDataCommand()
{
}
void ChangeCDataCommand::apply()
{
if (!shouldReapply()) {
oldValue = cdata.data();
has_newlines =
TQConstString(value.unicode(), value.length()).string().contains('\n')
|| TQConstString(oldValue.unicode(), oldValue.length()).string().contains('\n');
}
cdata.setData(value);
addChangedNode(cdata);
struc_changed = has_newlines;
}
void ChangeCDataCommand::unapply()
{
cdata.setData(oldValue);
addChangedNode(cdata);
struc_changed = has_newlines;
}
TQString ChangeCDataCommand::name() const
{
return i18n("Change textual content");
}
// == ManipulateNodeCommand ===========================================
ManipulateNodeCommand::ManipulateNodeCommand(const DOM::Node &node, const DOM::Node &parent, const DOM::Node &after)
: _node(node), _parent(parent), _after(after)
{
}
ManipulateNodeCommand::~ManipulateNodeCommand()
{
}
void ManipulateNodeCommand::insert()
{
_parent.insertBefore(_node, _after);
}
void ManipulateNodeCommand::remove()
{
DOM::DocumentFragment frag = _node;
if (frag.isNull()) { // do a normal remove
_node = _parent.removeChild(_node);
} else { // remove fragment nodes and recreate fragment
DOM::DocumentFragment newfrag = _parent.ownerDocument().createDocumentFragment();
for (DOM::Node i = frag.firstChild(); !i.isNull(); i = i.nextSibling()) {
newfrag.appendChild(_parent.removeChild(i));
}
_node = newfrag;
}
}
// == InsertNodeCommand ===========================================
InsertNodeCommand::InsertNodeCommand(const DOM::Node &node, const DOM::Node &parent, const DOM::Node &after)
: ManipulateNodeCommand(node, parent, after)
{
}
InsertNodeCommand::~InsertNodeCommand()
{
}
void InsertNodeCommand::apply()
{
insert();
struc_changed = true;
}
void InsertNodeCommand::unapply()
{
remove();
struc_changed = true;
}
TQString InsertNodeCommand::name() const
{
return i18n("Insert node");
}
// == RemoveNodeCommand ===========================================
RemoveNodeCommand::RemoveNodeCommand(const DOM::Node &node, const DOM::Node &parent, const DOM::Node &after)
: ManipulateNodeCommand(node, parent, after)
{
}
RemoveNodeCommand::~RemoveNodeCommand()
{
}
void RemoveNodeCommand::apply()
{
remove();
struc_changed = true;
}
void RemoveNodeCommand::unapply()
{
insert();
struc_changed = true;
}
TQString RemoveNodeCommand::name() const
{
return i18n("Remove node");
}
// == MoveNodeCommand ===========================================
MoveNodeCommand::MoveNodeCommand(const DOM::Node &node, const DOM::Node &parent, const DOM::Node &after)
: _node(node), new_parent(parent), new_after(after)
{
old_parent = node.parentNode();
old_after = node.nextSibling();
}
MoveNodeCommand::~MoveNodeCommand()
{
}
void MoveNodeCommand::apply()
{
old_parent.removeChild(_node);
try {
new_parent.insertBefore(_node, new_after);
} catch (DOM::DOMException &) {
try { // rollback
old_parent.insertBefore(_node, old_after);
} catch (DOM::DOMException &) {}
throw;
}
struc_changed = true;
}
void MoveNodeCommand::unapply()
{
new_parent.removeChild(_node);
try {
old_parent.insertBefore(_node, old_after);
} catch (DOM::DOMException &) {
try { // rollback
new_parent.insertBefore(_node, new_after);
} catch (DOM::DOMException &) {}
throw;
}
struc_changed = true;
}
TQString MoveNodeCommand::name() const
{
return i18n("Move node");
}
#include "domtreecommands.moc"
#undef MCSE