tizen_src/ewk/ubrowser/window_ui.cc

   1 // Copyright 2014 Samsung Electronics. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "window_ui.h"
   6
   7 #include <assert.h>
   8 #include <Elementary.h>
   9 #include <EWebKit.h>
  10 #include <EWebKit_internal.h>
  11 #include <EWebKit_product.h>
  12
  13 #ifdef OS_TIZEN
  14 #include <efl_extension.h>
  15 #endif
  16
  17 #include "browser.h"
  18 #include "logger.h"
  19 #include "window.h"
  20
  21 #include "tizen/system_info.h"
  22
  23 namespace {
  24 static std::string kDefaultNewWindowURL = "http://www.google.com";
  25 static double kMinViewScale = 1.0;
  26 static double kMaxViewScale = 4.0;
  27 static int kNotificationTimeoutSec = 3;
  28 }
  29
  30 WindowUI::WindowUI(Window& window, Browser& browser)
  31     : window_(window)
  32     , browser_(browser)
  33     , active_popup_(NULL)
  34     , menu_(0)
  35     , is_loading_(false) {
  36   navbar_ = elm_box_add(window_.GetEvasObject());
  37   elm_box_horizontal_set(navbar_, EINA_TRUE);
  38   elm_box_homogeneous_set(navbar_, EINA_TRUE);
  39   evas_object_size_hint_weight_set(navbar_, EVAS_HINT_EXPAND, 0.0f);
  40   evas_object_size_hint_align_set(navbar_, EVAS_HINT_FILL, EVAS_HINT_FILL);
  41
  42   AddButton(navbar_, "file", "New Window", &WindowUI::OnCreateWindow);
  43   if (browser_.IsDesktop())
  44     AddButton(navbar_, "file", "New Incognito Window",
  45               &WindowUI::OnCreateIncognitoWindow);
  46   back_button_ = AddButton(navbar_, "arrow_left", "Back", &WindowUI::OnBack);
  47   forward_button_ = AddButton(navbar_, "arrow_right", "Forward",
  48                               &WindowUI::OnForward);
  49   stop_reload_button_ = AddButton(navbar_, "refresh", "Reload",
  50                                   &WindowUI::OnStopOrReload);
  51   AddButton(navbar_, "arrow_up", "More Actions",
  52             &WindowUI::OnShowExtraActionsMenu);
  53
  54   urlbar_ = elm_box_add(window_.GetEvasObject());
  55   elm_box_horizontal_set(urlbar_, EINA_TRUE);
  56   evas_object_size_hint_weight_set(urlbar_, EVAS_HINT_EXPAND, 0.0f);
  57   evas_object_size_hint_align_set(urlbar_, EVAS_HINT_FILL, EVAS_HINT_FILL);
  58
  59   progress_bar_ = elm_progressbar_add(window_.GetEvasObject());
  60   elm_object_style_set(progress_bar_, "wheel");
  61   elm_progressbar_pulse_set(progress_bar_, EINA_TRUE);
  62   elm_progressbar_pulse(progress_bar_, EINA_FALSE);
  63   elm_box_pack_end(urlbar_, progress_bar_);
  64   evas_object_show(progress_bar_);
  65
  66   url_entry_ = elm_entry_add(urlbar_);
  67   elm_entry_single_line_set(url_entry_, EINA_TRUE);
  68   elm_entry_scrollable_set(url_entry_, EINA_TRUE);
  69   elm_entry_input_panel_layout_set(url_entry_, ELM_INPUT_PANEL_LAYOUT_URL);
  70   evas_object_size_hint_weight_set(url_entry_, EVAS_HINT_EXPAND, 1.0f);
  71   evas_object_size_hint_align_set(url_entry_, EVAS_HINT_FILL, EVAS_HINT_FILL);
  72   evas_object_smart_callback_add(url_entry_, "activated", OnURLEntered, this);
  73   elm_box_pack_end(urlbar_, url_entry_);
  74   evas_object_show(url_entry_);
  75
  76   Evas_Object* separator = elm_separator_add(urlbar_);
  77   elm_separator_horizontal_set(separator, EINA_TRUE);
  78   elm_box_pack_end(urlbar_, separator);
  79   evas_object_show(separator);
  80
  81 #if defined(OS_TIZEN)
  82   eext_object_event_callback_add(window_.GetEvasObject(), EEXT_CALLBACK_BACK, WindowUI::OnBack, this);
  83 #endif
  84
  85   EnableBackButton(false);
  86   EnableForwardButton(false);
  87 }
  88
  89 WindowUI::~WindowUI() {
  90   if (active_popup_)
  91     evas_object_del(active_popup_);
  92 }
  93
  94 void WindowUI::OnURLChanged(const char* url) {
  95   log_trace("%s: %s", __PRETTY_FUNCTION__, url);
  96   elm_object_text_set(url_entry_, url);
  97 }
  98
  99 void WindowUI::OnLoadingStarted() {
 100   log_trace("%s", __PRETTY_FUNCTION__);
 101   elm_progressbar_pulse(progress_bar_, EINA_TRUE);
 102   Evas_Object* icon = elm_object_part_content_get(stop_reload_button_, "icon");
 103   elm_icon_standard_set(icon, "close");
 104   if (browser_.IsDesktop())
 105     elm_object_text_set(stop_reload_button_, "Stop");
 106   is_loading_ = true;
 107 }
 108
 109 void WindowUI::OnLoadingFinished() {
 110   log_trace("%s", __PRETTY_FUNCTION__);
 111   elm_progressbar_pulse(progress_bar_, EINA_FALSE);
 112   Evas_Object* icon = elm_object_part_content_get(stop_reload_button_, "icon");
 113   elm_icon_standard_set(icon, "refresh");
 114   if (browser_.IsDesktop())
 115     elm_object_text_set(stop_reload_button_, "Reload");
 116   is_loading_ = false;
 117 }
 118
 119 void WindowUI::EnableBackButton(bool enable) {
 120   elm_object_disabled_set(back_button_, !enable);
 121 }
 122
 123 void WindowUI::EnableForwardButton(bool enable) {
 124   elm_object_disabled_set(forward_button_, !enable);
 125 }
 126
 127 void WindowUI::ShowNotification(const char* text) {
 128   log_trace("%s : %s", __PRETTY_FUNCTION__, text);
 129   Evas_Object* notification = elm_notify_add(window_.GetEvasObject());
 130   elm_notify_timeout_set(notification, kNotificationTimeoutSec);
 131   Evas_Object* content = elm_label_add(notification);
 132   elm_object_text_set(content, text);
 133   elm_object_content_set(notification, content);
 134   elm_notify_align_set(notification, 0.5, 0.5);
 135   evas_object_show(notification);
 136 }
 137
 138 Evas_Object* WindowUI::AddButton(Evas_Object* parent,
 139     const char* icon, const char* label, Evas_Smart_Cb cb) {
 140   Evas_Object* bt = elm_button_add(parent);
 141   evas_object_size_hint_weight_set(bt, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 142   evas_object_size_hint_align_set(bt, EVAS_HINT_FILL, 0.5);
 143   if (label && browser_.IsDesktop())
 144     elm_object_text_set(bt, label);
 145   if (icon) {
 146     Evas_Object* icon_elm = elm_icon_add(bt);
 147     elm_icon_standard_set(icon_elm, icon);
 148     elm_object_part_content_set(bt, "icon", icon_elm);
 149   }
 150   evas_object_smart_callback_add(bt, "clicked", cb, this);
 151   elm_box_pack_end(parent, bt);
 152   evas_object_show(bt);
 153
 154   return bt;
 155 }
 156
 157 namespace {
 158
 159 void _HideCtxPopup(void* data, Evas_Object* obj, void*) {
 160   evas_object_hide(obj);
 161 }
 162
 163 } // namespace
 164
 165 void WindowUI::CloseMenu() {
 166   evas_object_hide(menu_);
 167   evas_object_del(menu_);
 168   menu_ = 0;
 169 }
 170
 171 Evas_Object* WindowUI::CreateExtraActionsMenu(Evas_Object* parent) {
 172   if (menu_) {
 173     CloseMenu();
 174     return 0;
 175   }
 176   menu_ =  elm_ctxpopup_add(parent);
 177
 178   if (IsMobileProfile() || IsWearableProfile()) {
 179     int width;
 180     evas_object_geometry_get(parent, 0, 0, &width, 0);
 181     evas_object_size_hint_min_set(menu_, width, 0);
 182   }
 183
 184   evas_object_smart_callback_add(menu_, "dismissed", _HideCtxPopup, NULL);
 185
 186   if (window_.IsFormProfileEnabled()) {
 187     elm_ctxpopup_item_append(menu_, "Disable Form Profile", NULL,
 188                              &WindowUI::OnFormProfileChange, this);
 189   } else {
 190     elm_ctxpopup_item_append(menu_, "Enable Form Profile", NULL,
 191                              &WindowUI::OnFormProfileChange, this);
 192   }
 193
 194   if (window_.IsRememberFormDataEnabled()) {
 195     elm_ctxpopup_item_append(menu_, "Disable Remember Form Data", NULL,
 196                              &WindowUI::OnRememberFormDataChange, this);
 197   } else {
 198     elm_ctxpopup_item_append(menu_, "Enable Remember Form Data", NULL,
 199                              &WindowUI::OnRememberFormDataChange, this);
 200   }
 201
 202   if (window_.IsRememberPasswordEnabled()) {
 203     elm_ctxpopup_item_append(menu_, "Disable Remember Password", NULL,
 204                              &WindowUI::OnRememberPasswordChange, this);
 205   } else {
 206     elm_ctxpopup_item_append(menu_, "Enable Remember Password", NULL,
 207                              &WindowUI::OnRememberPasswordChange, this);
 208   }
 209
 210   elm_ctxpopup_item_append(menu_, "Override User Agent String", NULL,
 211                            &WindowUI::OnUAOverride, this);
 212
 213   if (browser_.IsDesktop()) {
 214     elm_ctxpopup_item_append(menu_, "Show Web Inspector", NULL,
 215                              &WindowUI::OnInspectorShow, this);
 216   } else {
 217     elm_ctxpopup_item_append(menu_, "Start Web Inspector server", NULL,
 218                              &WindowUI::OnInspectorServerStart, this);
 219   }
 220 #if !defined(OS_TIZEN)
 221   elm_ctxpopup_item_append(menu_, "Simulate screen rotation", NULL,
 222       &WindowUI::OnRotate, this);
 223 #endif
 224
 225   if (window_.AreTouchEventsEnabled()) {
 226     elm_ctxpopup_item_append(menu_, "Enable mouse events", NULL,
 227                              &WindowUI::OnSelectMouseInput, this);
 228   } else {
 229     elm_ctxpopup_item_append(menu_, "Enable touch events", NULL,
 230                              &WindowUI::OnSelectTouchInput, this);
 231   }
 232
 233   if (!browser_.IsTracingEnabled()) {
 234     elm_ctxpopup_item_append(menu_, "Start tracing", NULL,
 235                              &WindowUI::OnStartTracing, this);
 236   } else {
 237     elm_ctxpopup_item_append(menu_, "Stop tracing", NULL,
 238                              &WindowUI::OnStopTracing, this);
 239   }
 240
 241   Ewk_Settings* settings = window_.GetEwkSettings();
 242   if (!ewk_settings_auto_fitting_get(settings)) {
 243     elm_ctxpopup_item_append(menu_, "Enable auto fitting", NULL,
 244                              &WindowUI::OnAutoFittingEnabled, this);
 245   } else {
 246     elm_ctxpopup_item_append(menu_, "Disable auto fitting", NULL,
 247                              &WindowUI::OnAutoFittingDisabled, this);
 248   }
 249
 250   if (!ewk_settings_form_profile_data_enabled_get(settings) ||
 251      !ewk_settings_form_candidate_data_enabled_get(settings)) {
 252     elm_ctxpopup_item_append(menu_, "Enable autofill", NULL,
 253                              &WindowUI::OnAutoFillEnabled, this);
 254   } else {
 255     elm_ctxpopup_item_append(menu_, "Disable autofill", NULL,
 256                              &WindowUI::OnAutoFillDisabled, this);
 257   }
 258
 259   elm_ctxpopup_item_append(menu_, "Change page zoom level", NULL,
 260                            &WindowUI::OnShowZoomPopup, this);
 261
 262   elm_ctxpopup_item_append(menu_, "Quit", NULL, &WindowUI::Exit, this);
 263
 264   return menu_;
 265 }
 266
 267 void WindowUI::ShowPermissionPopup(const char* title,
 268     const char* description, PermissionCallback cb, void* data) {
 269   log_trace("%s: (%s, %s)", __PRETTY_FUNCTION__, title, description);
 270
 271   Evas_Object* popup = elm_popup_add(window_.GetEvasObject());
 272   elm_object_part_text_set(popup, "title,text", title);
 273   elm_object_part_text_set(popup, NULL, description);
 274   elm_popup_orient_set(popup, ELM_POPUP_ORIENT_CENTER);
 275   active_popup_ = popup;
 276
 277   Evas_Object* btn = elm_button_add(popup);
 278   elm_object_text_set(btn, "Yes");
 279   PermissionPopupButtonData* buttonData = new PermissionPopupButtonData;
 280   buttonData->callbackData=data;
 281   buttonData->callback=cb;
 282   buttonData->popupData=this;
 283
 284   evas_object_smart_callback_add(btn, "clicked", PermissionGranted,
 285                                  buttonData);
 286   elm_object_part_content_set(popup, "button1", btn);
 287
 288   btn = elm_button_add(popup);
 289   elm_object_text_set(btn, "No");
 290   evas_object_smart_callback_add(btn, "clicked", PermissionDeclined,
 291                                  buttonData);
 292   elm_object_part_content_set(popup, "button2", btn);
 293
 294   evas_object_show(popup);
 295 }
 296
 297 void WindowUI::PermissionGranted(void* data, Evas_Object* button, void*) {
 298   log_trace("%s", __PRETTY_FUNCTION__);
 299
 300   PermissionPopupButtonData* buttonData =(PermissionPopupButtonData*) data;
 301   ClosePopup(buttonData->popupData, NULL, NULL);
 302   buttonData->callback(true, buttonData->callbackData);
 303   delete buttonData;
 304 }
 305
 306 void WindowUI::PermissionDeclined(void* data, Evas_Object* button, void*) {
 307   log_trace("%s", __PRETTY_FUNCTION__);
 308
 309   PermissionPopupButtonData* buttonData =(PermissionPopupButtonData*) data;
 310   ClosePopup(buttonData->popupData, NULL, NULL);
 311   buttonData->callback(false, buttonData->callbackData);
 312   delete buttonData;
 313 }
 314
 315 void WindowUI::ShowTextEntryPopup(const char* title,
 316                                   const char* initial_content,
 317                                   Evas_Smart_Cb cb) {
 318   log_trace("%s: (%s, %s)", __PRETTY_FUNCTION__, title, initial_content);
 319
 320   Evas_Object* popup = elm_popup_add(window_.GetEvasObject());
 321   elm_object_part_text_set(popup, "title,text", title);
 322   elm_popup_orient_set(popup, ELM_POPUP_ORIENT_CENTER);
 323   active_popup_ = popup;
 324
 325   Evas_Object* entry = elm_entry_add(popup);
 326   elm_entry_single_line_set(entry, EINA_TRUE);
 327   elm_entry_scrollable_set(entry, EINA_TRUE);
 328   elm_entry_input_panel_layout_set(entry, ELM_INPUT_PANEL_LAYOUT_URL);
 329   evas_object_size_hint_weight_set(entry, EVAS_HINT_EXPAND, 0.0f);
 330   evas_object_size_hint_align_set(entry, EVAS_HINT_FILL, EVAS_HINT_FILL);
 331   evas_object_smart_callback_add(
 332       entry, "activated", cb,
 333       new std::pair<Evas_Object*, WindowUI*>(entry, this));
 334
 335   elm_object_part_content_set(popup, "default", entry);
 336   if (initial_content) {
 337     elm_object_text_set(entry, initial_content);
 338     elm_entry_cursor_end_set(entry);
 339   }
 340
 341   Evas_Object* btn = elm_button_add(popup);
 342   elm_object_text_set(btn, "OK");
 343   evas_object_smart_callback_add(
 344       btn, "clicked", cb, new std::pair<Evas_Object*, WindowUI*>(entry, this));
 345   elm_object_part_content_set(popup, "button1", btn);
 346
 347   btn = elm_button_add(popup);
 348   elm_object_text_set(btn, "Cancel");
 349   evas_object_smart_callback_add(btn, "clicked", ClosePopup, this);
 350   elm_object_part_content_set(popup, "button2", btn);
 351
 352   evas_object_show(popup);
 353 }
 354
 355 void WindowUI::OnCreateWindow(void* data, Evas_Object*, void*) {
 356   log_trace("%s", __PRETTY_FUNCTION__);
 357   WindowUI* thiz = static_cast<WindowUI*>(data);
 358   if (thiz->browser_.IsDesktop()) {
 359     thiz->browser_.CreateWindow().LoadURL(kDefaultNewWindowURL);
 360   } else {
 361     thiz->browser_.ActivateToolboxWindow();
 362   }
 363 }
 364
 365 void WindowUI::OnCreateIncognitoWindow(void* data, Evas_Object*, void*) {
 366   log_trace("%s", __PRETTY_FUNCTION__);
 367   WindowUI* thiz = static_cast<WindowUI*>(data);
 368   thiz->browser_.CreateWindow(true).LoadURL(kDefaultNewWindowURL);
 369 }
 370
 371 void WindowUI::OnBack(void* data, Evas_Object*, void*) {
 372   log_trace("%s", __PRETTY_FUNCTION__);
 373   static_cast<WindowUI*>(data)->window_.Back();
 374 }
 375
 376 void WindowUI::OnForward(void* data, Evas_Object*, void*) {
 377   log_trace("%s", __PRETTY_FUNCTION__);
 378   static_cast<WindowUI*>(data)->window_.Forward();
 379 }
 380
 381 void WindowUI::OnStopOrReload(void* data, Evas_Object*, void*) {
 382   log_trace("%s", __PRETTY_FUNCTION__);
 383   WindowUI* thiz = static_cast<WindowUI*>(data);
 384   if (thiz->is_loading_)
 385     thiz->window_.Stop();
 386   else
 387     thiz->window_.Reload();
 388 }
 389
 390 void WindowUI::OnShowExtraActionsMenu(void* data, Evas_Object* obj, void*) {
 391   log_trace("%s", __PRETTY_FUNCTION__);
 392   WindowUI* thiz = static_cast<WindowUI*>(data);
 393   Evas_Object* popup = thiz->CreateExtraActionsMenu(
 394       thiz->window_.GetEvasObject());
 395
 396   if (!popup)
 397     return;
 398
 399   int x, y;
 400   evas_object_geometry_get(obj, &x, &y, 0, 0);
 401   evas_object_move(popup, x, y);
 402   evas_object_show(popup);
 403 }
 404
 405 void WindowUI::OnURLEntered(void* data, Evas_Object*, void*) {
 406   log_trace("%s", __PRETTY_FUNCTION__);
 407   WindowUI* thiz = static_cast<WindowUI*>(data);
 408   thiz->window_.LoadURL(elm_object_text_get(thiz->url_entry_));
 409   elm_object_focus_set(thiz->url_entry_, EINA_FALSE);
 410 }
 411
 412 void WindowUI::OnUAOverride(void* data, Evas_Object* obj, void*) {
 413   log_trace("%s", __PRETTY_FUNCTION__);
 414   WindowUI* thiz = static_cast<WindowUI*>(data);
 415   const char* ua = thiz->window_.GetUserAgent();
 416   thiz->ShowTextEntryPopup("User Agent Override", ua,
 417                            &WindowUI::OnUAOverrideEntered);
 418   thiz->CloseMenu();
 419 }
 420
 421 void WindowUI::OnUAOverrideEntered(void* data, Evas_Object*, void*) {
 422   std::pair<Evas_Object*, WindowUI*>* p =
 423       static_cast<std::pair<Evas_Object*, WindowUI*>*>(data);
 424   p->second->window_.SetUserAgent(elm_object_text_get(p->first));
 425   evas_object_del(p->second->active_popup_);
 426   p->second->active_popup_ = NULL;
 427   delete p;
 428 }
 429
 430 void WindowUI::OnInspectorShow(void* data, Evas_Object* obj, void*) {
 431   log_trace("%s", __PRETTY_FUNCTION__);
 432   WindowUI* thiz = static_cast<WindowUI*>(data);
 433   thiz->browser_.ShowInspectorWindow();
 434   thiz->CloseMenu();
 435 }
 436
 437 void WindowUI::OnInspectorServerStart(void* data, Evas_Object* obj, void*) {
 438     log_trace("%s", __PRETTY_FUNCTION__);
 439     WindowUI* thiz = static_cast<WindowUI*>(data);
 440     thiz->browser_.StartInspectorServer();
 441     thiz->CloseMenu();
 442 }
 443
 444 void WindowUI::OnRotate(void* data, Evas_Object* obj, void*) {
 445   log_trace("%s", __PRETTY_FUNCTION__);
 446   WindowUI* thiz = static_cast<WindowUI*>(data);
 447   thiz->window_.FakeRotate();
 448   thiz->CloseMenu();
 449 }
 450
 451 void WindowUI::OnSelectMouseInput(void* data, Evas_Object* obj, void*) {
 452   log_trace("%s", __PRETTY_FUNCTION__);
 453   WindowUI* thiz = static_cast<WindowUI*>(data);
 454   thiz->window_.EnableTouchEvents(false);
 455   thiz->window_.EnableMouseEvents(true);
 456   thiz->ShowNotification("Mouse events enabled");
 457   thiz->CloseMenu();
 458 }
 459
 460 void WindowUI::OnSelectTouchInput(void* data, Evas_Object* obj, void*) {
 461   log_trace("%s", __PRETTY_FUNCTION__);
 462   WindowUI* thiz = static_cast<WindowUI*>(data);
 463   thiz->window_.EnableTouchEvents(true);
 464   thiz->window_.EnableMouseEvents(false);
 465   thiz->ShowNotification("Touch events enabled");
 466   thiz->CloseMenu();
 467 }
 468
 469 void WindowUI::OnStartTracing(void* data, Evas_Object* obj, void*) {
 470   log_trace("%s", __PRETTY_FUNCTION__);
 471   WindowUI* thiz = static_cast<WindowUI*>(data);
 472   thiz->browser_.StartTracing();
 473   thiz->CloseMenu();
 474   thiz->ShowNotification("Tracing started");
 475 }
 476
 477 void WindowUI::OnStopTracing(void* data, Evas_Object* obj, void*) {
 478   log_trace("%s", __PRETTY_FUNCTION__);
 479   WindowUI* thiz = static_cast<WindowUI*>(data);
 480   thiz->browser_.StopTracing();
 481   thiz->CloseMenu();
 482   thiz->ShowNotification("Tracing finished");
 483 }
 484
 485 void WindowUI::OnAutoFittingEnabled(void* data, Evas_Object* obj, void*) {
 486   log_trace("%s", __PRETTY_FUNCTION__);
 487   WindowUI* thiz = static_cast<WindowUI*>(data);
 488   Ewk_Settings* settings = thiz->window_.GetEwkSettings();
 489   ewk_settings_auto_fitting_set(settings, true);
 490   thiz->CloseMenu();
 491   thiz->ShowNotification("Auto fitting enabled");
 492 }
 493
 494 void WindowUI::OnAutoFittingDisabled(void* data, Evas_Object* obj, void*) {
 495   log_trace("%s", __PRETTY_FUNCTION__);
 496   WindowUI* thiz = static_cast<WindowUI*>(data);
 497   Ewk_Settings* settings = thiz->window_.GetEwkSettings();
 498   ewk_settings_auto_fitting_set(settings, false);
 499   thiz->CloseMenu();
 500   thiz->ShowNotification("Auto fitting disabled");
 501 }
 502
 503 void WindowUI::OnAutoFillEnabled(void* data, Evas_Object* obj, void*) {
 504   log_trace("%s", __PRETTY_FUNCTION__);
 505   WindowUI* thiz = static_cast<WindowUI*>(data);
 506   Ewk_Settings* settings = thiz->window_.GetEwkSettings();
 507   ewk_settings_form_profile_data_enabled_set(settings, true);
 508   ewk_settings_form_candidate_data_enabled_set(settings, true);
 509   thiz->CloseMenu();
 510   thiz->ShowNotification("Autofill enabled");
 511 }
 512
 513 void WindowUI::OnAutoFillDisabled(void* data, Evas_Object* obj, void*) {
 514   log_trace("%s", __PRETTY_FUNCTION__);
 515   WindowUI* thiz = static_cast<WindowUI*>(data);
 516   Ewk_Settings* settings = thiz->window_.GetEwkSettings();
 517   ewk_settings_form_profile_data_enabled_set(settings, false);
 518   ewk_settings_form_candidate_data_enabled_set(settings, false);
 519   thiz->CloseMenu();
 520   thiz->ShowNotification("Autofill disabled");
 521 }
 522
 523 void WindowUI::ClosePopup(void* data, Evas_Object*, void*) {
 524   WindowUI* thiz = static_cast<WindowUI*>(data);
 525   evas_object_del(thiz->active_popup_);
 526   thiz->active_popup_ = NULL;
 527 }
 528
 529 void WindowUI::OnShowZoomPopup(void* data, Evas_Object* obj, void*) {
 530   log_trace("%s", __PRETTY_FUNCTION__);
 531   WindowUI* thiz = static_cast<WindowUI*>(data);
 532
 533   Evas_Object* popup = elm_popup_add(thiz->window_.GetEvasObject());
 534   elm_object_part_text_set(popup, "title,text", "Change page zoom level");
 535   elm_popup_orient_set(popup, ELM_POPUP_ORIENT_CENTER);
 536   thiz->active_popup_ = popup;
 537   Evas_Object* btn = elm_button_add(popup);
 538
 539   Evas_Object* slider = elm_slider_add(popup);
 540   thiz->window_.GetScaleRange(&kMinViewScale, &kMaxViewScale);
 541   elm_slider_min_max_set(slider, kMinViewScale, kMaxViewScale);
 542   elm_slider_value_set(slider, thiz->window_.GetScale());
 543   elm_slider_indicator_format_set(slider, "%1.2f");
 544   elm_slider_indicator_show_set(slider, EINA_TRUE);
 545   evas_object_smart_callback_add(slider, "changed", &OnZoomChanged, thiz);
 546   elm_object_part_content_set(popup, "default", slider);
 547
 548   elm_object_text_set(btn, "Close");
 549   evas_object_smart_callback_add(btn, "clicked", ClosePopup, thiz);
 550   elm_object_part_content_set(popup, "button1", btn);
 551
 552   evas_object_show(popup);
 553   thiz->CloseMenu();
 554 }
 555
 556 void WindowUI::OnZoomChanged(void* data, Evas_Object* obj, void*) {
 557   log_trace("%s", __PRETTY_FUNCTION__);
 558   WindowUI* thiz = static_cast<WindowUI*>(data);
 559   thiz->window_.SetScale(elm_slider_value_get(obj));
 560 }
 561
 562 void WindowUI::OnRememberFormDataChange(void* data, Evas_Object* obj, void*) {
 563   log_trace("%s", __PRETTY_FUNCTION__);
 564   WindowUI* thiz = static_cast<WindowUI*>(data);
 565   Ewk_Settings* settings = thiz->window_.GetEwkSettings();
 566   if (thiz->window_.IsRememberFormDataEnabled()) {
 567     ewk_settings_form_candidate_data_enabled_set(settings, false);
 568     thiz->ShowNotification("Remember Form Data disabled");
 569   } else {
 570     ewk_settings_form_candidate_data_enabled_set(settings, true);
 571     thiz->ShowNotification("Remember Form Data enabled");
 572   }
 573   thiz->CloseMenu();
 574 }
 575
 576 void WindowUI::OnRememberPasswordChange(void* data, Evas_Object* obj, void*) {
 577   log_trace("%s", __PRETTY_FUNCTION__);
 578   WindowUI* thiz = static_cast<WindowUI*>(data);
 579   Ewk_Settings* settings = thiz->window_.GetEwkSettings();
 580   if (thiz->window_.IsRememberPasswordEnabled()) {
 581     ewk_settings_autofill_password_form_enabled_set(settings, false);
 582     thiz->ShowNotification("Remember Password disabled");
 583   } else {
 584     ewk_settings_autofill_password_form_enabled_set(settings, true);
 585     thiz->ShowNotification("Remember Password enabled");
 586   }
 587   thiz->CloseMenu();
 588 }
 589
 590 void WindowUI::OnFormProfileChange(void* data, Evas_Object* obj, void*) {
 591   log_trace("%s", __PRETTY_FUNCTION__);
 592   WindowUI* thiz = static_cast<WindowUI*>(data);
 593   Ewk_Settings* settings = thiz->window_.GetEwkSettings();
 594   if (thiz->window_.IsFormProfileEnabled()) {
 595     ewk_settings_form_profile_data_enabled_set(settings, false);
 596     thiz->ShowNotification("Form Profile disabled");
 597   } else {
 598     ewk_settings_form_profile_data_enabled_set(settings, true);
 599     thiz->ShowNotification("Form Profile enabled");
 600   }
 601   thiz->CloseMenu();
 602 }
 603
 604 void WindowUI::Exit(void* data, Evas_Object*, void*) {
 605   WindowUI* thiz = static_cast<WindowUI*>(data);
 606   thiz->window_.Exit();
 607 }