File indexing completed on 2024-05-12 15:39:36

 /* This file is part of the KDE project
  *
  * Copyright (C) 2008 Bernhard Beschow <bbeschow cs tu berlin de>
  *           (C) 2009 Germain Garand <germain@ebooksfrance.org>
  *
  * 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 "khtmlfind_p.h"
 
 #include "khtml_part.h"
 #include "khtmlviewbar.h"
 #include "khtmlfindbar.h"
 
 #include "dom/html_document.h"
 #include "html/html_documentimpl.h"
 #include "rendering/render_text.h"
 #include "rendering/render_replaced.h"
 #include "xml/dom_selection.h"
 
 #include "khtmlview.h"
 
 #include <QClipboard>
 
 #include "rendering/render_form.h"
 
 #define d this
 
 using khtml::RenderPosition;
 
 using namespace DOM;
 
 KHTMLFind::KHTMLFind(KHTMLPart *part, KHTMLFind *parent) :
     m_part(part),
     m_find(nullptr),
     m_parent(parent),
     m_findDialog(nullptr)
 {
     connect(part, SIGNAL(selectionChanged()), this, SLOT(slotSelectionChanged()));
 }
 
 KHTMLFind::~KHTMLFind()
 {
     d->m_find = nullptr; // deleted by its parent, the view.
 }
 
 void KHTMLFind::findTextBegin()
 {
     d->m_findPos = -1;
     d->m_findNode = nullptr;
     d->m_findPosEnd = -1;
     d->m_findNodeEnd = nullptr;
     d->m_findPosStart = -1;
     d->m_findNodeStart = nullptr;
     d->m_findNodePrevious = nullptr;
     delete d->m_find;
     d->m_find = nullptr;
 }
 
 bool KHTMLFind::initFindNode(bool selection, bool reverse, bool fromCursor)
 {
     if (m_part->document().isNull()) {
         return false;
     }
 
     DOM::NodeImpl *firstNode = nullptr;
     if (m_part->document().isHTMLDocument()) {
         firstNode = m_part->htmlDocument().body().handle();
     } else {
         firstNode = m_part->document().handle();
     }
 
     if (!firstNode) {
         //qCDebug(KHTML_LOG) << "no first node (body or doc) -> return false";
         return false;
     }
     if (selection && m_part->hasSelection()) {
         //qCDebug(KHTML_LOG) << "using selection";
         const Selection &sel = m_part->caret();
         if (!fromCursor) {
             d->m_findNode = reverse ? sel.end().node() : sel.start().node();
             d->m_findPos = reverse ? sel.end().offset() : sel.start().offset();
         }
         d->m_findNodeEnd = reverse ? sel.start().node() : sel.end().node();
         d->m_findPosEnd = reverse ? sel.start().offset() : sel.end().offset();
         d->m_findNodeStart = !reverse ? sel.start().node() : sel.end().node();
         d->m_findPosStart = !reverse ? sel.start().offset() : sel.end().offset();
         d->m_findNodePrevious = d->m_findNodeStart;
     } else { // whole document
         //qCDebug(KHTML_LOG) << "whole doc";
         if (!fromCursor) {
             d->m_findNode = firstNode;
             d->m_findPos = reverse ? -1 : 0;
         }
         d->m_findNodeEnd = reverse ? firstNode : nullptr;
         d->m_findPosEnd = reverse ? 0 : -1;
         d->m_findNodeStart = !reverse ? firstNode : nullptr;
         d->m_findPosStart = !reverse ? 0 : -1;
         d->m_findNodePrevious = d->m_findNodeStart;
         if (reverse) {
             // Need to find out the really last object, to start from it
             khtml::RenderObject *obj = d->m_findNode ? d->m_findNode->renderer() : nullptr;
             if (obj) {
                 // find the last object in the render tree
                 while (obj->lastChild()) {
                     obj = obj->lastChild();
                 }
                 // now get the last object with a NodeImpl associated
                 while (!obj->element() && obj->objectAbove()) {
                     obj = obj->objectAbove();
                 }
                 d->m_findNode = obj->element();
             }
         }
     }
     return true;
 }
 
 void KHTMLFind::deactivate()
 {
     // qCDebug(KHTML_LOG);
     d->m_lastFindState.options = d->m_findDialog->options();
     d->m_lastFindState.history = d->m_findDialog->findHistory();
     if (!m_parent) {
         d->m_findDialog->hide();
         d->m_findDialog->disconnect();
         d->m_findDialog->deleteLater();
     }
     d->m_findDialog = nullptr;
 
     // if the selection is limited to a single link, that link gets focus
     const DOM::Selection sel = m_part->caret();
     if (sel.start().node() == sel.end().node()) {
         bool isLink = false;
 
         // checks whether the node has a <A> parent
         DOM::NodeImpl *parent = sel.start().node();
         while (parent) {
             if (parent->nodeType() == Node::ELEMENT_NODE && parent->id() == ID_A) {
                 isLink = true;
                 break;
             }
             parent = parent->parentNode();
         }
 
         if (isLink == true) {
             static_cast<DOM::DocumentImpl *>(m_part->document().handle())->setFocusNode(parent);
         }
     }
 }
 
 void KHTMLFind::slotFindDestroyed()
 {
     d->m_find = nullptr;
 }
 
 void KHTMLFind::activate()
 {
     // First do some init to make sure we can search in this frame
     if (m_part->document().isNull()) {
         return;
     }
 
     // Raise if already opened
     if (d->m_findDialog && !m_parent) {
         m_part->pBottomViewBar()->showBarWidget(d->m_findDialog);
         return;
     }
 
     // The lineedit of the dialog would make khtml lose its selection, otherwise
 #ifndef QT_NO_CLIPBOARD
     disconnect(qApp->clipboard(), SIGNAL(selectionChanged()), m_part, SLOT(slotClearSelection()));
 #endif
 
     if (m_parent) {
         d->m_findDialog  = m_parent->findBar();
     } else {
         // Now show the dialog in which the user can choose options.
         d->m_findDialog = new KHTMLFindBar(m_part->widget());
         d->m_findDialog->setHasSelection(m_part->hasSelection());
         d->m_findDialog->setHasCursor(d->m_findNode != nullptr);
 #if 0
         if (d->m_findNode) { // has a cursor -> default to 'FromCursor'
             d->m_lastFindState.options |= KFind::FromCursor;
         }
 #endif
 
         // TODO? optionsDialog.setPattern( d->m_lastFindState.text );
         d->m_findDialog->setFindHistory(d->m_lastFindState.history);
         d->m_findDialog->setOptions(d->m_lastFindState.options);
         d->m_findDialog->setFocus();
 
         d->m_lastFindState.options = -1; // force update in findTextNext
         d->m_lastFindState.last_dir = -1;
 
         m_part->pBottomViewBar()->addBarWidget(d->m_findDialog);
         m_part->pBottomViewBar()->showBarWidget(d->m_findDialog);
         connect(d->m_findDialog, SIGNAL(searchChanged()), this, SLOT(slotSearchChanged()));
         connect(d->m_findDialog, SIGNAL(findNextClicked()), this, SLOT(slotFindNext()));
         connect(d->m_findDialog, SIGNAL(findPreviousClicked()), this, SLOT(slotFindPrevious()));
         connect(d->m_findDialog, SIGNAL(hideMe()), this, SLOT(deactivate()));
     }
 #ifndef QT_NO_CLIPBOARD
     connect(qApp->clipboard(), SIGNAL(selectionChanged()), m_part, SLOT(slotClearSelection()));
 #endif
     if (m_findDialog) {
         createNewKFind(m_findDialog->pattern(), 0 /*options*/, m_findDialog, nullptr);
     } else if (m_parent && m_parent->find()) {
         createNewKFind(m_parent->find()->pattern(), m_parent->find()->options(), static_cast<QWidget *>(m_parent->find()->parent()), nullptr);
     }
 }
 
 // ### this crawling through the render tree sucks. There should be another way to
 //     do that.
 static inline KHTMLPart *innerPart(khtml::RenderObject *ro)
 {
     if (!ro || !ro->isWidget() || ro->isFormElement()) {
         return nullptr;
     }
     KHTMLView *v = qobject_cast<KHTMLView *>(static_cast<khtml::RenderWidget *>(ro)->widget());
     return v ? v->part() : nullptr;
 }
 static inline KHTMLPart *innerPartFromNode(DOM::NodeImpl *node)
 {
     return (node && node->renderer() ? innerPart(node->renderer()) : nullptr);
 }
 
 void KHTMLFind::createNewKFind(const QString &str, long options, QWidget *parent, KFindDialog *findDialog)
 {
     // First do some init to make sure we can search in this frame
     if (m_part->document().isNull()) {
         return;
     }
 
     if (m_findNode) {
         if (KHTMLPart *p = innerPartFromNode(m_findNode)) {
             p->clearSelection();
             p->findTextBegin();
         }
     }
 
     // Create the KFind object
     delete d->m_find;
     d->m_find = new KFind(str, options, parent, findDialog);
     d->m_find->closeFindNextDialog(); // we use KFindDialog non-modal, so we don't want other dlg popping up
     connect(d->m_find, SIGNAL(highlight(QString,int,int)),
             this, SLOT(slotHighlight(QString,int,int)));
     connect(d->m_find, SIGNAL(destroyed()),
             this, SLOT(slotFindDestroyed()));
     //connect(d->m_find, SIGNAL(findNext()),
     //        this, SLOT(slotFindNext()) );
 
     if (!findDialog) {
         d->m_lastFindState.options = options;
         initFindNode(options & KFind::SelectedText,
                      options & KFind::FindBackwards,
                      options & KFind::FromCursor);
     }
 }
 
 bool KHTMLFind::findTextNext(bool reverse)
 {
     if (!d->m_find) {
         // We didn't show the find dialog yet, let's do it then (#49442)
         activate();
 
         // FIXME Ugly hack: activate() may not create KFind object, so check whether it was created
         if (!d->m_find) {
             return false;
         }
 
         // It also means the user is trying to match a previous pattern, so try and
         // restore the last saved pattern.
         if (!m_parent && (!d->m_findDialog || !d->m_findDialog->restoreLastPatternFromHistory())) {
             return false;
         }
     }
 
     long options = 0;
     if (d->m_findDialog) { // 0 when we close the dialog
         // there is a search dialog
         // make sure pattern from search dialog is used
         // (### in fact pattern changes should always trigger a reconstruction of the KFind object cf. slotSearchChanged
         //   - so make this an assert)
         if ((d->m_find->pattern() != d->m_findDialog->pattern())) {
             d->m_find->setPattern(d->m_findDialog->pattern());
             d->m_find->resetCounts();
         }
 
         // make sure options from search dialog are used
         options = d->m_findDialog->options();
         if (d->m_lastFindState.options != options) {
             d->m_find->setOptions(options);
 
             if (options & KFind::SelectedText) { //#### FIXME find in selection for frames!
                 Q_ASSERT(m_part->hasSelection());
             }
 
             long difference = d->m_lastFindState.options ^ options;
             if (difference & (KFind::SelectedText | KFind::FromCursor)) {
                 // Important options changed -> reset search range
                 (void) initFindNode(options & KFind::SelectedText,
                                     options & KFind::FindBackwards,
                                     options & KFind::FromCursor);
             }
             d->m_lastFindState.options = options;
         }
     } else {
         // no dialog
         options = d->m_lastFindState.options;
     }
 
     // only adopt options for search direction manually
     if (reverse) {
         options = options ^ KFind::FindBackwards;
     }
 
     // make sure our options are used by KFind
     if (d->m_find->options() != options) {
         d->m_find->setOptions(options);
     }
 
     // Changing find direction. Start and end nodes must be switched.
     // Additionally since d->m_findNode points after the last node
     // that was searched, it needs to be "after" it in the opposite direction.
     if (d->m_lastFindState.last_dir != -1
             && bool(d->m_lastFindState.last_dir) != bool(options & KFind::FindBackwards)) {
         qSwap(d->m_findNodeEnd, d->m_findNodeStart);
         qSwap(d->m_findPosEnd, d->m_findPosStart);
         qSwap(d->m_findNode, d->m_findNodePrevious);
 
         // d->m_findNode now point at the end of the last searched line - advance one node
         khtml::RenderObject *obj = d->m_findNode ? d->m_findNode->renderer() : nullptr;
         khtml::RenderObject *end = d->m_findNodeEnd ? d->m_findNodeEnd->renderer() : nullptr;
         if (obj == end) {
             obj = nullptr;
         } else if (obj) {
             do {
                 obj = (options & KFind::FindBackwards) ? obj->objectAbove() : obj->objectBelow();
             } while (obj && (!obj->element() || obj->isInlineContinuation()));
         }
         if (obj) {
             d->m_findNode = obj->element();
         } else {
             // already at end, start again
             (void) initFindNode(options & KFind::SelectedText,
                                 options & KFind::FindBackwards,
                                 options & KFind::FromCursor);
         }
     }
     d->m_lastFindState.last_dir = (options & KFind::FindBackwards) ? 1 : 0;
 
     int numMatchesOld = m_find->numMatches();
     KFind::Result res = KFind::NoMatch;
     khtml::RenderObject *obj = d->m_findNode ? d->m_findNode->renderer() : nullptr;
     khtml::RenderObject *end = d->m_findNodeEnd ? d->m_findNodeEnd->renderer() : nullptr;
     //qCDebug(KHTML_LOG) << "obj=" << obj << " end=" << end;
     while (res == KFind::NoMatch) {
         if (d->m_find->needData()) {
             if (!obj) {
                 //qCDebug(KHTML_LOG) << "obj=0 -> done";
                 break; // we're done
             }
             //qCDebug(KHTML_LOG) << " gathering data";
             // First make up the QString for the current 'line' (i.e. up to \n)
             // We also want to remember the DOMNode for every portion of the string.
             // We store this in an index->node list.
 
             d->m_stringPortions.clear();
             bool newLine = false;
             QString str;
             DOM::NodeImpl *lastNode = d->m_findNode;
             while (obj && !newLine) {
                 // Grab text from render object
                 QString s;
                 if (obj->renderName() == QLatin1String("RenderTextArea")) {
                     s = static_cast<khtml::RenderTextArea *>(obj)->text();
                     s = s.replace(0xa0, ' ');
                 } else if (obj->renderName() ==  QLatin1String("RenderLineEdit")) {
                     khtml::RenderLineEdit *parentLine = static_cast<khtml::RenderLineEdit *>(obj);
                     if (parentLine->widget()->echoMode() == QLineEdit::Normal) {
                         s = parentLine->widget()->text();
                     }
                     s = s.replace(0xa0, ' ');
                 } else if (obj->isText()) {
                     bool isLink = false;
 
                     // checks whether the node has a <A> parent
                     if (options & KHTMLPart::FindLinksOnly) {
                         DOM::NodeImpl *parent = obj->element();
                         while (parent) {
                             if (parent->nodeType() == Node::ELEMENT_NODE && parent->id() == ID_A) {
                                 isLink = true;
                                 break;
                             }
                             parent = parent->parentNode();
                         }
                     } else {
                         isLink = true;
                     }
 
                     if (isLink) {
                         s = static_cast<khtml::RenderText *>(obj)->data().string();
                         s = s.replace(0xa0, ' ');
                     }
                 } else if (KHTMLPart *p = innerPart(obj)) {
                     if (p->pFindTextNextInThisFrame(reverse)) {
                         numMatchesOld++;
                         res = KFind::Match;
                         lastNode = obj->element();
                         break;
                     }
 
                 } else if (obj->isBR()) {
                     s = '\n';
                 } else if (!obj->isInline() && !str.isEmpty()) {
                     s = '\n';
                 }
 
                 if (lastNode == d->m_findNodeEnd) {
                     s.truncate(d->m_findPosEnd);
                 }
                 if (!s.isEmpty()) {
                     newLine = s.indexOf('\n') != -1;   // did we just get a newline?
                     if (!(options & KFind::FindBackwards)) {
                         //qCDebug(KHTML_LOG) << "StringPortion: " << index << "-" << index+s.length()-1 << " -> " << lastNode;
                         d->m_stringPortions.append(StringPortion(str.length(), lastNode));
                         str += s;
                     } else { // KFind itself can search backwards, so str must not be built backwards
                         for (QList<StringPortion>::Iterator it = d->m_stringPortions.begin();
                                 it != d->m_stringPortions.end();
                                 ++it) {
                             (*it).index += s.length();
                         }
                         d->m_stringPortions.prepend(StringPortion(0, lastNode));
                         str.prepend(s);
                     }
                 }
                 // Compare obj and end _after_ we processed the 'end' node itself
                 if (obj == end) {
                     obj = nullptr;
                 } else {
                     // Move on to next object (note: if we found a \n already, then obj (and lastNode)
                     // will point to the _next_ object, i.e. they are in advance.
                     do {
                         // We advance until the next RenderObject that has a NodeImpl as its element().
                         // Otherwise (if we keep the 'last node', and it has a '\n') we might be stuck
                         // on that object forever...
                         obj = (options & KFind::FindBackwards) ? obj->objectAbove() : obj->objectBelow();
                     } while (obj && (!obj->element() || obj->isInlineContinuation()));
                 }
                 if (obj) {
                     lastNode = obj->element();
                 } else {
                     lastNode = nullptr;
                 }
             } // end while
 
             if (!str.isEmpty()) {
                 d->m_find->setData(str, d->m_findPos);
             }
             d->m_findPos = -1; // not used during the findnext loops. Only during init.
             d->m_findNodePrevious = d->m_findNode;
             d->m_findNode = lastNode;
         }
         if (!d->m_find->needData() && !(res == KFind::Match)) { // happens if str was empty
             // Let KFind inspect the text fragment, and emit highlighted if a match is found
             res = d->m_find->find();
         }
     } // end while
 
     if (res == KFind::NoMatch) { // i.e. we're done
         // qCDebug(KHTML_LOG) << "No more matches.";
         if (!(options & KHTMLPart::FindNoPopups) && d->m_find->shouldRestart()) {
             // qCDebug(KHTML_LOG) << "Restarting";
             initFindNode(false, options & KFind::FindBackwards, false);
             d->m_find->resetCounts();
             findTextNext(reverse);
         } else { // really done
             // qCDebug(KHTML_LOG) << "Finishing";
             //delete d->m_find;
             //d->m_find = 0L;
             initFindNode(false, options & KFind::FindBackwards, false);
             d->m_find->resetCounts();
             d->m_part->clearSelection();
         }
         // qCDebug(KHTML_LOG) << "Dialog closed.";
     }
 
     if (m_findDialog != nullptr) {
         m_findDialog->setFoundMatch(res == KFind::Match);
         m_findDialog->setAtEnd(m_find->numMatches() < numMatchesOld);
     }
 
     return res == KFind::Match;
 }
 
 void KHTMLFind::slotHighlight(const QString & /*text*/, int index, int length)
 {
     //qCDebug(KHTML_LOG) << "slotHighlight index=" << index << " length=" << length;
     QList<StringPortion>::Iterator it = d->m_stringPortions.begin();
     const QList<StringPortion>::Iterator itEnd = d->m_stringPortions.end();
     QList<StringPortion>::Iterator prev = it;
     // We stop at the first portion whose index is 'greater than', and then use the previous one
     while (it != itEnd && (*it).index <= index) {
         prev = it;
         ++it;
     }
     Q_ASSERT(prev != itEnd);
     DOM::NodeImpl *node = (*prev).node;
     Q_ASSERT(node);
 
     Selection sel(RenderPosition(node, index - (*prev).index).position());
 
     khtml::RenderObject *obj = node->renderer();
     khtml::RenderTextArea *renderTextArea = nullptr;
     khtml::RenderLineEdit *renderLineEdit = nullptr;
 
     Q_ASSERT(obj);
     if (obj) {
         int x = 0, y = 0;
 
         if (obj->renderName() == QLatin1String("RenderTextArea")) {
             renderTextArea = static_cast<khtml::RenderTextArea *>(obj);
         }
         if (obj->renderName() == QLatin1String("RenderLineEdit")) {
             renderLineEdit = static_cast<khtml::RenderLineEdit *>(obj);
         }
         if (!renderLineEdit && !renderTextArea)
             //if (static_cast<khtml::RenderText *>(node->renderer())
             //    ->posOfChar(d->m_startOffset, x, y))
         {
             int dummy;
             static_cast<khtml::RenderText *>(node->renderer())
             ->caretPos(RenderPosition::fromDOMPosition(sel.start()).renderedOffset(), false, x, y, dummy, dummy);   // more precise than posOfChar
             //qCDebug(KHTML_LOG) << "topleft: " << x << "," << y;
             if (x != -1 || y != -1) {
                 int gox = m_part->view()->contentsX();
                 if (x + 50 > m_part->view()->contentsX() + m_part->view()->visibleWidth()) {
                     gox = x - m_part->view()->visibleWidth() + 50;
                 }
                 if (x - 10 < m_part->view()->contentsX()) {
                     gox = x - m_part->view()->visibleWidth() - 10;
                 }
                 if (gox < 0) {
                     gox = 0;
                 }
                 m_part->view()->setContentsPos(gox, y - 50);
             }
         }
     }
     // Now look for end node
     it = prev; // no need to start from beginning again
     while (it != itEnd && (*it).index < index + length) {
         prev = it;
         ++it;
     }
     Q_ASSERT(prev != itEnd);
 
     sel.moveTo(sel.start(), RenderPosition((*prev).node, index + length - (*prev).index).position());
 
 #if 0
     // qCDebug(KHTML_LOG) << "slotHighlight: " << d->m_selectionStart.handle() << "," << d->m_startOffset << " - " <<
     d->m_selectionEnd.handle() << "," << d->m_endOffset;
     it = d->m_stringPortions.begin();
     for (; it != d->m_stringPortions.end(); ++it)
         // qCDebug(KHTML_LOG) << "  StringPortion: from index=" << (*it).index << " -> node=" << (*it).node;
 #endif
         if (renderTextArea) {
             renderTextArea->highLightWord(length, sel.end().offset() - length);
         } else if (renderLineEdit) {
             renderLineEdit->highLightWord(length, sel.end().offset() - length);
         } else {
             m_part->setCaret(sel);
 //    d->m_doc->updateSelection();
             if (sel.end().node()->renderer()) {
                 int x, y, height, dummy;
                 static_cast<khtml::RenderText *>(sel.end().node()->renderer())
                 ->caretPos(RenderPosition::fromDOMPosition(sel.end()).renderedOffset(), false, x, y, dummy, height);   // more precise than posOfChar
                 //qCDebug(KHTML_LOG) << "bottomright: " << x << "," << y+height;
             }
         }
     m_part->emitSelectionChanged();
 
 }
 
 void KHTMLFind::slotSelectionChanged()
 {
     if (d->m_findDialog) {
         d->m_findDialog->setHasSelection(m_part->hasSelection());
     }
 }
 
 void KHTMLFind::slotSearchChanged()
 {
     createNewKFind(m_findDialog->pattern(), m_findDialog->options(), m_findDialog, nullptr);
     findTextNext();
 }
 
 void KHTMLFind::slotFindNext()
 {
     findTextNext();
 }
 
 void KHTMLFind::slotFindPrevious()
 {
     findTextNext(true);    // find backwards
 }
 
 #include "moc_khtmlfind_p.cpp"