|
|
|
/*! @file
|
|
|
|
|
|
|
|
@id $Id: browser.hxx 15 2010-06-03 14:17:27Z marc $
|
|
|
|
*/
|
|
|
|
// 1 2 3 4 5 6 7 8
|
|
|
|
// 45678901234567890123456789012345678901234567890123456789012345678901234567890
|
|
|
|
|
|
|
|
#ifndef BROWSER_HXX
|
|
|
|
#define BROWSER_HXX
|
|
|
|
|
|
|
|
#include <ui_browser.h>
|
|
|
|
#include <QtGui/QMainWindow>
|
|
|
|
#include <QtGui/QLineEdit>
|
|
|
|
#include <QtGui/QProgressBar>
|
|
|
|
#include <QtGui/QSlider>
|
|
|
|
#include <QtGui/QMessageBox>
|
|
|
|
#include <QtGui/QPrinter>
|
|
|
|
#include <QtGui/QPrintDialog>
|
|
|
|
#include <QtGui/QPrintPreviewDialog>
|
|
|
|
#include <QtWebKit/QWebPage>
|
|
|
|
#include <QtWebKit/QWebView>
|
|
|
|
#include <QtWebKit/QWebFrame>
|
|
|
|
#include <QtWebKit/QWebHistory>
|
|
|
|
#include <QtNetwork/QNetworkReply>
|
|
|
|
#include <QtNetwork/QNetworkAccessManager>
|
|
|
|
#include <QtNetwork/QSslError>
|
|
|
|
#include <QtNetwork/QNetworkProxy>
|
|
|
|
|
|
|
|
#include <proxyface/proxy.hxx>
|
|
|
|
|
|
|
|
#include <smartcardauth.hxx>
|
|
|
|
|
|
|
|
#include <stdexcept>
|
|
|
|
#include <cassert>
|
|
|
|
#include <QtCore/QDebug>
|
|
|
|
|
|
|
|
#define LOG qDebug()<<__PRETTY_FUNCTION__
|
|
|
|
|
|
|
|
extern SmartCardAuth _scAuth;
|
|
|
|
|
|
|
|
class SslClientAuthNetworkAccessManager: public QNetworkAccessManager {
|
|
|
|
Q_OBJECT;
|
|
|
|
public:
|
|
|
|
|
|
|
|
SslClientAuthNetworkAccessManager(QObject* parent = 0):
|
|
|
|
QNetworkAccessManager(parent) {
|
|
|
|
LOG;
|
|
|
|
}
|
|
|
|
|
|
|
|
virtual ~SslClientAuthNetworkAccessManager() {
|
|
|
|
LOG;
|
|
|
|
}
|
|
|
|
|
|
|
|
protected:
|
|
|
|
|
|
|
|
virtual QNetworkReply* createRequest(Operation op,
|
|
|
|
const QNetworkRequest& req,
|
|
|
|
QIODevice* outgoingData = 0 ) {
|
|
|
|
LOG<<req.url();
|
|
|
|
QNetworkReply* rep
|
|
|
|
(QNetworkAccessManager::createRequest(op, req, outgoingData));
|
|
|
|
//qDebug()<<"Reply created: "<<(int)rep;
|
|
|
|
qDebug()<<"Reply to URL: "<<rep->url().toString();
|
|
|
|
return rep;
|
|
|
|
}
|
|
|
|
|
|
|
|
};
|
|
|
|
|
|
|
|
class Browser: public QMainWindow, protected Ui::Browser {
|
|
|
|
|
|
|
|
Q_OBJECT;
|
|
|
|
|
|
|
|
public:
|
|
|
|
|
|
|
|
Browser(const QString& url, bool kiosk = false,
|
|
|
|
bool proxydetection = false):
|
|
|
|
_url(0), _home(url), _proxy(0),
|
|
|
|
_kiosk(kiosk) {
|
|
|
|
LOG<<url;
|
|
|
|
if (!check(url))
|
|
|
|
throw std::runtime_error(tr("access to URL %1 not allowed")
|
|
|
|
.arg(url).toStdString());
|
|
|
|
setupUi(this);
|
|
|
|
on_actionNewTab_triggered();
|
|
|
|
actionProxySettings->setEnabled(proxydetection);
|
|
|
|
if (proxydetection) {
|
|
|
|
_proxy = new gui::Proxy(url, this);
|
|
|
|
assert(connect(_proxy, SIGNAL(proxyFound(const QUrl&,
|
|
|
|
const QNetworkProxy&)),
|
|
|
|
SLOT(startDownload(QUrl, const QNetworkProxy&))));
|
|
|
|
assert(connect(_proxy, SIGNAL(temporaryError
|
|
|
|
(QNetworkReply::NetworkError,
|
|
|
|
QString, QString)),
|
|
|
|
SLOT(proxy_error(QNetworkReply::NetworkError,
|
|
|
|
QString, QString))));
|
|
|
|
assert(connect(_proxy, SIGNAL(proxyError(QNetworkReply::NetworkError)),
|
|
|
|
SLOT(proxy_error(QNetworkReply::NetworkError))));
|
|
|
|
}
|
|
|
|
_toolbar->addWidget(_url = new QLineEdit(_toolbar));
|
|
|
|
_url->setText(url);
|
|
|
|
assert(connect(_url, SIGNAL(returnPressed()), SLOT(load())));
|
|
|
|
assert(connect(&_networkManager,
|
|
|
|
SIGNAL(extendedContextInitialization(ssl_ctx_st*,
|
|
|
|
QSslSocket*)),
|
|
|
|
&_scAuth,
|
|
|
|
SLOT(extendedContextInitialization(ssl_ctx_st*,
|
|
|
|
QSslSocket*))));
|
|
|
|
if (_kiosk) {
|
|
|
|
_menu->hide();
|
|
|
|
_url->setEnabled(false);
|
|
|
|
}
|
|
|
|
statusBar()->addPermanentWidget(_progress = new QProgressBar());
|
|
|
|
statusBar()->addPermanentWidget(_zoom = new QSlider(Qt::Horizontal));
|
|
|
|
_zoom->setMinimum(1);
|
|
|
|
_zoom->setMaximum(100);
|
|
|
|
_zoom->setValue(10);
|
|
|
|
assert(connect(_zoom, SIGNAL(valueChanged(int)), SLOT(zoom(int))));
|
|
|
|
load(url);
|
|
|
|
}
|
|
|
|
|
|
|
|
QString networkError(QNetworkReply::NetworkError err) {
|
|
|
|
LOG<<err;
|
|
|
|
switch (err) {
|
|
|
|
case QNetworkReply::NoError:
|
|
|
|
return tr("Network connection successful, remote host can be"
|
|
|
|
" reached.");
|
|
|
|
case QNetworkReply::ConnectionRefusedError:
|
|
|
|
return tr("The remote server refused the connection (the server is"
|
|
|
|
" not accepting requests).");
|
|
|
|
case QNetworkReply::RemoteHostClosedError:
|
|
|
|
return tr("The remote server closed the connection prematurely,"
|
|
|
|
" before the entire reply was received and processed.");
|
|
|
|
case QNetworkReply::HostNotFoundError:
|
|
|
|
return tr("The remote host name was not found (invalid hostname).");
|
|
|
|
case QNetworkReply::TimeoutError:
|
|
|
|
return tr("The connection to the remote server timed out.");
|
|
|
|
case QNetworkReply::OperationCanceledError:
|
|
|
|
return tr("The operation was canceled via calls to abort() or"
|
|
|
|
" close() before it was finished.");
|
|
|
|
case QNetworkReply::SslHandshakeFailedError:
|
|
|
|
return tr("The SSL/TLS handshake failed and the encrypted channel"
|
|
|
|
" could not be established. The sslErrors() signal should"
|
|
|
|
" have been emitted.");
|
|
|
|
case QNetworkReply::ProxyConnectionRefusedError:
|
|
|
|
return tr("The connection to the proxy server was refused (the"
|
|
|
|
" proxy server is not accepting requests).");
|
|
|
|
case QNetworkReply::ProxyConnectionClosedError:
|
|
|
|
return tr("The proxy server closed the connection prematurely,"
|
|
|
|
" before the entire reply was received and processed.");
|
|
|
|
case QNetworkReply::ProxyNotFoundError:
|
|
|
|
return tr("The proxy host name was not found (invalid proxy"
|
|
|
|
" hostname).");
|
|
|
|
case QNetworkReply::ProxyTimeoutError:
|
|
|
|
return tr("The connection to the proxy timed out or the proxy did"
|
|
|
|
" not reply in time to the request sent.");
|
|
|
|
case QNetworkReply::ProxyAuthenticationRequiredError:
|
|
|
|
return tr("The proxy requires authentication in order to honour the"
|
|
|
|
" request but did not accept any credentials offered"
|
|
|
|
" (if any).");
|
|
|
|
case QNetworkReply::ContentAccessDenied:
|
|
|
|
return tr("The access to the remote content was denied (similar to"
|
|
|
|
" HTTP error 401).");
|
|
|
|
case QNetworkReply::ContentOperationNotPermittedError:
|
|
|
|
return tr("The operation requested on the remote content is not"
|
|
|
|
" permitted.");
|
|
|
|
case QNetworkReply::ContentNotFoundError:
|
|
|
|
return tr("The remote content was not found at the server (similar"
|
|
|
|
" to HTTP error 404).");
|
|
|
|
case QNetworkReply::AuthenticationRequiredError:
|
|
|
|
return tr("The remote server requires authentication to serve the"
|
|
|
|
" content but the credentials provided were not accepted"
|
|
|
|
" (if any).");
|
|
|
|
case QNetworkReply::ProtocolUnknownError:
|
|
|
|
return tr("The Network Access API cannot honor the request because"
|
|
|
|
" the protocol is not known.");
|
|
|
|
case QNetworkReply::ProtocolInvalidOperationError:
|
|
|
|
return tr("The requested operation is invalid for this protocol.");
|
|
|
|
case QNetworkReply::UnknownNetworkError:
|
|
|
|
return tr("An unknown network-related error was detected.");
|
|
|
|
case QNetworkReply::UnknownProxyError:
|
|
|
|
return tr("An unknown proxy-related error was detected.");
|
|
|
|
case QNetworkReply::UnknownContentError:
|
|
|
|
return tr("An unknonwn error related to the remote content was"
|
|
|
|
" detected.");
|
|
|
|
case QNetworkReply::ProtocolFailure:
|
|
|
|
return tr("A breakdown in protocol was detected (parsing error,"
|
|
|
|
" invalid or unexpected responses, etc.).");
|
|
|
|
default:
|
|
|
|
return tr("<strong>Unknown network error (code: %1).</string>")
|
|
|
|
.arg(err);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
bool check(QUrl page) {
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
private Q_SLOTS:
|
|
|
|
|
|
|
|
void load() {
|
|
|
|
LOG;
|
|
|
|
load(_url->text());
|
|
|
|
}
|
|
|
|
|
|
|
|
void load(QString page) {
|
|
|
|
if (QUrl(page).scheme()=="") page = "http://"+page;
|
|
|
|
load(QUrl(page));
|
|
|
|
}
|
|
|
|
|
|
|
|
void load(QUrl page) {
|
|
|
|
LOG<<page.toString();
|
|
|
|
statusBar()->showMessage(tr("Checking: %1").arg(page.toString()));
|
|
|
|
try {
|
|
|
|
if (!check(page)) {
|
|
|
|
qDebug()<<"########## BLACK LISTED IGNORED ##########";
|
|
|
|
statusBar()->showMessage(tr("Forbidden: %1").arg(page.toString()));
|
|
|
|
QMessageBox::warning(this, tr("Access Denied"),
|
|
|
|
tr("<p>Access denied due to security"
|
|
|
|
" considerations.</p><p>You are not"
|
|
|
|
" allowed to connect to %1.")
|
|
|
|
.arg(page.toString()));
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
if (_proxy) _proxy->checkUrl(page.toString());
|
|
|
|
_progress->setValue(0);
|
|
|
|
_progress->setMaximum(0);
|
|
|
|
_progress->show();
|
|
|
|
if (!_proxy) startDownload(page);
|
|
|
|
} catch (...) {
|
|
|
|
reply_error(QNetworkReply::ProxyNotFoundError);
|
|
|
|
} // no network
|
|
|
|
}
|
|
|
|
|
|
|
|
void startDownload(QUrl url, const QNetworkProxy& proxy) {
|
|
|
|
LOG;
|
|
|
|
QNetworkProxy::setApplicationProxy(proxy);
|
|
|
|
startDownload(url);
|
|
|
|
}
|
|
|
|
|
|
|
|
void startDownload(QUrl url) {
|
|
|
|
LOG<<url.toString();
|
|
|
|
statusBar()->showMessage(tr("Reading: %1").arg(url.toString()));
|
|
|
|
if (!url.isValid()) {
|
|
|
|
statusBar()->showMessage(tr("Illegal URL: %1").arg(url.errorString()));
|
|
|
|
_progress->hide();
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
//if (url.scheme()=="") url.setScheme("http");
|
|
|
|
dynamic_cast<QWebView*>(_tabs->currentWidget())->load(url);
|
|
|
|
}
|
|
|
|
|
|
|
|
void reply_error(QNetworkReply::NetworkError err) {
|
|
|
|
LOG<<err;
|
|
|
|
statusBar()->showMessage(tr("network error"));
|
|
|
|
_error += tr("<h2>%1</h2><p>%2</p>")
|
|
|
|
.arg(tr("Reply Error"))
|
|
|
|
.arg(networkError(err));
|
|
|
|
}
|
|
|
|
|
|
|
|
//! intermediate proxy error
|
|
|
|
void proxy_error(QNetworkReply::NetworkError err,
|
|
|
|
QString errStr, QString proxy) {
|
|
|
|
LOG<<err<<errStr;
|
|
|
|
statusBar()->showMessage(tr("proxy error"));
|
|
|
|
_error += tr("<h2>%1</h2><p>Proxy: %3</p><p>%2</p><p>%4</p>")
|
|
|
|
.arg(tr("Possible Proxy Failed"))
|
|
|
|
.arg(networkError(err))
|
|
|
|
.arg(proxy)
|
|
|
|
.arg(errStr);
|
|
|
|
}
|
|
|
|
|
|
|
|
//! final proxy error
|
|
|
|
void proxy_error(QNetworkReply::NetworkError err) {
|
|
|
|
LOG<<err;
|
|
|
|
statusBar()->showMessage(tr("proxy error"));
|
|
|
|
_error = tr("<h2>%1</h2><p>%2</p>")
|
|
|
|
.arg(tr("Connection Cannot Be Established"))
|
|
|
|
.arg(networkError(err)) + _error;
|
|
|
|
// on__browser_loadFinished(false); //! @todo
|
|
|
|
}
|
|
|
|
|
|
|
|
void zoom(int i) {
|
|
|
|
LOG<<100.0*i/10.0;
|
|
|
|
statusBar()->showMessage(tr("Zoom: %1%").arg(100.0*i/10.0));
|
|
|
|
dynamic_cast<QWebView*>(_tabs->currentWidget())->setZoomFactor(i/10.0);
|
|
|
|
}
|
|
|
|
|
|
|
|
void on_actionHome_activated() {
|
|
|
|
LOG;
|
|
|
|
load(_home);
|
|
|
|
}
|
|
|
|
|
|
|
|
// void on__browser_urlChanged(const QUrl& url) { //!@todo
|
|
|
|
// LOG<<url.toString();
|
|
|
|
// if (_url) _url->setText(url.toString());
|
|
|
|
// }
|
|
|
|
|
|
|
|
// void on__browser_linkClicked(const QUrl& url) { //!@todo
|
|
|
|
// LOG<<url.toString();
|
|
|
|
// load(url);
|
|
|
|
// }
|
|
|
|
|
|
|
|
// void on__browser_iconChanged() { //!@todo
|
|
|
|
// LOG;
|
|
|
|
// setWindowIcon(_browser->icon());
|
|
|
|
// }
|
|
|
|
|
|
|
|
// void on__browser_titleChanged(const QString& text) { //!@todo
|
|
|
|
// LOG<<text;
|
|
|
|
// setWindowTitle(trUtf8("%1 - SwissSurfer").arg(text));
|
|
|
|
// }
|
|
|
|
|
|
|
|
// void on__browser_statusBarMessage(const QString& text) { //!@todo
|
|
|
|
// LOG<<text;
|
|
|
|
// qDebug()<<"Message: "<<text;
|
|
|
|
// if (text.size()) statusBar()->showMessage(tr("Info: %1").arg(text));
|
|
|
|
// }
|
|
|
|
|
|
|
|
// void on__browser_loadProgress(int i) {
|
|
|
|
// LOG<<i;
|
|
|
|
// _progress->setValue(i);
|
|
|
|
// }
|
|
|
|
|
|
|
|
// void on__browser_loadStarted() {
|
|
|
|
// LOG;
|
|
|
|
// _progress->setValue(0);
|
|
|
|
// _progress->setMaximum(100);
|
|
|
|
// _progress->show();
|
|
|
|
// actionStop->setEnabled(true);
|
|
|
|
// actionForward->setEnabled(false);
|
|
|
|
// actionBack->setEnabled(false);
|
|
|
|
// actionReload->setEnabled(false);
|
|
|
|
// actionHome->setEnabled(false);
|
|
|
|
// }
|
|
|
|
|
|
|
|
// void on__browser_loadFinished(bool ok) {
|
|
|
|
// LOG<<(ok?"success":"error");
|
|
|
|
// if (!ok) {
|
|
|
|
// _browser->setHtml(tr("<html><title>Page Load Error</title>"
|
|
|
|
// "<body><h1>Page Load Error</h1>%1"
|
|
|
|
// "</body></html>")
|
|
|
|
// .arg(_error),
|
|
|
|
// _errorUrl);
|
|
|
|
// statusBar()->showMessage(tr("download error"));
|
|
|
|
// } else {
|
|
|
|
// statusBar()->showMessage(tr("done."));
|
|
|
|
// }
|
|
|
|
// _error.clear();
|
|
|
|
// _progress->hide();
|
|
|
|
// on__browser_iconChanged();
|
|
|
|
// actionStop->setEnabled(false);
|
|
|
|
// actionForward->setEnabled(_browser->history()->canGoForward());
|
|
|
|
// actionBack->setEnabled(_browser->history()->canGoBack());
|
|
|
|
// actionReload->setEnabled(true);
|
|
|
|
// actionHome->setEnabled(true);
|
|
|
|
// }
|
|
|
|
|
|
|
|
// //!@todo ^^^
|
|
|
|
|
|
|
|
// void on_actionNew_triggered() { //@!todo exec new process
|
|
|
|
// LOG;
|
|
|
|
// (new Browser(dynamic_cast<QWebView*>(_tabs->currentWidget())->url().toString(), _kiosk, false))->show();
|
|
|
|
// }
|
|
|
|
|
|
|
|
void on_actionNewTab_triggered() {
|
|
|
|
QWebView* browser(new QWebView);
|
|
|
|
browser->page()->setLinkDelegationPolicy(QWebPage::DelegateAllLinks);
|
|
|
|
browser->page()->setNetworkAccessManager(&_networkManager);
|
|
|
|
// QWebPage WebAction
|
|
|
|
connect(browser->pageAction(QWebPage::OpenLink),
|
|
|
|
SIGNAL(triggered(bool)),
|
|
|
|
SLOT(triggeredOpenLink(bool)));
|
|
|
|
connect(browser->pageAction(QWebPage::OpenLinkInNewWindow),
|
|
|
|
SIGNAL(triggered(bool)),
|
|
|
|
SLOT(triggeredOpenLinkInNewWindow(bool)));
|
|
|
|
connect(browser->pageAction(QWebPage::OpenFrameInNewWindow),
|
|
|
|
SIGNAL(triggered(bool)),
|
|
|
|
SLOT(triggeredOpenFrameInNewWindow(bool)));
|
|
|
|
connect(browser->pageAction(QWebPage::DownloadLinkToDisk),
|
|
|
|
SIGNAL(triggered(bool)),
|
|
|
|
SLOT(triggeredDownloadLinkToDisk(bool)));
|
|
|
|
connect(browser->pageAction(QWebPage::CopyLinkToClipboard),
|
|
|
|
SIGNAL(triggered(bool)),
|
|
|
|
SLOT(triggeredCopyLinkToClipboard(bool)));
|
|
|
|
connect(browser->pageAction(QWebPage::OpenImageInNewWindow),
|
|
|
|
SIGNAL(triggered(bool)),
|
|
|
|
SLOT(triggeredOpenImageInNewWindow(bool)));
|
|
|
|
connect(browser->pageAction(QWebPage::DownloadImageToDisk),
|
|
|
|
SIGNAL(triggered(bool)),
|
|
|
|
SLOT(triggeredDownloadImageToDisk(bool)));
|
|
|
|
connect(browser->pageAction(QWebPage::CopyImageToClipboard),
|
|
|
|
SIGNAL(triggered(bool)),
|
|
|
|
SLOT(triggeredCopyImageToClipboard(bool)));
|
|
|
|
connect(browser->pageAction(QWebPage::Back),
|
|
|
|
SIGNAL(triggered(bool)),
|
|
|
|
SLOT(triggeredBack(bool)));
|
|
|
|
connect(browser->pageAction(QWebPage::Forward),
|
|
|
|
SIGNAL(triggered(bool)),
|
|
|
|
SLOT(triggeredForward(bool)));
|
|
|
|
connect(browser->pageAction(QWebPage::Stop),
|
|
|
|
SIGNAL(triggered(bool)),
|
|
|
|
SLOT(triggeredStop(bool)));
|
|
|
|
connect(browser->pageAction(QWebPage::Reload),
|
|
|
|
SIGNAL(triggered(bool)),
|
|
|
|
SLOT(triggeredReload(bool)));
|
|
|
|
connect(browser->pageAction(QWebPage::Cut),
|
|
|
|
SIGNAL(triggered(bool)),
|
|
|
|
SLOT(triggeredCut(bool)));
|
|
|
|
connect(browser->pageAction(QWebPage::Copy),
|
|
|
|
SIGNAL(triggered(bool)),
|
|
|
|
SLOT(triggeredCopy(bool)));
|
|
|
|
connect(browser->pageAction(QWebPage::Paste),
|
|
|
|
SIGNAL(triggered(bool)),
|
|
|
|
SLOT(triggeredPaste(bool)));
|
|
|
|
connect(browser->pageAction(QWebPage::Undo),
|
|
|
|
SIGNAL(triggered(bool)),
|
|
|
|
SLOT(triggeredUndo(bool)));
|
|
|
|
connect(browser->pageAction(QWebPage::Redo),
|
|
|
|
SIGNAL(triggered(bool)),
|
|
|
|
SLOT(triggeredRedo(bool)));
|
|
|
|
connect(browser->pageAction(QWebPage::MoveToNextChar),
|
|
|
|
SIGNAL(triggered(bool)),
|
|
|
|
SLOT(triggeredMoveToNextChar(bool)));
|
|
|
|
connect(browser->pageAction(QWebPage::MoveToPreviousChar),
|
|
|
|
SIGNAL(triggered(bool)),
|
|
|
|
SLOT(triggeredMoveToPreviousChar(bool)));
|
|
|
|
connect(browser->pageAction(QWebPage::MoveToNextWord),
|
|
|
|
SIGNAL(triggered(bool)),
|
|
|
|
SLOT(triggeredMoveToNextWord(bool)));
|
|
|
|
connect(browser->pageAction(QWebPage::MoveToPreviousWord),
|
|
|
|
SIGNAL(triggered(bool)),
|
|
|
|
SLOT(triggeredMoveToPreviousWord(bool)));
|
|
|
|
connect(browser->pageAction(QWebPage::MoveToNextLine),
|
|
|
|
SIGNAL(triggered(bool)),
|
|
|
|
SLOT(triggeredMoveToNextLine(bool)));
|
|
|
|
connect(browser->pageAction(QWebPage::MoveToPreviousLine),
|
|
|
|
SIGNAL(triggered(bool)),
|
|
|
|
SLOT(triggeredMoveToPreviousLine(bool)));
|
|
|
|
connect(browser->pageAction(QWebPage::MoveToStartOfLine),
|
|
|
|
SIGNAL(triggered(bool)),
|
|
|
|
SLOT(triggeredMoveToStartOfLine(bool)));
|
|
|
|
connect(browser->pageAction(QWebPage::MoveToEndOfLine),
|
|
|
|
SIGNAL(triggered(bool)),
|
|
|
|
SLOT(triggeredMoveToEndOfLine(bool)));
|
|
|
|
connect(browser->pageAction(QWebPage::MoveToStartOfBlock),
|
|
|
|
SIGNAL(triggered(bool)),
|
|
|
|
SLOT(triggeredMoveToStartOfBlock(bool)));
|
|
|
|
connect(browser->pageAction(QWebPage::MoveToEndOfBlock),
|
|
|
|
SIGNAL(triggered(bool)),
|
|
|
|
SLOT(triggeredMoveToEndOfBlock(bool)));
|
|
|
|
connect(browser->pageAction(QWebPage::MoveToStartOfDocument),
|
|
|
|
SIGNAL(triggered(bool)),
|
|
|
|
SLOT(triggeredMoveToStartOfDocument(bool)));
|
|
|
|
connect(browser->pageAction(QWebPage::MoveToEndOfDocument),
|
|
|
|
SIGNAL(triggered(bool)),
|
|
|
|
SLOT(triggeredMoveToEndOfDocument(bool)));
|
|
|
|
connect(browser->pageAction(QWebPage::SelectNextChar),
|
|
|
|
SIGNAL(triggered(bool)),
|
|
|
|
SLOT(triggeredSelectNextChar(bool)));
|
|
|
|
connect(browser->pageAction(QWebPage::SelectPreviousChar),
|
|
|
|
SIGNAL(triggered(bool)),
|
|
|
|
SLOT(triggeredSelectPreviousChar(bool)));
|
|
|
|
connect(browser->pageAction(QWebPage::SelectNextWord),
|
|
|
|
SIGNAL(triggered(bool)),
|
|
|
|
SLOT(triggeredSelectNextWord(bool)));
|
|
|
|
connect(browser->pageAction(QWebPage::SelectPreviousWord),
|
|
|
|
SIGNAL(triggered(bool)),
|
|
|
|
SLOT(triggeredSelectPreviousWord(bool)));
|
|
|
|
connect(browser->pageAction(QWebPage::SelectNextLine),
|
|
|
|
SIGNAL(triggered(bool)),
|
|
|
|
SLOT(triggeredSelectNextLine(bool)));
|
|
|
|
connect(browser->pageAction(QWebPage::SelectPreviousLine),
|
|
|
|
SIGNAL(triggered(bool)),
|
|
|
|
SLOT(triggeredSelectPreviousLine(bool)));
|
|
|
|
connect(browser->pageAction(QWebPage::SelectStartOfLine),
|
|
|
|
SIGNAL(triggered(bool)),
|
|
|
|
SLOT(triggeredSelectStartOfLine(bool)));
|
|
|
|
connect(browser->pageAction(QWebPage::SelectEndOfLine),
|
|
|
|
SIGNAL(triggered(bool)),
|
|
|
|
SLOT(triggeredSelectEndOfLine(bool)));
|
|
|
|
connect(browser->pageAction(QWebPage::SelectStartOfBlock),
|
|
|
|
SIGNAL(triggered(bool)),
|
|
|
|
SLOT(triggeredSelectStartOfBlock(bool)));
|
|
|
|
connect(browser->pageAction(QWebPage::SelectEndOfBlock),
|
|
|
|
SIGNAL(triggered(bool)),
|
|
|
|
SLOT(triggeredSelectEndOfBlock(bool)));
|
|
|
|
connect(browser->pageAction(QWebPage::SelectStartOfDocument),
|
|
|
|
SIGNAL(triggered(bool)),
|
|
|
|
SLOT(triggeredSelectStartOfDocument(bool)));
|
|
|
|
connect(browser->pageAction(QWebPage::SelectEndOfDocument),
|
|
|
|
SIGNAL(triggered(bool)),
|
|
|
|
SLOT(triggeredSelectEndOfDocument(bool)));
|
|
|
|
connect(browser->pageAction(QWebPage::DeleteStartOfWord),
|
|
|
|
SIGNAL(triggered(bool)),
|
|
|
|
SLOT(triggeredDeleteStartOfWord(bool)));
|
|
|
|
connect(browser->pageAction(QWebPage::DeleteEndOfWord),
|
|
|
|
SIGNAL(triggered(bool)),
|
|
|
|
SLOT(triggeredDeleteEndOfWord(bool)));
|
|
|
|
connect(browser->pageAction(QWebPage::SetTextDirectionDefault),
|
|
|
|
SIGNAL(triggered(bool)),
|
|
|
|
SLOT(triggeredSetTextDirectionDefault(bool)));
|
|
|
|
connect(browser->pageAction(QWebPage::SetTextDirectionLeftToRight),
|
|
|
|
SIGNAL(triggered(bool)),
|
|
|
|
SLOT(triggeredSetTextDirectionLeftToRight(bool)));
|
|
|
|
connect(browser->pageAction(QWebPage::SetTextDirectionRightToLeft),
|
|
|
|
SIGNAL(triggered(bool)),
|
|
|
|
SLOT(triggeredSetTextDirectionRightToLeft(bool)));
|
|
|
|
connect(browser->pageAction(QWebPage::ToggleBold),
|
|
|
|
SIGNAL(triggered(bool)),
|
|
|
|
SLOT(triggeredToggleBold(bool)));
|
|
|
|
connect(browser->pageAction(QWebPage::ToggleItalic),
|
|
|
|
SIGNAL(triggered(bool)),
|
|
|
|
SLOT(triggeredToggleItalic(bool)));
|
|
|
|
connect(browser->pageAction(QWebPage::ToggleUnderline),
|
|
|
|
SIGNAL(triggered(bool)),
|
|
|
|
SLOT(triggeredToggleUnderline(bool)));
|
|
|
|
connect(browser->pageAction(QWebPage::InspectElement),
|
|
|
|
SIGNAL(triggered(bool)),
|
|
|
|
SLOT(triggeredInspectElement(bool)));
|
|
|
|
connect(browser->pageAction(QWebPage::InsertParagraphSeparator),
|
|
|
|
SIGNAL(triggered(bool)),
|
|
|
|
SLOT(triggeredInsertParagraphSeparator(bool)));
|
|
|
|
connect(browser->pageAction(QWebPage::InsertLineSeparator),
|
|
|
|
SIGNAL(triggered(bool)),
|
|
|
|
SLOT(triggeredInsertLineSeparator(bool)));
|
|
|
|
connect(browser->pageAction(QWebPage::SelectAll),
|
|
|
|
SIGNAL(triggered(bool)),
|
|
|
|
SLOT(triggeredSelectAll(bool)));
|
|
|
|
// QWebPage
|
|
|
|
assert(connect(browser->page(), SIGNAL(contentsChanged()),
|
|
|
|
SLOT(contentsChanged())));
|
|
|
|
assert(connect(browser->page(),
|
|
|
|
SIGNAL(databaseQuotaExceeded(QWebFrame*, QString)),
|
|
|
|
SLOT(databaseQuotaExceeded(QWebFrame*, QString))));
|
|
|
|
assert(connect(browser->page(),
|
|
|
|
SIGNAL(downloadRequested(const QNetworkRequest&)),
|
|
|
|
SLOT(downloadRequested(const QNetworkRequest&))));
|
|
|
|
assert(connect(browser->page(), SIGNAL(frameCreated(QWebFrame*)),
|
|
|
|
SLOT(frameCreated(QWebFrame*))));
|
|
|
|
assert(connect(browser->page(),
|
|
|
|
SIGNAL(geometryChangeRequested(const QRect&)),
|
|
|
|
SLOT(geometryChangeRequested(const QRect&))));
|
|
|
|
assert(connect(browser->page(), SIGNAL(linkClicked(const QUrl&)),
|
|
|
|
SLOT(linkClicked(const QUrl&))));
|
|
|
|
assert(connect(browser->page(),
|
|
|
|
SIGNAL(linkHovered(const QString&, const QString&,
|
|
|
|
const QString&)),
|
|
|
|
SLOT(linkHovered(const QString&, const QString&,
|
|
|
|
const QString&))));
|
|
|
|
assert(connect(browser->page(), SIGNAL(loadFinished(bool)),
|
|
|
|
SLOT(loadFinished(bool))));
|
|
|
|
assert(connect(browser->page(), SIGNAL(loadProgress(int)),
|
|
|
|
SLOT(loadProgress(int))));
|
|
|
|
assert(connect(browser->page(), SIGNAL(loadStarted()),
|
|
|
|
SLOT(loadStarted())));
|
|
|
|
assert(connect(browser->page(),
|
|
|
|
SIGNAL(menuBarVisibilityChangeRequested(bool)),
|
|
|
|
SLOT(menuBarVisibilityChangeRequested(bool))));
|
|
|
|
assert(connect(browser->page(), SIGNAL(microFocusChanged()),
|
|
|
|
SLOT(microFocusChanged())));
|
|
|
|
assert(connect(browser->page(), SIGNAL(printRequested(QWebFrame*)),
|
|
|
|
SLOT(printRequested(QWebFrame*))));
|
|
|
|
assert(connect(browser->page(), SIGNAL(repaintRequested(const QRect&)),
|
|
|
|
SLOT(repaintRequested(const QRect&))));
|
|
|
|
assert(connect(browser->page(),
|
|
|
|
SIGNAL(restoreFrameStateRequested(QWebFrame*)),
|
|
|
|
SLOT(restoreFrameStateRequested(QWebFrame*))));
|
|
|
|
assert(connect(browser->page(),
|
|
|
|
SIGNAL(saveFrameStateRequested(QWebFrame*,
|
|
|
|
QWebHistoryItem*)),
|
|
|
|
SLOT(saveFrameStateRequested(QWebFrame*,
|
|
|
|
QWebHistoryItem*))));
|
|
|
|
assert(connect(browser->page(),
|
|
|
|
SIGNAL(scrollRequested(int, int, const QRect&)),
|
|
|
|
SLOT(scrollRequested(int, int, const QRect&))));
|
|
|
|
assert(connect(browser->page(), SIGNAL(selectionChanged()),
|
|
|
|
SLOT(selectionChanged())));
|
|
|
|
assert(connect(browser->page(), SIGNAL(statusBarMessage(const QString&)),
|
|
|
|
SLOT(statusBarMessage(const QString&))));
|
|
|
|
assert(connect(browser->page(),
|
|
|
|
SIGNAL(statusBarVisibilityChangeRequested(bool)),
|
|
|
|
SLOT(statusBarVisibilityChangeRequested(bool))));
|
|
|
|
assert(connect(browser->page(),
|
|
|
|
SIGNAL(toolBarVisibilityChangeRequested(bool)),
|
|
|
|
SLOT(toolBarVisibilityChangeRequested(bool))));
|
|
|
|
assert(connect(browser->page(),
|
|
|
|
SIGNAL(unsupportedContent(QNetworkReply*)),
|
|
|
|
SLOT(unsupportedContent(QNetworkReply*))));
|
|
|
|
assert(connect(browser->page(), SIGNAL(windowCloseRequested()),
|
|
|
|
SLOT(windowCloseRequested())));
|
|
|
|
// QNetworkAccessManager
|
|
|
|
assert(connect(browser->page()->networkAccessManager(),
|
|
|
|
SIGNAL(authenticationRequired(QNetworkReply*,
|
|
|
|
QAuthenticator*)),
|
|
|
|
SLOT(authenticationRequired(QNetworkReply*,
|
|
|
|
QAuthenticator*))));
|
|
|
|
assert(connect(browser->page()->networkAccessManager(),
|
|
|
|
SIGNAL(finished(QNetworkReply*)),
|
|
|
|
SLOT(finished(QNetworkReply*))));
|
|
|
|
assert(connect(browser->page()->networkAccessManager(),
|
|
|
|
SIGNAL(proxyAuthenticationRequired(const QNetworkProxy&,
|
|
|
|
QAuthenticator*)),
|
|
|
|
SLOT(proxyAuthenticationRequired(const QNetworkProxy&,
|
|
|
|
QAuthenticator*))));
|
|
|
|
assert(connect(browser->page()->networkAccessManager(),
|
|
|
|
SIGNAL(sslErrors(QNetworkReply*, const QList<QSslError>&)),
|
|
|
|
SLOT(sslErrors(QNetworkReply*, const QList<QSslError>&))));
|
|
|
|
_tabs->setCurrentIndex(_tabs->addTab(browser, "*empty*"));
|
|
|
|
_tabs->setTabsClosable(_tabs->count()>1);
|
|
|
|
}
|
|
|
|
|
|
|
|
void on__tabs_currentChanged(int index) {
|
|
|
|
}
|
|
|
|
|
|
|
|
void on__tabs_tabCloseRequested(int index) {
|
|
|
|
_tabs->removeTab(index);
|
|
|
|
_tabs->setTabsClosable(_tabs->count()>1);
|
|
|
|
}
|
|
|
|
|
|
|
|
void on_actionPrintPreview_triggered() {
|
|
|
|
QPrintPreviewDialog preview(&_printer, this);
|
|
|
|
connect(&preview, SIGNAL(paintRequested(QPrinter*)),
|
|
|
|
dynamic_cast<QWebView*>(_tabs->currentWidget()),
|
|
|
|
SLOT(print(QPrinter*)));
|
|
|
|
preview.exec();
|
|
|
|
}
|
|
|
|
|
|
|
|
void on_actionInstantPrint_triggered() {
|
|
|
|
dynamic_cast<QWebView*>(_tabs->currentWidget())->print(&_printer);
|
|
|
|
}
|
|
|
|
|
|
|
|
void on_actionPrint_triggered() {
|
|
|
|
QPrintDialog dialog(&_printer, this);
|
|
|
|
dialog.setWindowTitle(tr("Print Document"));
|
|
|
|
if (dialog.exec()!=QDialog::Accepted) return;
|
|
|
|
on_actionInstantPrint_triggered();
|
|
|
|
}
|
|
|
|
|
|
|
|
void on_actionClose_triggered() {
|
|
|
|
LOG;
|
|
|
|
close();
|
|
|
|
}
|
|
|
|
|
|
|
|
void on_actionProxySettings_triggered() {
|
|
|
|
LOG;
|
|
|
|
if (_proxy) _proxy->show();
|
|
|
|
}
|
|
|
|
|
|
|
|
//@name QWebPage slots
|
|
|
|
//@{
|
|
|
|
|
|
|
|
void triggeredOpenLink(bool) {
|
|
|
|
LOG;
|
|
|
|
}
|
|
|
|
|
|
|
|
void triggeredOpenLinkInNewWindow(bool) {
|
|
|
|
LOG;
|
|
|
|
}
|
|
|
|
|
|
|
|
void triggeredOpenFrameInNewWindow(bool) {
|
|
|
|
LOG;
|
|
|
|
}
|
|
|
|
|
|
|
|
void triggeredDownloadLinkToDisk(bool) {
|
|
|
|
LOG;
|
|
|
|
}
|
|
|
|
|
|
|
|
void triggeredCopyLinkToClipboard(bool) {
|
|
|
|
LOG;
|
|
|
|
}
|
|
|
|
|
|
|
|
void triggeredOpenImageInNewWindow(bool) {
|
|
|
|
LOG;
|
|
|
|
}
|
|
|
|
|
|
|
|
void triggeredDownloadImageToDisk(bool) {
|
|
|
|
LOG;
|
|
|
|
}
|
|
|
|
|
|
|
|
void triggeredCopyImageToClipboard(bool) {
|
|
|
|
LOG;
|
|
|
|
}
|
|
|
|
|
|
|
|
void triggeredBack(bool) {
|
|
|
|
LOG;
|
|
|
|
}
|
|
|
|
|
|
|
|
void triggeredForward(bool) {
|
|
|
|
LOG;
|
|
|
|
}
|
|
|
|
|
|
|
|
void triggeredStop(bool) {
|
|
|
|
LOG;
|
|
|
|
}
|
|
|
|
|
|
|
|
void triggeredReload(bool) {
|
|
|
|
LOG;
|
|
|
|
}
|
|
|
|
|
|
|
|
void triggeredCut(bool) {
|
|
|
|
LOG;
|
|
|
|
}
|
|
|
|
|
|
|
|
void triggeredCopy(bool) {
|
|
|
|
LOG;
|
|
|
|
}
|
|
|
|
|
|
|
|
void triggeredPaste(bool) {
|
|
|
|
LOG;
|
|
|
|
}
|
|
|
|
|
|
|
|
void triggeredUndo(bool) {
|
|
|
|
LOG;
|
|
|
|
}
|
|
|
|
|
|
|
|
void triggeredRedo(bool) {
|
|
|
|
LOG;
|
|
|
|
}
|
|
|
|
|
|
|
|
void triggeredMoveToNextChar(bool) {
|
|
|
|
LOG;
|
|
|
|
}
|
|
|
|
|
|
|
|
void triggeredMoveToPreviousChar(bool) {
|
|
|
|
LOG;
|
|
|
|
}
|
|
|
|
|
|
|
|
void triggeredMoveToNextWord(bool) {
|
|
|
|
LOG;
|
|
|
|
}
|
|
|
|
|
|
|
|
void triggeredMoveToPreviousWord(bool) {
|
|
|
|
LOG;
|
|
|
|
}
|
|
|
|
|
|
|
|
void triggeredMoveToNextLine(bool) {
|
|
|
|
LOG;
|
|
|
|
}
|
|
|
|
|
|
|
|
void triggeredMoveToPreviousLine(bool) {
|
|
|
|
LOG;
|
|
|
|
}
|
|
|
|
|
|
|
|
void triggeredMoveToStartOfLine(bool) {
|
|
|
|
LOG;
|
|
|
|
}
|
|
|
|
|
|
|
|
void triggeredMoveToEndOfLine(bool) {
|
|
|
|
LOG;
|
|
|
|
}
|
|
|
|
|
|
|
|
void triggeredMoveToStartOfBlock(bool) {
|
|
|
|
LOG;
|
|
|
|
}
|
|
|
|
|
|
|
|
void triggeredMoveToEndOfBlock(bool) {
|
|
|
|
LOG;
|
|
|
|
}
|
|
|
|
|
|
|
|
void triggeredMoveToStartOfDocument(bool) {
|
|
|
|
LOG;
|
|
|
|
}
|
|
|
|
|
|
|
|
void triggeredMoveToEndOfDocument(bool) {
|
|
|
|
LOG;
|
|
|
|
}
|
|
|
|
|
|
|
|
void triggeredSelectNextChar(bool) {
|
|
|
|
LOG;
|
|
|
|
}
|
|
|
|
|
|
|
|
void triggeredSelectPreviousChar(bool) {
|
|
|
|
LOG;
|
|
|
|
}
|
|
|
|
|
|
|
|
void triggeredSelectNextWord(bool) {
|
|
|
|
LOG;
|
|
|
|
}
|
|
|
|
|
|
|
|
void triggeredSelectPreviousWord(bool) {
|
|
|
|
LOG;
|
|
|
|
}
|
|
|
|
|
|
|
|
void triggeredSelectNextLine(bool) {
|
|
|
|
LOG;
|
|
|
|
}
|
|
|
|
|
|
|
|
void triggeredSelectPreviousLine(bool) {
|
|
|
|
LOG;
|
|
|
|
}
|
|
|
|
|
|
|
|
void triggeredSelectStartOfLine(bool) {
|
|
|
|
LOG;
|
|
|
|
}
|
|
|
|
|
|
|
|
void triggeredSelectEndOfLine(bool) {
|
|
|
|
LOG;
|
|
|
|
}
|
|
|
|
|
|
|
|
void triggeredSelectStartOfBlock(bool) {
|
|
|
|
LOG;
|
|
|
|
}
|
|
|
|
|
|
|
|
void triggeredSelectEndOfBlock(bool) {
|
|
|
|
LOG;
|
|
|
|
}
|
|
|
|
|
|
|
|
void triggeredSelectStartOfDocument(bool) {
|
|
|
|
LOG;
|
|
|
|
}
|
|
|
|
|
|
|
|
void triggeredSelectEndOfDocument(bool) {
|
|
|
|
LOG;
|
|
|
|
}
|
|
|
|
|
|
|
|
void triggeredDeleteStartOfWord(bool) {
|
|
|
|
LOG;
|
|
|
|
}
|
|
|
|
|
|
|
|
void triggeredDeleteEndOfWord(bool) {
|
|
|
|
LOG;
|
|
|
|
}
|
|
|
|
|
|
|
|
void triggeredSetTextDirectionDefault(bool) {
|
|
|
|
LOG;
|
|
|
|
}
|
|
|
|
|
|
|
|
void triggeredSetTextDirectionLeftToRight(bool) {
|
|
|
|
LOG;
|
|
|
|
}
|
|
|
|
|
|
|
|
void triggeredSetTextDirectionRightToLeft(bool) {
|
|
|
|
LOG;
|
|
|
|
}
|
|
|
|
|
|
|
|
void triggeredToggleBold(bool) {
|
|
|
|
LOG;
|
|
|
|
}
|
|
|
|
|
|
|
|
void triggeredToggleItalic(bool) {
|
|
|
|
LOG;
|
|
|
|
}
|
|
|
|
|
|
|
|
void triggeredToggleUnderline(bool) {
|
|
|
|
LOG;
|
|
|
|
}
|
|
|
|
|
|
|
|
void triggeredInspectElement(bool) {
|
|
|
|
LOG;
|
|
|
|
}
|
|
|
|
|
|
|
|
void triggeredInsertParagraphSeparator(bool) {
|
|
|
|
LOG;
|
|
|
|
}
|
|
|
|
|
|
|
|
void triggeredInsertLineSeparator(bool) {
|
|
|
|
LOG;
|
|
|
|
}
|
|
|
|
|
|
|
|
void triggeredSelectAll(bool) {
|
|
|
|
LOG;
|
|
|
|
}
|
|
|
|
|
|
|
|
//@}
|
|
|
|
|
|
|
|
//@name QWebPage slots
|
|
|
|
//@{
|
|
|
|
|
|
|
|
void contentsChanged() {
|
|
|
|
LOG;
|
|
|
|
}
|
|
|
|
|
|
|
|
void databaseQuotaExceeded(QWebFrame* frame, QString databaseName) {
|
|
|
|
LOG<<databaseName;
|
|
|
|
}
|
|
|
|
|
|
|
|
void downloadRequested(const QNetworkRequest& request) {
|
|
|
|
LOG;
|
|
|
|
}
|
|
|
|
|
|
|
|
void frameCreated(QWebFrame* frame) {
|
|
|
|
LOG;
|
|
|
|
}
|
|
|
|
|
|
|
|
void geometryChangeRequested(const QRect& geom) {
|
|
|
|
LOG;
|
|
|
|
}
|
|
|
|
|
|
|
|
void linkClicked(const QUrl& url) {
|
|
|
|
LOG<<url.toString();
|
|
|
|
}
|
|
|
|
|
|
|
|
void linkHovered(const QString& link, const QString& title,
|
|
|
|
const QString& textContent) {
|
|
|
|
LOG<<link<<title<<textContent;
|
|
|
|
statusBar()->showMessage(tr("%1", "statusbar for hovered link %1=url")
|
|
|
|
.arg(link));
|
|
|
|
}
|
|
|
|
|
|
|
|
void loadFinished(bool ok) {
|
|
|
|
LOG<<(ok?"succeess":"error");
|
|
|
|
}
|
|
|
|
|
|
|
|
void loadProgress(int progress) {
|
|
|
|
LOG<<progress;
|
|
|
|
}
|
|
|
|
|
|
|
|
void loadStarted() {
|
|
|
|
LOG;
|
|
|
|
}
|
|
|
|
|
|
|
|
void menuBarVisibilityChangeRequested(bool visible) {
|
|
|
|
LOG;
|
|
|
|
}
|
|
|
|
|
|
|
|
void microFocusChanged() {
|
|
|
|
LOG;
|
|
|
|
}
|
|
|
|
|
|
|
|
void printRequested(QWebFrame* frame) {
|
|
|
|
LOG;
|
|
|
|
}
|
|
|
|
|
|
|
|
void repaintRequested(const QRect& dirtyRect) {
|
|
|
|
//LOG;
|
|
|
|
}
|
|
|
|
|
|
|
|
void restoreFrameStateRequested(QWebFrame* frame) {
|
|
|
|
LOG;
|
|
|
|
}
|
|
|
|
|
|
|
|
void saveFrameStateRequested(QWebFrame* frame, QWebHistoryItem* item) {
|
|
|
|
LOG;
|
|
|
|
}
|
|
|
|
|
|
|
|
void scrollRequested(int dx, int dy, const QRect& rectToScroll) {
|
|
|
|
LOG;
|
|
|
|
}
|
|
|
|
|
|
|
|
void selectionChanged() {
|
|
|
|
LOG;
|
|
|
|
}
|
|
|
|
|
|
|
|
void statusBarMessage(const QString& text) {
|
|
|
|
LOG;
|
|
|
|
}
|
|
|
|
|
|
|
|
void statusBarVisibilityChangeRequested(bool visible) {
|
|
|
|
LOG;
|
|
|
|
}
|
|
|
|
|
|
|
|
void toolBarVisibilityChangeRequested(bool visible) {
|
|
|
|
LOG;
|
|
|
|
}
|
|
|
|
|
|
|
|
void unsupportedContent(QNetworkReply* reply) {
|
|
|
|
LOG;
|
|
|
|
statusBar()->showMessage(tr("unsupported content"));
|
|
|
|
_error += tr("<h2>%1</h2><p>URL: %3</p><p>%2</p>")
|
|
|
|
.arg(tr("Unsuported Content"))
|
|
|
|
.arg(networkError(reply->error()))
|
|
|
|
.arg(reply->url().toString());
|
|
|
|
_errorUrl = reply->url();
|
|
|
|
}
|
|
|
|
|
|
|
|
void windowCloseRequested() {
|
|
|
|
LOG;
|
|
|
|
}
|
|
|
|
|
|
|
|
//@}
|
|
|
|
|
|
|
|
//@name QNetworkAccessManager signals
|
|
|
|
//@{
|
|
|
|
|
|
|
|
void authenticationRequired(QNetworkReply* reply,
|
|
|
|
QAuthenticator* authenticator) {
|
|
|
|
LOG;
|
|
|
|
statusBar()->showMessage(tr("authentication required"));
|
|
|
|
_error += tr("<h2>%1</h2><p>URL: %3</p><p>%2</p>")
|
|
|
|
.arg(tr("Authentication Required"))
|
|
|
|
.arg(networkError(reply->error()))
|
|
|
|
.arg(reply->url().toString());
|
|
|
|
_errorUrl = reply->url();
|
|
|
|
}
|
|
|
|
|
|
|
|
void finished(QNetworkReply* reply) {
|
|
|
|
LOG<<(reply->error()==QNetworkReply::NoError?"success":"error");
|
|
|
|
if (reply->error()!=QNetworkReply::NoError) {
|
|
|
|
_error += tr("<h2>%1</h2><p>URL: %3</p><p>%2</p>")
|
|
|
|
.arg(tr("Network Error"))
|
|
|
|
.arg(networkError(reply->error()))
|
|
|
|
.arg(reply->url().toString());
|
|
|
|
_errorUrl = reply->url();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void proxyAuthenticationRequired(const QNetworkProxy& proxy,
|
|
|
|
QAuthenticator* authenticator) {
|
|
|
|
LOG;
|
|
|
|
}
|
|
|
|
|
|
|
|
void sslErrors(QNetworkReply* reply, const QList<QSslError>& errors) {
|
|
|
|
LOG;
|
|
|
|
statusBar()->showMessage(tr("ssl error"));
|
|
|
|
QString e;
|
|
|
|
for (QList<QSslError>::const_iterator err(errors.begin());
|
|
|
|
err!=errors.end(); ++err)
|
|
|
|
e+=tr("<li>%1</li>", "single ssl error").arg(err->errorString());
|
|
|
|
_error += tr("<h2>%1</h2><p>URL: %4</p><p>%2</p>"
|
|
|
|
"<h3>SSL Errors</h3>"
|
|
|
|
"<p><ul>%3</ul></p>")
|
|
|
|
.arg(tr("SSL Error"))
|
|
|
|
.arg(networkError(reply->error()))
|
|
|
|
.arg(e)
|
|
|
|
.arg(reply->url().toString());
|
|
|
|
_errorUrl = reply->url();
|
|
|
|
}
|
|
|
|
|
|
|
|
//@}
|
|
|
|
|
|
|
|
private:
|
|
|
|
|
|
|
|
QLineEdit* _url;
|
|
|
|
QSlider* _zoom;
|
|
|
|
QProgressBar* _progress;
|
|
|
|
QString _home;
|
|
|
|
gui::Proxy* _proxy;
|
|
|
|
bool _kiosk;
|
|
|
|
bool _proxydetection;
|
|
|
|
QString _error;
|
|
|
|
QUrl _errorUrl;
|
|
|
|
QPrinter _printer;
|
|
|
|
SslClientAuthNetworkAccessManager _networkManager;
|
|
|
|
|
|
|
|
};
|
|
|
|
|
|
|
|
#endif
|