File indexing completed on 2024-04-28 15:23:21

 /* This file is part of the KDE project
  *
  * Copyright (C) 2004 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., 59 Temple Place - Suite 330,
  * Boston, MA 02111-1307, USA.
  */
 
 #include "editor.h"
 
 #include "jsediting.h"
 #include "htmlediting_impl.h"
 
 #include "css/css_renderstyledeclarationimpl.h"
 #include "css/css_valueimpl.h"
 #include "xml/dom_selection.h"
 #include "xml/dom_docimpl.h"
 #include "xml/dom_elementimpl.h"
 #include "xml/dom_textimpl.h"
 #include "xml/dom2_rangeimpl.h"
 #include "khtml_part.h"
 #include "khtml_ext.h"
 #include "khtmlpart_p.h"
 
 #include <QStack>
 #include <QKeyEvent>
 
 #ifndef APPLE_CHANGES
 #  ifdef assert
 #    undef assert
 #  endif
 #  define assert(x) Q_ASSERT(x)
 #endif
 
 #define PREPARE_JSEDITOR_CALL(command, retval) \
     JSEditor *js = m_part->xmlDocImpl() ? m_part->xmlDocImpl()->jsEditor() : nullptr; \
     if (!js) return retval; \
     const CommandImp *imp = js->commandImp(command)
 
 #define DEBUG_COMMANDS
 
 using namespace WTF;
 
 using namespace DOM;
 
 using khtml::RenderStyleDeclarationImpl;
 using khtml::EditCommandImpl;
 using khtml::ApplyStyleCommandImpl;
 using khtml::TypingCommandImpl;
 using khtml::EditorContext;
 using khtml::IndentOutdentCommandImpl;
 
 // --------------------------------------------------------------------------
 
 namespace DOM
 {
 
 static const int sMaxUndoSteps = 1000;
 
 class EditorPrivate
 {
 public:
     void registerUndo(EditCommandImpl *cmd, bool clearRedoStack = true)
     {
         if (m_undo.count() >= sMaxUndoSteps) {
             m_undo.pop_front();
         }
         if (clearRedoStack) {
             m_redo.clear();
         }
         m_undo.push(cmd);
     }
     void registerRedo(EditCommandImpl *cmd)
     {
         if (m_redo.count() >= sMaxUndoSteps) {
             m_redo.pop_front();
         }
         m_redo.push(cmd);
     }
     RefPtr<EditCommandImpl> m_lastEditCommand;
     QStack<RefPtr<EditCommandImpl> > m_undo;
     QStack<RefPtr<EditCommandImpl> > m_redo;
 };
 
 }
 
 // ==========================================================================
 
 Editor::Editor(KHTMLPart *part)
     : d(new EditorPrivate), m_typingStyle(nullptr), m_part(part)
 {
 }
 
 Editor::~Editor()
 {
     if (m_typingStyle) {
         m_typingStyle->deref();
     }
     delete d;
 }
 
 bool Editor::execCommand(const DOMString &command, bool userInterface, const DOMString &value)
 {
     PREPARE_JSEDITOR_CALL(command, false);
     return js->execCommand(imp, userInterface, value);
 }
 
 bool Editor::queryCommandEnabled(const DOMString &command)
 {
     PREPARE_JSEDITOR_CALL(command, false);
     return js->queryCommandEnabled(imp);
 }
 
 bool Editor::queryCommandIndeterm(const DOMString &command)
 {
     PREPARE_JSEDITOR_CALL(command, false);
     return js->queryCommandIndeterm(imp);
 }
 
 bool Editor::queryCommandState(const DOMString &command)
 {
     PREPARE_JSEDITOR_CALL(command, false);
     return js->queryCommandState(imp);
 }
 
 bool Editor::queryCommandSupported(const DOMString &command)
 {
     PREPARE_JSEDITOR_CALL(command, false);
     return js->queryCommandSupported(imp);
 }
 
 DOMString Editor::queryCommandValue(const DOMString &command)
 {
     PREPARE_JSEDITOR_CALL(command, DOMString());
     return js->queryCommandValue(imp);
 }
 
 bool Editor::execCommand(EditorCommand command, bool userInterface, const DOMString &value)
 {
     PREPARE_JSEDITOR_CALL(command, false);
     return js->execCommand(imp, userInterface, value);
 }
 
 bool Editor::queryCommandEnabled(EditorCommand command)
 {
     PREPARE_JSEDITOR_CALL(command, false);
     return js->queryCommandEnabled(imp);
 }
 
 bool Editor::queryCommandIndeterm(EditorCommand command)
 {
     PREPARE_JSEDITOR_CALL(command, false);
     return js->queryCommandIndeterm(imp);
 }
 
 bool Editor::queryCommandState(EditorCommand command)
 {
     PREPARE_JSEDITOR_CALL(command, false);
     return js->queryCommandState(imp);
 }
 
 bool Editor::queryCommandSupported(EditorCommand command)
 {
     PREPARE_JSEDITOR_CALL(command, false);
     return js->queryCommandSupported(imp);
 }
 
 DOMString Editor::queryCommandValue(EditorCommand command)
 {
     PREPARE_JSEDITOR_CALL(command, DOMString());
     return js->queryCommandValue(imp);
 }
 
 void Editor::copy()
 {
     static_cast<KHTMLPartBrowserExtension *>(m_part->browserExtension())->copy();
 }
 
 void Editor::cut()
 {
     // ###
     static_cast<KHTMLPartBrowserExtension *>(m_part->browserExtension())->cut();
 }
 
 void Editor::paste()
 {
     // ###
     // security?
     // static_cast<KHTMLPartBrowserExtension*>(m_part->browserExtension())->paste();
 }
 
 void Editor::print()
 {
     static_cast<KHTMLPartBrowserExtension *>(m_part->browserExtension())->print();
 }
 
 bool Editor::canPaste() const
 {
     // ###
     return false;
 }
 
 void Editor::redo()
 {
     if (d->m_redo.isEmpty()) {
         return;
     }
     RefPtr<EditCommandImpl> e = d->m_redo.pop();
     e->reapply();
 }
 
 void Editor::undo()
 {
     if (d->m_undo.isEmpty()) {
         return;
     }
     RefPtr<EditCommandImpl> e = d->m_undo.pop();
     e->unapply();
 }
 
 bool Editor::canRedo() const
 {
     return !d->m_redo.isEmpty();
 }
 
 bool Editor::canUndo() const
 {
     return !d->m_undo.isEmpty();
 }
 
 void Editor::applyStyle(CSSStyleDeclarationImpl *style)
 {
     switch (m_part->caret().state()) {
     case Selection::NONE:
         // do nothing
         break;
     case Selection::CARET:
         // FIXME: This blows away all the other properties of the typing style.
         setTypingStyle(style);
         break;
     case Selection::RANGE:
         if (m_part->xmlDocImpl() && style) {
 #ifdef DEBUG_COMMANDS
             // qCDebug(KHTML_LOG) << "[create ApplyStyleCommand]";
 #endif
             // FIXME
             (new ApplyStyleCommandImpl(m_part->xmlDocImpl(), style))->apply();
         }
         break;
     }
 }
 
 static void updateState(CSSStyleDeclarationImpl *desiredStyle, CSSStyleDeclarationImpl *computedStyle, bool &atStart, Editor::TriState &state)
 {
     QListIterator<CSSProperty *> it(*desiredStyle->values());
     while (it.hasNext()) {
         int propertyID = it.next()->id();
         DOMString desiredProperty = desiredStyle->getPropertyValue(propertyID);
         DOMString computedProperty = computedStyle->getPropertyValue(propertyID);
         Editor::TriState propertyState = strcasecmp(desiredProperty, computedProperty) == 0
                                          ? Editor::TrueTriState : Editor::FalseTriState;
         if (atStart) {
             state = propertyState;
             atStart = false;
         } else if (state != propertyState) {
             state = Editor::MixedTriState;
             break;
         }
     }
 }
 
 Editor::TriState Editor::selectionHasStyle(CSSStyleDeclarationImpl *style) const
 {
     bool atStart = true;
     TriState state = FalseTriState;
 
     EditorContext *ctx = m_part->editorContext();
     if (ctx->m_selection.state() != Selection::RANGE) {
         NodeImpl *nodeToRemove;
         CSSStyleDeclarationImpl *selectionStyle = selectionComputedStyle(nodeToRemove);
         if (!selectionStyle) {
             return FalseTriState;
         }
         selectionStyle->ref();
         updateState(style, selectionStyle, atStart, state);
         selectionStyle->deref();
         if (nodeToRemove) {
             int exceptionCode = 0;
             nodeToRemove->remove(exceptionCode);
             assert(exceptionCode == 0);
         }
     } else {
         for (NodeImpl *node = ctx->m_selection.start().node(); node; node = node->traverseNextNode()) {
             if (node->isHTMLElement()) {
                 CSSStyleDeclarationImpl *computedStyle = new RenderStyleDeclarationImpl(node);
                 computedStyle->ref();
                 updateState(style, computedStyle, atStart, state);
                 computedStyle->deref();
                 if (state == MixedTriState) {
                     break;
                 }
             }
             if (node == ctx->m_selection.end().node()) {
                 break;
             }
         }
     }
 
     return state;
 }
 
 bool Editor::selectionStartHasStyle(CSSStyleDeclarationImpl *style) const
 {
     NodeImpl *nodeToRemove;
     CSSStyleDeclarationImpl *selectionStyle = selectionComputedStyle(nodeToRemove);
     if (!selectionStyle) {
         return false;
     }
 
     selectionStyle->ref();
 
     bool match = true;
 
     QListIterator<CSSProperty *> it(*style->values());
     while (it.hasNext()) {
         int propertyID = it.next()->id();
         DOMString desiredProperty = style->getPropertyValue(propertyID);
         DOMString selectionProperty = selectionStyle->getPropertyValue(propertyID);
         if (strcasecmp(selectionProperty, desiredProperty) != 0) {
             match = false;
             break;
         }
     }
 
     selectionStyle->deref();
 
     if (nodeToRemove) {
         int exceptionCode = 0;
         nodeToRemove->remove(exceptionCode);
         assert(exceptionCode == 0);
     }
 
     return match;
 }
 
 DOMString Editor::selectionStartStylePropertyValue(int stylePropertyID) const
 {
     NodeImpl *nodeToRemove;
     CSSStyleDeclarationImpl *selectionStyle = selectionComputedStyle(nodeToRemove);
     if (!selectionStyle) {
         return DOMString();
     }
 
     selectionStyle->ref();
     DOMString value = selectionStyle->getPropertyValue(stylePropertyID);
     selectionStyle->deref();
 
     if (nodeToRemove) {
         int exceptionCode = 0;
         nodeToRemove->remove(exceptionCode);
         assert(exceptionCode == 0);
     }
 
     return value;
 }
 
 CSSStyleDeclarationImpl *Editor::selectionComputedStyle(NodeImpl *&nodeToRemove) const
 {
     nodeToRemove = nullptr;
 
     if (!m_part->xmlDocImpl()) {
         return nullptr;
     }
 
     EditorContext *ctx = m_part->editorContext();
     if (ctx->m_selection.state() == Selection::NONE) {
         return nullptr;
     }
 
     Range range(ctx->m_selection.toRange());
     Position pos(range.startContainer().handle(), range.startOffset());
     assert(pos.notEmpty());
     ElementImpl *elem = pos.element();
     ElementImpl *styleElement = elem;
     int exceptionCode = 0;
 
     if (m_typingStyle) {
         styleElement = m_part->xmlDocImpl()->createHTMLElement("SPAN");
 //     assert(exceptionCode == 0);
 
         styleElement->setAttribute(ATTR_STYLE, m_typingStyle->cssText().implementation());
 //     assert(exceptionCode == 0);
 
         TextImpl *text = m_part->xmlDocImpl()->createEditingTextNode("");
         styleElement->appendChild(text, exceptionCode);
         assert(exceptionCode == 0);
 
         elem->appendChild(styleElement, exceptionCode);
         assert(exceptionCode == 0);
 
         nodeToRemove = styleElement;
     }
 
     return new RenderStyleDeclarationImpl(styleElement);
 }
 
 PassRefPtr<EditCommandImpl> Editor::lastEditCommand() const
 {
     return d->m_lastEditCommand;
 }
 
 void Editor::appliedEditing(EditCommandImpl *cmd)
 {
 #ifdef DEBUG_COMMANDS
     // qCDebug(KHTML_LOG) << "[Applied editing]";
 #endif
     // make sure we have all the changes in rendering tree applied with relayout if needed before setting caret
     // in particular that could be required for inline boxes recomputation when inserting text
     m_part->xmlDocImpl()->updateLayout();
 
     m_part->setCaret(cmd->endingSelection(), false);
     // Command will be equal to last edit command only in the case of typing
     if (d->m_lastEditCommand == cmd) {
         assert(cmd->isTypingCommand());
     } else {
         // Only register a new undo command if the command passed in is
         // different from the last command
         d->registerUndo(cmd);
         d->m_lastEditCommand = cmd;
     }
     m_part->editorContext()->m_selection.setNeedsLayout(true);
     m_part->selectionLayoutChanged();
     // ### only emit if caret pos changed
     m_part->emitCaretPositionChanged(cmd->endingSelection().caretPos());
 }
 
 void Editor::unappliedEditing(EditCommandImpl *cmd)
 {
     // see comment in appliedEditing()
     m_part->xmlDocImpl()->updateLayout();
 
     m_part->setCaret(cmd->startingSelection());
     d->registerRedo(cmd);
 #ifdef APPLE_CHANGES
     KWQ(this)->respondToChangedContents();
 #else
     m_part->editorContext()->m_selection.setNeedsLayout(true);
     m_part->selectionLayoutChanged();
     // ### only emit if caret pos changed
     m_part->emitCaretPositionChanged(cmd->startingSelection().caretPos());
 #endif
     d->m_lastEditCommand = nullptr;
 }
 
 void Editor::reappliedEditing(EditCommandImpl *cmd)
 {
     // see comment in appliedEditing()
     m_part->xmlDocImpl()->updateLayout();
 
     m_part->setCaret(cmd->endingSelection());
     d->registerUndo(cmd, false /*clearRedoStack*/);
 #ifdef APPLE_CHANGES
     KWQ(this)->respondToChangedContents();
 #else
     m_part->selectionLayoutChanged();
     // ### only emit if caret pos changed
     m_part->emitCaretPositionChanged(cmd->endingSelection().caretPos());
 #endif
     d->m_lastEditCommand = nullptr;
 }
 
 CSSStyleDeclarationImpl *Editor::typingStyle() const
 {
     return m_typingStyle;
 }
 
 void Editor::setTypingStyle(CSSStyleDeclarationImpl *style)
 {
     CSSStyleDeclarationImpl *old = m_typingStyle;
     m_typingStyle = style;
     if (m_typingStyle) {
         m_typingStyle->ref();
     }
     if (old) {
         old->deref();
     }
 }
 
 void Editor::clearTypingStyle()
 {
     setTypingStyle(nullptr);
 }
 
 void Editor::closeTyping()
 {
     EditCommandImpl *lastCommand = lastEditCommand().get();
     if (lastCommand && lastCommand->isTypingCommand()) {
         static_cast<TypingCommandImpl *>(lastCommand)->closeTyping();
     }
 }
 
 void Editor::indent()
 {
     RefPtr<IndentOutdentCommandImpl> command = new IndentOutdentCommandImpl(m_part->xmlDocImpl(),
             IndentOutdentCommandImpl::Indent);
     command->apply();
 }
 
 void Editor::outdent()
 {
     RefPtr<IndentOutdentCommandImpl> command = new IndentOutdentCommandImpl(m_part->xmlDocImpl(),
             IndentOutdentCommandImpl::Outdent);
     command->apply();
 }
 
 bool Editor::handleKeyEvent(QKeyEvent *_ke)
 {
     bool handled = false;
 
     bool ctrl  = _ke->modifiers() & Qt::ControlModifier;
     bool alt   = _ke->modifiers() & Qt::AltModifier;
     //bool shift = _ke->modifiers() & Qt::ShiftModifier;
     bool meta  = _ke->modifiers() & Qt::MetaModifier;
 
     if (ctrl || alt || meta) {
         return false;
     }
 
     switch (_ke->key()) {
 
     case Qt::Key_Delete: {
         Selection selectionToDelete = m_part->caret();
 #ifdef DEBUG_COMMANDS
         // qCDebug(KHTML_LOG) << "========== KEY_DELETE ==========";
 #endif
         if (selectionToDelete.state() == Selection::CARET) {
             Position pos(selectionToDelete.start());
 #ifdef DEBUG_COMMANDS
             // qCDebug(KHTML_LOG) << "pos.inLastEditableInRootEditableElement " << pos.inLastEditableInRootEditableElement() << " pos.offset " << pos.offset() << " pos.max " << pos.node()->caretMaxRenderedOffset();
 #endif
             if (pos.nextCharacterPosition() == pos) {
                 // we're at the end of a root editable block...do nothing
 #ifdef DEBUG_COMMANDS
                 // qCDebug(KHTML_LOG) << "no delete!!!!!!!!!!";
 #endif
                 break;
             }
             m_part->d->editor_context.m_selection
                 = Selection(pos, pos.nextCharacterPosition());
         }
         // fall through
     }
     case Qt::Key_Backspace:
         TypingCommandImpl::deleteKeyPressed0(m_part->xmlDocImpl());
         handled = true;
         break;
 
     case Qt::Key_Return:
     case Qt::Key_Enter:
 //       if (shift)
         TypingCommandImpl::insertNewline0(m_part->xmlDocImpl());
 //       else
 //         TypingCommand::insertParagraph(m_part->xmlDocImpl());
         handled = true;
         break;
 
     case Qt::Key_Escape:
     case Qt::Key_Insert:
         // FIXME implement me
         handled = true;
         break;
 
     default:
 // handle_input:
         if (m_part->caret().state() != Selection::CARET) {
             // We didn't get a chance to grab the caret, likely because
             // a script messed with contentEditable in the middle of events
             // acquire it now if there isn't a selection
             // qCDebug(KHTML_LOG) << "Editable node w/o caret!";
             DOM::NodeImpl *focus = m_part->xmlDocImpl()->focusNode();
             if (m_part->caret().state() == Selection::NONE) {
                 if (focus) {
                     m_part->setCaret(Position(focus, focus->caretMinOffset()));
                 } else {
                     break;
                 }
             }
         }
 
         if (!_ke->text().isEmpty()) {
             TypingCommandImpl::insertText0(m_part->xmlDocImpl(), _ke->text());
             handled = true;
         }
 
     }
 
     //if (handled) {
     // ### check when to emit it
 //     m_part->emitSelectionChanged();
     //}
 
     return handled;
 
 }
 
 #include "moc_editor.cpp"