closes #9; closes #10; closes #13

swisssurfer/src/browser.hxx

@@ -25,16 +25,21 @@
 #include <QtNetwork/QNetworkAccessManager>
 #include <QtNetwork/QSslError>
 #include <QtNetwork/QNetworkProxy>
-
-#include <proxyface/proxy.hxx>
+#include <QtCore/QTemporaryFile>
+#include <QtCore/QProcess>
+#include <QtCore/QDir>
+#include <QtGui/QFileDialog>
 
 #include <smartcardauth.hxx>
+#include <downloadmanager.hxx>
 
 #include <stdexcept>
 #include <cassert>
-#include <QtCore/QDebug>
 
+#include <QtCore/QDebug>
+#ifndef LOG
 #define LOG qDebug()<<__PRETTY_FUNCTION__
+#endif
 
 extern SmartCardAuth _scAuth;
 
@@ -50,6 +55,10 @@ class SslClientAuthNetworkAccessManager: public QNetworkAccessManager {
     virtual ~SslClientAuthNetworkAccessManager() {
       LOG;
     }
+
+  Q_SIGNALS:
+
+    void created(QNetworkReply*);
     
   protected:
     
@@ -59,8 +68,8 @@ class SslClientAuthNetworkAccessManager: public QNetworkAccessManager {
       LOG<<req.url();
       QNetworkReply* rep
         (QNetworkAccessManager::createRequest(op, req, outgoingData));
-      //qDebug()<<"Reply created: "<<(int)rep;
-      qDebug()<<"Reply to URL: "<<rep->url().toString();
+      created(rep);
+      LOG<<"Reply to URL: "<<rep->url().toString();
       return rep;
     }
 
@@ -72,31 +81,28 @@ class Browser: public QMainWindow, protected Ui::Browser {
 
   public:
 
-    Browser(const QString& url, bool kiosk = false,
-            bool proxydetection = false):
-        _url(0), _home(url), _proxy(0),
-        _kiosk(kiosk) {
+    typedef std::map<QString, std::pair<QString, QString> > MimeTypes;
+
+  public:
+
+    Browser(const QString& url, MimeTypes mimeTypes, bool kiosk = false):
+        _url(0), _find(0), _home(url), _kiosk(kiosk), _mimetypes(mimeTypes) {
       LOG<<url;
+      QNetworkProxyFactory::setUseSystemConfiguration(true);
+      QWebSettings::globalSettings()->setAttribute
+        (QWebSettings::PluginsEnabled, true);
       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))));
-      }
+      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))));
       _toolbar->addWidget(_url = new QLineEdit(_toolbar));
+      on_actionNewTab_triggered();
       _url->setText(url);
       assert(connect(_url, SIGNAL(returnPressed()), SLOT(load())));
       assert(connect(&_networkManager,
@@ -105,19 +111,35 @@ class Browser: public QMainWindow, protected Ui::Browser {
                      &_scAuth,
                      SLOT(extendedContextInitialization(ssl_ctx_st*,
                                                         QSslSocket*))));
+      assert(connect(&_networkManager, SIGNAL(created(QNetworkReply*)),
+                     &_downloadManager, SLOT(add(QNetworkReply*))));
+      
+      assert(connect(&_downloadManager, SIGNAL(progress(qint64, qint64)),
+                     SLOT(progress(qint64, qint64))));
+      assert(connect(&_downloadManager, SIGNAL(started()),
+                     SLOT(started())));
+      assert(connect(&_downloadManager, SIGNAL(finished()),
+                     SLOT(finished())));
+      
       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);
     }
 
