2011-04-09 21:34:04 +04:00
|
|
|
/*
|
|
|
|
|
This file is part of the PhantomJS project from Ofi Labs.
|
|
|
|
|
|
|
|
|
|
Copyright (C) 2011 Ariya Hidayat <ariya.hidayat@gmail.com>
|
2011-08-31 19:29:40 +04:00
|
|
|
Copyright (C) 2011 Ivan De Marino <ivan.de.marino@gmail.com>
|
2011-04-09 21:34:04 +04:00
|
|
|
|
|
|
|
|
Redistribution and use in source and binary forms, with or without
|
|
|
|
|
modification, are permitted provided that the following conditions are met:
|
|
|
|
|
|
|
|
|
|
* Redistributions of source code must retain the above copyright
|
|
|
|
|
notice, this list of conditions and the following disclaimer.
|
|
|
|
|
* Redistributions in binary form must reproduce the above copyright
|
|
|
|
|
notice, this list of conditions and the following disclaimer in the
|
|
|
|
|
documentation and/or other materials provided with the distribution.
|
|
|
|
|
* Neither the name of the <organization> nor the
|
|
|
|
|
names of its contributors may be used to endorse or promote products
|
|
|
|
|
derived from this software without specific prior written permission.
|
|
|
|
|
|
|
|
|
|
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
|
|
|
|
|
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
|
|
|
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
|
|
|
ARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
|
|
|
|
|
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
|
|
|
|
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
|
|
|
|
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
|
|
|
|
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
|
|
|
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
|
|
|
|
|
THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
|
|
|
*/
|
|
|
|
|
|
2011-05-25 21:46:51 +04:00
|
|
|
#include "webpage.h"
|
|
|
|
|
|
|
|
|
|
#include <math.h>
|
|
|
|
|
|
2011-04-08 17:30:50 +04:00
|
|
|
#include <QApplication>
|
2011-05-26 11:27:55 +04:00
|
|
|
#include <QDesktopServices>
|
2012-06-14 11:43:20 +04:00
|
|
|
#include <QDateTime>
|
2011-05-25 21:46:51 +04:00
|
|
|
#include <QDir>
|
|
|
|
|
#include <QFileInfo>
|
2012-07-01 20:47:22 +04:00
|
|
|
#include <QKeyEvent>
|
2011-09-15 08:41:26 +04:00
|
|
|
#include <QMouseEvent>
|
2011-05-28 12:38:11 +04:00
|
|
|
#include <QNetworkAccessManager>
|
2012-06-14 11:43:20 +04:00
|
|
|
#include <QNetworkCookie>
|
2011-09-15 08:41:26 +04:00
|
|
|
#include <QNetworkRequest>
|
2011-05-25 21:46:51 +04:00
|
|
|
#include <QPainter>
|
|
|
|
|
#include <QPrinter>
|
2012-09-27 02:08:55 +04:00
|
|
|
#include <QWebHistory>
|
2012-11-18 04:08:54 +04:00
|
|
|
#include <QWebHistoryItem>
|
2011-06-27 08:51:30 +04:00
|
|
|
#include <QWebElement>
|
2011-05-25 21:46:51 +04:00
|
|
|
#include <QWebFrame>
|
|
|
|
|
#include <QWebPage>
|
2011-10-25 23:16:25 +04:00
|
|
|
#include <QWebInspector>
|
2012-03-23 15:48:16 +04:00
|
|
|
#include <QMapIterator>
|
2012-05-17 00:35:51 +04:00
|
|
|
#include <QBuffer>
|
2012-05-12 04:32:16 +04:00
|
|
|
#include <QDebug>
|
2012-06-18 05:22:43 +04:00
|
|
|
#include <QImageWriter>
|
2013-01-10 08:07:32 +04:00
|
|
|
#include <QUuid>
|
2011-04-08 17:30:50 +04:00
|
|
|
|
2012-07-05 04:21:15 +04:00
|
|
|
#include "phantom.h"
|
2011-09-15 10:46:01 +04:00
|
|
|
#include "networkaccessmanager.h"
|
2011-06-10 19:50:49 +04:00
|
|
|
#include "utils.h"
|
2012-05-19 17:04:01 +04:00
|
|
|
#include "config.h"
|
2011-06-07 20:20:22 +04:00
|
|
|
#include "consts.h"
|
2012-04-11 17:23:25 +04:00
|
|
|
#include "callback.h"
|
2012-09-06 10:33:18 +04:00
|
|
|
#include "cookiejar.h"
|
2013-01-10 08:07:32 +04:00
|
|
|
#include "system.h"
|
|
|
|
|
|
|
|
|
|
#ifdef Q_OS_WIN32
|
|
|
|
|
#include <io.h>
|
|
|
|
|
#include <fcntl.h>
|
|
|
|
|
#endif
|
2011-06-07 20:20:22 +04:00
|
|
|
|
2011-09-16 18:12:57 +04:00
|
|
|
// Ensure we have at least head and body.
|
2012-05-12 04:32:16 +04:00
|
|
|
#define BLANK_HTML "<html><head></head><body></body></html>"
|
|
|
|
|
#define CALLBACKS_OBJECT_NAME "_phantom"
|
|
|
|
|
#define INPAGE_CALL_NAME "window.callPhantom"
|
2014-06-12 09:32:50 +04:00
|
|
|
#define CALLBACKS_OBJECT_INJECTION INPAGE_CALL_NAME" = function() { return window."CALLBACKS_OBJECT_NAME".call.call(_phantom, Array.prototype.slice.call(arguments, 0)); };"
|
2012-09-26 12:56:27 +04:00
|
|
|
#define CALLBACKS_OBJECT_PRESENT "typeof(window."CALLBACKS_OBJECT_NAME") !== \"undefined\";"
|
2011-09-15 11:15:56 +04:00
|
|
|
|
2013-01-10 08:07:32 +04:00
|
|
|
#define STDOUT_FILENAME "/dev/stdout"
|
|
|
|
|
#define STDERR_FILENAME "/dev/stderr"
|
|
|
|
|
|
2012-05-12 04:32:16 +04:00
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* @class CustomPage
|
|
|
|
|
*/
|
2011-05-25 21:46:51 +04:00
|
|
|
class CustomPage: public QWebPage
|
|
|
|
|
{
|
A REPL for PhantomJS
This covers [Issue 252](http://code.google.com/p/phantomjs/issues/detail?id=252)
The commit is composed of 12 squashed commits:
commit efdc6ba4f143c30a690fd97d92d80fa412e79999
Author: Ivan De Marino <ivan.de.marino@gmail.com>
Date: Mon Feb 27 00:19:36 2012 +0000
Pretty-pringing and Completion Caching done!
* This completes pretty-printing for the result of evaluated
* expressions in the REPL.
* Also, now we cache the "possible completions", to speed things up
* a bit (nothing fancy though).
* Minor tweaks to the internal doc and the way we "mock"
* pretty-printing for QObjects/REPLCompletanle
* All tests passing :)
commit 1f9ef690e112a535b431fca409b77bb9c09d1c70
Author: Ivan De Marino <ivan.de.marino@gmail.com>
Date: Sun Feb 26 22:35:00 2012 +0000
Moving most of REPL shim JavaScritp code in a separate file. Way
easier to work on.
commit 02d460a16fee14e7096ae7d899c03902c5b8a9c6
Author: Ivan De Marino <ivan.de.marino@gmail.com>
Date: Sat Feb 25 20:25:18 2012 +0000
Initialisation of the Completions is now done in a pure virtual.
This means that every REPLCompletable object will ACTUALLY register
completion strings, ONLY if we are running a REPL
and that object is ACTUALLY created.
Otherwise, why bother?
Adding completions for all exposed REPLCompletable objects
Also, fixed an issue with _getCompletions()
commit 412c3778fb04aa1c7379f8e760afce702b0428dd
Author: Ivan De Marino <ivan.de.marino@gmail.com>
Date: Tue Feb 21 00:49:17 2012 +0000
Few more tweaks to the REPL:
- Now 'phantom' is the first QObject with proper completion
- No repetition in QObject completions
- LVAL of any user expression is now correctly prettified and
printed
Major things left to do:
- Cache completions (using QCache?)
- Add completions for the other QObject
- When the LVAL of a user expression is a QObject, print what's
expected, not the QObject "real" structure
commit 46f04713c8165d898055e15478bb31403f8c93f1
Author: Ivan De Marino <ivan.de.marino@gmail.com>
Date: Tue Feb 7 10:13:23 2012 -0800
Pretty-print expressions result
Still not done though: there are issues with the NON-Native JS
objects.
commit 98b2fe67651dc750b62c6fa9cf1d80317fd9ae06
Author: Ivan De Marino <ivan.de.marino@gmail.com>
Date: Fri Feb 3 00:22:52 2012 -0800
Introducing REPLCompletable.
This class should be inherited by any JavaScript-exposed QObject, to
ensure correct Auto-Completion.
Correct auto-completion for QObjects.
- Now even QObjects can correctly provide auto-completion, and avoid
showing "not for users" methods
- The strings used for the auto-completion are stored in a single
Index: minimum memory footprint
- Still, there is optimization that should be done (when "searching"
for the right completion by prefix)
- Completion for the objects not set up yet, but now it's just a
trivial sequence of "addCompletion('bla')" in their constructors
commit 9bd48618154b1530a37b41f4060440184e23253d
Author: Ivan De Marino <ivan.de.marino@gmail.com>
Date: Thu Feb 2 00:20:25 2012 -0800
Changing the way we import Linenoise.
Will just import a specific commit, and update manually when needed.
commit cfc9bae9fbdab13b01019b34b7cbd565e3153780
Author: Ivan De Marino <ivan.de.marino@gmail.com>
Date: Sun Jan 29 23:22:26 2012 -0800
Made the REPL into a Singleton. With Auto-completion!.
Reasons:
1) Needed a pointer to function (i.e. a static method) to be used
with Linenoise to provide auto-completions
2) It makes more sense, as it's not like we are going to have 2 REPL
running at the same time, are we?
There are problems to address:
- the enumeration in JS seems to return only the native interface of
our objects
- the function completions contain argument types of those functions
- "private" methods are exposed
commit c78bd32e17f8e0e4cc4a0066858de8cc81d33b97
Author: Ivan De Marino <ivan.de.marino@gmail.com>
Date: Sun Jan 29 22:10:20 2012 -0800
Migrating from the original, now [unmantained
Linenoise](https://github.com/antirez/linenoise) to the fairly active
[tadmarshall fork](https://github.com/tadmarshall/linenoise).
Also now the project is imported as a Git Submodule.
Having migrated to the latest Linenoise (see prev. commit), now this
_SHOULD_ work on Windows too.
But, of course, this needs testing. :)
commit 43713c5723d7c5ed446ba41ae8d6f8c9feba7f9b
Author: Ivan De Marino <ivan.de.marino@gmail.com>
Date: Tue Jan 24 23:17:06 2012 -0800
Now that the basics work, I'm adding support for REPL history.
This is something almost everyone today is accustomed to.
Also, now REPL history works!
And I found some useful resources to solve pending TODOs.
commit 31e5f88b044a5b4a823c67527ef8c245d2ac7863
Author: Ivan De Marino <ivan.de.marino@gmail.com>
Date: Sun Jan 22 20:56:36 2012 -0800
Adding Linenoise Project (https://github.com/antirez/linenoise).
For now is included as a drop-in set of files.
Later on, if the Linenoise project has frequent
updates, we might prefer to do it as a
git-submodule.
commit 4be9c15c65db4767e482fba0be13f8aab286d5f3
Author: Ivan De Marino <ivan.de.marino@gmail.com>
Date: Thu Jan 5 15:31:13 2012 +0000
First simple REPL implementation.
- Not complete
- Still doesn't handle arrow keys (needed for history)
2012-01-05 19:31:13 +04:00
|
|
|
Q_OBJECT
|
|
|
|
|
|
2011-05-25 21:46:51 +04:00
|
|
|
public:
|
2011-05-29 08:16:18 +04:00
|
|
|
CustomPage(WebPage *parent = 0)
|
2011-05-25 21:46:51 +04:00
|
|
|
: QWebPage(parent)
|
2011-05-29 08:16:18 +04:00
|
|
|
, m_webPage(parent)
|
2011-05-25 21:46:51 +04:00
|
|
|
{
|
|
|
|
|
m_userAgent = QWebPage::userAgentForUrl(QUrl());
|
2011-08-20 12:24:56 +04:00
|
|
|
setForwardUnsupportedContent(true);
|
2011-05-25 21:46:51 +04:00
|
|
|
}
|
|
|
|
|
|
2012-06-11 02:24:45 +04:00
|
|
|
bool extension(Extension extension, const ExtensionOption* option, ExtensionReturn* output) {
|
2012-06-18 06:21:44 +04:00
|
|
|
Q_UNUSED(option);
|
|
|
|
|
|
2012-06-11 02:24:45 +04:00
|
|
|
if (extension == ChooseMultipleFilesExtension) {
|
2012-12-09 14:52:52 +04:00
|
|
|
static_cast<ChooseMultipleFilesExtensionReturn*>(output)->fileNames = m_uploadFiles;
|
2012-06-11 02:24:45 +04:00
|
|
|
return true;
|
|
|
|
|
} else {
|
|
|
|
|
return false;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2013-06-18 23:09:36 +04:00
|
|
|
void setCookieJar(CookieJar *cookieJar) {
|
|
|
|
|
m_cookieJar = cookieJar;
|
|
|
|
|
}
|
|
|
|
|
|
2011-05-25 21:46:51 +04:00
|
|
|
public slots:
|
|
|
|
|
bool shouldInterruptJavaScript() {
|
2013-04-03 22:06:38 +04:00
|
|
|
m_webPage->javascriptInterrupt();
|
|
|
|
|
|
|
|
|
|
if (m_webPage->m_shouldInterruptJs) {
|
|
|
|
|
|
|
|
|
|
// reset our flag
|
|
|
|
|
m_webPage->m_shouldInterruptJs = false;
|
|
|
|
|
return true;
|
|
|
|
|
}
|
2011-05-25 21:46:51 +04:00
|
|
|
return false;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
protected:
|
2012-06-11 02:24:45 +04:00
|
|
|
bool supportsExtension(Extension extension) const {
|
|
|
|
|
return extension == ChooseMultipleFilesExtension;
|
|
|
|
|
}
|
|
|
|
|
|
2011-06-05 11:28:14 +04:00
|
|
|
QString chooseFile(QWebFrame *originatingFrame, const QString &oldFile) {
|
|
|
|
|
Q_UNUSED(originatingFrame);
|
2012-10-29 04:30:23 +04:00
|
|
|
|
2013-01-17 04:45:45 +04:00
|
|
|
// Check if User set a file via File Picker
|
|
|
|
|
QString chosenFile = m_webPage->filePicker(oldFile);
|
|
|
|
|
if (chosenFile == QString::null && m_uploadFiles.count() > 0) {
|
|
|
|
|
// Check if instead User set a file via uploadFile API
|
|
|
|
|
chosenFile = m_uploadFiles.first();
|
|
|
|
|
}
|
2012-10-29 04:30:23 +04:00
|
|
|
|
|
|
|
|
// Return the value coming from the "filePicker" callback, IFF not null.
|
2013-01-17 04:45:45 +04:00
|
|
|
qDebug() << "CustomPage - file chosen for upload:" << chosenFile;
|
|
|
|
|
return chosenFile;
|
2011-06-05 11:28:14 +04:00
|
|
|
}
|
|
|
|
|
|
2011-05-25 21:46:51 +04:00
|
|
|
void javaScriptAlert(QWebFrame *originatingFrame, const QString &msg) {
|
|
|
|
|
Q_UNUSED(originatingFrame);
|
2012-07-05 04:21:15 +04:00
|
|
|
emit m_webPage->javaScriptAlertSent(msg);
|
2011-05-25 21:46:51 +04:00
|
|
|
}
|
|
|
|
|
|
2012-05-12 04:32:16 +04:00
|
|
|
bool javaScriptConfirm(QWebFrame *originatingFrame, const QString &msg) {
|
|
|
|
|
Q_UNUSED(originatingFrame);
|
|
|
|
|
return m_webPage->javaScriptConfirm(msg);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
bool javaScriptPrompt(QWebFrame *originatingFrame, const QString &msg, const QString &defaultValue, QString *result) {
|
|
|
|
|
Q_UNUSED(originatingFrame);
|
|
|
|
|
return m_webPage->javaScriptPrompt(msg, defaultValue, result);
|
|
|
|
|
}
|
|
|
|
|
|
2011-05-25 21:46:51 +04:00
|
|
|
void javaScriptConsoleMessage(const QString &message, int lineNumber, const QString &sourceID) {
|
2012-03-19 02:22:02 +04:00
|
|
|
Q_UNUSED(lineNumber);
|
|
|
|
|
Q_UNUSED(sourceID);
|
2012-07-05 04:21:15 +04:00
|
|
|
emit m_webPage->javaScriptConsoleMessageSent(message);
|
2011-05-25 21:46:51 +04:00
|
|
|
}
|
|
|
|
|
|
2012-06-16 22:44:43 +04:00
|
|
|
void javaScriptError(const QString &message, int lineNumber, const QString &sourceID, const QString &stack) {
|
2013-11-24 03:42:39 +04:00
|
|
|
emit m_webPage->javaScriptErrorSent(message, lineNumber, sourceID, stack);
|
2012-03-17 21:27:13 +04:00
|
|
|
}
|
|
|
|
|
|
2011-05-25 21:46:51 +04:00
|
|
|
QString userAgentForUrl(const QUrl &url) const {
|
|
|
|
|
Q_UNUSED(url);
|
|
|
|
|
return m_userAgent;
|
|
|
|
|
}
|
|
|
|
|
|
2012-06-15 10:51:42 +04:00
|
|
|
bool acceptNavigationRequest(QWebFrame *frame, const QNetworkRequest &request, QWebPage::NavigationType type) {
|
|
|
|
|
bool isMainFrame = (frame == m_webPage->m_mainFrame);
|
|
|
|
|
|
2012-07-05 04:21:15 +04:00
|
|
|
QString navigationType = "Undefined";
|
|
|
|
|
switch (type) {
|
|
|
|
|
case NavigationTypeLinkClicked:
|
|
|
|
|
navigationType = "LinkClicked";
|
|
|
|
|
break;
|
|
|
|
|
case NavigationTypeFormSubmitted:
|
|
|
|
|
navigationType = "FormSubmitted";
|
|
|
|
|
break;
|
|
|
|
|
case NavigationTypeBackOrForward:
|
|
|
|
|
navigationType = "BackOrForward";
|
|
|
|
|
break;
|
|
|
|
|
case NavigationTypeReload:
|
|
|
|
|
navigationType = "Reload";
|
|
|
|
|
break;
|
|
|
|
|
case NavigationTypeFormResubmitted:
|
|
|
|
|
navigationType = "FormResubmitted";
|
|
|
|
|
break;
|
|
|
|
|
case NavigationTypeOther:
|
|
|
|
|
navigationType = "Other";
|
|
|
|
|
break;
|
|
|
|
|
}
|
2012-12-12 17:00:26 +04:00
|
|
|
bool isNavigationLocked = m_webPage->navigationLocked();
|
2013-12-03 08:08:47 +04:00
|
|
|
|
2012-07-05 04:21:15 +04:00
|
|
|
emit m_webPage->navigationRequested(
|
|
|
|
|
request.url(), //< Requested URL
|
|
|
|
|
navigationType, //< Navigation Type
|
2013-01-10 08:26:55 +04:00
|
|
|
!isNavigationLocked, //< Will navigate (not locked)?
|
2012-07-05 04:21:15 +04:00
|
|
|
isMainFrame); //< Is main frame?
|
2012-06-15 10:51:42 +04:00
|
|
|
|
2012-12-12 17:00:26 +04:00
|
|
|
return !isNavigationLocked;
|
2012-06-15 10:51:42 +04:00
|
|
|
}
|
|
|
|
|
|
2012-07-05 04:21:15 +04:00
|
|
|
QWebPage *createWindow (WebWindowType type) {
|
|
|
|
|
Q_UNUSED(type);
|
2012-07-27 20:13:43 +04:00
|
|
|
WebPage *newPage;
|
2012-07-05 04:21:15 +04:00
|
|
|
|
|
|
|
|
// Create a new "raw" WebPage object
|
2012-07-27 20:13:43 +04:00
|
|
|
if (m_webPage->ownsPages()) {
|
|
|
|
|
newPage = new WebPage(m_webPage);
|
|
|
|
|
} else {
|
|
|
|
|
newPage = new WebPage(Phantom::instance());
|
2012-09-24 18:18:52 +04:00
|
|
|
Phantom::instance()->m_pages.append(newPage);
|
2012-07-27 20:13:43 +04:00
|
|
|
}
|
2013-06-18 23:09:36 +04:00
|
|
|
newPage->setCookieJar(m_cookieJar);
|
2012-07-27 20:13:43 +04:00
|
|
|
|
2012-07-05 04:21:15 +04:00
|
|
|
// Apply default settings
|
|
|
|
|
newPage->applySettings(Phantom::instance()->defaultPageSettings());
|
|
|
|
|
|
|
|
|
|
// Signal JS shim to catch, decorate and store this new child page
|
|
|
|
|
emit m_webPage->rawPageCreated(newPage);
|
|
|
|
|
|
|
|
|
|
// Return the new QWebPage to the QWebKit backend
|
|
|
|
|
return newPage->m_customWebPage;
|
|
|
|
|
}
|
2012-06-15 10:51:42 +04:00
|
|
|
|
2011-05-25 21:46:51 +04:00
|
|
|
private:
|
2011-05-29 08:16:18 +04:00
|
|
|
WebPage *m_webPage;
|
2011-05-25 21:46:51 +04:00
|
|
|
QString m_userAgent;
|
2012-12-09 14:52:52 +04:00
|
|
|
QStringList m_uploadFiles;
|
2011-05-25 21:46:51 +04:00
|
|
|
friend class WebPage;
|
2013-06-18 23:09:36 +04:00
|
|
|
CookieJar *m_cookieJar;
|
2011-05-25 21:46:51 +04:00
|
|
|
};
|
2011-04-08 17:30:50 +04:00
|
|
|
|
A REPL for PhantomJS
This covers [Issue 252](http://code.google.com/p/phantomjs/issues/detail?id=252)
The commit is composed of 12 squashed commits:
commit efdc6ba4f143c30a690fd97d92d80fa412e79999
Author: Ivan De Marino <ivan.de.marino@gmail.com>
Date: Mon Feb 27 00:19:36 2012 +0000
Pretty-pringing and Completion Caching done!
* This completes pretty-printing for the result of evaluated
* expressions in the REPL.
* Also, now we cache the "possible completions", to speed things up
* a bit (nothing fancy though).
* Minor tweaks to the internal doc and the way we "mock"
* pretty-printing for QObjects/REPLCompletanle
* All tests passing :)
commit 1f9ef690e112a535b431fca409b77bb9c09d1c70
Author: Ivan De Marino <ivan.de.marino@gmail.com>
Date: Sun Feb 26 22:35:00 2012 +0000
Moving most of REPL shim JavaScritp code in a separate file. Way
easier to work on.
commit 02d460a16fee14e7096ae7d899c03902c5b8a9c6
Author: Ivan De Marino <ivan.de.marino@gmail.com>
Date: Sat Feb 25 20:25:18 2012 +0000
Initialisation of the Completions is now done in a pure virtual.
This means that every REPLCompletable object will ACTUALLY register
completion strings, ONLY if we are running a REPL
and that object is ACTUALLY created.
Otherwise, why bother?
Adding completions for all exposed REPLCompletable objects
Also, fixed an issue with _getCompletions()
commit 412c3778fb04aa1c7379f8e760afce702b0428dd
Author: Ivan De Marino <ivan.de.marino@gmail.com>
Date: Tue Feb 21 00:49:17 2012 +0000
Few more tweaks to the REPL:
- Now 'phantom' is the first QObject with proper completion
- No repetition in QObject completions
- LVAL of any user expression is now correctly prettified and
printed
Major things left to do:
- Cache completions (using QCache?)
- Add completions for the other QObject
- When the LVAL of a user expression is a QObject, print what's
expected, not the QObject "real" structure
commit 46f04713c8165d898055e15478bb31403f8c93f1
Author: Ivan De Marino <ivan.de.marino@gmail.com>
Date: Tue Feb 7 10:13:23 2012 -0800
Pretty-print expressions result
Still not done though: there are issues with the NON-Native JS
objects.
commit 98b2fe67651dc750b62c6fa9cf1d80317fd9ae06
Author: Ivan De Marino <ivan.de.marino@gmail.com>
Date: Fri Feb 3 00:22:52 2012 -0800
Introducing REPLCompletable.
This class should be inherited by any JavaScript-exposed QObject, to
ensure correct Auto-Completion.
Correct auto-completion for QObjects.
- Now even QObjects can correctly provide auto-completion, and avoid
showing "not for users" methods
- The strings used for the auto-completion are stored in a single
Index: minimum memory footprint
- Still, there is optimization that should be done (when "searching"
for the right completion by prefix)
- Completion for the objects not set up yet, but now it's just a
trivial sequence of "addCompletion('bla')" in their constructors
commit 9bd48618154b1530a37b41f4060440184e23253d
Author: Ivan De Marino <ivan.de.marino@gmail.com>
Date: Thu Feb 2 00:20:25 2012 -0800
Changing the way we import Linenoise.
Will just import a specific commit, and update manually when needed.
commit cfc9bae9fbdab13b01019b34b7cbd565e3153780
Author: Ivan De Marino <ivan.de.marino@gmail.com>
Date: Sun Jan 29 23:22:26 2012 -0800
Made the REPL into a Singleton. With Auto-completion!.
Reasons:
1) Needed a pointer to function (i.e. a static method) to be used
with Linenoise to provide auto-completions
2) It makes more sense, as it's not like we are going to have 2 REPL
running at the same time, are we?
There are problems to address:
- the enumeration in JS seems to return only the native interface of
our objects
- the function completions contain argument types of those functions
- "private" methods are exposed
commit c78bd32e17f8e0e4cc4a0066858de8cc81d33b97
Author: Ivan De Marino <ivan.de.marino@gmail.com>
Date: Sun Jan 29 22:10:20 2012 -0800
Migrating from the original, now [unmantained
Linenoise](https://github.com/antirez/linenoise) to the fairly active
[tadmarshall fork](https://github.com/tadmarshall/linenoise).
Also now the project is imported as a Git Submodule.
Having migrated to the latest Linenoise (see prev. commit), now this
_SHOULD_ work on Windows too.
But, of course, this needs testing. :)
commit 43713c5723d7c5ed446ba41ae8d6f8c9feba7f9b
Author: Ivan De Marino <ivan.de.marino@gmail.com>
Date: Tue Jan 24 23:17:06 2012 -0800
Now that the basics work, I'm adding support for REPL history.
This is something almost everyone today is accustomed to.
Also, now REPL history works!
And I found some useful resources to solve pending TODOs.
commit 31e5f88b044a5b4a823c67527ef8c245d2ac7863
Author: Ivan De Marino <ivan.de.marino@gmail.com>
Date: Sun Jan 22 20:56:36 2012 -0800
Adding Linenoise Project (https://github.com/antirez/linenoise).
For now is included as a drop-in set of files.
Later on, if the Linenoise project has frequent
updates, we might prefer to do it as a
git-submodule.
commit 4be9c15c65db4767e482fba0be13f8aab286d5f3
Author: Ivan De Marino <ivan.de.marino@gmail.com>
Date: Thu Jan 5 15:31:13 2012 +0000
First simple REPL implementation.
- Not complete
- Still doesn't handle arrow keys (needed for history)
2012-01-05 19:31:13 +04:00
|
|
|
|
2012-05-12 04:32:16 +04:00
|
|
|
/**
|
|
|
|
|
* Contains the Callback Objects used to regulate callback-traffic from the webpage internal context.
|
|
|
|
|
* It's directly exposed within the webpage JS context,
|
|
|
|
|
* and indirectly in the phantom JS context.
|
|
|
|
|
*
|
|
|
|
|
* @class WebPageCallbacks
|
|
|
|
|
*/
|
|
|
|
|
class WebpageCallbacks : public QObject
|
|
|
|
|
{
|
|
|
|
|
Q_OBJECT
|
|
|
|
|
|
|
|
|
|
public:
|
|
|
|
|
WebpageCallbacks(QObject *parent = 0)
|
|
|
|
|
: QObject(parent)
|
|
|
|
|
, m_genericCallback(NULL)
|
2012-10-29 04:30:23 +04:00
|
|
|
, m_filePickerCallback(NULL)
|
2012-05-12 04:32:16 +04:00
|
|
|
, m_jsConfirmCallback(NULL)
|
|
|
|
|
, m_jsPromptCallback(NULL)
|
2013-04-03 22:06:38 +04:00
|
|
|
, m_jsInterruptCallback(NULL)
|
2012-05-12 04:32:16 +04:00
|
|
|
{
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
QObject *getGenericCallback() {
|
2012-10-29 04:30:23 +04:00
|
|
|
qDebug() << "WebpageCallbacks - getGenericCallback";
|
|
|
|
|
|
2012-05-12 04:32:16 +04:00
|
|
|
if (!m_genericCallback) {
|
|
|
|
|
m_genericCallback = new Callback(this);
|
|
|
|
|
}
|
|
|
|
|
return m_genericCallback;
|
|
|
|
|
}
|
|
|
|
|
|
2012-10-29 04:30:23 +04:00
|
|
|
QObject *getFilePickerCallback() {
|
|
|
|
|
qDebug() << "WebpageCallbacks - getFilePickerCallback";
|
|
|
|
|
|
|
|
|
|
if (!m_filePickerCallback) {
|
|
|
|
|
m_filePickerCallback = new Callback(this);
|
|
|
|
|
}
|
|
|
|
|
return m_filePickerCallback;
|
|
|
|
|
}
|
|
|
|
|
|
2012-05-12 04:32:16 +04:00
|
|
|
QObject *getJsConfirmCallback() {
|
2012-10-29 04:30:23 +04:00
|
|
|
qDebug() << "WebpageCallbacks - getJsConfirmCallback";
|
|
|
|
|
|
2012-05-12 04:32:16 +04:00
|
|
|
if (!m_jsConfirmCallback) {
|
|
|
|
|
m_jsConfirmCallback = new Callback(this);
|
|
|
|
|
}
|
|
|
|
|
return m_jsConfirmCallback;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
QObject *getJsPromptCallback() {
|
2012-10-29 04:30:23 +04:00
|
|
|
qDebug() << "WebpageCallbacks - getJsConfirmCallback";
|
|
|
|
|
|
2012-05-12 04:32:16 +04:00
|
|
|
if (!m_jsPromptCallback) {
|
|
|
|
|
m_jsPromptCallback = new Callback(this);
|
|
|
|
|
}
|
|
|
|
|
return m_jsPromptCallback;
|
|
|
|
|
}
|
2013-12-03 08:08:47 +04:00
|
|
|
|
2013-04-03 22:06:38 +04:00
|
|
|
QObject *getJsInterruptCallback() {
|
|
|
|
|
qDebug() << "WebpageCallbacks - getJsInterruptCallback";
|
|
|
|
|
|
|
|
|
|
if (!m_jsInterruptCallback) {
|
|
|
|
|
m_jsInterruptCallback = new Callback(this);
|
|
|
|
|
}
|
|
|
|
|
return m_jsInterruptCallback;
|
|
|
|
|
}
|
2012-05-12 04:32:16 +04:00
|
|
|
|
|
|
|
|
public slots:
|
|
|
|
|
QVariant call(const QVariantList &arguments) {
|
|
|
|
|
if (m_genericCallback) {
|
|
|
|
|
return m_genericCallback->call(arguments);
|
|
|
|
|
}
|
2012-05-21 14:10:48 +04:00
|
|
|
return QVariant();
|
2012-05-12 04:32:16 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
private:
|
|
|
|
|
Callback *m_genericCallback;
|
2012-10-29 04:30:23 +04:00
|
|
|
Callback *m_filePickerCallback;
|
2012-05-12 04:32:16 +04:00
|
|
|
Callback *m_jsConfirmCallback;
|
|
|
|
|
Callback *m_jsPromptCallback;
|
2013-04-03 22:06:38 +04:00
|
|
|
Callback *m_jsInterruptCallback;
|
2012-05-12 04:32:16 +04:00
|
|
|
|
|
|
|
|
friend class WebPage;
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
2012-07-05 04:21:15 +04:00
|
|
|
WebPage::WebPage(QObject *parent, const QUrl &baseUrl)
|
2012-12-29 20:23:10 +04:00
|
|
|
: QObject(parent)
|
2012-06-15 10:51:42 +04:00
|
|
|
, m_navigationLocked(false)
|
2012-08-13 22:51:40 +04:00
|
|
|
, m_mousePos(QPoint(0, 0))
|
2012-07-27 20:13:43 +04:00
|
|
|
, m_ownsPages(true)
|
2013-02-23 02:41:01 +04:00
|
|
|
, m_loadingProgress(0)
|
2013-04-03 22:06:38 +04:00
|
|
|
, m_shouldInterruptJs(false)
|
2011-05-25 21:46:51 +04:00
|
|
|
{
|
|
|
|
|
setObjectName("WebPage");
|
2012-09-26 12:56:27 +04:00
|
|
|
m_callbacks = new WebpageCallbacks(this);
|
2012-07-05 04:21:15 +04:00
|
|
|
m_customWebPage = new CustomPage(this);
|
|
|
|
|
m_mainFrame = m_customWebPage->mainFrame();
|
2012-09-26 12:56:27 +04:00
|
|
|
m_currentFrame = m_mainFrame;
|
2012-02-13 21:47:09 +04:00
|
|
|
m_mainFrame->setHtml(BLANK_HTML, baseUrl);
|
2011-05-25 21:46:51 +04:00
|
|
|
|
2012-07-05 04:21:15 +04:00
|
|
|
Config *phantomCfg = Phantom::instance()->config();
|
|
|
|
|
|
2012-09-26 12:56:27 +04:00
|
|
|
// NOTE: below you can see that between all the event handlers
|
|
|
|
|
// we listen for, "SLOT(setupFrame())" is connected to 2 signals:
|
|
|
|
|
// 1. page.loadFinished
|
|
|
|
|
// 2. mainFrame.javaScriptWindowObjectCleared
|
|
|
|
|
// We have found out that, despite our understanding, the event #1 above
|
|
|
|
|
// fires BEFORE the event #2 when loading a url.
|
|
|
|
|
// But, if no page load is requested, #2 is the only one to fire.
|
|
|
|
|
//
|
|
|
|
|
// So, we call the slot twice to setup the main frame
|
|
|
|
|
// (no parameter == main frame) but we make sure to do the setup only once.
|
|
|
|
|
//
|
|
|
|
|
// @see WebPage::setupFrame(QWebFrame *) for details.
|
2012-09-27 04:42:11 +04:00
|
|
|
connect(m_mainFrame, SIGNAL(loadStarted()), this, SLOT(switchToMainFrame()), Qt::QueuedConnection);
|
|
|
|
|
connect(m_mainFrame, SIGNAL(loadFinished(bool)), this, SLOT(setupFrame()), Qt::QueuedConnection);
|
2013-01-29 09:13:47 +04:00
|
|
|
connect(m_customWebPage, SIGNAL(frameCreated(QWebFrame*)), this, SLOT(setupFrame(QWebFrame*)), Qt::DirectConnection);
|
2012-09-26 12:56:27 +04:00
|
|
|
connect(m_mainFrame, SIGNAL(javaScriptWindowObjectCleared()), this, SLOT(setupFrame()));
|
2011-10-25 18:48:27 +04:00
|
|
|
connect(m_mainFrame, SIGNAL(javaScriptWindowObjectCleared()), SIGNAL(initialized()));
|
2012-06-15 10:51:42 +04:00
|
|
|
connect(m_mainFrame, SIGNAL(urlChanged(QUrl)), SIGNAL(urlChanged(QUrl)));
|
2012-07-05 04:21:15 +04:00
|
|
|
connect(m_customWebPage, SIGNAL(loadStarted()), SIGNAL(loadStarted()), Qt::QueuedConnection);
|
|
|
|
|
connect(m_customWebPage, SIGNAL(loadFinished(bool)), SLOT(finish(bool)), Qt::QueuedConnection);
|
2012-09-26 12:56:27 +04:00
|
|
|
connect(m_customWebPage, SIGNAL(windowCloseRequested()), this, SLOT(close()), Qt::QueuedConnection);
|
2013-02-23 02:41:01 +04:00
|
|
|
connect(m_customWebPage, SIGNAL(loadProgress(int)), this, SLOT(updateLoadingProgress(int)));
|
2013-12-03 08:08:47 +04:00
|
|
|
connect(m_customWebPage, SIGNAL(repaintRequested(QRect)), this, SLOT(handleRepaintRequested(QRect)), Qt::QueuedConnection);
|
|
|
|
|
|
2011-05-25 21:46:51 +04:00
|
|
|
|
|
|
|
|
// Start with transparent background.
|
2012-07-05 04:21:15 +04:00
|
|
|
QPalette palette = m_customWebPage->palette();
|
2011-05-25 21:46:51 +04:00
|
|
|
palette.setBrush(QPalette::Base, Qt::transparent);
|
2012-07-05 04:21:15 +04:00
|
|
|
m_customWebPage->setPalette(palette);
|
|
|
|
|
|
|
|
|
|
// Set the page Library path
|
|
|
|
|
setLibraryPath(QFileInfo(phantomCfg->scriptFile()).dir().absolutePath());
|
2011-05-25 21:46:51 +04:00
|
|
|
|
|
|
|
|
// Page size does not need to take scrollbars into account.
|
|
|
|
|
m_mainFrame->setScrollBarPolicy(Qt::Horizontal, Qt::ScrollBarAlwaysOff);
|
|
|
|
|
m_mainFrame->setScrollBarPolicy(Qt::Vertical, Qt::ScrollBarAlwaysOff);
|
|
|
|
|
|
2012-07-05 04:21:15 +04:00
|
|
|
m_customWebPage->settings()->setAttribute(QWebSettings::OfflineStorageDatabaseEnabled, true);
|
|
|
|
|
m_customWebPage->settings()->setAttribute(QWebSettings::OfflineWebApplicationCacheEnabled, true);
|
|
|
|
|
m_customWebPage->settings()->setAttribute(QWebSettings::FrameFlatteningEnabled, true);
|
2011-05-26 11:27:55 +04:00
|
|
|
|
2012-07-05 04:21:15 +04:00
|
|
|
m_customWebPage->settings()->setAttribute(QWebSettings::LocalStorageEnabled, true);
|
2014-07-24 21:25:46 +04:00
|
|
|
m_customWebPage->settings()->setLocalStoragePath(QStandardPaths::writableLocation(QStandardPaths::DataLocation));
|
2011-05-26 11:27:55 +04:00
|
|
|
|
2011-09-15 10:46:01 +04:00
|
|
|
// Custom network access manager to allow traffic monitoring.
|
2012-07-05 04:21:15 +04:00
|
|
|
m_networkAccessManager = new NetworkAccessManager(this, phantomCfg);
|
|
|
|
|
m_customWebPage->setNetworkAccessManager(m_networkAccessManager);
|
2013-01-02 15:41:56 +04:00
|
|
|
connect(m_networkAccessManager, SIGNAL(resourceRequested(QVariant, QObject *)),
|
|
|
|
|
SIGNAL(resourceRequested(QVariant, QObject *)));
|
2011-09-17 04:34:02 +04:00
|
|
|
connect(m_networkAccessManager, SIGNAL(resourceReceived(QVariant)),
|
2011-09-15 10:46:01 +04:00
|
|
|
SIGNAL(resourceReceived(QVariant)));
|
2013-01-18 12:37:22 +04:00
|
|
|
connect(m_networkAccessManager, SIGNAL(resourceError(QVariant)),
|
|
|
|
|
SIGNAL(resourceError(QVariant)));
|
2013-03-12 20:38:37 +04:00
|
|
|
connect(m_networkAccessManager, SIGNAL(resourceTimeout(QVariant)),
|
|
|
|
|
SIGNAL(resourceTimeout(QVariant)));
|
2011-09-15 10:46:01 +04:00
|
|
|
|
2012-07-05 04:21:15 +04:00
|
|
|
m_customWebPage->setViewportSize(QSize(400, 300));
|
2011-05-25 21:46:51 +04:00
|
|
|
}
|
|
|
|
|
|
2012-07-25 03:10:23 +04:00
|
|
|
WebPage::~WebPage()
|
|
|
|
|
{
|
|
|
|
|
emit closing(this);
|
|
|
|
|
}
|
|
|
|
|
|
2011-05-26 01:00:20 +04:00
|
|
|
QWebFrame *WebPage::mainFrame()
|
|
|
|
|
{
|
|
|
|
|
return m_mainFrame;
|
|
|
|
|
}
|
|
|
|
|
|
2011-05-25 21:46:51 +04:00
|
|
|
QString WebPage::content() const
|
|
|
|
|
{
|
|
|
|
|
return m_mainFrame->toHtml();
|
|
|
|
|
}
|
|
|
|
|
|
2012-09-06 08:14:59 +04:00
|
|
|
QString WebPage::frameContent() const
|
|
|
|
|
{
|
2012-09-16 20:57:56 +04:00
|
|
|
return m_currentFrame->toHtml();
|
2012-09-06 08:14:59 +04:00
|
|
|
}
|
|
|
|
|
|
2011-05-25 21:46:51 +04:00
|
|
|
void WebPage::setContent(const QString &content)
|
|
|
|
|
{
|
|
|
|
|
m_mainFrame->setHtml(content);
|
|
|
|
|
}
|
|
|
|
|
|
2012-12-07 21:54:55 +04:00
|
|
|
void WebPage::setContent(const QString &content, const QString &baseUrl)
|
|
|
|
|
{
|
|
|
|
|
if (baseUrl == "about:blank") {
|
|
|
|
|
m_mainFrame->setHtml(BLANK_HTML);
|
|
|
|
|
} else {
|
|
|
|
|
m_mainFrame->setHtml(content, QUrl(baseUrl));
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2012-09-06 08:14:59 +04:00
|
|
|
void WebPage::setFrameContent(const QString &content)
|
|
|
|
|
{
|
2012-09-16 20:57:56 +04:00
|
|
|
m_currentFrame->setHtml(content);
|
2012-09-06 08:14:59 +04:00
|
|
|
}
|
|
|
|
|
|
2012-09-26 04:09:32 +04:00
|
|
|
QString WebPage::title() const
|
|
|
|
|
{
|
|
|
|
|
return m_mainFrame->title();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
QString WebPage::frameTitle() const
|
|
|
|
|
{
|
|
|
|
|
return m_currentFrame->title();
|
|
|
|
|
}
|
|
|
|
|
|
2012-09-06 08:14:59 +04:00
|
|
|
QString WebPage::url() const
|
|
|
|
|
{
|
|
|
|
|
return m_mainFrame->url().toString();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
QString WebPage::frameUrl() const
|
|
|
|
|
{
|
2012-09-16 20:57:56 +04:00
|
|
|
return m_currentFrame->url().toString();
|
2012-09-06 08:14:59 +04:00
|
|
|
}
|
|
|
|
|
|
2013-02-23 02:41:01 +04:00
|
|
|
bool WebPage::loading() const
|
|
|
|
|
{
|
|
|
|
|
// Return "true" if Load Progress is "]0, 100["
|
|
|
|
|
return (0 < m_loadingProgress && m_loadingProgress < 100);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int WebPage::loadingProgress() const
|
|
|
|
|
{
|
|
|
|
|
return m_loadingProgress;
|
|
|
|
|
}
|
|
|
|
|
|
2012-09-27 02:08:55 +04:00
|
|
|
bool WebPage::canGoBack()
|
|
|
|
|
{
|
|
|
|
|
return m_customWebPage->history()->canGoBack();
|
|
|
|
|
}
|
|
|
|
|
|
2012-11-18 04:08:54 +04:00
|
|
|
bool WebPage::goBack()
|
2012-09-27 02:08:55 +04:00
|
|
|
{
|
|
|
|
|
if (canGoBack()) {
|
2012-11-18 04:08:54 +04:00
|
|
|
m_customWebPage->history()->back();
|
2012-09-27 02:08:55 +04:00
|
|
|
return true;
|
|
|
|
|
}
|
|
|
|
|
return false;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
bool WebPage::canGoForward()
|
|
|
|
|
{
|
|
|
|
|
return m_customWebPage->history()->canGoForward();
|
|
|
|
|
}
|
|
|
|
|
|
2012-11-18 04:08:54 +04:00
|
|
|
bool WebPage::goForward()
|
2012-09-27 02:08:55 +04:00
|
|
|
{
|
|
|
|
|
if (canGoForward()) {
|
2012-11-18 04:08:54 +04:00
|
|
|
m_customWebPage->history()->forward();
|
2012-09-27 02:08:55 +04:00
|
|
|
return true;
|
|
|
|
|
}
|
|
|
|
|
return false;
|
|
|
|
|
}
|
|
|
|
|
|
2012-11-18 04:08:54 +04:00
|
|
|
bool WebPage::go(int historyItemRelativeIndex)
|
|
|
|
|
{
|
|
|
|
|
// Convert the relative index to absolute
|
|
|
|
|
int historyItemIndex = m_customWebPage->history()->currentItemIndex() + historyItemRelativeIndex;
|
|
|
|
|
|
|
|
|
|
// Fetch the right item from the history
|
|
|
|
|
QWebHistoryItem historyItem = m_customWebPage->history()->itemAt(historyItemIndex);
|
|
|
|
|
|
|
|
|
|
// Go to the history item, if it's valid
|
|
|
|
|
if (historyItem.isValid()) {
|
|
|
|
|
m_customWebPage->history()->goToItem(historyItem);
|
|
|
|
|
return true;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return false;
|
|
|
|
|
}
|
|
|
|
|
|
2012-09-27 02:08:55 +04:00
|
|
|
void WebPage::reload()
|
|
|
|
|
{
|
|
|
|
|
m_customWebPage->triggerAction(QWebPage::Reload);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void WebPage::stop()
|
|
|
|
|
{
|
|
|
|
|
m_customWebPage->triggerAction(QWebPage::Stop);
|
|
|
|
|
}
|
|
|
|
|
|
2012-12-07 21:54:55 +04:00
|
|
|
|
2012-02-15 16:52:57 +04:00
|
|
|
QString WebPage::plainText() const
|
|
|
|
|
{
|
|
|
|
|
return m_mainFrame->toPlainText();
|
|
|
|
|
}
|
2011-06-08 02:22:41 +04:00
|
|
|
|
2012-09-06 08:14:59 +04:00
|
|
|
QString WebPage::framePlainText() const
|
|
|
|
|
{
|
2012-09-16 20:57:56 +04:00
|
|
|
return m_currentFrame->toPlainText();
|
2012-09-06 08:14:59 +04:00
|
|
|
}
|
|
|
|
|
|
2011-06-18 07:17:58 +04:00
|
|
|
QString WebPage::libraryPath() const
|
2011-06-08 02:22:41 +04:00
|
|
|
{
|
2011-06-18 07:17:58 +04:00
|
|
|
return m_libraryPath;
|
2011-06-08 02:22:41 +04:00
|
|
|
}
|
|
|
|
|
|
2011-06-18 07:17:58 +04:00
|
|
|
void WebPage::setLibraryPath(const QString &libraryPath)
|
2011-06-08 02:22:41 +04:00
|
|
|
{
|
2011-06-18 07:17:58 +04:00
|
|
|
m_libraryPath = libraryPath;
|
2012-06-02 17:42:14 +04:00
|
|
|
}
|
2012-05-19 17:04:01 +04:00
|
|
|
|
|
|
|
|
QString WebPage::offlineStoragePath() const
|
|
|
|
|
{
|
2012-07-05 04:21:15 +04:00
|
|
|
return m_customWebPage->settings()->offlineStoragePath();
|
2012-05-19 17:04:01 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int WebPage::offlineStorageQuota() const
|
|
|
|
|
{
|
2012-07-05 04:21:15 +04:00
|
|
|
return m_customWebPage->settings()->offlineStorageDefaultQuota();
|
2011-06-08 02:22:41 +04:00
|
|
|
}
|
|
|
|
|
|
2012-05-12 04:32:16 +04:00
|
|
|
void WebPage::showInspector(const int port)
|
2011-10-25 23:16:25 +04:00
|
|
|
{
|
2012-07-05 04:21:15 +04:00
|
|
|
m_customWebPage->settings()->setAttribute(QWebSettings::DeveloperExtrasEnabled, true);
|
2011-10-25 23:16:25 +04:00
|
|
|
m_inspector = new QWebInspector;
|
2012-07-05 04:21:15 +04:00
|
|
|
m_inspector->setPage(m_customWebPage);
|
2011-10-25 23:16:25 +04:00
|
|
|
|
2012-07-05 04:21:15 +04:00
|
|
|
if (port == -1) {
|
2011-10-25 23:16:25 +04:00
|
|
|
m_inspector->setVisible(true);
|
2012-07-05 04:21:15 +04:00
|
|
|
} else {
|
|
|
|
|
m_customWebPage->setProperty("_q_webInspectorServerPort", port);
|
2011-10-25 23:16:25 +04:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2011-05-28 09:36:34 +04:00
|
|
|
void WebPage::applySettings(const QVariantMap &def)
|
2011-05-28 07:37:36 +04:00
|
|
|
{
|
2012-07-05 04:21:15 +04:00
|
|
|
QWebSettings *opt = m_customWebPage->settings();
|
2011-05-28 07:37:36 +04:00
|
|
|
|
2011-06-24 18:57:55 +04:00
|
|
|
opt->setAttribute(QWebSettings::AutoLoadImages, def[PAGE_SETTINGS_LOAD_IMAGES].toBool());
|
2011-08-20 02:47:34 +04:00
|
|
|
opt->setAttribute(QWebSettings::JavascriptEnabled, def[PAGE_SETTINGS_JS_ENABLED].toBool());
|
|
|
|
|
opt->setAttribute(QWebSettings::XSSAuditingEnabled, def[PAGE_SETTINGS_XSS_AUDITING].toBool());
|
2011-06-24 18:57:55 +04:00
|
|
|
opt->setAttribute(QWebSettings::LocalContentCanAccessRemoteUrls, def[PAGE_SETTINGS_LOCAL_ACCESS_REMOTE].toBool());
|
2012-07-05 04:21:15 +04:00
|
|
|
opt->setAttribute(QWebSettings::JavascriptCanOpenWindows, def[PAGE_SETTINGS_JS_CAN_OPEN_WINDOWS].toBool());
|
|
|
|
|
opt->setAttribute(QWebSettings::JavascriptCanCloseWindows, def[PAGE_SETTINGS_JS_CAN_CLOSE_WINDOWS].toBool());
|
2011-05-28 07:37:36 +04:00
|
|
|
|
2011-06-24 18:57:55 +04:00
|
|
|
if (def.contains(PAGE_SETTINGS_USER_AGENT))
|
2012-07-05 04:21:15 +04:00
|
|
|
m_customWebPage->m_userAgent = def[PAGE_SETTINGS_USER_AGENT].toString();
|
2011-09-17 04:34:02 +04:00
|
|
|
|
|
|
|
|
if (def.contains(PAGE_SETTINGS_USERNAME))
|
|
|
|
|
m_networkAccessManager->setUserName(def[PAGE_SETTINGS_USERNAME].toString());
|
|
|
|
|
|
|
|
|
|
if (def.contains(PAGE_SETTINGS_PASSWORD))
|
2011-09-17 04:36:27 +04:00
|
|
|
m_networkAccessManager->setPassword(def[PAGE_SETTINGS_PASSWORD].toString());
|
2012-10-17 05:20:21 +04:00
|
|
|
|
|
|
|
|
if (def.contains(PAGE_SETTINGS_MAX_AUTH_ATTEMPTS))
|
|
|
|
|
m_networkAccessManager->setMaxAuthAttempts(def[PAGE_SETTINGS_MAX_AUTH_ATTEMPTS].toInt());
|
2013-03-12 20:38:37 +04:00
|
|
|
|
|
|
|
|
if (def.contains(PAGE_SETTINGS_RESOURCE_TIMEOUT))
|
|
|
|
|
m_networkAccessManager->setResourceTimeout(def[PAGE_SETTINGS_RESOURCE_TIMEOUT].toInt());
|
|
|
|
|
|
2011-05-25 21:46:51 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
QString WebPage::userAgent() const
|
2011-04-08 17:30:50 +04:00
|
|
|
{
|
2012-07-05 04:21:15 +04:00
|
|
|
return m_customWebPage->m_userAgent;
|
2011-04-08 17:30:50 +04:00
|
|
|
}
|
|
|
|
|
|
2012-06-15 10:51:42 +04:00
|
|
|
void WebPage::setNavigationLocked(bool lock)
|
|
|
|
|
{
|
2012-12-12 17:00:26 +04:00
|
|
|
m_navigationLocked = lock;
|
2012-06-15 10:51:42 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
bool WebPage::navigationLocked()
|
|
|
|
|
{
|
|
|
|
|
return m_navigationLocked;
|
|
|
|
|
}
|
|
|
|
|
|
2011-05-25 21:46:51 +04:00
|
|
|
void WebPage::setViewportSize(const QVariantMap &size)
|
2011-04-08 17:30:50 +04:00
|
|
|
{
|
2011-05-25 21:46:51 +04:00
|
|
|
int w = size.value("width").toInt();
|
|
|
|
|
int h = size.value("height").toInt();
|
|
|
|
|
if (w > 0 && h > 0)
|
2012-07-05 04:21:15 +04:00
|
|
|
m_customWebPage->setViewportSize(QSize(w, h));
|
2011-04-08 17:30:50 +04:00
|
|
|
}
|
|
|
|
|
|
2011-05-25 21:46:51 +04:00
|
|
|
QVariantMap WebPage::viewportSize() const
|
|
|
|
|
{
|
|
|
|
|
QVariantMap result;
|
2012-07-05 04:21:15 +04:00
|
|
|
QSize size = m_customWebPage->viewportSize();
|
2011-05-25 21:46:51 +04:00
|
|
|
result["width"] = size.width();
|
|
|
|
|
result["height"] = size.height();
|
|
|
|
|
return result;
|
2011-04-08 17:30:50 +04:00
|
|
|
}
|
|
|
|
|
|
2011-05-25 21:46:51 +04:00
|
|
|
void WebPage::setClipRect(const QVariantMap &size)
|
|
|
|
|
{
|
|
|
|
|
int w = size.value("width").toInt();
|
|
|
|
|
int h = size.value("height").toInt();
|
|
|
|
|
int top = size.value("top").toInt();
|
|
|
|
|
int left = size.value("left").toInt();
|
|
|
|
|
|
|
|
|
|
if (w >= 0 && h >= 0)
|
|
|
|
|
m_clipRect = QRect(left, top, w, h);
|
2011-04-08 17:30:50 +04:00
|
|
|
}
|
|
|
|
|
|
2011-05-25 21:46:51 +04:00
|
|
|
QVariantMap WebPage::clipRect() const
|
2011-04-08 17:30:50 +04:00
|
|
|
{
|
2011-05-25 21:46:51 +04:00
|
|
|
QVariantMap result;
|
|
|
|
|
result["width"] = m_clipRect.width();
|
|
|
|
|
result["height"] = m_clipRect.height();
|
|
|
|
|
result["top"] = m_clipRect.top();
|
|
|
|
|
result["left"] = m_clipRect.left();
|
|
|
|
|
return result;
|
2011-04-08 17:30:50 +04:00
|
|
|
}
|
|
|
|
|
|
2011-07-22 12:11:30 +04:00
|
|
|
|
|
|
|
|
void WebPage::setScrollPosition(const QVariantMap &size)
|
|
|
|
|
{
|
|
|
|
|
int top = size.value("top").toInt();
|
|
|
|
|
int left = size.value("left").toInt();
|
|
|
|
|
m_scrollPosition = QPoint(left,top);
|
2011-09-09 10:36:06 +04:00
|
|
|
m_mainFrame->setScrollPosition(m_scrollPosition);
|
2011-07-22 12:11:30 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
QVariantMap WebPage::scrollPosition() const
|
|
|
|
|
{
|
|
|
|
|
QVariantMap result;
|
|
|
|
|
result["top"] = m_scrollPosition.y();
|
|
|
|
|
result["left"] = m_scrollPosition.x();
|
|
|
|
|
return result;
|
|
|
|
|
}
|
|
|
|
|
|
2011-05-25 21:46:51 +04:00
|
|
|
void WebPage::setPaperSize(const QVariantMap &size)
|
2011-04-08 17:30:50 +04:00
|
|
|
{
|
2011-05-25 21:46:51 +04:00
|
|
|
m_paperSize = size;
|
2011-04-08 17:30:50 +04:00
|
|
|
}
|
|
|
|
|
|
2011-05-25 21:46:51 +04:00
|
|
|
QVariantMap WebPage::paperSize() const
|
2011-04-08 17:30:50 +04:00
|
|
|
{
|
2011-05-25 21:46:51 +04:00
|
|
|
return m_paperSize;
|
2011-04-08 17:30:50 +04:00
|
|
|
}
|
|
|
|
|
|
2012-04-11 10:52:56 +04:00
|
|
|
QVariant WebPage::evaluateJavaScript(const QString &code)
|
2011-04-08 17:30:50 +04:00
|
|
|
{
|
2012-09-26 12:56:27 +04:00
|
|
|
QVariant evalResult;
|
2011-06-01 23:14:20 +04:00
|
|
|
QString function = "(" + code + ")()";
|
2012-09-26 12:56:27 +04:00
|
|
|
|
|
|
|
|
qDebug() << "WebPage - evaluateJavaScript" << function;
|
|
|
|
|
|
2015-02-07 01:46:50 +03:00
|
|
|
evalResult = m_currentFrame->evaluateJavaScript(function);
|
2012-09-26 12:56:27 +04:00
|
|
|
|
|
|
|
|
qDebug() << "WebPage - evaluateJavaScript result" << evalResult;
|
|
|
|
|
|
|
|
|
|
return evalResult;
|
2011-05-25 21:46:51 +04:00
|
|
|
}
|
|
|
|
|
|
2012-10-29 04:30:23 +04:00
|
|
|
QString WebPage::filePicker(const QString &oldFile)
|
|
|
|
|
{
|
|
|
|
|
qDebug() << "WebPage - filePicker" << "- old file:" << oldFile;
|
|
|
|
|
|
|
|
|
|
if (m_callbacks->m_filePickerCallback) {
|
|
|
|
|
QVariant res = m_callbacks->m_filePickerCallback->call(QVariantList() << oldFile);
|
|
|
|
|
|
|
|
|
|
if (res.canConvert<QString>()) {
|
|
|
|
|
QString filePath = res.toString();
|
|
|
|
|
qDebug() << "WebPage - filePicker" << "- new file:" << filePath;
|
|
|
|
|
// Return this value only if the file actually exists
|
|
|
|
|
if (QFile::exists(filePath)) {
|
|
|
|
|
return filePath;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
2013-01-17 04:45:45 +04:00
|
|
|
return QString::null;
|
2012-10-29 04:30:23 +04:00
|
|
|
}
|
|
|
|
|
|
2012-05-12 04:32:16 +04:00
|
|
|
bool WebPage::javaScriptConfirm(const QString &msg)
|
|
|
|
|
{
|
|
|
|
|
if (m_callbacks->m_jsConfirmCallback) {
|
|
|
|
|
QVariant res = m_callbacks->m_jsConfirmCallback->call(QVariantList() << msg);
|
|
|
|
|
if (res.canConvert<bool>()) {
|
|
|
|
|
return res.toBool();
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
return false;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
bool WebPage::javaScriptPrompt(const QString &msg, const QString &defaultValue, QString *result)
|
|
|
|
|
{
|
|
|
|
|
if (m_callbacks->m_jsPromptCallback) {
|
|
|
|
|
QVariant res = m_callbacks->m_jsPromptCallback->call(QVariantList() << msg << defaultValue);
|
|
|
|
|
if (!res.isNull() && res.canConvert<QString>()) {
|
|
|
|
|
result->append(res.toString());
|
|
|
|
|
return true;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
return false;
|
|
|
|
|
}
|
|
|
|
|
|
2013-04-03 22:06:38 +04:00
|
|
|
void WebPage::javascriptInterrupt()
|
|
|
|
|
{
|
|
|
|
|
if (m_callbacks->m_jsInterruptCallback) {
|
|
|
|
|
QVariant res = m_callbacks->m_jsInterruptCallback->call(QVariantList());
|
|
|
|
|
|
|
|
|
|
if (res.canConvert<bool>()) {
|
|
|
|
|
m_shouldInterruptJs = res.toBool();
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2011-05-25 21:46:51 +04:00
|
|
|
void WebPage::finish(bool ok)
|
|
|
|
|
{
|
|
|
|
|
QString status = ok ? "success" : "fail";
|
2011-06-06 12:31:37 +04:00
|
|
|
emit loadFinished(status);
|
2011-05-25 21:46:51 +04:00
|
|
|
}
|
|
|
|
|
|
2012-02-19 12:46:08 +04:00
|
|
|
void WebPage::setCustomHeaders(const QVariantMap &headers)
|
|
|
|
|
{
|
|
|
|
|
m_networkAccessManager->setCustomHeaders(headers);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
QVariantMap WebPage::customHeaders() const
|
|
|
|
|
{
|
|
|
|
|
return m_networkAccessManager->customHeaders();
|
|
|
|
|
}
|
|
|
|
|
|
2013-06-18 23:09:36 +04:00
|
|
|
void WebPage::setCookieJar(CookieJar *cookieJar) {
|
|
|
|
|
m_cookieJar = cookieJar;
|
|
|
|
|
m_customWebPage->setCookieJar(m_cookieJar);
|
|
|
|
|
m_networkAccessManager->setCookieJar(m_cookieJar);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void WebPage::setCookieJarFromQObject(QObject *cookieJar) {
|
|
|
|
|
setCookieJar(qobject_cast<CookieJar *>(cookieJar));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
CookieJar *WebPage::cookieJar()
|
|
|
|
|
{
|
|
|
|
|
return m_cookieJar;
|
|
|
|
|
}
|
|
|
|
|
|
2012-09-09 15:24:15 +04:00
|
|
|
bool WebPage::setCookies(const QVariantList &cookies)
|
2012-06-14 11:43:20 +04:00
|
|
|
{
|
2012-09-06 10:33:18 +04:00
|
|
|
// Delete all the cookies for this URL
|
2013-06-18 23:09:36 +04:00
|
|
|
m_cookieJar->deleteCookies(this->url());
|
2012-09-06 10:33:18 +04:00
|
|
|
// Add a new set of cookies foor this URL
|
2013-06-18 23:09:36 +04:00
|
|
|
return m_cookieJar->addCookiesFromMap(cookies, this->url());
|
2012-06-14 11:43:20 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
QVariantList WebPage::cookies() const
|
|
|
|
|
{
|
2012-09-06 10:33:18 +04:00
|
|
|
// Return all the Cookies visible to this Page, as a list of Maps (aka JSON in JS space)
|
2013-06-18 23:09:36 +04:00
|
|
|
return m_cookieJar->cookiesToMap(this->url());
|
2012-09-06 10:33:18 +04:00
|
|
|
}
|
|
|
|
|
|
2012-09-09 15:24:15 +04:00
|
|
|
bool WebPage::addCookie(const QVariantMap &cookie)
|
2012-09-06 10:33:18 +04:00
|
|
|
{
|
2013-06-18 23:09:36 +04:00
|
|
|
return m_cookieJar->addCookieFromMap(cookie, this->url());
|
2012-09-06 10:33:18 +04:00
|
|
|
}
|
|
|
|
|
|
2012-09-09 15:24:15 +04:00
|
|
|
bool WebPage::deleteCookie(const QString &cookieName)
|
2012-09-06 10:33:18 +04:00
|
|
|
{
|
|
|
|
|
if (!cookieName.isEmpty()) {
|
2013-06-18 23:09:36 +04:00
|
|
|
return m_cookieJar->deleteCookie(cookieName, this->url());
|
2012-09-06 10:33:18 +04:00
|
|
|
}
|
2012-09-09 15:24:15 +04:00
|
|
|
return false;
|
2012-09-06 10:33:18 +04:00
|
|
|
}
|
|
|
|
|
|
2012-09-09 15:24:15 +04:00
|
|
|
bool WebPage::clearCookies()
|
2012-09-06 10:33:18 +04:00
|
|
|
{
|
2013-06-18 23:09:36 +04:00
|
|
|
return m_cookieJar->deleteCookies(this->url());
|
2012-06-14 11:43:20 +04:00
|
|
|
}
|
|
|
|
|
|
2011-05-28 12:38:11 +04:00
|
|
|
void WebPage::openUrl(const QString &address, const QVariant &op, const QVariantMap &settings)
|
2011-05-25 21:46:51 +04:00
|
|
|
{
|
2011-05-28 12:38:11 +04:00
|
|
|
QString operation;
|
|
|
|
|
QByteArray body;
|
2012-03-23 15:48:16 +04:00
|
|
|
QNetworkRequest request;
|
2011-05-28 12:38:11 +04:00
|
|
|
|
2011-05-28 09:36:34 +04:00
|
|
|
applySettings(settings);
|
2012-07-05 04:21:15 +04:00
|
|
|
m_customWebPage->triggerAction(QWebPage::Stop);
|
2011-05-28 12:38:11 +04:00
|
|
|
|
|
|
|
|
if (op.type() == QVariant::String)
|
|
|
|
|
operation = op.toString();
|
|
|
|
|
|
|
|
|
|
if (op.type() == QVariant::Map) {
|
2013-03-08 21:57:02 +04:00
|
|
|
QVariantMap settingsMap = op.toMap();
|
|
|
|
|
operation = settingsMap.value("operation").toString();
|
|
|
|
|
QString bodyString = settingsMap.value("data").toString();
|
|
|
|
|
QString encoding = settingsMap.value("encoding").toString().toLower();
|
2014-07-24 21:25:46 +04:00
|
|
|
body = encoding == "utf-8" || encoding == "utf8" ? bodyString.toUtf8() : bodyString.toLatin1();
|
2013-03-08 21:57:02 +04:00
|
|
|
if (settingsMap.contains("headers")) {
|
|
|
|
|
QMapIterator<QString, QVariant> i(settingsMap.value("headers").toMap());
|
2012-03-23 15:48:16 +04:00
|
|
|
while (i.hasNext()) {
|
|
|
|
|
i.next();
|
|
|
|
|
request.setRawHeader(i.key().toUtf8(), i.value().toString().toUtf8());
|
|
|
|
|
}
|
|
|
|
|
}
|
2011-05-28 12:38:11 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (operation.isEmpty())
|
|
|
|
|
operation = "get";
|
|
|
|
|
|
|
|
|
|
QNetworkAccessManager::Operation networkOp = QNetworkAccessManager::UnknownOperation;
|
|
|
|
|
operation = operation.toLower();
|
|
|
|
|
if (operation == "get")
|
|
|
|
|
networkOp = QNetworkAccessManager::GetOperation;
|
|
|
|
|
else if (operation == "head")
|
|
|
|
|
networkOp = QNetworkAccessManager::HeadOperation;
|
|
|
|
|
else if (operation == "put")
|
|
|
|
|
networkOp = QNetworkAccessManager::PutOperation;
|
|
|
|
|
else if (operation == "post")
|
|
|
|
|
networkOp = QNetworkAccessManager::PostOperation;
|
|
|
|
|
else if (operation == "delete")
|
|
|
|
|
networkOp = QNetworkAccessManager::DeleteOperation;
|
|
|
|
|
|
|
|
|
|
if (networkOp == QNetworkAccessManager::UnknownOperation) {
|
2015-02-07 01:46:50 +03:00
|
|
|
m_mainFrame->evaluateJavaScript("console.error('Unknown network operation: " + operation + "');");
|
2011-05-28 12:38:11 +04:00
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
2011-09-15 11:15:56 +04:00
|
|
|
if (address == "about:blank") {
|
|
|
|
|
m_mainFrame->setHtml(BLANK_HTML);
|
|
|
|
|
} else {
|
2014-07-24 21:25:46 +04:00
|
|
|
QUrl url = QUrl::fromEncoded(QByteArray(address.toLatin1()));
|
2012-02-04 19:28:42 +04:00
|
|
|
|
|
|
|
|
// Assume local file if scheme is empty
|
|
|
|
|
if (url.scheme().isEmpty()) {
|
|
|
|
|
url.setPath(QFileInfo(url.toString()).absoluteFilePath().prepend("/"));
|
|
|
|
|
url.setScheme("file");
|
|
|
|
|
}
|
2014-07-24 21:25:46 +04:00
|
|
|
|
2012-03-23 15:48:16 +04:00
|
|
|
request.setUrl(url);
|
|
|
|
|
m_mainFrame->load(request, networkOp, body);
|
2011-09-15 11:15:56 +04:00
|
|
|
}
|
2011-05-25 21:46:51 +04:00
|
|
|
}
|
|
|
|
|
|
2011-08-24 05:53:53 +04:00
|
|
|
void WebPage::release()
|
|
|
|
|
{
|
2012-07-25 03:10:23 +04:00
|
|
|
close();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void WebPage::close() {
|
2011-08-24 05:53:53 +04:00
|
|
|
deleteLater();
|
|
|
|
|
}
|
|
|
|
|
|
2013-01-10 08:07:32 +04:00
|
|
|
bool WebPage::render(const QString &fileName, const QVariantMap &option)
|
2011-05-25 21:46:51 +04:00
|
|
|
{
|
2011-05-29 00:51:39 +04:00
|
|
|
if (m_mainFrame->contentsSize().isEmpty())
|
|
|
|
|
return false;
|
|
|
|
|
|
2013-01-10 08:07:32 +04:00
|
|
|
QString outFileName = fileName;
|
|
|
|
|
QString tempFileName = "";
|
|
|
|
|
|
|
|
|
|
QString format = "";
|
|
|
|
|
int quality = -1; // QImage#save default
|
|
|
|
|
|
|
|
|
|
if( fileName == STDOUT_FILENAME || fileName == STDERR_FILENAME ){
|
|
|
|
|
if( !QFile::exists(fileName) ){
|
|
|
|
|
// create temporary file for OS that have no /dev/stdout or /dev/stderr. (ex. windows)
|
|
|
|
|
tempFileName = QDir::tempPath() + "/phantomjstemp" + QUuid::createUuid().toString();
|
|
|
|
|
outFileName = tempFileName;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
format = "png"; // default format for stdout and stderr
|
|
|
|
|
}
|
|
|
|
|
else{
|
|
|
|
|
QFileInfo fileInfo(outFileName);
|
|
|
|
|
QDir dir;
|
|
|
|
|
dir.mkpath(fileInfo.absolutePath());
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if( option.contains("format") ){
|
|
|
|
|
format = option.value("format").toString();
|
|
|
|
|
}
|
|
|
|
|
else if (fileName.endsWith(".pdf", Qt::CaseInsensitive) ){
|
|
|
|
|
format = "pdf";
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if( option.contains("quality") ){
|
|
|
|
|
quality = option.value("quality").toInt();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
bool retval = true;
|
|
|
|
|
if ( format == "pdf" ){
|
|
|
|
|
retval = renderPdf(outFileName);
|
|
|
|
|
}
|
|
|
|
|
else{
|
|
|
|
|
QImage rawPageRendering = renderImage();
|
|
|
|
|
|
|
|
|
|
const char *f = 0; // 0 is QImage#save default
|
|
|
|
|
if( format != "" ){
|
2014-11-06 18:08:37 +03:00
|
|
|
f = format.toLocal8Bit().constData();
|
2013-01-10 08:07:32 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
retval = rawPageRendering.save(outFileName, f, quality);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if( tempFileName != "" ){
|
2013-12-03 08:08:47 +04:00
|
|
|
// cleanup temporary file and render to stdout or stderr
|
2013-01-10 08:07:32 +04:00
|
|
|
QFile i(tempFileName);
|
|
|
|
|
i.open(QIODevice::ReadOnly);
|
2013-12-03 08:08:47 +04:00
|
|
|
|
2013-01-10 08:07:32 +04:00
|
|
|
QByteArray ba = i.readAll();
|
2013-12-03 08:08:47 +04:00
|
|
|
|
2013-01-10 08:07:32 +04:00
|
|
|
System *system = (System*)Phantom::instance()->createSystem();
|
|
|
|
|
if( fileName == STDOUT_FILENAME ){
|
|
|
|
|
#ifdef Q_OS_WIN32
|
|
|
|
|
_setmode(_fileno(stdout), O_BINARY);
|
|
|
|
|
#endif
|
|
|
|
|
|
2014-07-24 21:25:46 +04:00
|
|
|
((File *)system->_stdout())->write(QString::fromLatin1(ba.constData(), ba.size()));
|
2013-01-10 08:07:32 +04:00
|
|
|
|
|
|
|
|
#ifdef Q_OS_WIN32
|
|
|
|
|
_setmode(_fileno(stdout), O_TEXT);
|
2013-12-03 08:08:47 +04:00
|
|
|
#endif
|
2013-01-10 08:07:32 +04:00
|
|
|
}
|
|
|
|
|
else if( fileName == STDERR_FILENAME ){
|
|
|
|
|
#ifdef Q_OS_WIN32
|
|
|
|
|
_setmode(_fileno(stderr), O_BINARY);
|
|
|
|
|
#endif
|
|
|
|
|
|
2014-07-24 21:25:46 +04:00
|
|
|
((File *)system->_stderr())->write(QString::fromLatin1(ba.constData(), ba.size()));
|
2013-01-10 08:07:32 +04:00
|
|
|
|
|
|
|
|
#ifdef Q_OS_WIN32
|
|
|
|
|
_setmode(_fileno(stderr), O_TEXT);
|
2013-12-03 08:08:47 +04:00
|
|
|
#endif
|
2013-01-10 08:07:32 +04:00
|
|
|
}
|
2011-05-25 21:46:51 +04:00
|
|
|
|
2013-01-10 08:07:32 +04:00
|
|
|
i.close();
|
2011-05-25 21:46:51 +04:00
|
|
|
|
2013-01-10 08:07:32 +04:00
|
|
|
QFile::remove(tempFileName);
|
2011-05-29 00:51:39 +04:00
|
|
|
}
|
2011-05-25 21:46:51 +04:00
|
|
|
|
2013-01-10 08:07:32 +04:00
|
|
|
return retval;
|
2011-05-29 00:51:39 +04:00
|
|
|
}
|
2011-05-29 00:41:01 +04:00
|
|
|
|
2012-06-18 05:22:43 +04:00
|
|
|
QString WebPage::renderBase64(const QByteArray &format)
|
2012-05-17 00:35:51 +04:00
|
|
|
{
|
2012-06-18 05:22:43 +04:00
|
|
|
QByteArray nformat = format.toLower();
|
2012-05-17 00:35:51 +04:00
|
|
|
|
2012-06-18 05:22:43 +04:00
|
|
|
// Check if the given format is supported
|
|
|
|
|
if (QImageWriter::supportedImageFormats().contains(nformat)) {
|
|
|
|
|
QImage rawPageRendering = renderImage();
|
2012-05-17 00:35:51 +04:00
|
|
|
|
2012-06-18 05:22:43 +04:00
|
|
|
// Prepare buffer for writing
|
|
|
|
|
QByteArray bytes;
|
|
|
|
|
QBuffer buffer(&bytes);
|
|
|
|
|
buffer.open(QIODevice::WriteOnly);
|
2012-05-17 00:35:51 +04:00
|
|
|
|
2012-06-18 05:22:43 +04:00
|
|
|
// Writing image to the buffer, using PNG encoding
|
|
|
|
|
rawPageRendering.save(&buffer, nformat);
|
2012-05-17 00:35:51 +04:00
|
|
|
|
2012-06-18 05:22:43 +04:00
|
|
|
return bytes.toBase64();
|
|
|
|
|
}
|
2012-05-17 00:35:51 +04:00
|
|
|
|
2012-06-18 05:22:43 +04:00
|
|
|
// Return an empty string in case an unsupported format was provided
|
|
|
|
|
return "";
|
2012-05-17 00:35:51 +04:00
|
|
|
}
|
|
|
|
|
|
2011-05-29 00:51:39 +04:00
|
|
|
QImage WebPage::renderImage()
|
|
|
|
|
{
|
2011-09-09 10:36:06 +04:00
|
|
|
QSize contentsSize = m_mainFrame->contentsSize();
|
|
|
|
|
contentsSize -= QSize(m_scrollPosition.x(), m_scrollPosition.y());
|
|
|
|
|
QRect frameRect = QRect(QPoint(0, 0), contentsSize);
|
2011-05-29 00:41:01 +04:00
|
|
|
if (!m_clipRect.isNull())
|
|
|
|
|
frameRect = m_clipRect;
|
|
|
|
|
|
2012-07-05 04:21:15 +04:00
|
|
|
QSize viewportSize = m_customWebPage->viewportSize();
|
|
|
|
|
m_customWebPage->setViewportSize(contentsSize);
|
2011-05-25 21:46:51 +04:00
|
|
|
|
2012-09-21 11:05:18 +04:00
|
|
|
#ifdef Q_OS_WIN32
|
|
|
|
|
QImage::Format format = QImage::Format_ARGB32_Premultiplied;
|
|
|
|
|
#else
|
|
|
|
|
QImage::Format format = QImage::Format_ARGB32;
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
QImage buffer(frameRect.size(), format);
|
2013-06-23 13:17:12 +04:00
|
|
|
buffer.fill(Qt::transparent);
|
2011-05-29 02:45:16 +04:00
|
|
|
|
|
|
|
|
QPainter painter;
|
|
|
|
|
|
|
|
|
|
// We use tiling approach to work-around Qt software rasterizer bug
|
|
|
|
|
// when dealing with very large paint device.
|
2011-08-21 09:07:18 +04:00
|
|
|
// See http://code.google.com/p/phantomjs/issues/detail?id=54.
|
2011-05-29 02:45:16 +04:00
|
|
|
const int tileSize = 4096;
|
|
|
|
|
int htiles = (buffer.width() + tileSize - 1) / tileSize;
|
|
|
|
|
int vtiles = (buffer.height() + tileSize - 1) / tileSize;
|
|
|
|
|
for (int x = 0; x < htiles; ++x) {
|
|
|
|
|
for (int y = 0; y < vtiles; ++y) {
|
|
|
|
|
|
2012-09-21 11:05:18 +04:00
|
|
|
QImage tileBuffer(tileSize, tileSize, format);
|
2013-06-23 13:17:12 +04:00
|
|
|
tileBuffer.fill(Qt::transparent);
|
2011-05-29 02:45:16 +04:00
|
|
|
|
|
|
|
|
// Render the web page onto the small tile first
|
|
|
|
|
painter.begin(&tileBuffer);
|
|
|
|
|
painter.setRenderHint(QPainter::Antialiasing, true);
|
|
|
|
|
painter.setRenderHint(QPainter::TextAntialiasing, true);
|
|
|
|
|
painter.setRenderHint(QPainter::SmoothPixmapTransform, true);
|
|
|
|
|
painter.translate(-frameRect.left(), -frameRect.top());
|
|
|
|
|
painter.translate(-x * tileSize, -y * tileSize);
|
|
|
|
|
m_mainFrame->render(&painter, QRegion(frameRect));
|
|
|
|
|
painter.end();
|
|
|
|
|
|
|
|
|
|
// Copy the tile to the main buffer
|
|
|
|
|
painter.begin(&buffer);
|
|
|
|
|
painter.setCompositionMode(QPainter::CompositionMode_Source);
|
|
|
|
|
painter.drawImage(x * tileSize, y * tileSize, tileBuffer);
|
|
|
|
|
painter.end();
|
|
|
|
|
}
|
|
|
|
|
}
|
2011-05-29 00:41:01 +04:00
|
|
|
|
2012-07-05 04:21:15 +04:00
|
|
|
m_customWebPage->setViewportSize(viewportSize);
|
2011-05-29 00:51:39 +04:00
|
|
|
return buffer;
|
2011-05-25 21:46:51 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#define PHANTOMJS_PDF_DPI 72 // Different defaults. OSX: 72, X11: 75(?), Windows: 96
|
|
|
|
|
|
|
|
|
|
qreal stringToPointSize(const QString &string)
|
|
|
|
|
{
|
|
|
|
|
static const struct {
|
|
|
|
|
QString unit;
|
|
|
|
|
qreal factor;
|
|
|
|
|
} units[] = {
|
|
|
|
|
{ "mm", 72 / 25.4 },
|
|
|
|
|
{ "cm", 72 / 2.54 },
|
|
|
|
|
{ "in", 72 },
|
2013-10-19 14:49:38 +04:00
|
|
|
{ "px", 72.0 / PHANTOMJS_PDF_DPI },
|
|
|
|
|
{ "", 72.0 / PHANTOMJS_PDF_DPI }
|
2011-05-25 21:46:51 +04:00
|
|
|
};
|
|
|
|
|
for (uint i = 0; i < sizeof(units) / sizeof(units[0]); ++i) {
|
|
|
|
|
if (string.endsWith(units[i].unit)) {
|
|
|
|
|
QString value = string;
|
|
|
|
|
value.chop(units[i].unit.length());
|
|
|
|
|
return value.toDouble() * units[i].factor;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2012-02-23 17:25:16 +04:00
|
|
|
qreal printMargin(const QVariantMap &map, const QString &key)
|
|
|
|
|
{
|
|
|
|
|
const QVariant margin = map.value(key);
|
|
|
|
|
if (margin.isValid() && margin.canConvert(QVariant::String)) {
|
|
|
|
|
return stringToPointSize(margin.toString());
|
|
|
|
|
} else {
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2011-05-25 21:46:51 +04:00
|
|
|
bool WebPage::renderPdf(const QString &fileName)
|
|
|
|
|
{
|
|
|
|
|
QPrinter printer;
|
|
|
|
|
printer.setOutputFormat(QPrinter::PdfFormat);
|
|
|
|
|
printer.setOutputFileName(fileName);
|
|
|
|
|
printer.setResolution(PHANTOMJS_PDF_DPI);
|
|
|
|
|
QVariantMap paperSize = m_paperSize;
|
|
|
|
|
|
|
|
|
|
if (paperSize.isEmpty()) {
|
|
|
|
|
const QSize pageSize = m_mainFrame->contentsSize();
|
|
|
|
|
paperSize.insert("width", QString::number(pageSize.width()) + "px");
|
|
|
|
|
paperSize.insert("height", QString::number(pageSize.height()) + "px");
|
2012-02-23 17:25:16 +04:00
|
|
|
paperSize.insert("margin", "0px");
|
2011-05-25 21:46:51 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (paperSize.contains("width") && paperSize.contains("height")) {
|
|
|
|
|
const QSizeF sizePt(ceil(stringToPointSize(paperSize.value("width").toString())),
|
|
|
|
|
ceil(stringToPointSize(paperSize.value("height").toString())));
|
|
|
|
|
printer.setPaperSize(sizePt, QPrinter::Point);
|
|
|
|
|
} else if (paperSize.contains("format")) {
|
|
|
|
|
const QPrinter::Orientation orientation = paperSize.contains("orientation")
|
|
|
|
|
&& paperSize.value("orientation").toString().compare("landscape", Qt::CaseInsensitive) == 0 ?
|
|
|
|
|
QPrinter::Landscape : QPrinter::Portrait;
|
|
|
|
|
printer.setOrientation(orientation);
|
|
|
|
|
static const struct {
|
|
|
|
|
QString format;
|
|
|
|
|
QPrinter::PaperSize paperSize;
|
|
|
|
|
} formats[] = {
|
2011-06-07 21:57:08 +04:00
|
|
|
{ "A0", QPrinter::A0 },
|
|
|
|
|
{ "A1", QPrinter::A1 },
|
|
|
|
|
{ "A2", QPrinter::A2 },
|
2011-05-25 21:46:51 +04:00
|
|
|
{ "A3", QPrinter::A3 },
|
|
|
|
|
{ "A4", QPrinter::A4 },
|
|
|
|
|
{ "A5", QPrinter::A5 },
|
2011-06-07 21:57:08 +04:00
|
|
|
{ "A6", QPrinter::A6 },
|
|
|
|
|
{ "A7", QPrinter::A7 },
|
|
|
|
|
{ "A8", QPrinter::A8 },
|
|
|
|
|
{ "A9", QPrinter::A9 },
|
|
|
|
|
{ "B0", QPrinter::B0 },
|
|
|
|
|
{ "B1", QPrinter::B1 },
|
|
|
|
|
{ "B2", QPrinter::B2 },
|
|
|
|
|
{ "B3", QPrinter::B3 },
|
|
|
|
|
{ "B4", QPrinter::B4 },
|
|
|
|
|
{ "B5", QPrinter::B5 },
|
|
|
|
|
{ "B6", QPrinter::B6 },
|
|
|
|
|
{ "B7", QPrinter::B7 },
|
|
|
|
|
{ "B8", QPrinter::B8 },
|
|
|
|
|
{ "B9", QPrinter::B9 },
|
|
|
|
|
{ "B10", QPrinter::B10 },
|
2011-06-07 22:26:41 +04:00
|
|
|
{ "C5E", QPrinter::C5E },
|
2011-06-07 21:57:08 +04:00
|
|
|
{ "Comm10E", QPrinter::Comm10E },
|
|
|
|
|
{ "DLE", QPrinter::DLE },
|
|
|
|
|
{ "Executive", QPrinter::Executive },
|
|
|
|
|
{ "Folio", QPrinter::Folio },
|
|
|
|
|
{ "Ledger", QPrinter::Ledger },
|
2011-05-25 21:46:51 +04:00
|
|
|
{ "Legal", QPrinter::Legal },
|
|
|
|
|
{ "Letter", QPrinter::Letter },
|
|
|
|
|
{ "Tabloid", QPrinter::Tabloid }
|
|
|
|
|
};
|
|
|
|
|
printer.setPaperSize(QPrinter::A4); // Fallback
|
|
|
|
|
for (uint i = 0; i < sizeof(formats) / sizeof(formats[0]); ++i) {
|
|
|
|
|
if (paperSize.value("format").toString().compare(formats[i].format, Qt::CaseInsensitive) == 0) {
|
|
|
|
|
printer.setPaperSize(formats[i].paperSize);
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
} else {
|
|
|
|
|
return false;
|
|
|
|
|
}
|
|
|
|
|
|
2012-02-23 17:25:16 +04:00
|
|
|
if (paperSize.contains("border") && !paperSize.contains("margin")) {
|
|
|
|
|
// backwards compatibility
|
|
|
|
|
paperSize["margin"] = paperSize["border"];
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
qreal marginLeft = 0;
|
|
|
|
|
qreal marginTop = 0;
|
|
|
|
|
qreal marginRight = 0;
|
|
|
|
|
qreal marginBottom = 0;
|
|
|
|
|
|
|
|
|
|
if (paperSize.contains("margin")) {
|
|
|
|
|
const QVariant margins = paperSize["margin"];
|
|
|
|
|
if (margins.canConvert(QVariant::Map)) {
|
|
|
|
|
const QVariantMap map = margins.toMap();
|
|
|
|
|
marginLeft = printMargin(map, "left");
|
|
|
|
|
marginTop = printMargin(map, "top");
|
|
|
|
|
marginRight = printMargin(map, "right");
|
|
|
|
|
marginBottom = printMargin(map, "bottom");
|
|
|
|
|
} else if (margins.canConvert(QVariant::String)) {
|
|
|
|
|
const qreal margin = stringToPointSize(margins.toString());
|
|
|
|
|
marginLeft = margin;
|
|
|
|
|
marginTop = margin;
|
|
|
|
|
marginRight = margin;
|
|
|
|
|
marginBottom = margin;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
printer.setPageMargins(marginLeft, marginTop, marginRight, marginBottom, QPrinter::Point);
|
2011-05-25 21:46:51 +04:00
|
|
|
|
2015-02-07 01:46:50 +03:00
|
|
|
m_mainFrame->print(&printer);
|
2011-05-25 21:46:51 +04:00
|
|
|
return true;
|
2011-04-08 17:30:50 +04:00
|
|
|
}
|
2011-06-05 11:28:14 +04:00
|
|
|
|
2012-06-01 18:06:48 +04:00
|
|
|
void WebPage::setZoomFactor(qreal zoom)
|
|
|
|
|
{
|
|
|
|
|
m_mainFrame->setZoomFactor(zoom);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
qreal WebPage::zoomFactor() const
|
|
|
|
|
{
|
|
|
|
|
return m_mainFrame->zoomFactor();
|
|
|
|
|
}
|
|
|
|
|
|
2012-07-05 04:21:15 +04:00
|
|
|
QString WebPage::windowName() const
|
|
|
|
|
{
|
|
|
|
|
return m_mainFrame->evaluateJavaScript("window.name;").toString();
|
|
|
|
|
}
|
|
|
|
|
|
2012-04-11 17:23:25 +04:00
|
|
|
qreal getHeight(const QVariantMap &map, const QString &key)
|
|
|
|
|
{
|
|
|
|
|
QVariant footer = map.value(key);
|
|
|
|
|
if (!footer.canConvert(QVariant::Map)) {
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
QVariant height = footer.toMap().value("height");
|
|
|
|
|
if (!height.canConvert(QVariant::String)) {
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
return stringToPointSize(height.toString());
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
qreal WebPage::footerHeight() const
|
|
|
|
|
{
|
|
|
|
|
return getHeight(m_paperSize, "footer");
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
qreal WebPage::headerHeight() const
|
|
|
|
|
{
|
|
|
|
|
return getHeight(m_paperSize, "header");
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
QString getHeaderFooter(const QVariantMap &map, const QString &key, QWebFrame *frame, int page, int numPages)
|
|
|
|
|
{
|
|
|
|
|
QVariant header = map.value(key);
|
|
|
|
|
if (!header.canConvert(QVariant::Map)) {
|
|
|
|
|
return QString();
|
|
|
|
|
}
|
|
|
|
|
QVariant callback = header.toMap().value("contents");
|
|
|
|
|
if (callback.canConvert<QObject*>()) {
|
|
|
|
|
Callback* caller = qobject_cast<Callback*>(callback.value<QObject*>());
|
|
|
|
|
if (caller) {
|
|
|
|
|
QVariant ret = caller->call(QVariantList() << page << numPages);
|
|
|
|
|
if (ret.canConvert(QVariant::String)) {
|
|
|
|
|
return ret.toString();
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
2015-02-07 01:46:50 +03:00
|
|
|
frame->evaluateJavaScript("console.error('Bad header callback given, use phantom.callback);");
|
2012-04-11 17:23:25 +04:00
|
|
|
return QString();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
QString WebPage::header(int page, int numPages)
|
|
|
|
|
{
|
|
|
|
|
return getHeaderFooter(m_paperSize, "header", m_mainFrame, page, numPages);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
QString WebPage::footer(int page, int numPages)
|
|
|
|
|
{
|
|
|
|
|
return getHeaderFooter(m_paperSize, "footer", m_mainFrame, page, numPages);
|
|
|
|
|
}
|
|
|
|
|
|
2012-12-09 14:52:52 +04:00
|
|
|
void WebPage::_uploadFile(const QString &selector, const QStringList &fileNames)
|
2011-06-05 11:28:14 +04:00
|
|
|
{
|
2012-09-16 20:57:56 +04:00
|
|
|
QWebElement el = m_currentFrame->findFirstElement(selector);
|
2011-06-05 11:28:14 +04:00
|
|
|
if (el.isNull())
|
|
|
|
|
return;
|
|
|
|
|
|
2013-01-17 04:45:45 +04:00
|
|
|
// Filter out "fileNames" that don't actually exist
|
|
|
|
|
m_customWebPage->m_uploadFiles.clear();
|
|
|
|
|
for (int i = 0, ilen = fileNames.length(); i < ilen; ++i) {
|
|
|
|
|
if (QFile::exists(fileNames[i])) {
|
|
|
|
|
m_customWebPage->m_uploadFiles.append(fileNames[i]);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2011-06-07 20:20:22 +04:00
|
|
|
el.evaluateJavaScript(JS_ELEMENT_CLICK);
|
|
|
|
|
}
|
|
|
|
|
|
2011-06-08 02:22:41 +04:00
|
|
|
bool WebPage::injectJs(const QString &jsFilePath) {
|
2012-09-16 20:57:56 +04:00
|
|
|
return Utils::injectJsInFrame(jsFilePath, m_libraryPath, m_currentFrame);
|
2011-06-07 20:20:22 +04:00
|
|
|
}
|
2011-06-09 19:11:39 +04:00
|
|
|
|
|
|
|
|
void WebPage::_appendScriptElement(const QString &scriptUrl) {
|
2015-02-07 01:46:50 +03:00
|
|
|
m_currentFrame->evaluateJavaScript(QString(JS_APPEND_SCRIPT_ELEMENT).arg(scriptUrl));
|
2011-06-09 19:11:39 +04:00
|
|
|
}
|
2011-08-02 04:31:13 +04:00
|
|
|
|
2012-05-12 04:32:16 +04:00
|
|
|
QObject *WebPage::_getGenericCallback() {
|
|
|
|
|
if (!m_callbacks) {
|
|
|
|
|
m_callbacks = new WebpageCallbacks(this);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return m_callbacks->getGenericCallback();
|
|
|
|
|
}
|
|
|
|
|
|
2012-10-29 04:30:23 +04:00
|
|
|
QObject *WebPage::_getFilePickerCallback()
|
|
|
|
|
{
|
|
|
|
|
if (!m_callbacks) {
|
|
|
|
|
m_callbacks = new WebpageCallbacks(this);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return m_callbacks->getFilePickerCallback();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
QObject *WebPage::_getJsConfirmCallback()
|
|
|
|
|
{
|
2012-05-12 04:32:16 +04:00
|
|
|
if (!m_callbacks) {
|
|
|
|
|
m_callbacks = new WebpageCallbacks(this);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return m_callbacks->getJsConfirmCallback();
|
|
|
|
|
}
|
|
|
|
|
|
2012-10-29 04:30:23 +04:00
|
|
|
QObject *WebPage::_getJsPromptCallback()
|
|
|
|
|
{
|
2012-05-12 04:32:16 +04:00
|
|
|
if (!m_callbacks) {
|
|
|
|
|
m_callbacks = new WebpageCallbacks(this);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return m_callbacks->getJsPromptCallback();
|
|
|
|
|
}
|
|
|
|
|
|
2013-04-03 22:06:38 +04:00
|
|
|
QObject *WebPage::_getJsInterruptCallback()
|
|
|
|
|
{
|
|
|
|
|
if (!m_callbacks) {
|
|
|
|
|
m_callbacks = new WebpageCallbacks(this);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return m_callbacks->getJsInterruptCallback();
|
|
|
|
|
}
|
|
|
|
|
|
2012-10-23 22:11:26 +04:00
|
|
|
void WebPage::sendEvent(const QString &type, const QVariant &arg1, const QVariant &arg2, const QString &mouseButton, const QVariant &modifierArg)
|
2011-09-16 18:15:21 +04:00
|
|
|
{
|
2012-10-23 22:11:26 +04:00
|
|
|
Qt::KeyboardModifiers keyboardModifiers(modifierArg.toInt());
|
2012-08-13 22:51:40 +04:00
|
|
|
// Normalize the event "type" to lowercase
|
|
|
|
|
const QString eventType = type.toLower();
|
|
|
|
|
|
|
|
|
|
// single keyboard events
|
|
|
|
|
if (eventType == "keydown" || eventType == "keyup") {
|
2012-07-01 20:47:22 +04:00
|
|
|
QKeyEvent::Type keyEventType = QEvent::None;
|
2012-08-13 22:51:40 +04:00
|
|
|
if (eventType == "keydown")
|
2012-07-01 20:47:22 +04:00
|
|
|
keyEventType = QKeyEvent::KeyPress;
|
2012-08-13 22:51:40 +04:00
|
|
|
if (eventType == "keyup")
|
2012-07-01 20:47:22 +04:00
|
|
|
keyEventType = QKeyEvent::KeyRelease;
|
|
|
|
|
Q_ASSERT(keyEventType != QEvent::None);
|
|
|
|
|
|
2012-07-04 14:01:16 +04:00
|
|
|
int key = 0;
|
|
|
|
|
QString text;
|
|
|
|
|
if (arg1.type() == QVariant::Char) {
|
|
|
|
|
// a single char was given
|
|
|
|
|
text = arg1.toChar();
|
2012-11-02 18:32:25 +04:00
|
|
|
key = text.at(0).toUpper().unicode();
|
2012-07-04 14:01:16 +04:00
|
|
|
} else if (arg1.type() == QVariant::String) {
|
|
|
|
|
// javascript invokation of a single char
|
|
|
|
|
text = arg1.toString();
|
|
|
|
|
if (!text.isEmpty()) {
|
2012-11-02 18:32:25 +04:00
|
|
|
key = text.at(0).toUpper().unicode();
|
2012-07-04 14:01:16 +04:00
|
|
|
}
|
|
|
|
|
} else {
|
|
|
|
|
// assume a raw integer char code was given
|
|
|
|
|
key = arg1.toInt();
|
|
|
|
|
}
|
2012-10-23 22:11:26 +04:00
|
|
|
QKeyEvent *keyEvent = new QKeyEvent(keyEventType, key, keyboardModifiers, text);
|
2012-07-13 21:41:38 +04:00
|
|
|
QApplication::postEvent(m_customWebPage, keyEvent);
|
2012-07-01 20:47:22 +04:00
|
|
|
QApplication::processEvents();
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
2012-08-13 22:51:40 +04:00
|
|
|
// sequence of key events: will generate all the single keydown/keyup events
|
|
|
|
|
if (eventType == "keypress") {
|
2012-07-04 14:01:16 +04:00
|
|
|
if (arg1.type() == QVariant::String) {
|
|
|
|
|
// this is the case for e.g. sendEvent("...", 'A')
|
|
|
|
|
// but also works with sendEvent("...", "ABCD")
|
2012-10-23 22:11:26 +04:00
|
|
|
foreach(const QChar typeChar, arg1.toString()) {
|
2012-10-31 14:39:45 +04:00
|
|
|
sendEvent("keydown", typeChar, QVariant(), QString(), modifierArg);
|
|
|
|
|
sendEvent("keyup", typeChar, QVariant(), QString(), modifierArg);
|
2012-07-04 14:01:16 +04:00
|
|
|
}
|
|
|
|
|
} else {
|
|
|
|
|
// otherwise we assume a raw integer char-code was given
|
2012-10-31 14:39:45 +04:00
|
|
|
sendEvent("keydown", arg1.toInt(), QVariant(), QString(), modifierArg);
|
|
|
|
|
sendEvent("keyup", arg1.toInt(), QVariant(), QString(), modifierArg);
|
2012-07-04 14:01:16 +04:00
|
|
|
}
|
|
|
|
|
return;
|
2012-07-01 20:47:22 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// mouse events
|
2012-08-13 22:51:40 +04:00
|
|
|
if (eventType == "mousedown" ||
|
|
|
|
|
eventType == "mouseup" ||
|
|
|
|
|
eventType == "mousemove" ||
|
2012-11-01 06:31:16 +04:00
|
|
|
eventType == "mousedoubleclick") {
|
2012-08-13 22:51:40 +04:00
|
|
|
QMouseEvent::Type mouseEventType = QEvent::None;
|
|
|
|
|
|
|
|
|
|
// Which mouse button (if it's a click)
|
2011-09-16 18:15:21 +04:00
|
|
|
Qt::MouseButton button = Qt::LeftButton;
|
2012-08-13 22:51:40 +04:00
|
|
|
Qt::MouseButton buttons = Qt::LeftButton;
|
|
|
|
|
if (mouseButton.toLower() == "middle") {
|
|
|
|
|
button = Qt::MiddleButton;
|
|
|
|
|
buttons = Qt::MiddleButton;
|
|
|
|
|
} else if (mouseButton.toLower() == "right") {
|
|
|
|
|
button = Qt::RightButton;
|
|
|
|
|
buttons = Qt::RightButton;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Which mouse event
|
|
|
|
|
if (eventType == "mousedown") {
|
|
|
|
|
mouseEventType = QEvent::MouseButtonPress;
|
|
|
|
|
} else if (eventType == "mouseup") {
|
|
|
|
|
mouseEventType = QEvent::MouseButtonRelease;
|
2012-11-01 06:31:16 +04:00
|
|
|
} else if (eventType == "mousedoubleclick") {
|
2012-08-13 22:51:40 +04:00
|
|
|
mouseEventType = QEvent::MouseButtonDblClick;
|
|
|
|
|
} else if (eventType == "mousemove") {
|
|
|
|
|
mouseEventType = QEvent::MouseMove;
|
2011-09-16 18:15:21 +04:00
|
|
|
button = Qt::NoButton;
|
|
|
|
|
buttons = Qt::NoButton;
|
|
|
|
|
}
|
2012-08-13 22:51:40 +04:00
|
|
|
Q_ASSERT(mouseEventType != QEvent::None);
|
|
|
|
|
|
|
|
|
|
// Gather coordinates
|
|
|
|
|
if (arg1.isValid() && arg2.isValid()) {
|
|
|
|
|
m_mousePos.setX(arg1.toInt());
|
|
|
|
|
m_mousePos.setY(arg2.toInt());
|
|
|
|
|
}
|
|
|
|
|
|
2012-10-23 22:11:26 +04:00
|
|
|
// Prepare the Mouse event
|
2012-08-13 22:51:40 +04:00
|
|
|
qDebug() << "Mouse Event:" << eventType << "(" << mouseEventType << ")" << m_mousePos << ")" << button << buttons;
|
2012-10-23 22:11:26 +04:00
|
|
|
QMouseEvent *event = new QMouseEvent(mouseEventType, m_mousePos, button, buttons, keyboardModifiers);
|
2011-08-07 17:29:50 +04:00
|
|
|
|
2012-08-13 22:51:40 +04:00
|
|
|
// Post and process events
|
2012-07-05 04:21:15 +04:00
|
|
|
QApplication::postEvent(m_customWebPage, event);
|
2011-09-16 18:15:21 +04:00
|
|
|
QApplication::processEvents();
|
|
|
|
|
return;
|
|
|
|
|
}
|
2011-08-07 17:29:50 +04:00
|
|
|
|
2012-08-13 22:51:40 +04:00
|
|
|
// mouse click events: Qt doesn't provide this as a separate events,
|
|
|
|
|
// so we compose it with a mousedown/mouseup sequence
|
2012-11-01 06:31:16 +04:00
|
|
|
// mouse doubleclick events: It is not enough to simply send a
|
|
|
|
|
// MouseButtonDblClick event by itself; it must be accompanied
|
|
|
|
|
// by a preceding press-release, and a following release.
|
|
|
|
|
if (type == "click" || type == "doubleclick") {
|
2014-01-01 20:06:11 +04:00
|
|
|
sendEvent("mousedown", arg1, arg2, mouseButton, modifierArg);
|
|
|
|
|
sendEvent("mouseup", arg1, arg2, mouseButton, modifierArg);
|
2012-11-01 06:31:16 +04:00
|
|
|
if (type == "doubleclick") {
|
2014-01-01 20:06:11 +04:00
|
|
|
sendEvent("mousedoubleclick", arg1, arg2, mouseButton, modifierArg);
|
|
|
|
|
sendEvent("mouseup", arg1, arg2, mouseButton, modifierArg);
|
2012-11-01 06:31:16 +04:00
|
|
|
}
|
2011-09-16 18:15:21 +04:00
|
|
|
return;
|
|
|
|
|
}
|
2011-08-07 17:29:50 +04:00
|
|
|
}
|
|
|
|
|
|
2012-07-05 04:21:15 +04:00
|
|
|
QObjectList WebPage::pages() const
|
2012-05-30 15:28:20 +04:00
|
|
|
{
|
2012-07-05 04:21:15 +04:00
|
|
|
QObjectList pages;
|
|
|
|
|
|
2012-09-26 12:56:27 +04:00
|
|
|
QList<WebPage *> childPages = this->findChildren<WebPage *>();
|
|
|
|
|
for (int i = childPages.length() -1; i >= 0; --i) {
|
|
|
|
|
pages << childPages.at(i);
|
2012-07-05 04:21:15 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return pages;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
QStringList WebPage::pagesWindowName() const
|
|
|
|
|
{
|
|
|
|
|
QStringList pagesWindowName;
|
|
|
|
|
|
2012-09-26 12:56:27 +04:00
|
|
|
foreach (const WebPage *p, this->findChildren<WebPage *>()) {
|
2012-07-05 04:21:15 +04:00
|
|
|
pagesWindowName << p->windowName();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return pagesWindowName;
|
2012-05-30 15:28:20 +04:00
|
|
|
}
|
|
|
|
|
|
2012-07-05 04:21:15 +04:00
|
|
|
QObject *WebPage::getPage(const QString &windowName) const
|
2012-05-30 15:28:20 +04:00
|
|
|
{
|
2012-09-26 12:56:27 +04:00
|
|
|
QList<WebPage *> childPages = this->findChildren<WebPage *>();
|
|
|
|
|
for (int i = childPages.length() -1; i >= 0; --i) {
|
|
|
|
|
if (childPages.at(i)->windowName() == windowName) {
|
|
|
|
|
return childPages.at(i);
|
2012-07-05 04:21:15 +04:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
return NULL;
|
|
|
|
|
}
|
2012-05-30 15:28:20 +04:00
|
|
|
|
2012-07-27 20:13:43 +04:00
|
|
|
bool WebPage::ownsPages() const
|
|
|
|
|
{
|
|
|
|
|
return m_ownsPages;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void WebPage::setOwnsPages(const bool owns)
|
|
|
|
|
{
|
|
|
|
|
m_ownsPages = owns;
|
|
|
|
|
}
|
|
|
|
|
|
2012-07-12 04:38:45 +04:00
|
|
|
int WebPage::framesCount() const
|
2012-07-05 04:21:15 +04:00
|
|
|
{
|
2012-09-16 20:57:56 +04:00
|
|
|
return m_currentFrame->childFrames().count();
|
2012-07-05 04:21:15 +04:00
|
|
|
}
|
|
|
|
|
|
2012-07-12 04:38:45 +04:00
|
|
|
int WebPage::childFramesCount() const //< deprecated
|
|
|
|
|
{
|
|
|
|
|
return this->framesCount();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
QStringList WebPage::framesName() const
|
2012-07-05 04:21:15 +04:00
|
|
|
{
|
|
|
|
|
QStringList framesName;
|
|
|
|
|
|
2012-09-26 12:56:27 +04:00
|
|
|
foreach(const QWebFrame *f, m_currentFrame->childFrames()) {
|
2012-05-30 15:28:20 +04:00
|
|
|
framesName << f->frameName();
|
|
|
|
|
}
|
|
|
|
|
return framesName;
|
|
|
|
|
}
|
|
|
|
|
|
2012-07-12 04:38:45 +04:00
|
|
|
QStringList WebPage::childFramesName() const //< deprecated
|
|
|
|
|
{
|
|
|
|
|
return this->framesName();
|
|
|
|
|
}
|
|
|
|
|
|
2012-09-16 20:57:56 +04:00
|
|
|
void WebPage::changeCurrentFrame(QWebFrame * const frame)
|
|
|
|
|
{
|
2012-09-27 04:42:11 +04:00
|
|
|
if (frame != m_currentFrame) {
|
2014-02-17 13:21:27 +04:00
|
|
|
qDebug() << "WebPage - changeCurrentFrame" << "from" << (m_currentFrame == NULL ? "Undefined" : m_currentFrame->frameName()) << "to" << frame->frameName();
|
2012-09-27 04:42:11 +04:00
|
|
|
m_currentFrame = frame;
|
|
|
|
|
}
|
2012-09-16 20:57:56 +04:00
|
|
|
}
|
|
|
|
|
|
2012-07-12 04:38:45 +04:00
|
|
|
bool WebPage::switchToFrame(const QString &frameName)
|
2012-05-30 15:28:20 +04:00
|
|
|
{
|
2012-09-26 12:56:27 +04:00
|
|
|
QList<QWebFrame *> childFrames = m_currentFrame->childFrames();
|
|
|
|
|
for (int i = childFrames.length() -1; i >= 0; --i) {
|
|
|
|
|
if (childFrames.at(i)->frameName() == frameName) {
|
|
|
|
|
this->changeCurrentFrame(childFrames.at(i));
|
2012-05-30 15:28:20 +04:00
|
|
|
return true;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
return false;
|
|
|
|
|
}
|
|
|
|
|
|
2012-07-12 04:38:45 +04:00
|
|
|
bool WebPage::switchToChildFrame(const QString &frameName) //< deprecated
|
|
|
|
|
{
|
|
|
|
|
return this->switchToFrame(frameName);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
bool WebPage::switchToFrame(const int framePosition)
|
2012-05-30 15:28:20 +04:00
|
|
|
{
|
2012-09-16 20:57:56 +04:00
|
|
|
QList<QWebFrame *> childFrames = m_currentFrame->childFrames();
|
2012-07-05 04:21:15 +04:00
|
|
|
if (framePosition >= 0 && framePosition < childFrames.size()) {
|
2012-09-16 20:57:56 +04:00
|
|
|
this->changeCurrentFrame(childFrames.at(framePosition));
|
2012-05-30 15:28:20 +04:00
|
|
|
return true;
|
|
|
|
|
}
|
|
|
|
|
return false;
|
|
|
|
|
}
|
|
|
|
|
|
2012-07-12 04:38:45 +04:00
|
|
|
bool WebPage::switchToChildFrame(const int framePosition) //< deprecated
|
|
|
|
|
{
|
|
|
|
|
return this->switchToFrame(framePosition);
|
|
|
|
|
}
|
|
|
|
|
|
2012-05-30 15:28:20 +04:00
|
|
|
void WebPage::switchToMainFrame()
|
|
|
|
|
{
|
2012-09-27 04:42:11 +04:00
|
|
|
if (m_currentFrame != m_mainFrame) {
|
|
|
|
|
this->changeCurrentFrame(m_mainFrame);
|
|
|
|
|
}
|
2012-05-30 15:28:20 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
bool WebPage::switchToParentFrame()
|
|
|
|
|
{
|
2012-09-16 20:57:56 +04:00
|
|
|
if (m_currentFrame->parentFrame() != NULL) {
|
|
|
|
|
this->changeCurrentFrame(m_currentFrame->parentFrame());
|
2012-05-30 15:28:20 +04:00
|
|
|
return true;
|
|
|
|
|
}
|
|
|
|
|
return false;
|
|
|
|
|
}
|
|
|
|
|
|
2012-09-16 20:57:56 +04:00
|
|
|
void WebPage::switchToFocusedFrame()
|
|
|
|
|
{
|
|
|
|
|
this->changeCurrentFrame(m_customWebPage->currentFrame());
|
|
|
|
|
}
|
|
|
|
|
|
2012-07-12 04:38:45 +04:00
|
|
|
QString WebPage::frameName() const
|
2012-05-30 15:28:20 +04:00
|
|
|
{
|
2012-09-16 20:57:56 +04:00
|
|
|
return m_currentFrame->frameName();
|
2012-07-05 04:21:15 +04:00
|
|
|
}
|
|
|
|
|
|
2012-07-12 04:38:45 +04:00
|
|
|
QString WebPage::currentFrameName() const //< deprecated
|
|
|
|
|
{
|
|
|
|
|
return this->frameName();
|
|
|
|
|
}
|
|
|
|
|
|
2012-09-16 20:57:56 +04:00
|
|
|
QString WebPage::focusedFrameName() const
|
|
|
|
|
{
|
|
|
|
|
return m_customWebPage->currentFrame()->frameName();
|
|
|
|
|
}
|
|
|
|
|
|
2012-09-26 12:56:27 +04:00
|
|
|
static void injectCallbacksObjIntoFrame(QWebFrame *frame, WebpageCallbacks *callbacksObject)
|
2012-09-18 22:07:02 +04:00
|
|
|
{
|
2012-09-26 12:56:27 +04:00
|
|
|
// Inject object only if it's not already present
|
|
|
|
|
if (frame->evaluateJavaScript(CALLBACKS_OBJECT_PRESENT).toBool() == false) {
|
|
|
|
|
// Decorate the window object in this frame (object ownership left to the creator/parent)
|
2014-07-24 21:25:46 +04:00
|
|
|
frame->addToJavaScriptWindowObject(CALLBACKS_OBJECT_NAME, callbacksObject, QWebFrame::QtOwnership);
|
2012-09-26 12:56:27 +04:00
|
|
|
frame->evaluateJavaScript(CALLBACKS_OBJECT_INJECTION);
|
2012-09-18 22:07:02 +04:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2012-09-26 12:56:27 +04:00
|
|
|
void WebPage::setupFrame(QWebFrame *frame)
|
2012-07-05 04:21:15 +04:00
|
|
|
{
|
2012-09-26 12:56:27 +04:00
|
|
|
qDebug() << "WebPage - setupFrame" << (frame == NULL ? "" : frame->frameName());
|
2012-07-05 04:21:15 +04:00
|
|
|
|
2012-09-26 12:56:27 +04:00
|
|
|
// Inject the Callbacks object in the main frame
|
|
|
|
|
injectCallbacksObjIntoFrame(frame == NULL ? m_mainFrame : frame, m_callbacks);
|
2012-05-30 15:28:20 +04:00
|
|
|
}
|
|
|
|
|
|
2013-02-23 02:41:01 +04:00
|
|
|
void WebPage::updateLoadingProgress(int progress)
|
|
|
|
|
{
|
|
|
|
|
qDebug() << "WebPage - updateLoadingProgress:" << progress;
|
|
|
|
|
m_loadingProgress = progress;
|
|
|
|
|
}
|
|
|
|
|
|
2013-12-03 08:08:47 +04:00
|
|
|
void WebPage::handleRepaintRequested(const QRect &dirtyRect)
|
|
|
|
|
{
|
|
|
|
|
emit repaintRequested(dirtyRect.x(), dirtyRect.y(), dirtyRect.width(), dirtyRect.height());
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2013-04-03 22:06:38 +04:00
|
|
|
void WebPage::stopJavaScript()
|
|
|
|
|
{
|
|
|
|
|
m_shouldInterruptJs = true;
|
|
|
|
|
}
|
|
|
|
|
|
2014-09-25 18:09:33 +04:00
|
|
|
void WebPage::clearMemoryCache()
|
|
|
|
|
{
|
|
|
|
|
QWebSettings::clearMemoryCaches();
|
|
|
|
|
}
|
|
|
|
|
|
2011-08-02 04:31:13 +04:00
|
|
|
#include "webpage.moc"
|
