1 files changed, 145 insertions, 0 deletions
diff --git a/src/core/api/qwebengineframe.cpp b/src/core/api/qwebengineframe.cpp
index edd89d663..fa2cbb507 100644
--- a/src/core/api/qwebengineframe.cpp
+++ b/src/core/api/qwebengineframe.cpp
@@ -3,6 +3,11 @@
 
 #include "qwebengineframe.h"
 
+#include "qwebenginescript.h"
+#include <QtQml/qqmlengine.h>
+#include <QtGui/qpagelayout.h>
+#include <QtGui/qpageranges.h>
+
 #include "web_contents_adapter_client.h"
 #include "web_contents_adapter.h"
 
@@ -101,6 +106,146 @@ QSizeF QWebEngineFrame::size() const
     return m_adapterClient->webContentsAdapter()->frameSize(m_id);
 }
 
+/*!
+    Returns \c{true} if this object represents the page's main frame; \c{false} otherwise.
+*/
+bool QWebEngineFrame::isMainFrame() const
+{
+    return m_adapterClient->webContentsAdapter()->mainFrameId() == m_id;
+}
+
+/*! \fn void QWebEngineFrame::runJavaScript(const QString &script, const std::function<void(const QVariant &)> &callback)
+    \fn void QWebEngineFrame::runJavaScript(const QString &script, quint32 worldId)
+    \fn void QWebEngineFrame::runJavaScript(const QString &script, quint32 worldId, const
+   std::function<void(const QVariant &)> &callback)
+
+    Runs the JavaScript code contained in \a script on this frame, without checking
+    whether the DOM of the page has been constructed.
+    To avoid conflicts with other scripts executed on the page, the world in
+    which the script is run is specified by \a worldId. The world ID values are
+    the same as provided by QWebEngineScript::ScriptWorldId, and between \c 0
+    and \c 256. If you leave out the \c world ID, the script is run in the
+    \c MainWorld.
+    When the script has been executed, \a callback is called with the result of the last
+    executed statement. \c callback can be any of a function pointer, a functor or a lambda,
+    and it is expected to take a QVariant parameter. For example:
+    \code
+    page.runJavaScript("document.title", [](const QVariant &v) { qDebug() << v.toString(); });
+    \endcode
+    Only plain data can be returned from JavaScript as the result value.
+    Supported data types include all of the JSON data types as well as, for
+    example, \c{Date} and \c{ArrayBuffer}. Unsupported data types include, for
+    example, \c{Function} and \c{Promise}.
+    \warning Do not execute lengthy routines in the callback function, because it might block the
+    rendering of the web engine page.
+    \warning We guarantee that the \a callback is always called, but it might be
+   done during page destruction. When QWebEnginePage is deleted, the callback is triggered with an
+   invalid value and it is not safe to use the corresponding QWebEnginePage or QWebEngineView
+   instance inside it.
+    \sa QWebEngineScript::ScriptWorldId, QWebEnginePage::runJavaScript, {Script Injection}
+ */
+void QWebEngineFrame::runJavaScript(const QString &script,
+                                    const std::function<void(const QVariant &)> &callback)
+{
+    runJavaScript(script, QWebEngineScript::MainWorld, callback);
+}
+
+void QWebEngineFrame::runJavaScript(const QString &script, quint32 worldId,
+                                    const std::function<void(const QVariant &)> &callback)
+{
+    m_adapterClient->runJavaScript(script, worldId, m_id, callback);
+}
+
+void QWebEngineFrame::runJavaScript(const QString &script, quint32 worldId)
+{
+    runJavaScript(script, worldId, std::function<void(const QVariant &)>{});
+}
+
+void QWebEngineFrame::runJavaScript(const QString &script, const QJSValue &callback)
+{
+    runJavaScript(script, QWebEngineScript::MainWorld, callback);
+}
+
+void QWebEngineFrame::runJavaScript(const QString &script, quint32 worldId,
+                                    const QJSValue &callback)
+{
+    std::function<void(const QVariant &)> wrappedCallback;
+    if (!callback.isUndefined()) {
+        const QObject *holdingObject = m_adapterClient->holdingQObject();
+        wrappedCallback = [holdingObject, callback](const QVariant &result) {
+            if (auto engine = qmlEngine(holdingObject)) {
+                QJSValueList args;
+                args.append(engine->toScriptValue(result));
+                callback.call(args);
+            } else {
+                qWarning("No QML engine found to execute runJavaScript() callback");
+            }
+        };
+    }
+    runJavaScript(script, worldId, wrappedCallback);
+}
+
+/*!
+    Renders the current content of the frame into a PDF document and saves it in the location
+    specified in \a filePath. Printing uses a page size of A4, portrait layout, and includes the
+    full range of pages.
+
+    This method issues an asynchronous request for printing the web page into a PDF and returns
+    immediately. To be informed about the result of the request, connect to the \l
+    QWebEnginePage::pdfPrintingFinished() signal.
+
+    \note The \l QWebEnginePage::Stop web action can be used to interrupt this asynchronous
+    operation.
+
+    If a file already exists at the provided file path, it will be overwritten.
+
+    \sa QWebEnginePage::pdfPrintingFinished()
+ */
+void QWebEngineFrame::printToPdf(const QString &filePath)
+{
+    QPageLayout layout(QPageSize(QPageSize::A4), QPageLayout::Portrait, QMarginsF());
+    m_adapterClient->printToPdf(filePath, layout, QPageRanges(), m_id);
+}
+
+/*!
+    Renders the current content of the frame into a PDF document and returns a byte array containing
+    the PDF data as parameter to \a callback. Printing uses a page size of A4, portrait layout, and
+    includes the full range of pages.
+
+    The \a callback must take a const reference to a QByteArray as parameter. If printing was
+    successful, this byte array will contain the PDF data, otherwise, the byte array will be empty.
+
+    \note The \l QWebEnginePage::Stop web action can be used to interrupt this operation.
+*/
+void QWebEngineFrame::printToPdf(const std::function<void(const QByteArray &)> &callback)
+{
+    std::function wrappedCallback = [callback](QSharedPointer<QByteArray> result) {
+        if (callback)
+            callback(result ? *result : QByteArray());
+    };
+    QPageLayout layout(QPageSize(QPageSize::A4), QPageLayout::Portrait, QMarginsF());
+    m_adapterClient->printToPdf(std::move(wrappedCallback), layout, QPageRanges(), m_id);
+}
+
+void QWebEngineFrame::printToPdf(const QJSValue &callback)
+{
+    std::function<void(QSharedPointer<QByteArray>)> wrappedCallback;
+    if (!callback.isUndefined()) {
+        const QObject *holdingObject = m_adapterClient->holdingQObject();
+        wrappedCallback = [holdingObject, callback](QSharedPointer<QByteArray> result) {
+            if (auto engine = qmlEngine(holdingObject)) {
+                QJSValueList args;
+                args.append(engine->toScriptValue(result ? *result : QByteArray()));
+                callback.call(args);
+            } else {
+                qWarning("No QML engine found to execute runJavaScript() callback");
+            }
+        };
+    }
+    QPageLayout layout(QPageSize(QPageSize::A4), QPageLayout::Portrait, QMarginsF());
+    m_adapterClient->printToPdf(std::move(wrappedCallback), layout, QPageRanges(), m_id);
+}
+
 /*! \fn bool QWebEngineFrame::operator==(const QWebEngineFrame &left, const QWebEngineFrame &right) noexcept
 
     Returns \c{true} if \a left and \a right represent the same frame in the same web page,