surfer/src/browser.hxx

/*! @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/QComboBox>
#include <QtGui/QToolButton>
#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/QSslError>
#include <QtNetwork/QNetworkProxy>
#include <QtCore/QProcess>
#include <QtCore/QDir>
#include <QtGui/QFileDialog>

#include <smartcardauth.hxx>
#include <logincertificate.hxx>
#include <errorlog.hxx>
#include <downloadmanager.hxx>
#include <authentication.hxx>
#include <webpage.hxx>
#include <settings.hxx>
#include <editbookmarks.hxx>
#include <pluginfactory.hxx>
#include <temporaryfile.hxx>
#include <saveorrun.hxx>
#include <sslclientnetworkmanager.hxx>
#include <proxyface/proxy.hxx>

#include <stdexcept>
#include <cassert>

#include <QtCore/QDebug>
#ifndef LOG
#define LOG qDebug()<<__PRETTY_FUNCTION__
#endif

class Browser: public QMainWindow, protected Ui::Browser {

    Q_OBJECT;

  public:

    Browser(const QString& actlib, const QStringList& urls = QStringList(),
            QSettings* settings=0,
            Settings::MimeTypes mimeTypes = Settings::MimeTypes(),
            bool kiosk = false, bool login = true, bool quirks=true):
        _url(0), _find(new ButtonLineEdit),
        _kiosk(kiosk), 
        _settings(mimeTypes, this, settings, !kiosk),
        _errorLog(this), _logincertificate(this),
        _proxy("http://swisssign.com", this),
        _showErrorLog(0),
        _startUrl(urls.size()),
        _quirks(quirks), _search(new ButtonLineEdit),
        _searchEngines(new QComboBox) {
      LOG<<urls;
      _home = "about:blank";
      if (urls.size()) _home = urls.at(0);
      setupUi(this);
      show();
      try {
        _networkManager.scAuth(new SmartCardAuth(actlib, this, login));
      } catch (const std::exception& x) {
        LOG<<"No SmartCard Support:"<<x.what();
      }
      statusBar()->addPermanentWidget(_find);
      _find->add(actionUnFind);
      _find->add(actionClearFind);
      _find->hide();
      statusBar()->addPermanentWidget(_progress = new QProgressBar());
      _progress -> setSizePolicy(QSizePolicy::Minimum, QSizePolicy::Minimum);
      statusBar()->addPermanentWidget(new QLabel("-"));
      statusBar()->addPermanentWidget(_zoom = new QSlider(Qt::Horizontal));
      statusBar()->addPermanentWidget(new QLabel("+"));
      _zoom->setSizePolicy(QSizePolicy::Minimum, QSizePolicy::Minimum);
      _zoom->setMinimum(10);
      _zoom->setMaximum(190);
      _zoom->setValue(100);
      _zoom->setSingleStep(1);
      _zoom->setPageStep(10);
      _zoom->setTickPosition(QSlider::TicksAbove);
      assert(connect(_zoom, SIGNAL(valueChanged(int)), SLOT(zoom(int))));
      if (!_quirks) {
        _toolbar->addAction(actionReload);
        _toolbar->addAction(actionStop);
      }
      if (!_kiosk) {
        QComboBox* combo(new QComboBox(_toolbar));
        _url = combo;
        combo->setInsertPolicy(QComboBox::NoInsert);
        combo->setLineEdit(new ButtonLineEdit(combo));
        combo->setSizeAdjustPolicy(QComboBox::AdjustToMinimumContentsLength);
        combo->setSizePolicy(QSizePolicy(QSizePolicy::Expanding,
                                         QSizePolicy::Preferred));
        combo->setEditable(!_kiosk);
        assert(connect(combo, SIGNAL(currentIndexChanged(const QString&)),
                       SLOT(load(QString))));
        assert(connect(combo->lineEdit(), SIGNAL(returnPressed()),
                       SLOT(load())));
        assert(connect(combo->lineEdit(), SIGNAL(textChanged(QString)),
                       SLOT(goodUrl())));
        if (_quirks) {
          dynamic_cast<ButtonLineEdit*>(combo->lineEdit())->add
            (actionStop);
        dynamic_cast<ButtonLineEdit*>(combo->lineEdit())->add
          (actionReload);
        }
        if (!_quirks) {
          dynamic_cast<ButtonLineEdit*>(combo->lineEdit())->add
            (actionAddBookmark);
          dynamic_cast<ButtonLineEdit*>(combo->lineEdit())->add
            (actionClearLocation);
        }
        _editbookmarks =
          std::auto_ptr<EditBookmarks>(new EditBookmarks(combo, this));
      } else {
        QLineEdit* label(new QLineEdit(_toolbar));
        _url = label;
        label->setReadOnly(true);
        _url->setSizePolicy(QSizePolicy(QSizePolicy::Expanding,
                                        QSizePolicy::Minimum));
      }
      _toolbar->addWidget(_url);
      QFrame* searchFrame(new QFrame);
      searchFrame->setBackgroundRole(QPalette::Base);
      searchFrame->setAutoFillBackground(true);
      QHBoxLayout* layout(new QHBoxLayout);
      layout->addWidget(_searchEngines);
      _searchEngines->setStyleSheet(tr("background-color: white",
                                       "search engines combobox"));
      layout->addWidget(_search);
      searchFrame->setLayout(layout);
      _toolbar->addWidget(searchFrame);
      _search->add(actionSearch);
      if (!_quirks) _search->add(actionClearSearch);
      _search->setSizePolicy(QSizePolicy(QSizePolicy::Fixed,
                                         QSizePolicy::Minimum));
      assert(connect(_search, SIGNAL(returnPressed()),
                     SLOT(on_actionSearch_triggered())));
      if (_quirks) {
        _toolbar->addAction(actionAddBookmark);
        _toolbar->addAction(actionHome);
      }
      assert(connect(&_errorLog, SIGNAL(reset()), SLOT(errorReset())));
      assert(connect(&_networkManager, SIGNAL(finished(QNetworkReply*)),
                     SLOT(finished(QNetworkReply*))));
      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())));
      assert(connect(&_downloadManager, SIGNAL(error(QString)),
                     SLOT(downloadError(QString))));
      assert(connect(&_downloadManager, SIGNAL(metaDataChanged(QNetworkReply*)),
                     SLOT(metaDataChanged(QNetworkReply*))));
      assert(connect(&_settings, SIGNAL(newSettings()), SLOT(newSettings())));
      newSettings();
      on_actionNewTab_triggered();

      if (!settings || _kiosk) {
        actionSettings->setVisible(false);
        actionEditBookmarks->setVisible(false);
      }
      if (_kiosk) {
        actionNew->setEnabled(false);
        actionNew->setVisible(false);
        actionNewTab->setEnabled(false);
        actionNewTab->setVisible(false);
        actionCloseTab->setVisible(false);
      }
      if (!_kiosk && !_startUrl && _settings.flag("SaveWindowState")
          && _settings())
        loadWin();
      if (urls.size()) load(urls.at(0));
      for (int i(1); i<urls.size(); ++i) load(urls.at(i), newTab());
      if (!QSslSocket::supportsSsl())
        QMessageBox::critical(this, tr("SSL Not Supported"),
                              tr("SSL is not supported on your system"));
    }

    ~Browser() {
      LOG;
      for (DownloadProcesses::iterator it(_downloadProcesses.begin());
           it!=_downloadProcesses.end(); ++it) {
        LOG<<"cleanup:"<<it->second->fileName();
        it->second->setAutoRemove(_settings.flag("CloseApps"));
        delete it->second;
        it->second = 0;
        if (_settings.flag("CloseApps")) {
          it->first->terminate();
          delete it->first;
        }
      }
    }

    //! Whitelisting
    bool check(QUrl page) {
      return true;
    }

    QWebView* newTab() {
      QWebView* browser(new QWebView);
      browser->setPage(new WebPage(this, browser));
      browser->page()->setPluginFactory(new PluginFactory);
      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))));
      // QWebPage WebAction
      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())));
      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(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, tr("New Tab")));
      _tabs->setTabsClosable(_tabs->count()>1);
      return browser;
    }

  protected:
    
    void closeEvent(QCloseEvent *event) {
      LOG;
      if (!_kiosk && !_startUrl && _settings.flag("SaveWindowState")
          && _settings())
        saveWin();
      QMainWindow::closeEvent(event);
      QApplication::exit(0);
    }

  private Q_SLOTS:
      
    void load() {
      LOG;
      if (qobject_cast<QComboBox*>(_url))
        load(qobject_cast<QComboBox*>(_url)->currentText());
      else
        load(qobject_cast<QLineEdit*>(_url)->text());
    }
    
    void load(QString page) {
      _settings.replaceSearchEngine(page);
      if (QUrl(page).scheme()=="") page = "http://"+page;
      load(QUrl(page));
    }

    void load(QUrl page, QWebView* view=0) {
      LOG<<page.toString();
      statusBar()->showMessage(tr("Checking: %1").arg(page.toString()));
      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;
      }
      statusBar()->showMessage(tr("Reading: %1").arg(page.toString()));
      if (!page.isValid()) {
        statusBar()->showMessage(tr("Illegal URL: %1").arg(page.errorString()));
        return;
      }
      if (!view) view=qobject_cast<QWebView*>(_tabs->currentWidget());
      view->load(page);
    }

    void newSettings() {
      _searchEngines->clear();
      for (Settings::SearchEngines::const_iterator
             it(_settings.searchEngines().begin());
           it!=_settings.searchEngines().end(); it++)
        if (QFile(":/icons/"+it.key()).exists())
          _searchEngines->addItem(QIcon(":/icons/"+it.key()), "", it.value());
        else
          _searchEngines->addItem(it.key(), it.value());
      if (_searchEngines->count()==0)
        _searchEngines->addItem(QIcon(":/icons/gg"), tr("gg"),
                                tr("http://www.google.com/search?hl=%2&q=%1"));
    }

    void on_actionAddBookmark_triggered() {
      QComboBox* url(qobject_cast<QComboBox*>(_url));
      if (_url) {
        url->addItem(url->currentText());
        QAction* a(_bookmarks->addAction(url->currentText()));
        a->setData(url->currentText());
        connect(a, SIGNAL(triggered(bool)), SLOT(loadFromHistory()));
      }
    }
    
    void on_actionEditBookmarks_triggered() {
      _editbookmarks->show();
    }
    
    void zoom(int i) {
      LOG<<i;
      statusBar()->showMessage(tr("Zoom: %1%").arg(i));
      qobject_cast<QWebView*>(_tabs->currentWidget())->setZoomFactor(i/100.0);
    }

    void  loadFromHistory() {
      load(qobject_cast<QAction*>(sender())->data().toString());
    }
    
    void on_actionHome_activated() {
      LOG;
      load(_home);
    }
    
    void on_actionNew_triggered() {
      LOG;
      QStringList args(QCoreApplication::arguments());
      QString prg(args.takeFirst());
      statusBar()->showMessage(tr("opening new window"), 5000);
      QProcess::startDetached(prg, args);
    }

    void on_actionNewTab_triggered() {
      newTab();
    }

    void on_actionCloseTab_triggered() {
      on__tabs_tabCloseRequested(_tabs->currentIndex());
    }

    void on__tabs_currentChanged(int index) {
      if (qobject_cast<QComboBox*>(_url))
        qobject_cast<QComboBox*>(_url)->setEditText
          (qobject_cast<QWebView*>(_tabs->currentWidget())
           ->url().toString());
      else
        qobject_cast<QLineEdit*>(_url)->setText
          (qobject_cast<QWebView*>(_tabs->currentWidget())
           ->url().toString());
      activateTab();
    }
    
    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*)),
              qobject_cast<QWebView*>(_tabs->currentWidget()),
              SLOT(print(QPrinter*)));
      preview.exec();
    }
    
    void on_actionInstantPrint_triggered() {
      qobject_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_actionBack_triggered() {
      LOG;
      qobject_cast<QWebView*>(_tabs->currentWidget())->history()->back();
    }

    void on_actionBack_hovered() {
      LOG;
      if (!qobject_cast<QWebView*>(_tabs->currentWidget())->history()
          ->backItem().isValid())
        return;
      actionBack->setStatusTip
        (tr("%1 - %2", "statusbar actionBack_hovered %1=url %2=title")
         .arg(qobject_cast<QWebView*>(_tabs->currentWidget())->history()
              ->backItem().url().toString())
         .arg(qobject_cast<QWebView*>(_tabs->currentWidget())->history()
              ->backItem().title()));
      actionBack->showStatusText(this);
    }

    void on_actionForward_triggered() {
      LOG;
      qobject_cast<QWebView*>(_tabs->currentWidget())->history()->forward();
    }

    void on_actionForward_hovered() {
      LOG;
      if (!qobject_cast<QWebView*>(_tabs->currentWidget())->history()
          ->forwardItem().isValid())
        return;
      actionForward->setStatusTip
        (tr("%1 - %2", "statusbar actionForward_hovered %1=url %2=title")
         .arg(qobject_cast<QWebView*>(_tabs->currentWidget())->history()
              ->forwardItem().url().toString())
         .arg(qobject_cast<QWebView*>(_tabs->currentWidget())->history()
              ->forwardItem().title()));
      actionForward->showStatusText(this);
    }

    void on_actionReload_triggered() {
      LOG;
      qobject_cast<QWebView*>(_tabs->currentWidget())->reload();
    }

    void on_actionStop_triggered() {
      LOG;
      for (int i(0); i<_tabs->count(); ++i)
        qobject_cast<QWebView*>(_tabs->widget(i))->stop();
      _downloadManager.abort();
    }

    void on_actionClearLocation_triggered() {
      if (!qobject_cast<QComboBox*>(_url)) return;
      qobject_cast<QComboBox*>(_url)->clearEditText();
      qobject_cast<QComboBox*>(_url)->setFocus();
    }

    void on_actionClearFind_triggered() {
      _find->clear();
      _find->setFocus();
    }

    void on_actionFind_triggered() {
      if (_find->isHidden()) {
        _find->setText(qobject_cast<QWebView*>(_tabs->currentWidget())
                       ->selectedText());
        _find->show();
      }
      disconnect(_find, SIGNAL(returnPressed()), this, SLOT(rfind()));
      disconnect(_find, SIGNAL(textEdited(QString)), this, SLOT(rfind()));
      assert(connect(_find, SIGNAL(returnPressed()), SLOT(find())));
      assert(connect(_find, SIGNAL(textEdited(QString)), SLOT(find())));
      _find->changeStyleSheet(tr("background-color: white", "neutral find"));
      _find->setFocus();
    }

    void on_actionReverseFind_triggered() {
      if (_find->isHidden()) {
        _find->setText(qobject_cast<QWebView*>(_tabs->currentWidget())
                       ->selectedText());
        _find->show();
      }
      disconnect(_find, SIGNAL(returnPressed()), this, SLOT(find()));
      disconnect(_find, SIGNAL(textEdited(QString)), this, SLOT(find()));
      assert(connect(_find, SIGNAL(returnPressed()), SLOT(rfind())));
      assert(connect(_find, SIGNAL(textEdited(QString)), SLOT(rfind())));
      _find->changeStyleSheet(tr("background-color: white", "neutral find"));
      _find->setFocus();
    }

    void find(const QString& txt=QString()) {
      if (qobject_cast<QWebView*>(_tabs->currentWidget())->findText
          (_find->text(),
           QWebPage::FindWrapsAroundDocument))
        _find->changeStyleSheet(tr("background-color: #ADA", "text found"));
      else
        _find->changeStyleSheet(tr("background-color: #F77", "text not found"));
    }

    void rfind(const QString& txt=QString()) {
      if(qobject_cast<QWebView*>(_tabs->currentWidget())->findText
         (_find->text(),
          QWebPage::FindWrapsAroundDocument
          |QWebPage::FindBackward))
        _find->changeStyleSheet(tr("background-color: #ADA", "text found"));
      else
        _find->changeStyleSheet(tr("background-color: #F77", "text not found"));
    }

    void on_actionUnFind_triggered() {
      _find->hide();
    }
    
    void on_actionSearch_triggered() {
      load(_searchEngines->itemData(_searchEngines->currentIndex()).toString()
           .arg(_search->text())
           .arg(QLocale::system().name().left(2)));
    }

    void on_actionClearSearch_triggered() {
      _search->clear();
    }

    void on_actionProxy_triggered() {
      _proxy.show();
    }

    void on_actionLoginCertificate_triggered() {
      _logincertificate.show();
    }

    void on_actionErrorLog_triggered() {
      _errorLog.show();
    }
    
    void on_actionAbout_triggered() {
      QMessageBox::about(this, tr("About"),
                         tr("%8\n"
                            "Version: %1\n"
                            "Builddate: %2\n"
                            "Libraries:\n"
                            "%3\n"
                            "%4\n"
                            "qt-%5 (%6)\n"
                            "openssl-%7")
                         .arg(VERSION)
                         .arg(BUILDDATE)
                         .arg(QString::fromStdString(proxy::version()))
                         .arg(QString::fromStdString(pcsc::version()))
                         .arg(qVersion())
                         .arg(QT_VERSION_STR)
                         .arg(SHLIB_VERSION_NUMBER)
                         .arg(QApplication::applicationName()));
    }
    
    void on_actionSettings_triggered() {
      _settings.show();
    }

    void on_actionSaveWindowState_triggered() {
      saveWin();
    }

    void on_actionLoadWindowState_triggered() {
      loadWin();
    }

    void saveWin() {
      LOG<<"Save Window State";
      if (!_settings()) return;
      QStringList urls;
      if (qobject_cast<QComboBox*>(_url))
        for (int i(0); i<qobject_cast<QComboBox*>(_url)->count(); ++i)
          urls<<qobject_cast<QComboBox*>(_url)->itemText(i);
      _settings()->setValue("Window/Urls", urls);
      QStringList tabs;
      for (int i(0); i<_tabs->count(); ++i)
        tabs<<qobject_cast<QWebView*>(_tabs->widget(i))->url().toString();
      _settings()->setValue("Window/Tabs", tabs);
      _settings()->setValue("Window/CurrentTab", _tabs->currentIndex());
      _settings()->setValue("Window/Geometry", saveGeometry());
      _settings()->setValue("Window/WindowState", saveState());
    }

    void loadWin() {
      LOG;
      QStringList urls(_settings()->value("Window/Urls").toStringList());
      urls.sort();
      urls.removeDuplicates();
      if (qobject_cast<QComboBox*>(_url)) {
        qobject_cast<QComboBox*>(_url)->clear();
        qobject_cast<QComboBox*>(_url)->addItems(urls);
      }
      _bookmarks->clear();
      for (QStringList::iterator it(urls.begin()); it!=urls.end(); ++it) {
        QAction* a(_bookmarks->addAction(*it));
        a->setData(*it);
        connect(a, SIGNAL(triggered(bool)), SLOT(loadFromHistory()));
      }
      QStringList tabs(_settings()->value("Window/Tabs").toStringList());
      int oldCnt(_tabs->count());
      for (QStringList::iterator it(tabs.begin()); it!=tabs.end(); ++it) {
        LOG<<"-------------------------------------------------------------";
        load(*it, newTab());
        LOG<<"+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++";
      }
      for (int i(0); i<oldCnt && _tabs->count()>1; ++i) _tabs->removeTab(0);
      _tabs->setTabsClosable(_tabs->count()>1);
      _tabs->setCurrentIndex(_settings()->value("Window/CurrentTab").toInt());
      restoreGeometry(_settings()->value("Window/Geometry").toByteArray());
      restoreState(_settings()->value("Window/WindowState").toByteArray());
    }
    
    //@name                                                       QWebView slots
    //@{
    
    void urlChanged(const QUrl& url) {
      LOG<<url.toString();
      if (sender()!=_tabs->currentWidget()) return;
      LOG<<"signal on current tab";
      if (qobject_cast<QComboBox*>(_url))
        qobject_cast<QComboBox*>(_url)->setEditText(url.toString());
      else
        qobject_cast<QLineEdit*>(_url)->setText(url.toString());
    }
    
    void linkClicked(const QUrl& url) {
      LOG<<url.toString();
      load(url, qobject_cast<QWebView*>(sender()));
    }
    
    void iconChanged() {
      LOG;
      QWebView* view(qobject_cast<QWebView*>(sender()));
      int index = _tabs->indexOf(view);
      if (index<0) return;
      QIcon icon(QWebSettings::iconForUrl(view->url()));
      if (icon.isNull()) {
        LOG<<"Icon for URL is Null"<<view->url();
        QPixmap pixmap(QWebSettings::webGraphic
                       (QWebSettings::DefaultFrameIconGraphic));
        if (!pixmap.isNull()) icon = pixmap;
      } else icon = icon.pixmap(16, 16);
      if (icon.isNull()) LOG<<"Icon is still null";
      _tabs->setTabIcon(index, icon);
    }
    
    void titleChanged(const QString& text) {
      LOG<<text;
      _tabs->setTabText(_tabs->indexOf(qobject_cast<QWidget*>(sender())),
                        trUtf8("%1").arg(text));
    }
    
    void statusBarMessage(const QString& text) {
      LOG<<text;
      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");
      QSize sz(qobject_cast<QWebView*>(_tabs->currentWidget())->size());
      qobject_cast<QWebView*>(_tabs->currentWidget())->resize(0,0);
      qobject_cast<QWebView*>(_tabs->currentWidget())->resize(sz);
      if (ok) {
        statusBar()->showMessage(tr("done."));
        goodUrl();
      }
      activateTab();
    }

    //@}

    //@name                                             QWebPage WebAction slots
    //@{
    
    void triggeredOpenLink(bool) {
      LOG<<qobject_cast<QAction*>(sender())->data().toString();
    }
    
    void triggeredOpenLinkInNewWindow(bool) {
      LOG<<qobject_cast<QAction*>(sender())->data().toString();
    }
    
    void triggeredOpenFrameInNewWindow(bool) {
      LOG<<qobject_cast<QAction*>(sender())->data().toString();
    }
    
    void triggeredDownloadLinkToDisk(bool) {
      LOG<<qobject_cast<QAction*>(sender())->data().toString();
    }
    
    void triggeredCopyLinkToClipboard(bool) {
      LOG<<qobject_cast<QAction*>(sender())->data().toString();
    }
    
    void triggeredOpenImageInNewWindow(bool) {
      LOG<<qobject_cast<QAction*>(sender())->data().toString();
    }
    
    void triggeredDownloadImageToDisk(bool) {
      LOG<<qobject_cast<QAction*>(sender())->data().toString();
    }
    
    void triggeredCopyImageToClipboard(bool) {
      LOG<<qobject_cast<QAction*>(sender())->data().toString();
    }
    
    void triggeredBack(bool) {
      LOG<<qobject_cast<QAction*>(sender())->data().toString();
    }
    
    void triggeredForward(bool) {
      LOG<<qobject_cast<QAction*>(sender())->data().toString();
    }
    
    void triggeredStop(bool) {
      LOG<<qobject_cast<QAction*>(sender())->data().toString();
    }
    
    void triggeredReload(bool) {
      LOG<<qobject_cast<QAction*>(sender())->data().toString();
    }
    
    void triggeredCut(bool) {
      LOG<<qobject_cast<QAction*>(sender())->data().toString();
    }
    
    void triggeredCopy(bool) {
      LOG<<qobject_cast<QAction*>(sender())->data().toString();
    }
    
    void triggeredPaste(bool) {
      LOG<<qobject_cast<QAction*>(sender())->data().toString();
    }
    
    void triggeredUndo(bool) {
      LOG<<qobject_cast<QAction*>(sender())->data().toString();
    }
    
    void triggeredRedo(bool) {
      LOG<<qobject_cast<QAction*>(sender())->data().toString();
    }
    
    void triggeredMoveToNextChar(bool) {
      LOG<<qobject_cast<QAction*>(sender())->data().toString();
    }
    
    void triggeredMoveToPreviousChar(bool) {
      LOG<<qobject_cast<QAction*>(sender())->data().toString();
    }
    
    void triggeredMoveToNextWord(bool) {
      LOG<<qobject_cast<QAction*>(sender())->data().toString();
    }
    
    void triggeredMoveToPreviousWord(bool) {
      LOG<<qobject_cast<QAction*>(sender())->data().toString();
    }
    
    void triggeredMoveToNextLine(bool) {
      LOG<<qobject_cast<QAction*>(sender())->data().toString();
    }
    
    void triggeredMoveToPreviousLine(bool) {
      LOG<<qobject_cast<QAction*>(sender())->data().toString();
    }
    
    void triggeredMoveToStartOfLine(bool) {
      LOG<<qobject_cast<QAction*>(sender())->data().toString();
    }
    
    void triggeredMoveToEndOfLine(bool) {
      LOG<<qobject_cast<QAction*>(sender())->data().toString();
    }
    
    void triggeredMoveToStartOfBlock(bool) {
      LOG<<qobject_cast<QAction*>(sender())->data().toString();
    }
    
    void triggeredMoveToEndOfBlock(bool) {
      LOG<<qobject_cast<QAction*>(sender())->data().toString();
    }
    
    void triggeredMoveToStartOfDocument(bool) {
      LOG<<qobject_cast<QAction*>(sender())->data().toString();
    }
    
    void triggeredMoveToEndOfDocument(bool) {
      LOG<<qobject_cast<QAction*>(sender())->data().toString();
    }
    
    void triggeredSelectNextChar(bool) {
      LOG<<qobject_cast<QAction*>(sender())->data().toString();
    }
    
    void triggeredSelectPreviousChar(bool) {
      LOG<<qobject_cast<QAction*>(sender())->data().toString();
    }
    
    void triggeredSelectNextWord(bool) {
      LOG<<qobject_cast<QAction*>(sender())->data().toString();
    }
    
    void triggeredSelectPreviousWord(bool) {
      LOG<<qobject_cast<QAction*>(sender())->data().toString();
    }
    
    void triggeredSelectNextLine(bool) {
      LOG<<qobject_cast<QAction*>(sender())->data().toString();
    }
    
    void triggeredSelectPreviousLine(bool) {
      LOG<<qobject_cast<QAction*>(sender())->data().toString();
    }
    
    void triggeredSelectStartOfLine(bool) {
      LOG<<qobject_cast<QAction*>(sender())->data().toString();
    }
    
    void triggeredSelectEndOfLine(bool) {
      LOG<<qobject_cast<QAction*>(sender())->data().toString();
    }
    
    void triggeredSelectStartOfBlock(bool) {
      LOG<<qobject_cast<QAction*>(sender())->data().toString();
    }
    
    void triggeredSelectEndOfBlock(bool) {
      LOG<<qobject_cast<QAction*>(sender())->data().toString();
    }
    
    void triggeredSelectStartOfDocument(bool) {
      LOG<<qobject_cast<QAction*>(sender())->data().toString();
    }
    
    void triggeredSelectEndOfDocument(bool) {
      LOG<<qobject_cast<QAction*>(sender())->data().toString();
    }
    
    void triggeredDeleteStartOfWord(bool) {
      LOG<<qobject_cast<QAction*>(sender())->data().toString();
    }
    
    void triggeredDeleteEndOfWord(bool) {
      LOG<<qobject_cast<QAction*>(sender())->data().toString();
    }
    
    void triggeredSetTextDirectionDefault(bool) {
      LOG<<qobject_cast<QAction*>(sender())->data().toString();
    }
    
    void triggeredSetTextDirectionLeftToRight(bool) {
      LOG<<qobject_cast<QAction*>(sender())->data().toString();
    }
    
    void triggeredSetTextDirectionRightToLeft(bool) {
      LOG<<qobject_cast<QAction*>(sender())->data().toString();
    }
    
    void triggeredToggleBold(bool) {
      LOG<<qobject_cast<QAction*>(sender())->data().toString();
    }
    
    void triggeredToggleItalic(bool) {
      LOG<<qobject_cast<QAction*>(sender())->data().toString();
    }
    
    void triggeredToggleUnderline(bool) {
      LOG<<qobject_cast<QAction*>(sender())->data().toString();
    }
    
    void triggeredInspectElement(bool) {
      LOG<<qobject_cast<QAction*>(sender())->data().toString();
    }
    
    void triggeredInsertParagraphSeparator(bool) {
      LOG<<qobject_cast<QAction*>(sender())->data().toString();
    }
    
    void triggeredInsertLineSeparator(bool) {
      LOG<<qobject_cast<QAction*>(sender())->data().toString();
    }
    
    void triggeredSelectAll(bool) {
      LOG<<qobject_cast<QAction*>(sender())->data().toString();
    }
    
    //@}

    //@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;
    }

    //@name                                                     handle downloads
    //@{
    
    void unsupportedContent(QNetworkReply* reply) {
      LOG<<reply->header(QNetworkRequest::ContentTypeHeader).toString();
      LOG<<"Status:"<<_downloadManager.networkError(reply->error());
      QList<QNetworkReply::RawHeaderPair> rh(reply->rawHeaderPairs());
      for(QList<QNetworkReply::RawHeaderPair>::iterator it(rh.begin());
          it!=rh.end(); ++it) {
        LOG<<"RawHeader:"<<it->first<<it->second;
      }
      if (reply->isFinished())
        handleContent(reply);
      else
        assert(connect(reply, SIGNAL(finished()), SLOT(downloadFinished())));
    }

    void downloadFinished() {
      LOG;
      QNetworkReply *reply(qobject_cast<QNetworkReply*>(sender()));
      handleContent(reply);
    }

    //! check and handle content that is defined in settings
    void metaDataChanged(QNetworkReply* reply) {
      QString filename
        (QString::fromUtf8(reply->rawHeader("Content-Disposition")));
      if (filename.contains
          (QRegExp("^\\s*attachment\\s*;\\s*filename\\s*=\\s*\"[^\"]+\""))) {
        LOG<<"From Content-Disposition";
        filename = filename.replace
          (QRegExp("^\\s*attachment\\s*;\\s*filename\\s*=\\s*\"([^\"]+)\".*"),
           "\\1");
      } else {
        LOG<<"From path";
        filename =
          QFileInfo(!reply->url().toLocalFile().isEmpty()
                    ?reply->url().toLocalFile()
                    :reply->url().path()).fileName();
      }
      LOG<<"Filename:"<<filename;
      QStringList type
        (_settings.mimetype
         (reply->header(QNetworkRequest::ContentTypeHeader).toString(),
          filename));
      if (!type.isEmpty()) unsupportedContent(reply);
    }

    void handleContent(QNetworkReply* reply) {
      LOG<<"Location:"<<reply->header(QNetworkRequest::LocationHeader)
        .toString();
      LOG<<"Content-Type:"<<reply->header(QNetworkRequest::ContentTypeHeader)
        .toString();
      LOG<<"Content-Disposition:"<<reply->rawHeader("Content-Disposition");
      LOG<<"Status:"<<_downloadManager.networkError(reply->error());
      LOG<<"URL:"<<reply->url().toString();
      LOG<<"File:"<<reply->url().toLocalFile();
      LOG<<"Path:"<<reply->url().path();
      if (reply->error()!=QNetworkReply::NoError) {
        LOG<<"Error:"<<_downloadManager.networkError(reply->error());
        return;
      }
      QString filename
        (QString::fromUtf8(reply->rawHeader("Content-Disposition")));
      if (filename.contains
          (QRegExp("^\\s*attachment\\s*;\\s*filename\\s*=\\s*\"[^\"]+\""))) {
        LOG<<"From Content-Disposition";
        filename = filename.replace
          (QRegExp("^\\s*attachment\\s*;\\s*filename\\s*=\\s*\"([^\"]+)\".*"),
           "\\1");
      } else {
        LOG<<"From path";
        filename =
          QFileInfo(!reply->url().toLocalFile().isEmpty()
                    ?reply->url().toLocalFile()
                    :reply->url().path()).fileName();
      }
      LOG<<"Filename:"<<filename;
      QStringList type
        (_settings.mimetype
         (reply->header(QNetworkRequest::ContentTypeHeader).toString(),
          filename));
      if (!type.isEmpty()) {
        filename.replace(QRegExp("^(.*)\\."+type.at(0)+"$"),
                         "\\1"); // remove extension
        run(reply, filename+"."+type.at(0), type.at(1));
      } else {
        SaveOrRunDialog choice(_kiosk, this);
        choice.setup(filename,
                     reply->header(QNetworkRequest::ContentTypeHeader)
                     .toString(),
                     reply->url().host());
        if (choice.exec()==QDialog::Accepted) {
          if (choice.save()) {
            QFile file(choice.sor()->filename());
            file.open(QIODevice::WriteOnly);
            file.write(reply->readAll());
            file.close();
          } else if (choice.run()) {
            run(reply, filename, choice.sor()->program()+" %1");
          } else {
            // ...
          }
        }
      }
    }

    void run(QNetworkReply* reply, QString filename, QString command) {
      TemporaryFile *file(new TemporaryFile
                            (QDir::tempPath()+QDir::separator()
                             +filename));
      file->open();
      reply->seek(0);
      file->write(reply->readAll());
      file->close();
      LOG<<"Stored as:"<<file->fileName();
      statusBar()->showMessage(tr("launching application ..."), 5000);
      QProcess* process(new QProcess);
      _downloadProcesses[process] = file;
      assert(connect(process, SIGNAL(finished(int, QProcess::ExitStatus)),
                     SLOT(processFinished())));
      QStringList args(command.split(" ")
                       .replaceInStrings("%1", file->fileName()));
      QString prg(args.takeFirst());
      LOG<<"Running:"<<prg<<args.join(" ");
      process->start(prg, args);
    }

    void processFinished() {
      LOG;
      if (_downloadProcesses.find(qobject_cast<QProcess*>(sender()))
          == _downloadProcesses.end()) return;
      if (_downloadProcesses[qobject_cast<QProcess*>(sender())])
        _downloadProcesses[qobject_cast<QProcess*>(sender())]
          ->setAutoRemove(true);
      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() {
      QApplication::setOverrideCursor(QCursor(Qt::WaitCursor));
      if (_quirks) {
        actionStop->setEnabled(true);
      } else {
        actionStop->setVisible(true);
        actionReload->setVisible(false);
      }
      _progress->setRange(0, 0);
      _progress->setValue(0);
      _progress->setEnabled(true);
      _progress->show();
    }
        
    void finished() {
      LOG;
      QApplication::restoreOverrideCursor();
      if (_quirks) {
        actionStop->setEnabled(false);
      } else {
        actionStop->setVisible(false);
        actionReload->setVisible(true);
      }
      _progress->setRange(0, 1);
      _progress->setValue(1);
      _progress->setEnabled(false);
    }

    void finished(QNetworkReply *r) {
      LOG;
      if (r->error()!=QNetworkReply::NoError &&
          r->error()!=QNetworkReply::OperationCanceledError) {
        statusBar()->showMessage(DownloadManager::networkError(r->error()));
        badUrl();
        if (!_showErrorLog) {
          statusBar()->addPermanentWidget
            ((_showErrorLog = new QPushButton(QIcon(":/icons/error"),
                                              tr("errors", "show error log"))));
          assert(connect(_showErrorLog, SIGNAL(clicked(bool)),
                         actionErrorLog, SLOT(trigger())));
        }
        _showErrorLog->show();
      }
    }

    void errorReset() {
      LOG;
      _showErrorLog->hide();
    }

    void badUrl() {
      if (qobject_cast<QComboBox*>(_url))
        dynamic_cast<ButtonLineEdit*>
          (qobject_cast<QComboBox*>(_url)->lineEdit())
          ->changeStyleSheet(tr("background-color: #F77", "invalid url"));
      else
        qobject_cast<QLineEdit*>(_url)
          ->setStyleSheet(tr("background-color: #F77", "invalid url"));
    }

    void goodUrl() {
      if (qobject_cast<QComboBox*>(_url))
        dynamic_cast<ButtonLineEdit*>
          (qobject_cast<QComboBox*>(_url)->lineEdit())
          ->changeStyleSheet(tr("background-color: white", "valid url"));
      else
        qobject_cast<QLineEdit*>(_url)
          ->setStyleSheet(tr("background-color: white", "valid url"));
    }

    void downloadError(QString error) {
      _errorLog.append(error);
    }

    //@}
    
    //@name                                        QNetworkAccessManager signals
    //@{

    void authenticationRequired(QNetworkReply* reply,
                                QAuthenticator* authenticator) {
      LOG<<reply->url().toString()<<authenticator->realm();
      statusBar()->showMessage(tr("authentication required"));
      Authentication auth(authenticator, this);
      if (auth.exec()==QDialog::Rejected) reply->abort();
    }
    
    void proxyAuthenticationRequired(const QNetworkProxy& proxy,
                                     QAuthenticator* authenticator) {
      LOG;
    }
    
    void sslErrors(QNetworkReply* reply, const QList<QSslError>& errors) {
      LOG;
      statusBar()->showMessage(tr("ssl error"));
    }
    
    //@}

  private:

    void activateTab() {
      iconChanged();
      QWebHistory* history(qobject_cast<QWebView*>(_tabs->currentWidget())
                          ->history());
      actionForward->setEnabled(history->canGoForward());
      actionBack->setEnabled(history->canGoBack());
      _history->clear();
      QList<QWebHistoryItem> items(history->items());
      for (int i = 0; i < items.size(); ++i) {
        QAction* a(_history->addAction(items[i].title()));
        a->setData(items[i].url());
        connect(a, SIGNAL(triggered(bool)), SLOT(loadFromHistory()));
      }
    }

  private:

    class ButtonLineEdit: public QLineEdit {
      public:
        ButtonLineEdit(QWidget* p=0): QLineEdit(p) {
          LOG;
        }
        QToolButton* add(QAction* a) {
          LOG;
          QToolButton* b(new QToolButton(this));
          b->setDefaultAction(a);
          add(b);
          return b;
        }
        ButtonLineEdit& add(QToolButton* b) {
          LOG;
          b->setParent(this);
          b->setStyleSheet("QToolButton { border: none; padding: 0; }");
          b->setCursor(Qt::ArrowCursor);
          _buttons.push_back(b);
          resizeEvent(0);
          return *this;
        }
        ButtonLineEdit& changeStyleSheet(QString s) {
          LOG;
          _style = s;
          resizeEvent(0);
          return *this;
        }
      protected:
         void resizeEvent(QResizeEvent*) {
           QSize sz;
           int frameWidth = style()->pixelMetric(QStyle::PM_DefaultFrameWidth);
           for (Buttons::iterator it(_buttons.begin());
                it!=_buttons.end(); ++it) {
             if (sz.isEmpty()) sz = (*it)->sizeHint();
             else sz.setWidth(sz.width()+(*it)->sizeHint().width());
             (*it)->move(rect().right() - frameWidth - sz.width(),
                         (rect().bottom() + 1 - (*it)->sizeHint().height())/2);
           }
           setStyleSheet(QString("QLineEdit { padding-right: %1px; %2 }")
                         .arg(sz.width() + frameWidth + 1)
                         .arg(_style));
         }
      private:
        typedef QList<QToolButton*> Buttons;
        Buttons _buttons;
        QString _style;
    };

  private:
    
    QWidget* _url;
    ButtonLineEdit* _find;
    QSlider* _zoom;
    QProgressBar* _progress;
    QString _home;
    bool _kiosk;
    QPrinter _printer;
    SslClientAuthNetworkAccessManager _networkManager;
    DownloadManager _downloadManager;
    typedef std::map<QProcess*, TemporaryFile*> DownloadProcesses;
    DownloadProcesses _downloadProcesses;
    Settings _settings;
    ErrorLog _errorLog;
    LoginCertificate _logincertificate;
    gui::Proxy _proxy;
    QPushButton* _showErrorLog;
    std::auto_ptr<EditBookmarks> _editbookmarks;
    bool _startUrl;
    bool _quirks;
    ButtonLineEdit* _search;
    QComboBox* _searchEngines;
};
#endif