+    ~Browser() {
+      LOG;
+      for (DownloadProcesses::iterator it(_downloadProcesses.begin());
+           it!=_downloadProcesses.end(); ++it) {
+        LOG<<"delete:"<<it->second->fileName();
+        delete it->second;
+        it->second = 0;
+        it->first->terminate();
+        delete it->first;
+      }
+    }
+
     QString networkError(QNetworkReply::NetworkError err) {
       LOG<<err;
       switch (err) {
@@ -191,6 +213,7 @@ class Browser: public QMainWindow, protected Ui::Browser {
       }
     }
 
+    //! Whitelisting
     bool check(QUrl page) {
       return true;
     }
@@ -203,82 +226,44 @@ class Browser: public QMainWindow, protected Ui::Browser {
     }
     
     void load(QString page) {
-      if (QUrl(page).scheme()=="") page = "http://"+page;
+      if (QUrl(page).scheme()=="")
+        page = "http://"+page;
+      if (page.contains(QRegExp("^gg[: ]")))
+        page = QString("http://google.com/search?q=%1")
+          .arg(page.mid(3));
+      if (page.contains(QRegExp("^wp[: ]")))
+        page = QString("http://%1.wikipedia.com/wiki/%2")
+          .arg(QLocale::system().name().left(2)).arg(page.mid(3));
       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
+      if (!check(page)) {
+        LOG<<"########## 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;
+      }
+      startDownload(page);
     }
 
-    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));
@@ -290,73 +275,6 @@ class Browser: public QMainWindow, protected Ui::Browser {
       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();
@@ -366,166 +284,187 @@ class Browser: public QMainWindow, protected Ui::Browser {
       QWebView* browser(new QWebView);
       browser->page()->setLinkDelegationPolicy(QWebPage::DelegateAllLinks);
       browser->page()->setNetworkAccessManager(&_networkManager);
+      browser->page()->setForwardUnsupportedContent(true);
+      _url->setFocus();
+      // QWebView
+      assert(connect(browser, SIGNAL(urlChanged(const QUrl&)),
+                     SLOT(urlChanged(const QUrl&))));
+      assert(connect(browser, SIGNAL(linkClicked(const QUrl&)),
+                     SLOT(linkClicked(const QUrl&))));
+      assert(connect(browser, SIGNAL(iconChanged()),
+                     SLOT(iconChanged())));
+      assert(connect(browser, SIGNAL(titleChanged(const QString&)),
+                     SLOT(titleChanged(const QString&))));
+      assert(connect(browser, SIGNAL(statusBarMessage(const QString&)),
+                     SLOT(statusBarMessage(const QString&))));
+      assert(connect(browser, SIGNAL(loadProgress(int)),
+                     SLOT(loadProgress(int))));
+      assert(connect(browser, SIGNAL(loadStarted()),
+                     SLOT(loadStarted())));
+      assert(connect(browser, SIGNAL(loadFinished(bool)),
+                     SLOT(loadFinished(bool))));
+      assert(connect(browser, SIGNAL(iconChanged()),
+                     SLOT(iconChanged())));
       // 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)));
+      assert(connect(browser->pageAction(QWebPage::OpenLink),
+                     SIGNAL(triggered(bool)),
+                     SLOT(triggeredOpenLink(bool))));
+      assert(connect(browser->pageAction(QWebPage::OpenLinkInNewWindow),
+                     SIGNAL(triggered(bool)),
+                     SLOT(triggeredOpenLinkInNewWindow(bool))));
+      assert(connect(browser->pageAction(QWebPage::OpenFrameInNewWindow),
+                     SIGNAL(triggered(bool)),
+                     SLOT(triggeredOpenFrameInNewWindow(bool))));
+      assert(connect(browser->pageAction(QWebPage::DownloadLinkToDisk),
+                     SIGNAL(triggered(bool)),
+                     SLOT(triggeredDownloadLinkToDisk(bool))));
+      assert(connect(browser->pageAction(QWebPage::CopyLinkToClipboard),
+                     SIGNAL(triggered(bool)),
+                     SLOT(triggeredCopyLinkToClipboard(bool))));
+      assert(connect(browser->pageAction(QWebPage::OpenImageInNewWindow),
+                     SIGNAL(triggered(bool)),
+                     SLOT(triggeredOpenImageInNewWindow(bool))));
+      assert(connect(browser->pageAction(QWebPage::DownloadImageToDisk),
+                     SIGNAL(triggered(bool)),
+                     SLOT(triggeredDownloadImageToDisk(bool))));
+      assert(connect(browser->pageAction(QWebPage::CopyImageToClipboard),
+                     SIGNAL(triggered(bool)),
+                     SLOT(triggeredCopyImageToClipboard(bool))));
+      assert(connect(browser->pageAction(QWebPage::Back),
+                     SIGNAL(triggered(bool)),
+                     SLOT(triggeredBack(bool))));
+      assert(connect(browser->pageAction(QWebPage::Forward),
+                     SIGNAL(triggered(bool)),
+                     SLOT(triggeredForward(bool))));
+      assert(connect(browser->pageAction(QWebPage::Stop),
+                     SIGNAL(triggered(bool)),
+                     SLOT(triggeredStop(bool))));
+      assert(connect(browser->pageAction(QWebPage::Reload),
+                     SIGNAL(triggered(bool)),
+                     SLOT(triggeredReload(bool))));
+      assert(connect(browser->pageAction(QWebPage::Cut),
+                     SIGNAL(triggered(bool)),
+                     SLOT(triggeredCut(bool))));
+      assert(connect(browser->pageAction(QWebPage::Copy),
+                     SIGNAL(triggered(bool)),
+                     SLOT(triggeredCopy(bool))));
+      assert(connect(browser->pageAction(QWebPage::Paste),
+                     SIGNAL(triggered(bool)),
+                     SLOT(triggeredPaste(bool))));
+      assert(connect(browser->pageAction(QWebPage::Undo),
+                     SIGNAL(triggered(bool)),
+                     SLOT(triggeredUndo(bool))));
+      assert(connect(browser->pageAction(QWebPage::Redo),
+                     SIGNAL(triggered(bool)),
+                     SLOT(triggeredRedo(bool))));
+      assert(connect(browser->pageAction(QWebPage::MoveToNextChar),
+                     SIGNAL(triggered(bool)),
+                     SLOT(triggeredMoveToNextChar(bool))));
+      assert(connect(browser->pageAction(QWebPage::MoveToPreviousChar),
+                     SIGNAL(triggered(bool)),
+                     SLOT(triggeredMoveToPreviousChar(bool))));
+      assert(connect(browser->pageAction(QWebPage::MoveToNextWord),
+                     SIGNAL(triggered(bool)),
+                     SLOT(triggeredMoveToNextWord(bool))));
+      assert(connect(browser->pageAction(QWebPage::MoveToPreviousWord),
+                     SIGNAL(triggered(bool)),
+                     SLOT(triggeredMoveToPreviousWord(bool))));
+      assert(connect(browser->pageAction(QWebPage::MoveToNextLine),
+                     SIGNAL(triggered(bool)),
+                     SLOT(triggeredMoveToNextLine(bool))));
+      assert(connect(browser->pageAction(QWebPage::MoveToPreviousLine),
+                     SIGNAL(triggered(bool)),
+                     SLOT(triggeredMoveToPreviousLine(bool))));
+      assert(connect(browser->pageAction(QWebPage::MoveToStartOfLine),
+                     SIGNAL(triggered(bool)),
+                     SLOT(triggeredMoveToStartOfLine(bool))));
+      assert(connect(browser->pageAction(QWebPage::MoveToEndOfLine),
+                     SIGNAL(triggered(bool)),
+                     SLOT(triggeredMoveToEndOfLine(bool))));
+      assert(connect(browser->pageAction(QWebPage::MoveToStartOfBlock),
+                     SIGNAL(triggered(bool)),
+                     SLOT(triggeredMoveToStartOfBlock(bool))));
+      assert(connect(browser->pageAction(QWebPage::MoveToEndOfBlock),
+                     SIGNAL(triggered(bool)),
+                     SLOT(triggeredMoveToEndOfBlock(bool))));
+      assert(connect(browser->pageAction(QWebPage::MoveToStartOfDocument),
+                     SIGNAL(triggered(bool)),
+                     SLOT(triggeredMoveToStartOfDocument(bool))));
+      assert(connect(browser->pageAction(QWebPage::MoveToEndOfDocument),
+                     SIGNAL(triggered(bool)),
+                     SLOT(triggeredMoveToEndOfDocument(bool))));
+      assert(connect(browser->pageAction(QWebPage::SelectNextChar),
+                     SIGNAL(triggered(bool)),
+                     SLOT(triggeredSelectNextChar(bool))));
+      assert(connect(browser->pageAction(QWebPage::SelectPreviousChar),
+                     SIGNAL(triggered(bool)),
+                     SLOT(triggeredSelectPreviousChar(bool))));
+      assert(connect(browser->pageAction(QWebPage::SelectNextWord),
+                     SIGNAL(triggered(bool)),
+                     SLOT(triggeredSelectNextWord(bool))));
+      assert(connect(browser->pageAction(QWebPage::SelectPreviousWord),
+                     SIGNAL(triggered(bool)),
+                     SLOT(triggeredSelectPreviousWord(bool))));
+      assert(connect(browser->pageAction(QWebPage::SelectNextLine),
+                     SIGNAL(triggered(bool)),
+                     SLOT(triggeredSelectNextLine(bool))));
+      assert(connect(browser->pageAction(QWebPage::SelectPreviousLine),
+                     SIGNAL(triggered(bool)),
+                     SLOT(triggeredSelectPreviousLine(bool))));
+      assert(connect(browser->pageAction(QWebPage::SelectStartOfLine),
+                     SIGNAL(triggered(bool)),
+                     SLOT(triggeredSelectStartOfLine(bool))));
+      assert(connect(browser->pageAction(QWebPage::SelectEndOfLine),
+                     SIGNAL(triggered(bool)),
+                     SLOT(triggeredSelectEndOfLine(bool))));
+      assert(connect(browser->pageAction(QWebPage::SelectStartOfBlock),
+                     SIGNAL(triggered(bool)),
+                     SLOT(triggeredSelectStartOfBlock(bool))));
+      assert(connect(browser->pageAction(QWebPage::SelectEndOfBlock),
+                     SIGNAL(triggered(bool)),
+                     SLOT(triggeredSelectEndOfBlock(bool))));
+      assert(connect(browser->pageAction(QWebPage::SelectStartOfDocument),
+                     SIGNAL(triggered(bool)),
+                     SLOT(triggeredSelectStartOfDocument(bool))));
+      assert(connect(browser->pageAction(QWebPage::SelectEndOfDocument),
+                     SIGNAL(triggered(bool)),
+                     SLOT(triggeredSelectEndOfDocument(bool))));
+      assert(connect(browser->pageAction(QWebPage::DeleteStartOfWord),
+                     SIGNAL(triggered(bool)),
+                     SLOT(triggeredDeleteStartOfWord(bool))));
+      assert(connect(browser->pageAction(QWebPage::DeleteEndOfWord),
+                     SIGNAL(triggered(bool)),
+                     SLOT(triggeredDeleteEndOfWord(bool))));
+      assert(connect(browser->pageAction(QWebPage::SetTextDirectionDefault),
+                     SIGNAL(triggered(bool)),
+                     SLOT(triggeredSetTextDirectionDefault(bool))));
+      assert(connect(browser->pageAction(QWebPage::SetTextDirectionLeftToRight),
+                     SIGNAL(triggered(bool)),
+                     SLOT(triggeredSetTextDirectionLeftToRight(bool))));
+      assert(connect(browser->pageAction(QWebPage::SetTextDirectionRightToLeft),
+                     SIGNAL(triggered(bool)),
+                     SLOT(triggeredSetTextDirectionRightToLeft(bool))));
+      assert(connect(browser->pageAction(QWebPage::ToggleBold),
+                     SIGNAL(triggered(bool)),
+                     SLOT(triggeredToggleBold(bool))));
+      assert(connect(browser->pageAction(QWebPage::ToggleItalic),
+                     SIGNAL(triggered(bool)),
+                     SLOT(triggeredToggleItalic(bool))));
+      assert(connect(browser->pageAction(QWebPage::ToggleUnderline),
+                     SIGNAL(triggered(bool)),
+                     SLOT(triggeredToggleUnderline(bool))));
+      assert(connect(browser->pageAction(QWebPage::InspectElement),
+                     SIGNAL(triggered(bool)),
+                     SLOT(triggeredInspectElement(bool))));
+      assert(connect(browser->pageAction(QWebPage::InsertParagraphSeparator),
+                     SIGNAL(triggered(bool)),
+                     SLOT(triggeredInsertParagraphSeparator(bool))));
+      assert(connect(browser->pageAction(QWebPage::InsertLineSeparator),
+                     SIGNAL(triggered(bool)),
+                     SLOT(triggeredInsertLineSeparator(bool))));
+      assert(connect(browser->pageAction(QWebPage::SelectAll),
+                     SIGNAL(triggered(bool)),
+                     SLOT(triggeredSelectAll(bool))));
       // QWebPage
       assert(connect(browser->page(), SIGNAL(contentsChanged()),
                      SLOT(contentsChanged())));
@@ -540,19 +479,19 @@ class Browser: public QMainWindow, protected Ui::Browser {
       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(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(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))));
@@ -575,8 +514,8 @@ class Browser: public QMainWindow, protected Ui::Browser {
                      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(statusBarMessage(const QString&)),
+//                      SLOT(statusBarMessage(const QString&))));
       assert(connect(browser->page(),
                      SIGNAL(statusBarVisibilityChangeRequested(bool)),
                      SLOT(statusBarVisibilityChangeRequested(bool))));
@@ -594,9 +533,6 @@ class Browser: public QMainWindow, protected Ui::Browser {
                                                    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*)),
@@ -610,9 +546,14 @@ class Browser: public QMainWindow, protected Ui::Browser {
     }
 
     void on__tabs_currentChanged(int index) {
+      _url->setText(dynamic_cast<QWebView*>(_tabs->currentWidget())
+                    ->url().toString());
+      activateTab();
     }
     
     void on__tabs_tabCloseRequested(int index) {
+      _error.erase(_tabs->widget(index));
+      _errorUrl.erase(_tabs->widget(index));
       _tabs->removeTab(index);
       _tabs->setTabsClosable(_tabs->count()>1);
     }
@@ -641,14 +582,145 @@ class Browser: public QMainWindow, protected Ui::Browser {
       close();
     }
 
-    void on_actionProxySettings_triggered() {
+    void on_actionBack_triggered() {
       LOG;
-      if (_proxy) _proxy->show();
+      dynamic_cast<QWebView*>(_tabs->currentWidget())->history()->back();
     }
 
-    //@name                                                       QWebPage slots
-    //@{
+    void on_actionBack_hovered() {
+      LOG;
+      if (!dynamic_cast<QWebView*>(_tabs->currentWidget())->history()
+          ->backItem().isValid())
+        return;
+      actionBack->setStatusTip
+        (tr("%1 - %2", "statusbar actionBack_hovered %1=url %2=title")
+         .arg(dynamic_cast<QWebView*>(_tabs->currentWidget())->history()
+              ->backItem().url().toString())
+         .arg(dynamic_cast<QWebView*>(_tabs->currentWidget())->history()
+              ->backItem().title()));
+      actionBack->showStatusText(this);
+    }
 
+    void on_actionForward_triggered() {
+      LOG;
+      dynamic_cast<QWebView*>(_tabs->currentWidget())->history()->forward();
+    }
+
+    void on_actionForward_hovered() {
+      LOG;
+      if (!dynamic_cast<QWebView*>(_tabs->currentWidget())->history()
+          ->forwardItem().isValid())
+        return;
+      actionForward->setStatusTip
+        (tr("%1 - %2", "statusbar actionForward_hovered %1=url %2=title")
+         .arg(dynamic_cast<QWebView*>(_tabs->currentWidget())->history()
+              ->forwardItem().url().toString())
+         .arg(dynamic_cast<QWebView*>(_tabs->currentWidget())->history()
+              ->forwardItem().title()));
+      actionForward->showStatusText(this);
+    }
+
+    void on_actionReload_triggered() {
+      LOG;
+      dynamic_cast<QWebView*>(_tabs->currentWidget())->reload();
+    }
+
+    void on_actionStop_triggered() {
+      LOG;
+      _downloadManager.abort();
+    }
+
+    void on_actionFind_triggered() {
+      if (!_find) {
+        statusBar()->addPermanentWidget(_find = new QLineEdit);
+        _find->setText(dynamic_cast<QWebView*>(_tabs->currentWidget())
+                       ->selectedText());
+        assert(connect(_find, SIGNAL(returnPressed()), SLOT(find())));
+      }
+      _find->setFocus();
+    }
+
+    void find() {
+      dynamic_cast<QWebView*>(_tabs->currentWidget())->findText(_find->text());
+    }
+
+    void on_actionUnFind_triggered() {
+      delete _find; _find=0;
+    }
+    
+    void on_actionAbout_triggered() {
+      QMessageBox::aboutQt(this);
+    }
+    
+    //@name                                                       QWebView slots
+    //@{
+    
+    void urlChanged(const QUrl& url) { //!@todo
+      LOG<<url.toString();
+      if (sender()!=_tabs->currentWidget()) return;
+      LOG<<"signal on current tab";
+      if (_url) _url->setText(url.toString());
+    }
+    
+    void linkClicked(const QUrl& url) { //!@todo
+      LOG<<url.toString();
+      if (sender()!=_tabs->currentWidget()) return;
+      LOG<<"signal on current tab";
+      load(url);
+    }
+    
+    void iconChanged() { //!@todo
+      LOG;
+      if (sender()!=_tabs->currentWidget()) return;
+      LOG<<"signal on current tab";
+      setWindowIcon(dynamic_cast<QWebView*>(_tabs->currentWidget())->icon());
+    }
+    
+    void titleChanged(const QString& text) { //!@todo
+      LOG<<text;
+      if (sender()!=_tabs->currentWidget()) return;
+      LOG<<"signal on current tab";
+      _tabs->setTabText(_tabs->indexOf(qobject_cast<QWidget*>(sender())),
+                        trUtf8("%1").arg(text));
+    }
+    
+    void statusBarMessage(const QString& text) { //!@todo
+      LOG<<text;
+      if (sender()!=_tabs->currentWidget()) return;
+      LOG<<"signal on current tab";
+      if (text.size()) statusBar()->showMessage(tr("Info: %1").arg(text));
+    }
+    
+    void loadProgress(int i) {
+      LOG<<i;
+    }
+    
+    void loadStarted() {
+      LOG;
+    }
+    
+    void loadFinished(bool ok) {
+      LOG<<(ok?"success":"error");
+//       if (!ok) {
+//         dynamic_cast<QWebView*>(sender())
+//           ->setHtml(tr("<html><title>Page Load Error</title>"
+//                        "<body><h1>Page Load Error</h1>%1"
+//                        "</body></html>")
+//                     .arg(_error[sender()]),
+//                     _errorUrl[sender()]);
+//       }
+      if (sender()!=_tabs->currentWidget()) return;
+      LOG<<"signal on current tab";
+      _error[sender()].clear();
+      if (ok) statusBar()->showMessage(tr("done."));
+      activateTab();
+    }
+
+    //@}
+
+    //@name                                             QWebPage WebAction slots
+    //@{
+    
     void triggeredOpenLink(bool) {
       LOG;
     }
@@ -886,9 +958,9 @@ class Browser: public QMainWindow, protected Ui::Browser {
       LOG;
     }
     
-    void linkClicked(const QUrl& url) {
-      LOG<<url.toString();
-    }
+//     void linkClicked(const QUrl& url) {
+//       LOG<<url.toString();
+//     }
     
     void linkHovered(const QString& link, const QString& title,
                      const QString& textContent) {
@@ -897,17 +969,17 @@ class Browser: public QMainWindow, protected Ui::Browser {
                                .arg(link));
     }
     
-    void loadFinished(bool ok) {
-      LOG<<(ok?"succeess":"error");
-    }
+//     void loadFinished(bool ok) {
+//       LOG<<(ok?"succeess":"error");
+//     }
     
-    void loadProgress(int progress) {
-      LOG<<progress;
-    }
+//     void loadProgress(int progress) {
+//       LOG<<progress;
+//     }
     
-    void loadStarted() {
-      LOG;
-    }
+//     void loadStarted() {
+//       LOG;
+//     }
     
     void menuBarVisibilityChangeRequested(bool visible) {
       LOG;
@@ -941,9 +1013,9 @@ class Browser: public QMainWindow, protected Ui::Browser {
       LOG;
     }
     
-    void statusBarMessage(const QString& text) {
-      LOG;
-    }
+//     void statusBarMessage(const QString& text) {
+//       LOG;
+//     }
     
     void statusBarVisibilityChangeRequested(bool visible) {
       LOG;
@@ -952,21 +1024,94 @@ class Browser: public QMainWindow, protected Ui::Browser {
     void toolBarVisibilityChangeRequested(bool visible) {
       LOG;
     }
+
+    //@name                                                     handle downloads
+    //@{
     
     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();
+      LOG<<reply->header(QNetworkRequest::ContentTypeHeader).toString();
+      LOG<<"Status:"<<networkError(reply->error());
+      assert(connect(reply, SIGNAL(finished()), SLOT(downloadFinished())));
     }
+
+    void downloadFinished() {
+      QNetworkReply *reply(qobject_cast<QNetworkReply*>(sender()));
+      LOG<<"Location:"<<reply->header(QNetworkRequest::LocationHeader)
+        .toString();
+      LOG<<"Content-Type:"<<reply->header(QNetworkRequest::ContentTypeHeader)
+        .toString();
+      LOG<<"Status:"<<networkError(reply->error());
+      LOG<<"URL:"<<reply->url().toString();
+      LOG<<"File:"<<reply->url().toLocalFile();
+      LOG<<"Path:"<<reply->url().path();
+      MimeTypes::iterator it
+        (_mimetypes.find(reply->header(QNetworkRequest::ContentTypeHeader)
+                         .toString()));
+      if (it!=_mimetypes.end()) {
+        QTemporaryFile *file =
+          new QTemporaryFile(QDir::tempPath()+QDir::separator()
+                             +"swisssurferXXXXXX."+it->second.first, this);
+        file->open();
+        file->write(reply->readAll());
+        file->close();
+        QProcess* process(new QProcess);
+        _downloadProcesses[process] = file;
+        assert(connect(process, SIGNAL(finished(int, QProcess::ExitStatus)),
+                       SLOT(processFinished())));
+        QStringList args(it->second.second.split(" ")
+                         .replaceInStrings("<FILENAME>", file->fileName()));
+        QString prg(args.takeFirst());
+        LOG<<"Running:"<<prg<<args.join(" ");
+        process->start(prg, args);
+      } else {
+        QString saveFile
+          (QFileDialog::getSaveFileName(this, tr("Save File As ..."),
+                                        !reply->url().toLocalFile().isEmpty()
+                                        ?reply->url().toLocalFile()
+                                        :reply->url().path()));
+        if (!saveFile.isEmpty()) {
+          QFile file(saveFile);
+          file.open(QIODevice::WriteOnly);
+          file.write(reply->readAll());
+          file.close();
+        }
+      }
+    }
+
+    void processFinished() {
+      delete _downloadProcesses[qobject_cast<QProcess*>(sender())];
+      _downloadProcesses.erase(qobject_cast<QProcess*>(sender()));
+    }
+
+    //@}
     
     void windowCloseRequested() {
       LOG;
     }
     
+    //@}
+
+    //@name                                              DownloadManager signals
+    //@{
+
+    void progress(qint64 done, qint64 total) {
+      _progress->setMaximum(total);
+      _progress->setValue(done);
+    }
+
+    void started() {
+      actionStop->setEnabled(true);
+      _progress->setRange(0, 0);
+      _progress->setValue(0);
+      _progress->show();
+    }
+        
+    void finished() {
+      LOG;
+      actionStop->setEnabled(false);
+      _progress->hide();
+    }
+
     //@}
     
     //@name                                        QNetworkAccessManager signals
@@ -976,22 +1121,11 @@ class Browser: public QMainWindow, protected Ui::Browser {
                                 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();
-      }
+//       _error[sender()] += tr("<h2>%1</h2><p>URL: %3</p><p>%2</p>")
+//         .arg(tr("Authentication Required"))
+//         .arg(networkError(reply->error()))
+//         .arg(reply->url().toString());
+//       _errorUrl[sender()] = reply->url();
     }
     
     void proxyAuthenticationRequired(const QNetworkProxy& proxy,
@@ -1002,35 +1136,48 @@ class Browser: public QMainWindow, protected Ui::Browser {
     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();
+//       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[sender()] += 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[sender()] = reply->url();
     }
     
     //@}
+
+  private:
+
+    void activateTab() {
+      iconChanged();
+      actionForward->setEnabled(dynamic_cast<QWebView*>(_tabs->currentWidget())
+                                ->history()->canGoForward());
+      actionBack->setEnabled(dynamic_cast<QWebView*>(_tabs->currentWidget())
+                             ->history()->canGoBack());
+    }
     
   private:
     
     QLineEdit* _url;
+    QLineEdit* _find;
     QSlider* _zoom;
     QProgressBar* _progress;
     QString _home;
-    gui::Proxy* _proxy;
     bool _kiosk;
-    bool _proxydetection;
-    QString _error;
-    QUrl _errorUrl;
+    std::map<QObject*, QString> _error;
+    std::map<QObject*, QUrl> _errorUrl;
     QPrinter _printer;
     SslClientAuthNetworkAccessManager _networkManager;
+    DownloadManager _downloadManager;
+    typedef std::map<QProcess*, QTemporaryFile*> DownloadProcesses;
+    DownloadProcesses _downloadProcesses;
+    MimeTypes _mimetypes;
     
 };