Mercurial Repositories > eric / file comparison
comparison: WebBrowser/Sync/SyncManager.py
WebBrowser/Sync/SyncManager.py
- branch
- QtWebEngine
- changeset 4774
- 2c6ffa778c3b
- parent 4631
- 5c1a96925da4
- child 4868
- 985d275502c8
equal
deleted
inserted
replaced
| 4773:cad470dfd807 | 4774:2c6ffa778c3b |
|---|---|
| 1 # -*- coding: utf-8 -*- | |
| 2 | |
| 3 # Copyright (c) 2012 - 2016 Detlev Offenbach <detlev@die-offenbachs.de> | |
| 4 # | |
| 5 | |
| 6 """ | |
| 7 Module implementing the synchronization manager class. | |
| 8 """ | |
| 9 | |
| 10 from __future__ import unicode_literals | |
| 11 | |
| 12 from PyQt5.QtCore import QObject, pyqtSignal | |
| 13 | |
| 14 import Preferences | |
| 15 | |
| 16 from WebBrowser.WebBrowserWindow import WebBrowserWindow | |
| 17 | |
| 18 | |
| 19 class SyncManager(QObject): | |
| 20 """ | |
| 21 Class implementing the synchronization manager. | |
| 22 | |
| 23 @signal syncError(message) emitted for a general error with the error | |
| 24 message (string) | |
| 25 @signal syncMessage(message) emitted to give status info about the sync | |
| 26 process (string) | |
| 27 @signal syncStatus(type_, message) emitted to indicate the synchronization | |
| 28 status (string one of "bookmarks", "history", "passwords", | |
| 29 "useragents" or "speeddial", string) | |
| 30 @signal syncFinished(type_, done, download) emitted after a | |
| 31 synchronization has finished (string one of "bookmarks", "history", | |
| 32 "passwords", "useragents" or "speeddial", boolean, boolean) | |
| 33 """ | |
| 34 syncError = pyqtSignal(str) | |
| 35 syncMessage = pyqtSignal(str) | |
| 36 syncStatus = pyqtSignal(str, str) | |
| 37 syncFinished = pyqtSignal(str, bool, bool) | |
| 38 | |
| 39 def __init__(self, parent=None): | |
| 40 """ | |
| 41 Constructor | |
| 42 | |
| 43 @param parent reference to the parent object (QObject) | |
| 44 """ | |
| 45 super(SyncManager, self).__init__(parent) | |
| 46 | |
| 47 self.__handler = None | |
| 48 | |
| 49 def handler(self): | |
| 50 """ | |
| 51 Public method to get a reference to the sync handler object. | |
| 52 | |
| 53 @return reference to the sync handler object (SyncHandler) | |
| 54 """ | |
| 55 return self.__handler | |
| 56 | |
| 57 def showSyncDialog(self): | |
| 58 """ | |
| 59 Public method to show the synchronization dialog. | |
| 60 """ | |
| 61 from .SyncAssistantDialog import SyncAssistantDialog | |
| 62 dlg = SyncAssistantDialog() | |
| 63 dlg.exec_() | |
| 64 | |
| 65 def loadSettings(self, forceUpload=False): | |
| 66 """ | |
| 67 Public method to load the settings. | |
| 68 | |
| 69 @keyparam forceUpload flag indicating a forced upload of the files | |
| 70 (boolean) | |
| 71 """ | |
| 72 if self.__handler is not None: | |
| 73 self.__handler.syncError.disconnect(self.__syncError) | |
| 74 self.__handler.syncFinished.disconnect(self.__syncFinished) | |
| 75 self.__handler.syncStatus.disconnect(self.__syncStatus) | |
| 76 self.__handler.syncMessage.disconnect(self.syncMessage) | |
| 77 self.__handler.shutdown() | |
| 78 | |
| 79 if self.syncEnabled(): | |
| 80 from . import SyncGlobals | |
| 81 if Preferences.getWebBrowser("SyncType") == SyncGlobals.SyncTypeFtp: | |
| 82 from .FtpSyncHandler import FtpSyncHandler | |
| 83 self.__handler = FtpSyncHandler(self) | |
| 84 elif Preferences.getWebBrowser("SyncType") == \ | |
| 85 SyncGlobals.SyncTypeDirectory: | |
| 86 from .DirectorySyncHandler import DirectorySyncHandler | |
| 87 self.__handler = DirectorySyncHandler(self) | |
| 88 self.__handler.syncError.connect(self.__syncError) | |
| 89 self.__handler.syncFinished.connect(self.__syncFinished) | |
| 90 self.__handler.syncStatus.connect(self.__syncStatus) | |
| 91 self.__handler.syncMessage.connect(self.syncMessage) | |
| 92 | |
| 93 self.__handler.initialLoadAndCheck(forceUpload=forceUpload) | |
| 94 | |
| 95 # connect sync manager to bookmarks manager | |
| 96 if Preferences.getWebBrowser("SyncBookmarks"): | |
| 97 WebBrowserWindow.bookmarksManager()\ | |
| 98 .bookmarksSaved.connect(self.__syncBookmarks) | |
| 99 else: | |
| 100 try: | |
| 101 WebBrowserWindow.bookmarksManager()\ | |
| 102 .bookmarksSaved.disconnect(self.__syncBookmarks) | |
| 103 except TypeError: | |
| 104 pass | |
| 105 | |
| 106 # connect sync manager to history manager | |
| 107 if Preferences.getWebBrowser("SyncHistory"): | |
| 108 WebBrowserWindow.historyManager().historySaved\ | |
| 109 .connect(self.__syncHistory) | |
| 110 else: | |
| 111 try: | |
| 112 WebBrowserWindow.historyManager()\ | |
| 113 .historySaved.disconnect(self.__syncHistory) | |
| 114 except TypeError: | |
| 115 pass | |
| 116 | |
| 117 # connect sync manager to passwords manager | |
| 118 if Preferences.getWebBrowser("SyncPasswords"): | |
| 119 WebBrowserWindow.passwordManager()\ | |
| 120 .passwordsSaved.connect(self.__syncPasswords) | |
| 121 else: | |
| 122 try: | |
| 123 WebBrowserWindow.passwordManager()\ | |
| 124 .passwordsSaved.disconnect(self.__syncPasswords) | |
| 125 except TypeError: | |
| 126 pass | |
| 127 | |
| 128 # TODO: UserAgents | |
| 129 # connect sync manager to user agent manager | |
| 130 ## if Preferences.getWebBrowser("SyncUserAgents"): | |
| 131 ## WebBrowserWindow.userAgentsManager()\ | |
| 132 ## .userAgentSettingsSaved.connect(self.__syncUserAgents) | |
| 133 ## else: | |
| 134 ## try: | |
| 135 ## WebBrowserWindow.userAgentsManager()\ | |
| 136 ## .userAgentSettingsSaved.disconnect( | |
| 137 ## self.__syncUserAgents) | |
| 138 ## except TypeError: | |
| 139 ## pass | |
| 140 | |
| 141 # TODO: SpeedDial | |
| 142 # connect sync manager to speed dial | |
| 143 ## if Preferences.getWebBrowser("SyncSpeedDial"): | |
| 144 ## WebBrowserWindow.speedDial()\ | |
| 145 ## .speedDialSaved.connect(self.__syncSpeedDial) | |
| 146 ## else: | |
| 147 ## try: | |
| 148 ## WebBrowserWindow.speedDial()\ | |
| 149 ## .speedDialSaved.disconnect(self.__syncSpeedDial) | |
| 150 ## except TypeError: | |
| 151 ## pass | |
| 152 else: | |
| 153 self.__handler = None | |
| 154 | |
| 155 try: | |
| 156 WebBrowserWindow.bookmarksManager()\ | |
| 157 .bookmarksSaved.disconnect(self.__syncBookmarks) | |
| 158 except TypeError: | |
| 159 pass | |
| 160 try: | |
| 161 WebBrowserWindow.historyManager().historySaved\ | |
| 162 .disconnect(self.__syncHistory) | |
| 163 except TypeError: | |
| 164 pass | |
| 165 try: | |
| 166 WebBrowserWindow.passwordManager()\ | |
| 167 .passwordsSaved.disconnect(self.__syncPasswords) | |
| 168 except TypeError: | |
| 169 pass | |
| 170 # TODO: UserAgents | |
| 171 ## try: | |
| 172 ## WebBrowserWindow.userAgentsManager()\ | |
| 173 ## .userAgentSettingsSaved.disconnect(self.__syncUserAgents) | |
| 174 ## except TypeError: | |
| 175 ## pass | |
| 176 # TODO: SpeedDial | |
| 177 ## try: | |
| 178 ## WebBrowserWindow.speedDial()\ | |
| 179 ## .speedDialSaved.disconnect(self.__syncSpeedDial) | |
| 180 ## except TypeError: | |
| 181 ## pass | |
| 182 | |
| 183 def syncEnabled(self): | |
| 184 """ | |
| 185 Public method to check, if synchronization is enabled. | |
| 186 | |
| 187 @return flag indicating enabled synchronization | |
| 188 """ | |
| 189 from . import SyncGlobals | |
| 190 return Preferences.getWebBrowser("SyncEnabled") and \ | |
| 191 Preferences.getWebBrowser("SyncType") != SyncGlobals.SyncTypeNone | |
| 192 | |
| 193 def __syncBookmarks(self): | |
| 194 """ | |
| 195 Private slot to synchronize the bookmarks. | |
| 196 """ | |
| 197 if self.__handler is not None: | |
| 198 self.__handler.syncBookmarks() | |
| 199 | |
| 200 def __syncHistory(self): | |
| 201 """ | |
| 202 Private slot to synchronize the history. | |
| 203 """ | |
| 204 if self.__handler is not None: | |
| 205 self.__handler.syncHistory() | |
| 206 | |
| 207 def __syncPasswords(self): | |
| 208 """ | |
| 209 Private slot to synchronize the passwords. | |
| 210 """ | |
| 211 if self.__handler is not None: | |
| 212 self.__handler.syncPasswords() | |
| 213 | |
| 214 def __syncUserAgents(self): | |
| 215 """ | |
| 216 Private slot to synchronize the user agent settings. | |
| 217 """ | |
| 218 if self.__handler is not None: | |
| 219 self.__handler.syncUserAgents() | |
| 220 | |
| 221 def __syncSpeedDial(self): | |
| 222 """ | |
| 223 Private slot to synchronize the speed dial settings. | |
| 224 """ | |
| 225 if self.__handler is not None: | |
| 226 self.__handler.syncSpeedDial() | |
| 227 | |
| 228 def __syncError(self, message): | |
| 229 """ | |
| 230 Private slot to handle general synchronization issues. | |
| 231 | |
| 232 @param message error message (string) | |
| 233 """ | |
| 234 self.syncError.emit(message) | |
| 235 | |
| 236 def __syncFinished(self, type_, status, download): | |
| 237 """ | |
| 238 Private slot to handle a finished synchronization event. | |
| 239 | |
| 240 @param type_ type of the synchronization event (string one | |
| 241 of "bookmarks", "history", "passwords", "useragents" or | |
| 242 "speeddial") | |
| 243 @param status flag indicating success (boolean) | |
| 244 @param download flag indicating a download of a file (boolean) | |
| 245 """ | |
| 246 if status and download: | |
| 247 if type_ == "bookmarks": | |
| 248 WebBrowserWindow.bookmarksManager().reload() | |
| 249 elif type_ == "history": | |
| 250 WebBrowserWindow.historyManager().reload() | |
| 251 elif type_ == "passwords": | |
| 252 WebBrowserWindow.passwordManager().reload() | |
| 253 # TODO: UserAgents | |
| 254 ## elif type_ == "useragents": | |
| 255 ## WebBrowserWindow.userAgentsManager().reload() | |
| 256 # TODO: SpeeedDial | |
| 257 ## elif type_ == "speeddial": | |
| 258 ## WebBrowserWindow.speedDial().reload() | |
| 259 self.syncFinished.emit(type_, status, download) | |
| 260 | |
| 261 def __syncStatus(self, type_, message): | |
| 262 """ | |
| 263 Private slot to handle a status update of a synchronization event. | |
| 264 | |
| 265 @param type_ type of the synchronization event (string one | |
| 266 of "bookmarks", "history", "passwords", "useragents" or | |
| 267 "speeddial") | |
| 268 @param message status message for the event (string) | |
| 269 """ | |
| 270 self.syncMessage.emit(message) | |
| 271 self.syncStatus.emit(type_, message) | |
| 272 | |
| 273 def close(self): | |
| 274 """ | |
| 275 Public slot to shut down the synchronization manager. | |
| 276 """ | |
| 277 if not self.syncEnabled(): | |
| 278 return | |
| 279 | |
| 280 if self.__handler is not None: | |
| 281 self.__handler.shutdown() |
