services/SimpleUI/SimpleUI.h

   1 /*
   2  * Copyright (c) 2014 Samsung Electronics Co., Ltd.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the License);
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an AS IS BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 /*
  18  * SimpleUI.h
  19  *
  20  *  Created on: Mar 18, 2014
  21  *      Author: k.szalilow
  22  */
  23
  24 #ifndef SIMPLEUI_H_
  25 #define SIMPLEUI_H_
  26
  27 #include <Evas.h>
  28
  29 #include "AbstractMainWindow.h"
  30 #include "AbstractService.h"
  31 #include "AbstractFavoriteService.h"
  32 #include "ServiceFactory.h"
  33 #include "service_macros.h"
  34
  35 // components
  36 #include "AbstractWebEngine.h"
  37 #include "MoreMenuUI.h"
  38 #include "HistoryUI.h"
  39 #include "SettingsUI.h"
  40 #include "MainUI.h"
  41 #include "TabUI.h"
  42 #include "ButtonBar.h"
  43 #include "HistoryService.h"
  44 #include "BookmarkManagerUI.h"
  45 #include "SimpleURI.h"
  46 #include "SimpleScroller.h"
  47 #include "WebTitleBar.h"
  48 #include "PlatformInputManager.h"
  49 #include "SessionStorage.h"
  50 #include "SqlStorage.h"
  51
  52 // other
  53 #include "Action.h"
  54 #include "SimplePopup.h"
  55 #include "WebConfirmation.h"
  56 #include "ZoomList.h"
  57 #include "TabList.h"
  58 #include "BookmarksManager.h"
  59 #include "Settings.h"
  60 #include "HistoryList.h"
  61 #include "NetworkErrorHandler.h"
  62 #include "CustomPopup.h"
  63 #include "Config.h"
  64
  65 namespace tizen_browser{
  66 namespace base_ui{
  67
  68 template <>
  69 void AbstractMainWindow<Evas_Object>::setMainWindow(Evas_Object * rawPtr)
  70 {
  71     m_window = std::shared_ptr<Evas_Object>(rawPtr, evas_object_del);
  72 }
  73
  74 class BROWSER_EXPORT SimpleUI : public AbstractMainWindow<Evas_Object>
  75 {
  76 public:
  77     SimpleUI(/*Evas_Object *window*/);
  78     virtual ~SimpleUI();
  79     virtual int exec(const std::string& url);
  80     virtual std::string getName();
  81
  82     void destroyUI();
  83 private:
  84     // setup functions
  85     void loadThemes();
  86     void createActions();
  87     void connectActions();
  88     void loadUIServices();
  89     void connectUISignals();
  90     void loadModelServices();
  91     void initModelServices();
  92     void connectModelSignals();
  93     void restoreLastSession();
  94     Evas_Object* createWebLayout(Evas_Object* parent);
  95     Evas_Object* createErrorLayout(Evas_Object* parent);
  96
  97
  98     void backEnable(bool enable);
  99     void forwardEnable(bool enable);
 100     void stopEnable(bool enable);
 101     void reloadEnable(bool enable);
 102     void addBookmarkEnable(bool enable);
 103     void removeBookmarkEnable(bool enable);
 104     void zoomEnable(bool enable);
 105
 106     void settingsButtonEnable(bool enable);
 107
 108     void loadFinished();
 109     void progressChanged(double progress);
 110     void loadStarted();
 111
 112     void loadError();
 113     void setErrorButtons();
 114     bool isErrorPageActive();
 115
 116     void bookmarkAdded();
 117     void bookmarkDeleted();
 118
 119     bool isHomePageActive();
 120     void switchViewToHomePage();
 121     void updateBrowserView();
 122     void updateWebView();
 123     void updateURIBarView();
 124     void updateView();
 125
 126     void openNewTab(const std::string &uri, bool desktopMode = true);
 127     void switchToTab(const tizen_browser::basic_webengine::TabId& tabId);
 128     void newTabClicked(const std::string &);
 129     void tabClicked(const tizen_browser::basic_webengine::TabId& tabId);
 130     void closeTabsClicked(const tizen_browser::basic_webengine::TabId& tabId);
 131     void tabCreated();
 132     void tabClosed(const tizen_browser::basic_webengine::TabId& id);
 133
 134     void bookmarkCheck();
 135     std::vector<std::shared_ptr<tizen_browser::services::BookmarkItem> > getBookmarks(int folder_id = -1);
 136     std::vector<std::shared_ptr<tizen_browser::services::BookmarkItem> > getBookmarkFolders(int folder_id);
 137     std::shared_ptr<services::HistoryItemVector> getHistory();
 138     std::shared_ptr<services::HistoryItemVector> getMostVisitedItems();
 139
 140     //UI signal handling functions
 141     void onBookmarkAdded(std::shared_ptr<tizen_browser::services::BookmarkItem> bookmarkItem);
 142
 143     void onBookmarkClicked(std::shared_ptr<tizen_browser::services::BookmarkItem> bookmarkItem);
 144     void onBookmarkDeleteClicked(std::shared_ptr<tizen_browser::services::BookmarkItem> bookmarkItem);
 145     void onBookmarkRemoved(const std::string& uri);
 146
 147     void onHistoryAdded(std::shared_ptr<tizen_browser::services::HistoryItem> historyItem);
 148     void onHistoryRemoved(const std::string& uri);
 149     void onOpenURLInNewTab(std::shared_ptr<tizen_browser::services::HistoryItem> historyItem, bool desktopMode);
 150     void onMostVisitedTileClicked(std::shared_ptr<tizen_browser::services::HistoryItem> historyItem, int itemsNumber);
 151     void onClearHistoryClicked(const std::string&);
 152
 153     void onMostVisitedClicked(const std::string&);
 154     void onBookmarkButtonClicked(const std::string&);
 155     void onBookmarkManagerButtonClicked(const std::string&);
 156
 157     void handleConfirmationRequest(basic_webengine::WebConfirmationPtr webConfirmation);
 158     void authPopupButtonClicked(PopupButtons button, std::shared_ptr<PopupData> popupData);
 159
 160     void onActionTriggered(const Action& action);
 161
 162
 163     void setwvIMEStatus(bool status);
 164
 165     sharedAction m_back;
 166     sharedAction m_forward;
 167     sharedAction m_stopLoading;
 168     sharedAction m_reload;
 169     sharedAction m_bookmark;
 170     sharedAction m_unbookmark;
 171     sharedAction m_tab;
 172     sharedAction m_share;
 173     sharedAction m_zoom_in;
 174     sharedAction m_showMoreMenu;
 175     sharedAction m_showBookmarkManagerUI;
 176     sharedAction m_settingPointerMode;
 177     sharedAction m_settingPrivateBrowsing;
 178     sharedAction m_settingDeleteHistory;
 179     sharedAction m_settingDeleteData;
 180     sharedAction m_settingDeleteFavorite;
 181     sharedAction m_mostvisited;
 182     sharedAction m_bookmarksvisited;
 183     sharedAction m_bookmarks_manager_Add_NewFolder;
 184     sharedAction m_bookmarks_manager_BookmarkBar;
 185     sharedAction m_bookmarks_manager_Folder1;
 186     sharedAction m_bookmarks_manager_Folder2;
 187     sharedAction m_bookmarks_manager_Folder3;
 188
 189     /**
 190      * \brief filters URL before it is passed to WebEngine.
 191      *
 192      * This function should be connected with m_simpleURI->uriChanged.
 193      * it is a good place to check for special urls (like "about:home"),
 194      * filter forbidden addresses and to check set favorite icon.
 195      */
 196     void filterURL(const std::string& url);
 197
 198     /**
 199      * Checks if correct tab is visible to user, and if not, it update browser view
 200      * @param id of tab that should be visible to user
 201      */
 202     void checkTabId(const tizen_browser::basic_webengine::TabId& id);
 203
 204     /**
 205      * \brief check if url comming back from WebEngine should be passed to URI.
 206      *
 207      * For filtered addresses we need to hide real URI so the user would be confused.
 208      * and this is a back function that checks if address emited from browser should be changed.
 209      */
 210     void webEngineURLChanged(const std::string url);
 211     void onmostHistoryvisitedClicked();
 212     void onBookmarkvisitedClicked();
 213      /**
 214      * @brief Adds current page to bookmarks.
 215      *
 216      */
 217     void addToBookmarks(int);
 218     /**
 219      * @brief Remove current page from bookmarks
 220      *
 221      * @param  ...
 222      * @return void
 223      */
 224     void deleteBookmark(void);
 225
 226     /**
 227      * \brief shows Zoom showZoomMenu
 228      */
 229     void showZoomMenu();
 230
 231     void zoomLevelChanged(int zoom_level);
 232
 233     void showHistory();
 234     void hideHistory();
 235     void AddBookmarkPopup(std::string& str);
 236     void AddNewFolderPopup(std::string& str);
 237     void addBookmarkFolders();
 238
 239     void newFolderBookmarkManager(const char* title, int by_user);
 240     void newFolderMoreMenu(const char* title, int by_user);
 241     void showTabUI();
 242     void closeTabUI(const std::string& str);
 243     void showMoreMenu();
 244     void closeMoreMenu(const std::string& str);
 245     void switchToMobileMode();
 246     void switchToDesktopMode();
 247     void showHistoryUI(const std::string& str);
 248     void closeHistoryUI(const std::string&);
 249     void showMainUI();
 250     void hideMainUI();
 251     void showURIBar();
 252     void hideURIBar();
 253     void hideWebView();
 254     void hideSettingsMenu();
 255     void showSettingsUI(const std::string&);
 256     void closeSettingsUI(const std::string&);
 257
 258     void showProgressBar();
 259     void hideProgressBar();
 260
 261     void closeBookmarkManagerMenu(std::string& str);
 262     void updateBookmarkManagerGenGrid(int folder_id);
 263     void showBookmarkManagerMenu();
 264
 265     void showPopup(Evas_Object *content, char* btn1_text, char* btn2_text);
 266
 267     void closeTab();
 268     void closeTab(const tizen_browser::basic_webengine::TabId& id);
 269
 270     void settingsPointerModeSwitch(bool newState);
 271     void settingsPrivateModeSwitch(bool newState);
 272     void settingsDeleteData();
 273     void settingsDeleteFavorite();
 274     void settingsDeleteSelectedData(const std::string& str);
 275     void settingsResetMostVisited(const std::string& str);
 276     void settingsResetBrowser(const std::string& str);
 277     void onDeleteSelectedDataButton(PopupButtons button, std::shared_ptr<PopupData> popupData);
 278     void onDeleteMostVisitedButton(PopupButtons button, std::shared_ptr<PopupData> popupData);
 279     void onResetBrowserButton(PopupButtons button, std::shared_ptr<PopupData> popupData);
 280     void onDeleteDataButton(PopupButtons button, std::shared_ptr<PopupData> popupData);
 281     void onDeleteFavoriteButton(PopupButtons button, std::shared_ptr<PopupData> popupData);
 282     void tabLimitPopupButtonClicked(PopupButtons button, std::shared_ptr< PopupData > /*popupData*/);
 283     void openLinkFromPopup(const std::string &);
 284     void disableHistoryButton(bool flag);
 285     int tabsCount();
 286
 287     void onNetworkError();
 288     void onNetworkConnected();
 289     void onNetErrorButtonPressed(PopupButtons, std::shared_ptr<PopupData>);
 290
 291     void onReturnPressed(MenuButton *m);
 292     void onBackPressed();
 293
 294     boost::signals2::signal<void ()> hidePopup;
 295
 296     std::string edjePath(const std::string &);
 297
 298     Evas_Object *m_mainLayout;
 299     Evas_Object *m_progressBar;
 300     Evas_Object *m_popup;
 301     Evas_Object *m_entry;
 302     Evas_Object *m_errorLayout;
 303     CustomPopup *m_ownPopup;
 304     SimpleScroller *m_scroller;
 305
 306     std::shared_ptr<basic_webengine::AbstractWebEngine<Evas_Object>>  m_webEngine;
 307     std::shared_ptr<tizen_browser::base_ui::SimpleURI> m_simpleURI;
 308     std::shared_ptr<ButtonBar> leftButtonBar;
 309     std::shared_ptr<ButtonBar> webviewbar;
 310
 311     std::shared_ptr<ButtonBar> rightButtonBar;
 312     std::shared_ptr<tizen_browser::interfaces::AbstractFavoriteService> m_favoriteService;
 313     std::shared_ptr<tizen_browser::services::HistoryService> m_historyService;
 314     std::shared_ptr<tizen_browser::base_ui::MoreMenuUI> m_moreMenuUI;
 315     std::shared_ptr<tizen_browser::base_ui::BookmarkManagerUI> m_bookmarkManagerUI;
 316     std::shared_ptr<tizen_browser::base_ui::MainUI> m_mainUI;
 317     std::shared_ptr<tizen_browser::base_ui::HistoryUI> m_historyUI;
 318     std::shared_ptr<tizen_browser::base_ui::SettingsUI> m_settingsUI;
 319     std::shared_ptr<tizen_browser::base_ui::TabUI> m_tabUI;
 320     std::shared_ptr<tizen_browser::base_ui::ZoomList> m_zoomList;
 321     std::shared_ptr<tizen_browser::base_ui::TabList> m_tabList;
 322     std::shared_ptr<tizen_browser::services::PlatformInputManager> m_platformInputManager;
 323     std::shared_ptr<tizen_browser::services::SessionStorage> m_sessionService;
 324     tizen_browser::Session::Session m_currentSession;
 325     std::shared_ptr<BookmarksManager> m_bookmarks_manager;
 326     std::shared_ptr<Settings> m_settings;
 327     std::shared_ptr<HistoryList> m_historyList;
 328     std::shared_ptr<WebTitleBar> webTitleBar;
 329     bool m_initialised;
 330     bool m_isHomePageActive;
 331     zoom_type m_currentZoom;
 332     int m_tabLimit;
 333     int m_favoritesLimit;
 334     bool m_wvIMEStatus;
 335     int m_curr_folder_id;
 336     // This context object is used to implicitly init internal ewk data used by opengl to create the first and
 337     // consecutive webviews in the application, otherwise we would encounter a crash after creating
 338     // the first web view
 339     Ewk_Context *m_ewkContext;
 340
 341     std::vector<std::shared_ptr<tizen_browser::services::HistoryItem>> items_vector;
 342     std::unique_ptr<tizen_browser::basic_ui::NetworkErrorHandler> m_netErrorHandler;
 343     SimplePopup* m_networkErrorPopup;
 344
 345     void searchWebPage(std::string &text, int flags);
 346     static void favicon_clicked(void *data, Evas_Object *obj, const char *emission, const char *source);
 347
 348 };
 349
 350 }
 351 }
 352
 353 #endif /* SIMPLEUI_H_ */