TEST_F(WebPluginContainerTest, PrintAllPages)
{
URLTestHelpers::registerMockedURLFromBaseURL(WebString::fromUTF8(m_baseURL.c_str()), WebString::fromUTF8("test.pdf"), WebString::fromUTF8("application/pdf"));
TestPluginWebFrameClient pluginWebFrameClient; // Must outlive webViewHelper.
FrameTestHelpers::WebViewHelper webViewHelper;
WebView* webView = webViewHelper.initializeAndLoad(m_baseURL + "test.pdf", true, &pluginWebFrameClient);
ASSERT(webView);
webView->updateAllLifecyclePhases();
runPendingTasks();
WebFrame* frame = webView->mainFrame();
WebPrintParams printParams;
printParams.printContentArea.width = 500;
printParams.printContentArea.height = 500;
frame->printBegin(printParams);
SkPictureRecorder recorder;
frame->printPagesWithBoundaries(recorder.beginRecording(IntRect()), WebSize());
frame->printEnd();
ASSERT(pluginWebFrameClient.printedAtLeastOnePage());
}
void TabWidget::currentChanged(int index)
{
WebView *webView = this->webView(index);
if (!webView)
return;
Q_ASSERT(m_lineEdits->count() == count());
WebView *oldWebView = this->webView(m_lineEdits->currentIndex());
if (oldWebView) {
disconnect(oldWebView, SIGNAL(statusBarMessage(const QString&)),
this, SIGNAL(showStatusBarMessage(const QString&)));
disconnect(oldWebView->page(), SIGNAL(linkHovered(const QString&, const QString&, const QString&)),
this, SIGNAL(linkHovered(const QString&)));
disconnect(oldWebView, SIGNAL(loadProgress(int)),
this, SIGNAL(loadProgress(int)));
}
connect(webView, SIGNAL(statusBarMessage(const QString&)),
this, SIGNAL(showStatusBarMessage(const QString&)));
connect(webView->page(), SIGNAL(linkHovered(const QString&, const QString&, const QString&)),
this, SIGNAL(linkHovered(const QString&)));
connect(webView, SIGNAL(loadProgress(int)),
this, SIGNAL(loadProgress(int)));
for (int i = 0; i < m_actions.count(); ++i) {
WebActionMapper *mapper = m_actions[i];
mapper->updateCurrent(webView->page());
}
emit setCurrentTitle(webView->title());
m_lineEdits->setCurrentIndex(index);
emit loadProgress(webView->progress());
emit showStatusBarMessage(webView->lastStatusBarText());
if (webView->url().isEmpty())
m_lineEdits->currentWidget()->setFocus();
else
webView->setFocus();
}
void StatusBarMessage::showMessage(const QString &message)
{
if (m_window->statusBar()->isVisible()) {
const static QChar LRE(0x202a);
m_window->statusBar()->showMessage(message.isRightToLeft() ? message : (LRE + message));
}
#ifdef Q_OS_WIN
else if (mApp->activeWindow() == m_window) {
#else
else {
#endif
WebView* view = m_window->weView();
m_statusBarText->setText(message);
m_statusBarText->setMaximumWidth(view->width() - 20);
m_statusBarText->resize(m_statusBarText->sizeHint());
QPoint position(0, view->height() - m_statusBarText->height());
const QRect statusRect = QRect(view->mapToGlobal(QPoint(0, position.y())), m_statusBarText->size());
if (statusRect.contains(QCursor::pos())) {
position.setY(position.y() - m_statusBarText->height());
}
m_statusBarText->move(view->mapToGlobal(position));
m_statusBarText->show(view);
}
}
void StatusBarMessage::clearMessage()
{
if (m_window->statusBar()->isVisible()) {
m_window->statusBar()->showMessage(QString());
}
else {
m_statusBarText->hideDelayed();
}
}
void WebVisitedLinkStore::populateVisitedLinksIfNeeded(Page& sourcePage)
{
if (m_visitedLinksPopulated)
return;
m_visitedLinksPopulated = true;
WebView* webView = kit(&sourcePage);
if (!webView)
return;
COMPtr<IWebHistoryDelegate> historyDelegate;
webView->historyDelegate(&historyDelegate);
if (historyDelegate) {
historyDelegate->populateVisitedLinksForWebView(webView);
return;
}
WebHistory* history = WebHistory::sharedHistory();
if (!history)
return;
history->addVisitedLinksToVisitedLinkStore(*this);
}
void TextInputController::setComposition(const CppArgumentList& arguments, CppVariant* result)
{
result->setNull();
WebView* view = getMainFrame() ? getMainFrame()->view() : 0;
if (!view)
return;
if (arguments.size() < 1)
return;
// Sends a keydown event with key code = 0xE5 to emulate input method behavior.
WebKeyboardEvent keyDown;
keyDown.type = WebInputEvent::RawKeyDown;
keyDown.modifiers = 0;
keyDown.windowsKeyCode = 0xE5; // VKEY_PROCESSKEY
keyDown.setKeyIdentifierFromWindowsKeyCode();
view->handleInputEvent(keyDown);
WebVector<WebCompositionUnderline> underlines;
WebString text(WebString::fromUTF8(arguments[0].toString()));
view->setComposition(text, underlines, 0, text.length());
}
void WebFrameLoaderClient::dispatchWillSendRequest(DocumentLoader* loader, unsigned long identifier, ResourceRequest& request, const ResourceResponse& redirectResponse)
{
WebView* webView = m_webFrame->webView();
COMPtr<IWebResourceLoadDelegate> resourceLoadDelegate;
if (FAILED(webView->resourceLoadDelegate(&resourceLoadDelegate)))
return;
COMPtr<WebMutableURLRequest> webURLRequest(AdoptCOM, WebMutableURLRequest::createInstance(request));
COMPtr<WebURLResponse> webURLRedirectResponse(AdoptCOM, WebURLResponse::createInstance(redirectResponse));
COMPtr<IWebURLRequest> newWebURLRequest;
if (FAILED(resourceLoadDelegate->willSendRequest(webView, identifier, webURLRequest.get(), webURLRedirectResponse.get(), getWebDataSource(loader), &newWebURLRequest)))
return;
if (webURLRequest == newWebURLRequest)
return;
COMPtr<WebMutableURLRequest> newWebURLRequestImpl(Query, newWebURLRequest);
if (!newWebURLRequestImpl)
return;
request = newWebURLRequestImpl->resourceRequest();
}
void WebFrameLoaderClient::dispatchDidReceiveResponse(DocumentLoader* loader, unsigned long identifier, const ResourceResponse& response)
{
#if ENABLE(WIDGET_ENGINE)
SharedPtr<WebWidgetEngineDelegate> widgetEngineDelegate = m_webFrame->webView()->webWidgetEngineDelegate();
if (widgetEngineDelegate && loader->responseMIMEType() == "application/widget") {
const char* url = widgetEngineDelegate->receiveWidget(strdup(loader->responseURL().string().utf8().data()), m_webFrame);
loader->stopLoading();
if (url)
m_webFrame->loadURL(url);
return;
}
#endif
WebView* webView = m_webFrame->webView();
SharedPtr<WebResourceLoadDelegate> resourceLoadDelegate = webView->webResourceLoadDelegate();
if (!resourceLoadDelegate)
return;
WebURLResponse* webURLResponse = WebURLResponse::createInstance(response);
resourceLoadDelegate->didReceiveResponse(webView, identifier, webURLResponse, getWebDataSource(loader));
delete webURLResponse;
}
ApplicationUI::ApplicationUI(bb::cascades::Application *app) :
QObject(app)
{
// prepare the localization
m_pTranslator = new QTranslator(this);
m_pLocaleHandler = new LocaleHandler(this);
bool res = QObject::connect(m_pLocaleHandler, SIGNAL(systemLanguageChanged()), this, SLOT(onSystemLanguageChanged()));
// This is only available in Debug builds
Q_ASSERT(res);
// Since the variable is not used in the app, this is added to avoid a
// compiler warning
Q_UNUSED(res);
// initial load
onSystemLanguageChanged();
// Create scene document from main.qml asset, the parent is set
// to ensure the document gets destroyed properly at shut down.
QmlDocument *qml = QmlDocument::create("asset:///main.qml").parent(this);
qml->setContextProperty("app", this);
// Create root object for the UI
AbstractPane *root = qml->createRootObject<AbstractPane>();
WebView* wv = root->findChild<WebView*>("oauthWebView");
QString url = "https://www.dropbox.com/1/oauth2/authorize?";
url.append("client_id=").append("<appkey>").append("&");
url.append("response_type=token&");
url.append("redirect_uri=").append("<redirect_uri>").append("&");
url.append("state=").append("<CSRF token>");
wv->setUrl(QUrl(url));
// Set created root object as the application scene
app->setScene(root);
}
void WebFrameLoaderClient::updateGlobalHistoryRedirectLinks()
{
WebView* webView = m_webFrame->webView();
SharedPtr<WebHistoryDelegate> historyDelegate = webView->historyDelegate();
WebHistory* history = WebHistory::sharedHistory();
DocumentLoader* loader = core(m_webFrame)->loader()->documentLoader();
ASSERT(loader->unreachableURL().isEmpty());
if (!loader->clientRedirectSourceForHistory().isNull()) {
if (historyDelegate) {
String sourceURL(loader->clientRedirectSourceForHistory());
String destinationURL(loader->clientRedirectDestinationForHistory());
historyDelegate->didPerformClientRedirectFromURL(webView, sourceURL.utf8().data(), destinationURL.utf8().data(), m_webFrame);
} else {
if (history) {
if (WebHistoryItem* webHistoryItem = history->itemForURLString(strdup(loader->clientRedirectSourceForHistory().utf8().data())))
webHistoryItem->getPrivateItem()->m_historyItem.get()->addRedirectURL(loader->clientRedirectDestinationForHistory());
}
}
}
if (!loader->serverRedirectSourceForHistory().isNull()) {
if (historyDelegate) {
String sourceURL(loader->serverRedirectSourceForHistory());
String destinationURL(loader->serverRedirectDestinationForHistory());
historyDelegate->didPerformServerRedirectFromURL(webView, sourceURL.utf8().data(), destinationURL.utf8().data(), m_webFrame);
} else {
if (history) {
if (WebHistoryItem *webHistoryItem = history->itemForURLString(strdup(loader->serverRedirectSourceForHistory().utf8().data())))
webHistoryItem->getPrivateItem()->m_historyItem.get()->addRedirectURL(loader->serverRedirectDestinationForHistory());
}
}
}
}
void WebFrameLoaderClient::updateGlobalHistory()
{
DocumentLoader* loader = core(m_webFrame)->loader()->documentLoader();
WebView* webView = m_webFrame->webView();
COMPtr<IWebHistoryDelegate> historyDelegate;
webView->historyDelegate(&historyDelegate);
if (historyDelegate) {
COMPtr<IWebURLResponse> urlResponse(AdoptCOM, WebURLResponse::createInstance(loader->response()));
COMPtr<IWebURLRequest> urlRequest(AdoptCOM, WebMutableURLRequest::createInstance(loader->originalRequestCopy()));
COMPtr<IWebNavigationData> navigationData(AdoptCOM, WebNavigationData::createInstance(
loader->urlForHistory(), loader->title(), urlRequest.get(), urlResponse.get(), loader->substituteData().isValid(), loader->clientRedirectSourceForHistory()));
historyDelegate->didNavigateWithNavigationData(webView, navigationData.get(), m_webFrame);
return;
}
WebHistory* history = WebHistory::sharedHistory();
if (!history)
return;
history->visitedURL(loader->urlForHistory(), loader->title(), loader->originalRequestCopy().httpMethod(), loader->urlForHistoryReflectsFailure(), !loader->clientRedirectSourceForHistory());
}
// Verify that isRectTopmost returns false when the document is detached.
TEST_F(WebPluginContainerTest, IsRectTopmostTest)
{
URLTestHelpers::registerMockedURLFromBaseURL(WebString::fromUTF8(m_baseURL.c_str()), WebString::fromUTF8("plugin_container.html"));
TestPluginWebFrameClient pluginWebFrameClient; // Must outlive webViewHelper.
FrameTestHelpers::WebViewHelper webViewHelper;
WebView* webView = webViewHelper.initializeAndLoad(m_baseURL + "plugin_container.html", true, &pluginWebFrameClient);
ASSERT(webView);
webView->settings()->setPluginsEnabled(true);
webView->resize(WebSize(300, 300));
webView->updateAllLifecyclePhases();
runPendingTasks();
RefPtrWillBeRawPtr<WebPluginContainerImpl> pluginContainerImpl =
toWebPluginContainerImpl(getWebPluginContainer(webView, WebString::fromUTF8("translated-plugin")));
pluginContainerImpl->setFrameRect(IntRect(0, 0, 300, 300));
WebRect rect = pluginContainerImpl->element().boundsInViewportSpace();
EXPECT_TRUE(pluginContainerImpl->isRectTopmost(rect));
// Cause the plugin's frame to be detached.
webViewHelper.reset();
EXPECT_FALSE(pluginContainerImpl->isRectTopmost(rect));
}
void MainMenu::aboutToShowEditMenu()
{
if (!m_window) {
return;
}
WebView* view = m_window->weView();
m_actions[QSL("Edit/Undo")]->setEnabled(view->pageAction(QWebPage::Undo)->isEnabled());
m_actions[QSL("Edit/Redo")]->setEnabled(view->pageAction(QWebPage::Redo)->isEnabled());
m_actions[QSL("Edit/Cut")]->setEnabled(view->pageAction(QWebPage::Cut)->isEnabled());
m_actions[QSL("Edit/Copy")]->setEnabled(view->pageAction(QWebPage::Copy)->isEnabled());
m_actions[QSL("Edit/Paste")]->setEnabled(view->pageAction(QWebPage::Paste)->isEnabled());
m_actions[QSL("Edit/SelectAll")]->setEnabled(view->pageAction(QWebPage::SelectAll)->isEnabled());
m_actions[QSL("Edit/Find")]->setEnabled(true);
}
// Verifies executing the command 'Copy' results in copying to the clipboard.
TEST_F(WebPluginContainerTest, Copy)
{
URLTestHelpers::registerMockedURLFromBaseURL(WebString::fromUTF8(m_baseURL.c_str()), WebString::fromUTF8("plugin_container.html"));
TestPluginWebFrameClient pluginWebFrameClient; // Must outlive webViewHelper.
FrameTestHelpers::WebViewHelper webViewHelper;
WebView* webView = webViewHelper.initializeAndLoad(m_baseURL + "plugin_container.html", true, &pluginWebFrameClient);
ASSERT(webView);
webView->settings()->setPluginsEnabled(true);
webView->resize(WebSize(300, 300));
webView->updateAllLifecyclePhases();
runPendingTasks();
WebElement pluginContainerOneElement = webView->mainFrame()->document().getElementById(WebString::fromUTF8("translated-plugin"));
EXPECT_TRUE(webView->mainFrame()->executeCommand("Copy", pluginContainerOneElement));
EXPECT_EQ(WebString("x"), Platform::current()->clipboard()->readPlainText(WebClipboard::Buffer()));
}
TEST_F(WebPluginContainerTest, GestureLongPressReachesPlugin)
{
URLTestHelpers::registerMockedURLFromBaseURL(
WebString::fromUTF8(m_baseURL.c_str()),
WebString::fromUTF8("plugin_container.html"));
EventTestPluginWebFrameClient pluginWebFrameClient; // Must outlive webViewHelper.
FrameTestHelpers::WebViewHelper webViewHelper;
WebView* webView = webViewHelper.initializeAndLoad(m_baseURL + "plugin_container.html", true, &pluginWebFrameClient);
ASSERT(webView);
webView->settings()->setPluginsEnabled(true);
webView->resize(WebSize(300, 300));
webView->updateAllLifecyclePhases();
runPendingTasks();
WebElement pluginContainerOneElement = webView->mainFrame()->document().getElementById(WebString::fromUTF8("translated-plugin"));
WebPlugin* plugin = static_cast<WebPluginContainerImpl*>(pluginContainerOneElement.pluginContainer())->plugin();
EventTestPlugin* testPlugin = static_cast<EventTestPlugin*>(plugin);
WebGestureEvent event;
event.type = WebInputEvent::GestureLongPress;
event.sourceDevice = WebGestureDeviceTouchscreen;
// First, send an event that doesn't hit the plugin to verify that the
// plugin doesn't receive it.
event.x = 0;
event.y = 0;
webView->handleInputEvent(event);
runPendingTasks();
EXPECT_EQ(WebInputEvent::Undefined, testPlugin->getLastInputEventType());
// Next, send an event that does hit the plugin, and verify it does receive it.
WebRect rect = pluginContainerOneElement.boundsInViewportSpace();
event.x = rect.x + rect.width / 2;
event.y = rect.y + rect.height / 2;
webView->handleInputEvent(event);
runPendingTasks();
EXPECT_EQ(WebInputEvent::GestureLongPress, testPlugin->getLastInputEventType());
}
TEST_F(WebFrameTest, DeviceScaleFactorUsesDefaultWithoutViewportTag)
{
registerMockedHttpURLLoad("no_viewport_tag.html");
int viewportWidth = 640;
int viewportHeight = 480;
FixedLayoutTestWebViewClient client;
client.m_screenInfo.horizontalDPI = 160;
client.m_windowRect = WebRect(0, 0, viewportWidth, viewportHeight);
WebView* webView = static_cast<WebView*>(FrameTestHelpers::createWebViewAndLoad(m_baseURL + "no_viewport_tag.html", true, 0, &client));
webView->resize(WebSize(viewportWidth, viewportHeight));
webView->settings()->setViewportEnabled(true);
webView->settings()->setDefaultDeviceScaleFactor(2);
webView->enableFixedLayoutMode(true);
webView->layout();
EXPECT_EQ(2, webView->deviceScaleFactor());
}
void WebFrameLoaderClient::setTitle(const String& title, const KURL& url)
{
#if OS(AMIGAOS4)
if (!m_webFrame->parentFrame()) {
BalWidget* viewWindow = m_webFrame->webView()->viewWindow();
if (viewWindow && viewWindow->window) {
extern char* utf8ToAmiga(const char* utf8);
char *titlestr = utf8ToAmiga(title.utf8().data());
if (titlestr && titlestr[0])
snprintf(viewWindow->title, sizeof(viewWindow->title), viewWindow->clickTabNode ? "%s" : "OWB: %s", titlestr);
else
strcpy(viewWindow->title, "Origyn Web Browser");
free(titlestr);
if (amigaConfig.tabs) {
IIntuition->SetGadgetAttrs(viewWindow->gad_clicktab, viewWindow->window, NULL,
CLICKTAB_Labels, ~0,
TAG_DONE);
IClickTab->SetClickTabNodeAttrs(viewWindow->clickTabNode, TNA_Text, viewWindow->title, TAG_DONE);
IIntuition->RefreshSetGadgetAttrs(viewWindow->gad_clicktab, viewWindow->window, NULL,
CLICKTAB_Labels, viewWindow->clickTabList,
TAG_DONE);
}
else
IIntuition->SetWindowTitles(viewWindow->window, viewWindow->title, (STRPTR)~0UL);
CString urlLatin1 = url.prettyURL().latin1();
const char *urlstr = urlLatin1.data();
if (urlstr && urlstr[0] && viewWindow->gad_url) {
snprintf(viewWindow->url, sizeof(viewWindow->url), "%s", urlstr);
if (ILayout->SetPageGadgetAttrs(viewWindow->gad_url, viewWindow->page,
viewWindow->window, NULL,
STRINGA_TextVal, viewWindow->url,
TAG_DONE))
ILayout->RefreshPageGadget(viewWindow->gad_url, viewWindow->page, viewWindow->window, NULL);
}
}
}
#endif
WebView* webView = m_webFrame->webView();
SharedPtr<WebHistoryDelegate> historyDelegate = webView->historyDelegate();
if (historyDelegate) {
historyDelegate->updateHistoryTitle(webView, title.utf8().data(), url.string().utf8().data());
return;
}
bool privateBrowsingEnabled = false;
WebPreferences* preferences = m_webFrame->webView()->preferences();
if (preferences)
privateBrowsingEnabled = preferences->privateBrowsingEnabled();
if (privateBrowsingEnabled)
return;
// update title in global history
WebHistory* history = webHistory();
if (!history)
return;
WebHistoryItem* item = history->itemForURL(strdup(url.string().utf8().data()));
if (!item)
return;
item->setTitle(title.utf8().data());
}
SiteInfoWidget::SiteInfoWidget(QupZilla* mainClass, QWidget* parent)
: QMenu(parent)
, ui(new Ui::SiteInfoWidget)
, p_QupZilla(mainClass)
{
this->setAttribute(Qt::WA_DeleteOnClose);
ui->setupUi(this);
WebView* view = p_QupZilla->weView();
WebPage* webPage = qobject_cast<WebPage*>(view->page());
QUrl url = view->url();
if (webPage->sslCertificate().isValid()) {
ui->secureLabel->setText(tr("Your connection to this site is <b>secured</b>."));
ui->secureIcon->setPixmap(QPixmap(":/icons/locationbar/accept.png"));
}
else {
ui->secureLabel->setText(tr("Your connection to this site is <b>unsecured</b>."));
ui->secureIcon->setPixmap(QPixmap(":/icons/locationbar/warning.png"));
}
QString scheme = url.scheme();
QSqlQuery query;
QString host = url.host();
query.exec("SELECT sum(count) FROM history WHERE url LIKE '" + scheme + "://" + host + "%' ");
if (query.next()) {
int count = query.value(0).toInt();
if (count > 3) {
ui->historyLabel->setText(tr("This is your <b>%1</b> visit of this site.").arg(QString::number(count) + "."));
ui->historyIcon->setPixmap(QPixmap(":/icons/locationbar/accept.png"));
}
else if (count == 0) {
ui->historyLabel->setText(tr("You have <b>never</b> visited this site before."));
ui->historyIcon->setPixmap(QPixmap(":/icons/locationbar/warning.png"));
}
else {
ui->historyIcon->setPixmap(QPixmap(":/icons/locationbar/warning.png"));
QString text;
if (count == 1) {
text = tr("first");
}
else if (count == 2) {
text = tr("second");
}
else if (count == 3) {
text = tr("third");
}
ui->historyLabel->setText(tr("This is your <b>%1</b> visit of this site.").arg(text));
}
}
connect(ui->pushButton, SIGNAL(clicked()), p_QupZilla, SLOT(showPageInfo()));
#ifndef KDE
// Use light color for QLabels even with Ubuntu Ambiance theme
QPalette pal = palette();
pal.setColor(QPalette::WindowText, QToolTip::palette().color(QPalette::ToolTipText));
ui->historyLabel->setPalette(pal);
ui->secureLabel->setPalette(pal);
#endif
}
WebView* WebView::create()
{
WebView* view = new WebView();
view->setContentSize(CCSizeMake(300, 400));
return (WebView*)(view->autorelease());
}
void SettingsDialog::saveToSettings()
{
QSettings settings;
settings.beginGroup(QLatin1String("MainWindow"));
settings.setValue(QLatin1String("home"), homeLineEdit->text());
settings.setValue(QLatin1String("startupBehavior"), startupBehavior->currentIndex());
settings.endGroup();
settings.beginGroup(QLatin1String("downloadmanager"));
settings.setValue(QLatin1String("alwaysPromptForFileName"), downloadAsk->isChecked());
settings.setValue(QLatin1String("downloadDirectory"), downloadsLocation->text());
settings.endGroup();
settings.beginGroup(QLatin1String("history"));
int historyExpire = expireHistory->currentIndex();
int idx = -1;
switch (historyExpire) {
case 0: idx = 1; break;
case 1: idx = 7; break;
case 2: idx = 14; break;
case 3: idx = 30; break;
case 4: idx = 365; break;
case 5: idx = -1; break;
case 6: idx = -2; break;
}
settings.setValue(QLatin1String("historyLimit"), idx);
settings.endGroup();
// Appearance
settings.beginGroup(QLatin1String("websettings"));
settings.setValue(QLatin1String("fixedFont"), m_fixedFont);
settings.setValue(QLatin1String("standardFont"), m_standardFont);
settings.setValue(QLatin1String("blockPopupWindows"), blockPopupWindows->isChecked());
settings.setValue(QLatin1String("enableJavascript"), enableJavascript->isChecked());
settings.setValue(QLatin1String("enablePlugins"), enablePlugins->isChecked());
settings.setValue(QLatin1String("enableImages"), enableImages->isChecked());
QString userStyleSheetString = userStyleSheet->text();
if (QFile::exists(userStyleSheetString))
settings.setValue(QLatin1String("userStyleSheet"), QUrl::fromLocalFile(userStyleSheetString));
else
settings.setValue(QLatin1String("userStyleSheet"), QUrl::fromEncoded(userStyleSheetString.toUtf8()));
settings.setValue(QLatin1String("enableClickToFlash"), clickToFlash->isChecked());
settings.endGroup();
// Privacy
settings.beginGroup(QLatin1String("cookies"));
CookieJar::AcceptPolicy acceptCookies;
switch (acceptCombo->currentIndex()) {
default:
case 0:
acceptCookies = CookieJar::AcceptAlways;
break;
case 1:
acceptCookies = CookieJar::AcceptNever;
break;
case 2:
acceptCookies = CookieJar::AcceptOnlyFromSitesNavigatedTo;
break;
}
CookieJar *jar = BrowserApplication::cookieJar();
QMetaEnum acceptPolicyEnum = jar->staticMetaObject.enumerator(jar->staticMetaObject.indexOfEnumerator("AcceptPolicy"));
settings.setValue(QLatin1String("acceptCookies"), QLatin1String(acceptPolicyEnum.valueToKey(acceptCookies)));
CookieJar::KeepPolicy keepPolicy;
switch (keepUntilCombo->currentIndex()) {
default:
case 0:
keepPolicy = CookieJar::KeepUntilExpire;
break;
case 1:
keepPolicy = CookieJar::KeepUntilExit;
break;
case 2:
keepPolicy = CookieJar::KeepUntilTimeLimit;
break;
}
QMetaEnum keepPolicyEnum = jar->staticMetaObject.enumerator(jar->staticMetaObject.indexOfEnumerator("KeepPolicy"));
settings.setValue(QLatin1String("keepCookiesUntil"), QLatin1String(keepPolicyEnum.valueToKey(keepPolicy)));
settings.setValue(QLatin1String("filterTrackingCookies"), filterTrackingCookiesCheckbox->isChecked());
settings.endGroup();
#if QT_VERSION >= 0x040500
// Network
settings.beginGroup(QLatin1String("network"));
settings.setValue(QLatin1String("cacheEnabled"), networkCache->isChecked());
settings.setValue(QLatin1String("maximumCacheSize"), networkCacheMaximumSizeSpinBox->value());
settings.endGroup();
#endif
// proxy
settings.beginGroup(QLatin1String("proxy"));
settings.setValue(QLatin1String("enabled"), proxySupport->isChecked());
settings.setValue(QLatin1String("type"), proxyType->currentIndex());
settings.setValue(QLatin1String("hostName"), proxyHostName->text());
settings.setValue(QLatin1String("port"), proxyPort->text());
settings.setValue(QLatin1String("userName"), proxyUserName->text());
settings.setValue(QLatin1String("password"), proxyPassword->text());
settings.endGroup();
// Tabs
settings.beginGroup(QLatin1String("tabs"));
settings.setValue(QLatin1String("selectNewTabs"), selectTabsWhenCreated->isChecked());
settings.setValue(QLatin1String("confirmClosingMultipleTabs"), confirmClosingMultipleTabs->isChecked());
#if QT_VERSION >= 0x040500
settings.setValue(QLatin1String("oneCloseButton"), oneCloseButton->isChecked());
#endif
settings.setValue(QLatin1String("quitAsLastTabClosed"), quitAsLastTabClosed->isChecked());
settings.setValue(QLatin1String("openTargetBlankLinksIn"), openTargetBlankLinksIn->currentIndex());
settings.setValue(QLatin1String("openLinksFromAppsIn"), openLinksFromAppsIn->currentIndex());
settings.endGroup();
BrowserApplication::instance()->loadSettings();
BrowserApplication::networkAccessManager()->loadSettings();
BrowserApplication::cookieJar()->loadSettings();
BrowserApplication::historyManager()->loadSettings();
if (BrowserMainWindow *mw = static_cast<BrowserMainWindow*>(parent())) {
WebView *webView = mw->currentTab();
if (webView) {
webView->webPage()->webPluginFactory()->refreshPlugins();
}
}
QList<BrowserMainWindow*> list = BrowserApplication::instance()->mainWindows();
foreach (BrowserMainWindow *mainWindow, list) {
mainWindow->tabWidget()->loadSettings();
}
}
WebViewRecipe::WebViewRecipe(Container *parent) :
CustomControl(parent)
{
bool connectResult;
Q_UNUSED(connectResult);
// Get the UIConfig object in order to use resolution independent sizes.
UIConfig *ui = this->ui();
// The recipe Container
Container *recipeContainer = new Container();
recipeContainer->setLayout(new DockLayout());
WebView *webView = new WebView();
webView->setUrl(QUrl("https://github.com/blackberry/Cascades-Samples/blob/master/cascadescookbookqml/assets/Slider.qml"));
// We let the scroll view scroll in both x and y and enable zooming,
// max and min content zoom property is set in the WebViews onMinContentScaleChanged
// and onMaxContentScaleChanged signal handlers.
mScrollView = ScrollView::create().scrollMode(ScrollMode::Both).pinchToZoomEnabled(true);
mScrollView->setContent(webView);
// Connect to signals to manage the progress indicator.
connectResult = connect(webView, SIGNAL(loadingChanged(bb::cascades::WebLoadRequest *)), this,
SLOT(onLoadingChanged(bb::cascades::WebLoadRequest *)));
Q_ASSERT(connectResult);
connectResult = connect(webView, SIGNAL(loadProgressChanged(int)), this,
SLOT(onProgressChanged(int)));
Q_ASSERT(connectResult);
connectResult = connect(webView, SIGNAL(navigationRequested(bb::cascades::WebNavigationRequest *)), this,
SLOT(onNavigationRequested(bb::cascades::WebNavigationRequest *)));
Q_ASSERT(connectResult);
// Connect signals to manage the web contents suggested size.
connectResult = connect(webView, SIGNAL(maxContentScaleChanged(float)), this,
SLOT(onMaxContentScaleChanged(float)));
Q_ASSERT(connectResult);
connectResult = connect(webView, SIGNAL(minContentScaleChanged(float)), this,
SLOT(onMinContentScaleChanged(float)));
Q_ASSERT(connectResult);
// Connect signal to handle java script calls to navigator.cascades.postMessage()
connectResult = connect(webView, SIGNAL(messageReceived(const QVariantMap&)), this,
SLOT(onMessageReceived(const QVariantMap&)));
Q_ASSERT(connectResult);
WebSettings *settings = webView->settings();
QVariantMap settingsMap;
settingsMap["width"] = QString("device-width");
settingsMap["initial-scale"] = 1.0;
settings->setViewportArguments(settingsMap);
// A progress indicator that is used to show the loading status
Container *progressContainer = Container::create().bottom(ui->du(2));
progressContainer->setLayout(new DockLayout());
progressContainer->setVerticalAlignment(VerticalAlignment::Bottom);
progressContainer->setHorizontalAlignment(HorizontalAlignment::Center);
mLoadingIndicator = ProgressIndicator::create().opacity(0.0);
progressContainer->add(mLoadingIndicator);
// Add the controls and set the root Container of the Custom Control.
recipeContainer->add(mScrollView);
recipeContainer->add(progressContainer);
setRoot(recipeContainer);
}
void TestShell::resetWebSettings(WebView& webView)
{
// Match the settings used by Mac DumpRenderTree, with the exception of
// fonts.
WebSettings* settings = webView.settings();
#if OS(MAC_OS_X)
WebString serif = WebString::fromUTF8("Times");
settings->setCursiveFontFamily(WebString::fromUTF8("Apple Chancery"));
settings->setFantasyFontFamily(WebString::fromUTF8("Papyrus"));
#else
// NOTE: case matters here, this must be 'times new roman', else
// some layout tests fail.
WebString serif = WebString::fromUTF8("times new roman");
// These two fonts are picked from the intersection of
// Win XP font list and Vista font list :
// http://www.microsoft.com/typography/fonts/winxp.htm
// http://blogs.msdn.com/michkap/archive/2006/04/04/567881.aspx
// Some of them are installed only with CJK and complex script
// support enabled on Windows XP and are out of consideration here.
// (although we enabled both on our buildbots.)
// They (especially Impact for fantasy) are not typical cursive
// and fantasy fonts, but it should not matter for layout tests
// as long as they're available.
settings->setCursiveFontFamily(WebString::fromUTF8("Comic Sans MS"));
settings->setFantasyFontFamily(WebString::fromUTF8("Impact"));
#endif
settings->setSerifFontFamily(serif);
settings->setStandardFontFamily(serif);
settings->setFixedFontFamily(WebString::fromUTF8("Courier"));
settings->setSansSerifFontFamily(WebString::fromUTF8("Helvetica"));
settings->setDefaultTextEncodingName(WebString::fromUTF8("ISO-8859-1"));
settings->setDefaultFontSize(16);
settings->setDefaultFixedFontSize(13);
settings->setMinimumFontSize(1);
settings->setMinimumLogicalFontSize(9);
settings->setJavaScriptCanOpenWindowsAutomatically(true);
settings->setJavaScriptCanAccessClipboard(true);
settings->setDOMPasteAllowed(true);
settings->setDeveloperExtrasEnabled(false);
settings->setNeedsSiteSpecificQuirks(true);
settings->setShrinksStandaloneImagesToFit(false);
settings->setUsesEncodingDetector(false);
settings->setTextAreasAreResizable(false);
settings->setJavaEnabled(false);
settings->setAllowScriptsToCloseWindows(false);
settings->setXSSAuditorEnabled(false);
settings->setDownloadableBinaryFontsEnabled(true);
settings->setLocalStorageEnabled(true);
settings->setOfflineWebApplicationCacheEnabled(true);
settings->setAllowFileAccessFromFileURLs(true);
// LayoutTests were written with Safari Mac in mind which does not allow
// tabbing to links by default.
webView.setTabsToLinks(false);
// Allow those layout tests running as local files, i.e. under
// LayoutTests/http/tests/local, to access http server.
settings->setAllowUniversalAccessFromFileURLs(true);
settings->setJavaScriptEnabled(true);
settings->setPluginsEnabled(true);
settings->setWebSecurityEnabled(true);
settings->setEditableLinkBehaviorNeverLive();
settings->setFontRenderingModeNormal();
settings->setShouldPaintCustomScrollbars(true);
settings->setTextDirectionSubmenuInclusionBehaviorNeverIncluded();
settings->setLoadsImagesAutomatically(true);
settings->setImagesEnabled(true);
#if OS(DARWIN)
settings->setEditingBehavior(WebSettings::EditingBehaviorMac);
#else
settings->setEditingBehavior(WebSettings::EditingBehaviorWin);
#endif
}
static IntSize getWebViewSize(WebView& webView)
{
RECT r;
webView.frameRect(&r);
return IntSize(r.right - r.left, r.bottom - r.top);
}
static void webViewSizeAllocate(GtkWidget* widget, GtkAllocation* allocation)
{
WebView* webView = webViewWidgetGetWebViewInstance(WEB_VIEW_WIDGET(widget));
GTK_WIDGET_CLASS(webViewWidgetParentClass)->size_allocate(widget, allocation);
webView->setSize(widget, IntSize(allocation->width, allocation->height));
}
bool WebPage::acceptNavigationRequest(QWebFrame *frame, const QNetworkRequest &request, NavigationType type)
{
if (_isOnRekonqPage)
{
WebView *view = qobject_cast<WebView *>(parent());
WebTab *tab = qobject_cast<WebTab *>(view->parent());
_isOnRekonqPage = false;
tab->setPart(0, KUrl()); // re-enable the view page
}
// reset webpage values
_suggestedFileName.clear();
_loadingUrl = request.url();
KIO::AccessManager *manager = qobject_cast<KIO::AccessManager*>(networkAccessManager());
KIO::MetaData metaData = manager->requestMetaData();
// Get the SSL information sent, if any...
if (metaData.contains(QL1S("ssl_in_use")))
{
WebSslInfo info;
info.restoreFrom(metaData.toVariant(), request.url());
info.setUrl(request.url());
_sslInfo = info;
}
if (frame)
{
if (_protHandler.preHandling(request, frame))
{
return false;
}
switch (type)
{
case QWebPage::NavigationTypeLinkClicked:
if (_sslInfo.isValid())
{
setRequestMetaData("ssl_was_in_use", "TRUE");
}
break;
case QWebPage::NavigationTypeFormSubmitted:
break;
case QWebPage::NavigationTypeFormResubmitted:
if (KMessageBox::warningContinueCancel(view(),
i18n("Are you sure you want to send your data again?"),
i18n("Resend form data")
)
== KMessageBox::Cancel)
{
return false;
}
break;
case QWebPage::NavigationTypeReload:
case QWebPage::NavigationTypeBackOrForward:
case QWebPage::NavigationTypeOther:
break;
default:
break;
}
}
return KWebPage::acceptNavigationRequest(frame, request, type);
}
const BitmapSurface* surface()const
{
return static_cast<BitmapSurface*>(view_->surface());
};
void MenuListener::OnShowPopupMenu(WebView *caller, const WebPopupMenuInfo &menu_info)
{
// DevMsg("DISABLED FOR TESTING!\n");
// return;
//C_WebTab* pWebTab = g_pAnarchyManager->GetWebManager()->GetWebBrowser()->FindWebTab(caller);
//C_WebTab* pHudWebTab = g_pAnarchyManager->GetWebManager()->GetHudWebTab();
//WebView* pHudWebView = g_pAnarchyManager->GetWebManager()->GetWebBrowser()->FindWebView(pHudWebTab);
C_AwesomiumBrowserInstance* pAwesomiumBrowserInstance = g_pAnarchyManager->GetAwesomiumBrowserManager()->FindAwesomiumBrowserInstance(caller); // FIXME: This should be a general EmbeddedInstance of any type.
C_AwesomiumBrowserInstance* pHudBrowserInstance = g_pAnarchyManager->GetAwesomiumBrowserManager()->FindAwesomiumBrowserInstance("hud");
WebView* pHudWebView = pHudBrowserInstance->GetWebView();
DevMsg("Pop menu detected!\n");
std::vector<std::string> methodArguments;
methodArguments.push_back(pAwesomiumBrowserInstance->GetId());
methodArguments.push_back(VarArgs("%i", menu_info.bounds.x));
methodArguments.push_back(VarArgs("%i", menu_info.bounds.y));
methodArguments.push_back(VarArgs("%i", menu_info.bounds.width));
methodArguments.push_back(VarArgs("%i", menu_info.bounds.height));
methodArguments.push_back(VarArgs("%i", menu_info.item_height));
methodArguments.push_back(VarArgs("%f", menu_info.item_font_size));
methodArguments.push_back(VarArgs("%i", menu_info.selected_item));
methodArguments.push_back(VarArgs("%i", menu_info.right_aligned));
for (int i = 0; i < menu_info.items.size(); i++)
{
if (menu_info.items[i].type == kWebMenuItemType_Option)
methodArguments.push_back("Option");
else if (menu_info.items[i].type == kWebMenuItemType_CheckableOption)
methodArguments.push_back("CheckableOption");
else if (menu_info.items[i].type == kWebMenuItemType_Group)
methodArguments.push_back("Group");
else if (menu_info.items[i].type == kWebMenuItemType_Separator)
methodArguments.push_back("Separator");
methodArguments.push_back(WebStringToCharString(menu_info.items[i].label));
methodArguments.push_back(WebStringToCharString(menu_info.items[i].tooltip));
methodArguments.push_back(VarArgs("%i", menu_info.items[i].action));
methodArguments.push_back(VarArgs("%i", menu_info.items[i].right_to_left));
methodArguments.push_back(VarArgs("%i", menu_info.items[i].has_directional_override));
methodArguments.push_back(VarArgs("%i", menu_info.items[i].enabled));
methodArguments.push_back(VarArgs("%i", menu_info.items[i].checked));
}
std::string objectName = "window.arcadeHud";
std::string objectMethod = "showPopupMenu";
JSValue response = pHudWebView->ExecuteJavascriptWithResult(WSLit(objectName.c_str()), WSLit(""));
if (response.IsObject())
{
JSObject object = response.ToObject();
JSArray arguments;
for (auto argument : methodArguments)
arguments.Push(WSLit(argument.c_str()));
object.InvokeAsync(WSLit(objectMethod.c_str()), arguments);
}
}
Widget* WebFrameLoaderClient::createPlugin(const IntSize& pluginSize, HTMLPlugInElement* element, const KURL& url, const Vector<String>& paramNames, const Vector<String>& paramValues, const String& mimeType, bool loadManually)
{
WebView* webView = m_webFrame->webView();
COMPtr<IWebUIDelegate> ui;
if (SUCCEEDED(webView->uiDelegate(&ui)) && ui) {
COMPtr<IWebUIDelegatePrivate4> uiPrivate(Query, ui);
if (uiPrivate) {
// Assemble the view arguments in a property bag.
HashMap<String, String> viewArguments;
for (unsigned i = 0; i < paramNames.size(); i++)
viewArguments.set(paramNames[i], paramValues[i]);
COMPtr<IPropertyBag> viewArgumentsBag(AdoptCOM, COMPropertyBag<String>::adopt(viewArguments));
COMPtr<IDOMElement> containingElement(AdoptCOM, DOMElement::createInstance(element));
HashMap<String, COMVariant> arguments;
arguments.set(WebEmbeddedViewAttributesKey, viewArgumentsBag);
arguments.set(WebEmbeddedViewBaseURLKey, url.string());
arguments.set(WebEmbeddedViewContainingElementKey, containingElement);
arguments.set(WebEmbeddedViewMIMETypeKey, mimeType);
COMPtr<IPropertyBag> argumentsBag(AdoptCOM, COMPropertyBag<COMVariant>::adopt(arguments));
COMPtr<IWebEmbeddedView> view;
HRESULT result = uiPrivate->embeddedViewWithArguments(webView, m_webFrame, argumentsBag.get(), &view);
if (SUCCEEDED(result)) {
HWND parentWindow;
HRESULT hr = webView->viewWindow((OLE_HANDLE*)&parentWindow);
ASSERT(SUCCEEDED(hr));
return EmbeddedWidget::create(view.get(), element, parentWindow, pluginSize);
}
}
}
Frame* frame = core(m_webFrame);
PluginView* pluginView = PluginView::create(frame, pluginSize, element, url, paramNames, paramValues, mimeType, loadManually);
if (pluginView->status() == PluginStatusLoadedSuccessfully)
return pluginView;
COMPtr<IWebResourceLoadDelegate> resourceLoadDelegate;
if (FAILED(webView->resourceLoadDelegate(&resourceLoadDelegate)))
return pluginView;
RetainPtr<CFMutableDictionaryRef> userInfo(AdoptCF, CFDictionaryCreateMutable(0, 0, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks));
unsigned count = (unsigned)paramNames.size();
for (unsigned i = 0; i < count; i++) {
if (paramNames[i] == "pluginspage") {
static CFStringRef key = MarshallingHelpers::LPCOLESTRToCFStringRef(WebKitErrorPlugInPageURLStringKey);
RetainPtr<CFStringRef> str(AdoptCF, paramValues[i].createCFString());
CFDictionarySetValue(userInfo.get(), key, str.get());
break;
}
}
if (!mimeType.isNull()) {
static CFStringRef key = MarshallingHelpers::LPCOLESTRToCFStringRef(WebKitErrorMIMETypeKey);
RetainPtr<CFStringRef> str(AdoptCF, mimeType.createCFString());
CFDictionarySetValue(userInfo.get(), key, str.get());
}
String pluginName;
if (pluginView->plugin())
pluginName = pluginView->plugin()->name();
if (!pluginName.isNull()) {
static CFStringRef key = MarshallingHelpers::LPCOLESTRToCFStringRef(WebKitErrorPlugInNameKey);
RetainPtr<CFStringRef> str(AdoptCF, pluginName.createCFString());
CFDictionarySetValue(userInfo.get(), key, str.get());
}
COMPtr<CFDictionaryPropertyBag> userInfoBag(AdoptCOM, CFDictionaryPropertyBag::createInstance());
userInfoBag->setDictionary(userInfo.get());
int errorCode = 0;
switch (pluginView->status()) {
case PluginStatusCanNotFindPlugin:
errorCode = WebKitErrorCannotFindPlugIn;
break;
case PluginStatusCanNotLoadPlugin:
errorCode = WebKitErrorCannotLoadPlugIn;
break;
default:
ASSERT_NOT_REACHED();
}
ResourceError resourceError(String(WebKitErrorDomain), errorCode, url.string(), String());
COMPtr<IWebError> error(AdoptCOM, WebError::createInstance(resourceError, userInfoBag.get()));
resourceLoadDelegate->plugInFailedWithError(webView, error.get(), getWebDataSource(frame->loader()->documentLoader()));
return pluginView;
}
bool WebPage::acceptNavigationRequest(QWebFrame *frame, const QNetworkRequest &request, NavigationType type, const QByteArray& postData)
{
QString scheme = request.url().scheme();
if (scheme == QLatin1String("mailto")
|| scheme == QLatin1String("ftp")) {
// QDesktopServices::openUrl(request.url());
return false;
}
if (IS_CRAWLER) // when crawler, we run the webapplication is the same process
// make it easier for replay
return QWebPage::acceptNavigationRequest(frame, request, type, postData);
WebView::OpenType t = WebView::NewWebApp;
WebView* view = qobject_cast<WebView*>(parent());
Q_ASSERT(view != 0);
// little trick to avoid double post
if (m_posted) {
m_posted = false;
} else if (postData.size() > 0) {
m_posted = true;
}
// ctrl open in new tab
// ctrl-shift open in new tab and select
// ctrl-alt open in new window
if (type == QWebPage::NavigationTypeLinkClicked
&& (m_keyboardModifiers & Qt::ControlModifier
|| m_pressedButtons == Qt::MidButton)) {
bool newWindow = (m_keyboardModifiers & Qt::AltModifier);
if (newWindow) {
t = WebView::NewWindow;
} else {
bool selectNewTab = (m_keyboardModifiers & Qt::ShiftModifier);
if (selectNewTab)
t = WebView::NewTabSelect;
else
t = WebView::NewTabNoSelect;
}
// check and load
view->loadPolicy(request, postData, t);
m_keyboardModifiers = Qt::NoModifier;
m_pressedButtons = Qt::NoButton;
return false;
}
//qDebug() << "navigation request url: " << request.url();
QUrl::FormattingOptions format = QUrl::RemoveQuery | QUrl::RemoveFragment | QUrl::StripTrailingSlash;
if (frame == mainFrame()) {
//qDebug() << "mainFrame navigation request to " << request.url();
m_loadingUrl = request.url();
QUrl current = view->url();
bool sop = (m_loadingUrl.scheme().toLower() == current.scheme().toLower())
&& (m_loadingUrl.host().toLower() == current.host().toLower())
&& (m_loadingUrl.port() == current.port());
//QUrl::FormattingOptions format = QUrl::RemoveQuery | QUrl::RemoveFragment | QUrl::StripTrailingSlash;
if (!sop //(view->loaded() || type == QWebPage::NavigationTypeLinkClicked) && !sop
/*(m_loadingUrl.toString(format) != current.toString(format)) */) {
t = WebView::NewWebApp;
// check and load
if (m_posted)
view->loadPolicy(request, postData, t);
else
view->loadPolicy(request, QByteArray(), t);
return false;
} else {
emit loadingUrl(m_loadingUrl);
if ((type != NavigationTypeOther) && (type != NavigationTypeReload) && (type != NavigationTypeBackOrForward)
|| (view->m_userAction)) {
QVariant var(m_loadingUrl.toString());
OPNET::OpNetwork::instance()->sendUIMsg(MSG_addHistoryItem, getByteArray(var));
view->m_userAction = false;
}
if (type == NavigationTypeBackOrForward) {
//QVariant var(m_back);
//OPNET::OpNetwork::instance()->sendUIMsg(MSG_navBackOrForward, getByteArray(var));
m_back = false;
}
}
}
else if(frame == 0)
{
t = WebView::NewTabNoSelect;
// check and load
view->loadPolicy(request, postData, t);
return false;
}
// same-origin and "about:blank" navigation requests fall-through to acceptNavigationRequest
else if( m_iframeHandled &&
(request.url().toString(format | QUrl::RemovePath) != view->url().toString(format | QUrl::RemovePath)
&& request.url().toString() != "about:blank")) {
//qDebug() << "navigation request for sub-frame \"" << frame->frameName() << "\" to " << request.url() << " type: " << type;
t = WebView::NewSubFrame;
OPNET::OpNetwork::instance()->sendSysCall(MSG_EMBED_FRAME, 0, frame->frameName().toAscii());
view->loadPolicy(request, postData, t);
return false;
}
return QWebPage::acceptNavigationRequest(frame, request, type, postData);
}
