Esempio n. 1
0
 def __spaceDone(self):
     self.__spaceInited = True
     if self.__spaceDestroyedDuringLoad:
         self.__spaceDestroyedDuringLoad = False
         self.destroy()
     self.onSpaceCreate()
     Waiting.hide('loadHangarSpace')
Esempio n. 2
0
 def processLobby(self):
     yield self.__populateData()
     self._subscribe()
     if constants.IS_SHOW_SERVER_STATS:
         self.__requestServerStats()
     self.updateAccountInfo()
     Waiting.hide('enter')
Esempio n. 3
0
 def stopProcessing(self, result = False, data = None):
     if self._callback is not None:
         self._callback(result, data)
         self._callback = None
     if len(self._waitingID):
         Waiting.hide(self._waitingID)
     return
Esempio n. 4
0
 def __handleStartTraining(self, event):
     if not event.settingsID:
         LOG_ERROR('Name of tutorial is not defined', event.settingsID)
         return
     Waiting.show('tutorial-chapter-loading', isSingle=True)
     self.startTraining(event.settingsID, event.getState())
     Waiting.hide('tutorial-chapter-loading')
Esempio n. 5
0
        def callback(result):
            if result:
                cd.function(*cd._packArgs(), **cd._kwargs)
            else:
                from gui.Scaleform.Waiting import Waiting

                Waiting.rollback()
Esempio n. 6
0
 def show():
     if Disconnect.__window is None:
         Disconnect.__showParentCursor(False)
         Disconnect.__window = _Disconnect()
         Disconnect.__window.active(True)
         Waiting.close()
     return
Esempio n. 7
0
 def onLogin(self, user, password, host, hdlr, isSocialToken2Login = False):
     self.__onLoggingTryingEndHdlr = hdlr
     self.__kickedFromServer = False
     self.__kickPeripheryID = None
     if self.__closeCallbackId:
         BigWorld.cancelCallback(self.__closeCallbackId)
         self.__closeCallbackId = None
     if not isSocialToken2Login:
         if not self.__validateCredentials(user.lower().strip(), password.strip()):
             self.__onLoggingTryingEndHdlr()
             return
     Waiting.show('login')
     self.__loginDataLoader.host = host
     self.__loginDataLoader.user = user
     self.__loginDataLoader.passLength = len(password)
     self.__loginDataLoader.saveUserConfig(user, self.__loginDataLoader.host)
     password = pwd_token.generate(password)
     if len(self.__loginDataLoader.token2):
         password = ''
     token2 = self.__loginDataLoader.token2
     if AUTO_LOGIN_QUERY_URL == host:
         g_preDefinedHosts.autoLoginQuery(lambda host: connectionManager.connect(getHostURL(host, token2), user, password, host.keyPath, nickName=None, token2=token2, isNeedSavingPwd=self.__loginDataLoader.rememberPwd))
         return
     else:
         host = g_preDefinedHosts.byUrl(host)
         connectionManager.connect(getHostURL(host, token2, True), user, password, host.keyPath, nickName=None, token2=token2, isNeedSavingPwd=self.__loginDataLoader.rememberPwd)
         return
Esempio n. 8
0
 def _populate(self):
     super(BattleLoading, self)._populate()
     g_sessionProvider.addArenaCtrl(self)
     BigWorld.wg_updateColorGrading()
     BigWorld.wg_enableGUIBackground(True, False)
     self._addArenaTypeData()
     Waiting.close()
Esempio n. 9
0
    def _populate(self):
        super(LoginView, self)._populate()
        if self.__onLoadCallback is not None:
            self.__onLoadCallback()
        self.__setupDispatcherHandlers(True)
        self.__loginDispatcher.create()
        self.__enableInputsIfModalViewsNotExisting()
        self.__loadVersion()
        self.__setCopyright()
        Waiting.close()
        MusicController.g_musicController.stopAmbient()
        MusicController.g_musicController.play(MusicController.MUSIC_EVENT_LOGIN)
        self.__loadRandomBgImage()
        if constants.IS_DEVELOPMENT:
            try:
                tmp_fil = open('GUIUnitTest.ut', 'r')
                if tmp_fil.readline().strip() != '':
                    tmp_fil.close()
                    sys.path.append('../../gui_unit_test/scripts')
                    import GUIUnitTest
                else:
                    tmp_fil.close()
            except IOError:
                pass

        self.__capsLockCallback = BigWorld.callback(0.1, self.__checkUserInputState)
        g_sessionProvider.getCtx().lastArenaUniqueID = None
        self.__showRequiredLoginScreen()
 def __ci_onCustomizationDropSuccess(self, message):
     self.as_onDropSuccessS()
     Waiting.hide('customizationDrop')
     self.__lockUpdate = False
     BigWorld.player().resyncDossiers()
     self.__refreshData()
     SystemMessages.pushMessage(message, type=SystemMessages.SM_TYPE.Information)
Esempio n. 11
0
 def callback(result):
     if result:
         cd.function(*cd._packArgs(), **cd._kwargs)
     else:
         from gui.Scaleform.Waiting import Waiting
         Waiting.rollback()
         self.__controller.onCaptchaInputCanceled()
Esempio n. 12
0
def fini():
    Waiting.close()
    g_eventBus.removeListener(events.GUICommonEvent.APP_STARTED, onAppStarted)
    LogitechMonitor.destroy()
    g_windowsManager.destroy()
    SystemMessages.g_instance.destroy()
    g_eventBus.clear()
    g_prbLoader.fini()
    g_clanCache.fini()
    game_control.g_instance.fini()
    g_settingsCore.fini()
    g_settingsCache.fini()
    g_eventsCache.fini()
    g_itemsCache.fini()
    g_playerEvents.onIGRTypeChanged -= onIGRTypeChanged
    g_playerEvents.onAccountShowGUI -= onAccountShowGUI
    g_playerEvents.onAccountBecomeNonPlayer -= onAccountBecomeNonPlayer
    g_playerEvents.onAvatarBecomePlayer -= onAvatarBecomePlayer
    g_playerEvents.onAccountBecomePlayer -= onAccountBecomePlayer
    g_playerEvents.onClientUpdated -= onClientUpdate
    g_playerEvents.onShopResyncStarted -= onShopResyncStarted
    g_playerEvents.onShopResync -= onShopResync
    g_playerEvents.onCenterIsLongDisconnected -= onCenterIsLongDisconnected
    from constants import IS_DEVELOPMENT
    if IS_DEVELOPMENT:
        try:
            from gui.development import fini
        except ImportError:
            LOG_ERROR('Development features not found.')
            fini = lambda : None

        fini()
Esempio n. 13
0
    def getVehicleInfo(self):
        Waiting.show('updating')
        items = yield ItemsRequester().request()
        vehicle = items.getItemByCD(self.vehicleDescr.type.compactDescr)
        if vehicle is None:
            LOG_ERROR('There is error while showing vehicle info window: ', self.vehicleDescr.type.compactDescr)
            return
        else:
            params = vehicle.getParams()
            tankmenParams = list()
            for slotIdx, tankman in vehicle.crew:
                role = vehicle.descriptor.type.crewRoles[slotIdx][0]
                tankmanLabel = ''
                if tankman is not None:
                    tankmanLabel = '%s %s (%d%%)' % (tankman.rankUserName, tankman.lastUserName, tankman.roleLevel)
                tankmenParams.append({'tankmanType': i18n.convert(tankmen.getSkillsConfig()[role].get('userString', '')),
                 'value': tankmanLabel})

            info = {'vehicleName': vehicle.longUserName,
             'vehicleDiscription': vehicle.fullDescription,
             'vehicleImage': vehicle.icon,
             'vehicleLevel': vehicle.level,
             'vehicleNation': vehicle.nationID,
             'vehicleElite': vehicle.isElite,
             'vehicleType': vehicle.type,
             'VehicleInfoPropsData': [ {'name': n,
                                      'value': v} for n, v in params['parameters'] ],
             'VehicleInfoBaseData': params['base'],
             'VehicleInfoCrewData': tankmenParams}
            self.as_setVehicleInfoS(info)
            Waiting.hide('updating')
            return
Esempio n. 14
0
 def showKick(reason, isBan, expiryTime):
     if Disconnect.__window is None:
         Disconnect.__showParentCursor(False)
         Disconnect.__window = _Disconnect()
         Disconnect.__window.show(reason, isBan, expiryTime)
         Disconnect.__window.active(True)
         Waiting.close()
Esempio n. 15
0
def onAvatarBecomePlayer():
    yield g_settingsCache.update()
    g_settingsCore.serverSettings.applySettings()
    g_prbLoader.onAvatarBecomePlayer()
    game_control.g_instance.onAvatarBecomePlayer()
    g_clanCache.onAvatarBecomePlayer()
    Waiting.cancelCallback()
Esempio n. 16
0
 def cancelQueue(self, showWaiting = True, logged = False):
     if self.__onLoginQueue:
         if showWaiting:
             Waiting.show('enter')
         self.__setLoginQueue(False)
     self.fireEvent(LoginEvent(LoginEvent.CANCEL_LGN_QUEUE, View.alias))
     self.as_cancelLoginQueueS()
Esempio n. 17
0
 def removeVehicle(self):
     if self.__inited:
         Waiting.show('loadHangarSpaceVehicle')
         if self.__space is not None:
             self.__space.removeVehicle()
         self.__changeDone()
         self.__lastUpdatedVehicle = None
Esempio n. 18
0
 def buyAndInstallItem(self, itemCD, rootCD, state):
     itemTypeID, nationID, itemID = vehicles.parseIntCompactDescr(itemCD)
     raise itemTypeID in GUI_ITEM_TYPE.VEHICLE_MODULES or AssertionError
     vehicle = g_itemsCache.items.getItemByCD(rootCD)
     if not vehicle.isInInventory:
         raise AssertionError('Vehicle must be in inventory')
         item = g_itemsCache.items.getItemByCD(itemCD)
         conflictedEqs = item.getConflictedEquipments(vehicle)
         if not self._canBuy(item) and self._canBuyWithExchange(item):
             isOk, args = yield DialogsInterface.showDialog(ExchangeCreditsMeta(itemCD, vehicle.intCD))
             if not isOk:
                 return
         if self._canBuy(item):
             Waiting.show('buyAndInstall')
             vehicle = g_itemsCache.items.getItemByCD(rootCD)
             gunCD = getGunCD(item, vehicle)
             result = yield BuyAndInstallItemProcessor(vehicle, item, 0, gunCD, conflictedEqs=conflictedEqs).request()
             processMsg(result)
             if result.success and item.itemTypeID in (GUI_ITEM_TYPE.TURRET, GUI_ITEM_TYPE.GUN):
                 item = g_itemsCache.items.getItemByCD(itemCD)
                 vehicle = g_itemsCache.items.getItemByCD(rootCD)
                 item.isInstalled(vehicle) and (yield tryToLoadDefaultShellsLayout(vehicle))
         Waiting.hide('buyAndInstall')
     RequestState.received(state)
     yield lambda callback = None: callback
     return
Esempio n. 19
0
 def _populate(self):
     battle_selector_items.create()
     super(LobbyHeader, self)._populate()
     self.app.containerManager.onViewAddedToContainer += self.__onViewAddedToContainer
     game_control.g_instance.wallet.onWalletStatusChanged += self.__onWalletChanged
     game_control.g_instance.gameSession.onPremiumNotify += self.__onPremiumTimeChanged
     g_currentVehicle.onChanged += self.__onVehicleChanged
     g_eventsCache.onSyncCompleted += self.__onEventsCacheResync
     self.addListener(events.FightButtonEvent.FIGHT_BUTTON_UPDATE, self.__handleFightButtonUpdated, scope=EVENT_BUS_SCOPE.LOBBY)
     self.addListener(events.CoolDownEvent.PREBATTLE, self.__handleSetPrebattleCoolDown, scope=EVENT_BUS_SCOPE.LOBBY)
     self.addListener(events.BubbleTooltipEvent.SHOW, self.__showBubbleTooltip, scope=EVENT_BUS_SCOPE.LOBBY)
     self.addListener(events.CloseWindowEvent.GOLD_FISH_CLOSED, self.__onGoldFishWindowClosed, scope=EVENT_BUS_SCOPE.LOBBY)
     g_clientUpdateManager.addCallbacks({'stats.credits': self.__setCredits,
      'stats.gold': self.__setGold,
      'stats.freeXP': self.__setFreeXP,
      'stats.clanInfo': self.__setClanInfo,
      'goodies': self.__updateGoodies,
      'account.premiumExpiryTime': self.__onPremiumExpireTimeChanged,
      'cache.SPA': self.__onSPAUpdated})
     self.as_setFightButtonS(i18n.makeString('#menu:headerButtons/battle'))
     self.as_setWalletStatusS(game_control.g_instance.wallet.componentsStatuses)
     self.updateAccountInfo()
     self.startGlobalListening()
     self.__updateServerName()
     if not isTimeToShowGoldFishPromo():
         enabledVal = isGoldFishActionActive()
         tooltip = TOOLTIPS.HEADER_REFILL_ACTION if enabledVal else TOOLTIPS.HEADER_REFILL
         self.as_setGoldFishEnabledS(enabledVal, False, tooltip, TOOLTIP_TYPES.COMPLEX)
     Waiting.hide('enter')
Esempio n. 20
0
 def beforeDelete(self):
     LOG_DEBUG('[App] beforeDelete')
     from gui.Scaleform.Waiting import Waiting
     Waiting.setWainingViewGetter(None)
     g_guiResetters.discard(self.onUpdateStage)
     g_repeatKeyHandlers.discard(self.component.handleKeyEvent)
     if self._containerMgr is not None:
         self._containerMgr.destroy()
         self._containerMgr = None
     if self._loaderMgr is not None:
         self._loaderMgr.destroy()
         self._loaderMgr = None
     if self._cacheMgr is not None:
         self._cacheMgr.destroy()
         self._cacheMgr = None
     if self._contextMgr is not None:
         self._contextMgr.destroy()
         self._contextMgr = None
     if self._popoverManager is not None:
         self._popoverManager.destroy()
         self._popoverManager = None
     if self._soundMgr is not None:
         self._soundMgr.destroy()
         self._soundMgr = None
     if self._varsMgr is not None:
         self._varsMgr.destroy()
         self._varsMgr = None
     if self.__toolTip is not None:
         self.__toolTip.destroy()
         self.__toolTip = None
     if self._colorSchemeMgr is not None:
         self._colorSchemeMgr.destroy()
         self._colorSchemeMgr = None
     if self._eventLogMgr is not None:
         self._eventLogMgr.destroy()
         self._eventLogMgr = None
     if self._guiItemsMgr is not None:
         self._guiItemsMgr.destroy()
         self._guiItemsMgr = None
     if self._tweenMgr is not None:
         self._tweenMgr.destroy()
         self._tweenMgr = None
     if self._voiceChatMgr is not None:
         self._voiceChatMgr.destroy()
         self._voiceChatMgr = None
     if self._gameInputMgr is not None:
         self._gameInputMgr.destroy()
         self._gameInputMgr = None
     if self._utilsMgr is not None:
         self._utilsMgr.destroy()
         self._utilsMgr = None
     if self._tutorialMgr is not None:
         self._tutorialMgr.destroy()
         self._tutorialMgr = None
     if self._businessHandler is not None:
         self._businessHandler.destroy()
         self._businessHandler = None
     self._dispose()
     super(App, self).beforeDelete()
     self.fireEvent(AppLifeCycleEvent(self.__ns, AppLifeCycleEvent.DESTROYED))
Esempio n. 21
0
def onAccountShowGUI(ctx):
    g_lobbyContext.onAccountShowGUI(ctx)
    yield g_itemsCache.update()
    yield g_questsCache.update()
    yield g_settingsCache.update()
    if not g_itemsCache.isSynced():
        return
    g_settingsCore.serverSettings.applySettings()
    game_control.g_instance.onAccountShowGUI(g_lobbyContext.getGuiCtx())
    accDossier = g_itemsCache.items.getAccountDossier()
    g_rareAchievesCache.request(accDossier.getRecord('rareAchievements'))
    MusicController.g_musicController.setAccountAttrs(g_itemsCache.items.stats.attributes)
    MusicController.g_musicController.play(MusicController.MUSIC_EVENT_LOBBY)
    MusicController.g_musicController.play(MusicController.AMBIENT_EVENT_LOBBY)
    premium = isPremiumAccount(g_itemsCache.items.stats.attributes)
    if g_hangarSpace.inited:
        g_hangarSpace.refreshSpace(premium)
    else:
        g_hangarSpace.init(premium)
    g_currentVehicle.init()
    g_windowsManager.onAccountShowGUI(g_lobbyContext.getGuiCtx())
    yield g_windowsManager.window.tooltipManager.request()
    g_prbLoader.onAccountShowGUI(g_lobbyContext.getGuiCtx())
    SoundGroups.g_instance.enableLobbySounds(True)
    onCenterIsLongDisconnected(True)
    Waiting.hide('enter')
Esempio n. 22
0
    def __handleConnectionStatus(self, stage, status, serverMsg, isAutoRegister):
        if self.__onLoggingTryingEndHdlr:
            self.__onLoggingTryingEndHdlr()
        STATUS_LOGGED_ON = "LOGGED_ON"
        LOG_DEBUG("__handleConnectionStatus %s %s %s" % (stage, status, isAutoRegister))
        if stage == 1:
            if status == STATUS_LOGGED_ON:
                handlerFunc = self.__logOnSuccess[status]
            elif isAutoRegister:
                handlerFunc = self.__logAutoRegisterHandlers.get(status, self.__logOnFailedDefaultHandler)
                if status == "DNS_LOOKUP_FAILED":
                    self.onLoginAppFailed(status, serverMsg)
            else:
                handlerFunc = self.__logOnFailedHandlers.get(status, self.__logOnFailedDefaultHandler)
                if status != "LOGIN_REJECTED_LOGIN_QUEUE":
                    self.__clearAutoLoginTimer()
                if status != "LOGIN_REJECTED_RATE_LIMITED":
                    self.__resetLgTimeout()
                self.onCancelQueue(False, False)
                if status not in ("LOGIN_REJECTED_INVALID_PASSWORD",):
                    g_preDefinedHosts.clearPeripheryTL()
            try:
                getattr(self, handlerFunc)(status, serverMsg)
            except:
                LOG_ERROR("Handle logon status error: status = %r, message = %r" % (status, serverMsg))
                LOG_CURRENT_EXCEPTION()
                Waiting.hide("login")

            if connectionManager.isUpdateClientSoftwareNeeded():
                self.onHandleUpdateClientSoftwareNeeded()
                if connectionManager.isConnected():
                    connectionManager.disconnect()
            elif status != STATUS_LOGGED_ON:
                connectionManager.disconnect()
        elif stage == 6:
            if not self.__kickedFromServer:
                self.onCancelQueue(False, False)
            msg = MENU.LOGIN_STATUS_DISCONNECTED
            if self.__kickPeripheryID is not None:
                if self.__kickPeripheryID == -1:
                    msg = MENU.LOGIN_STATUS_ACCOUNTNOTREADY
                elif self.__kickPeripheryID == -2:
                    msg = "#menu:login/status/centerRestart"
                elif self.__kickPeripheryID == -3:
                    msg = "#menu:login/status/versionMismatch"
            elif connectionManager.isVersionsDiffered:
                msg = ""
                self.onHandleUpdateClientSoftwareNeeded()
            localizedMessage = i18n.convert(i18n.makeString(msg))
            lastLoginType = Settings.g_instance.userPrefs[Settings.KEY_LOGIN_INFO].readString("lastLoginType", "basic")
            if lastLoginType != "basic" and not Settings.g_instance.userPrefs[Settings.KEY_LOGIN_INFO].readBool(
                "rememberPwd", False
            ):
                from gui.social_network_login import Bridge as socialNetworkLogin

                localizedMessage = socialNetworkLogin.getLogoutWarning(lastLoginType)
            self.onSetStatus(localizedMessage, self.ALL_VALID)
            connectionManager.disconnect()
        return
Esempio n. 23
0
 def callback(result):
     if result:
         from CurrentVehicle import g_currentVehicle
         BigWorld.player().enqueueEventBattles(g_currentVehicle.invID)
     else:
         from gui.Scaleform.Waiting import Waiting
         Waiting.rollback()
         self.onCaptchaInputCanceled()
Esempio n. 24
0
def onShopResync():
    yield g_itemsCache.update()
    if not g_itemsCache.isSynced():
        return
    Waiting.hide('sinhronize')
    import time
    now = time.time()
    SystemMessages.g_instance.pushI18nMessage(SYSTEM_MESSAGES.SHOP_RESYNC, date=BigWorld.wg_getLongDateFormat(now), time=BigWorld.wg_getShortTimeFormat(now), type=SystemMessages.SM_TYPE.Information)
Esempio n. 25
0
 def updateVehicle(self, vehicle):
     if self.__inited:
         Waiting.show('loadHangarSpaceVehicle', True)
         igrRoomType = game_control.g_instance.igr.getRoomType()
         igrLayout = g_itemsCache.items.inventory.getIgrCustomizationsLayout()
         updatedVehCompactDescr = getCustomizedVehCompDescr(igrLayout, vehicle.invID, igrRoomType, vehicle.descriptor.makeCompactDescr())
         self.__space.recreateVehicle(self._stripVehCompDescrIfRoaming(updatedVehCompactDescr), vehicle.modelState, self.__changeDone)
         self.__lastUpdatedVehicle = vehicle
Esempio n. 26
0
 def handleQueue(self, queueNumber):
     if not self.__loginQueue:
         Waiting.hide("enter")
         self.__loginQueue = True
     message = i18n.makeString(
         WAITING.MESSAGE_QUEUE, connectionManager.serverUserName, BigWorld.wg_getIntegralFormat(queueNumber)
     )
     self.onHandleQueue(message)
Esempio n. 27
0
 def _onKickedWhileLogin(self, peripheryID):
     Waiting.hide('login')
     messageType = 'another_periphery' if peripheryID else 'checkout_error'
     self.as_setErrorMessageS(_ms(SYSTEM_MESSAGES.all(messageType)), INVALID_FIELDS.ALL_VALID)
     if not self.__loginRetryDialogShown:
         self.__showLoginRetryDialog({'waitingOpen': WAITING.titles(messageType),
          'waitingClose': WAITING.BUTTONS_CEASE,
          'message': _ms(WAITING.message(messageType), connectionManager.serverUserName)})
Esempio n. 28
0
 def _populate(self):
     g_fortSoundController.init()
     super(FortificationsView, self)._populate()
     self.addListener(events.FortEvent.VIEW_LOADED, self.__onViewLoaded, scope=EVENT_BUS_SCOPE.FORT)
     self.addListener(events.FortEvent.REQUEST_TIMEOUT, self.__loadDisconnectedView, scope=EVENT_BUS_SCOPE.FORT)
     self.startFortListening()
     Waiting.hide('loadPage')
     self.loadView()
Esempio n. 29
0
 def __onDataServerReceivedData(self, token, spaID, socialNetwork):
     Waiting.show('login')
     BigWorld.callback(0.1, BigWorld.wg_bringWindowToForeground)
     self.__loginParams['token'] = token
     self.__loginParams['account_id'] = spaID
     from Manager import SOCIAL_NETWORKS
     self.__preferences['login_type'] = socialNetwork or SOCIAL_NETWORKS.WGNI
     connectionManager.initiateConnection(self.__loginParams, '', self.__preferences['server_name'])
Esempio n. 30
0
 def onLogin(self, userName, password, serverName, isSocialToken2Login):
     self._autoSearchVisited = serverName == AUTO_LOGIN_QUERY_URL
     result = self.__validateCredentials(userName.lower().strip(), password.strip(), bool(g_loginManager.getPreference('token2')))
     if result.isValid:
         Waiting.show('login')
         g_loginManager.initiateLogin(userName, password, serverName, isSocialToken2Login, isSocialToken2Login or self._rememberUser)
     else:
         self.as_setErrorMessageS(result.errorMessage, result.invalidFields)
 def beforeDelete(self):
     from gui.Scaleform.Waiting import Waiting
     Waiting.close()
     super(LobbyEntry, self).beforeDelete()
Esempio n. 32
0
 def _response(self, code, callback, errStr='', ctx=None):
     super(OptDeviceInstaller, self)._response(code, callback, errStr, ctx)
     from gui.Scaleform.Waiting import Waiting
     Waiting.hide('applyModule')
Esempio n. 33
0
 def startProcessing(self, callback=None):
     if len(self._waitingID):
         Waiting.show(self._waitingID)
     if callback is not None and callable(callback):
         self._callback = callback
     return
Esempio n. 34
0
 def __subViewTransferStop(self, alias):
     if alias != VIEW_ALIAS.BATTLE_LOADING and alias in self.VIEW_WAITING:
         Waiting.hide('loadPage')
Esempio n. 35
0
 def beforeDelete(self):
     from gui.Scaleform.Waiting import Waiting
     Waiting.setWainingViewGetter(None)
     super(LobbyEntry, self).beforeDelete()
     return
Esempio n. 36
0
 def _onLoaded(self, *args, **kwargs):
     Waiting.suspend(id(self))
Esempio n. 37
0
 def hideWaiting(self, messageID=None):
     if messageID is not None:
         Waiting.hide('tutorial-{0:>s}'.format(messageID))
     else:
         Waiting.close()
     return
Esempio n. 38
0
 def load(self,
          url=None,
          title=None,
          showActionBtn=True,
          showWaiting=True,
          browserID=None,
          isAsync=False,
          browserSize=None,
          isDefault=True,
          callback=None,
          showCloseBtn=False,
          useBrowserWindow=True,
          isModal=False,
          showCreateWaiting=False,
          handlers=None,
          showBrowserCallback=None,
          isSolidBorder=False):
     if showCreateWaiting:
         Waiting.show('browser/init')
     url = yield self.__urlMacros.parse(url or GUI_SETTINGS.browser.url)
     suffix = yield self.__urlMacros.parse(GUI_SETTINGS.browser.params)
     concatenator = '&' if '?' in url else '?'
     if suffix not in url:
         url = concatenator.join([url, suffix])
     size = browserSize or BROWSER.SIZE
     webBrowserID = browserID
     if browserID is None:
         browserID = self.__browserIDGenerator.next()
         webBrowserID = browserID
     elif not isinstance(browserID, int):
         webBrowserID = self.__browserIDGenerator.next()
     ctx = {
         'url': url,
         'title': title,
         'showActionBtn': showActionBtn,
         'showWaiting': showWaiting,
         'browserID': browserID,
         'size': size,
         'isAsync': isAsync,
         'showCloseBtn': showCloseBtn,
         'showWindow': useBrowserWindow,
         'alias': VIEW_ALIAS.BROWSER_WINDOW_MODAL
         if isModal else VIEW_ALIAS.BROWSER_WINDOW,
         'showCreateWaiting': showCreateWaiting,
         'handlers': handlers,
         'showBrowserCallback': showBrowserCallback,
         'isSolidBorder': isSolidBorder
     }
     if browserID not in self.__browsers and browserID not in self.__pendingBrowsers:
         appLoader = dependency.instance(IAppLoader)
         app = appLoader.getApp()
         if app is None:
             raise SoftException('Application can not be None')
         browser = WebBrowser(webBrowserID,
                              app,
                              size,
                              url,
                              handlers=self.__filters)
         self.__browsers[browserID] = browser
         if self.__isCreatingBrowser():
             _logger.info('CTRL: Queueing a browser creation: %r - %s',
                          browserID, url)
             self.__pendingBrowsers[browserID] = ctx
         else:
             self.__createBrowser(ctx)
     elif browserID in self.__pendingBrowsers:
         _logger.info(
             'CTRL: Re-queuing a browser creation, overriding: %r - %s',
             browserID, url)
         self.__pendingBrowsers[browserID] = ctx
     elif browserID in self.__browsers:
         _logger.info('CTRL: Re-navigating an existing browser: %r - %s',
                      browserID, url)
         browser = self.__browsers[browserID]
         browser.navigate(url)
         browser.changeTitle(title)
     callback(browserID)
     return
 def __createDone(self, ctx):
     _logger.debug('CTRL: Finished creating a browser: %s',
                   self.__creatingBrowserID)
     if ctx['showCreateWaiting']:
         Waiting.hide('browser/init')
 def __onSpaceRefreshHandler(self):
     Waiting.show('loadHangarSpace')
 def __onSpaceDestroyHandler(self, _):
     Waiting.hide('loadHangarSpace')
     self.__onConfirmCloseWindow(proceed=True)
Esempio n. 42
0
 def login(self, selectedServer):
     self.__selectedServer = selectedServer
     BigWorld.WGC_prepareToken()
     Waiting.show('login')
     self.__wgcCheck()
Esempio n. 43
0
 def __hideWaiting(self):
     if self.__currentMessage is not None:
         Waiting.hide(self.__currentMessage)
         self.__currentMessage = None
     return
Esempio n. 44
0
 def hideWaiting(self, messageID):
     if Waiting.isVisible():
         Waiting.hide('tutorial-{0:>s}'.format(messageID))
Esempio n. 45
0
 def getSceneID(self):
     result = None
     if not Waiting.isVisible():
         guiPage = self.uiHolder.currentInterface
         result = self.config.getSceneID(guiPage)
     return result
Esempio n. 46
0
 def stopProcessing(self, result=False, data=None):
     if self._callback is not None:
         self._callback(result, data)
         self._callback = None
     if len(self._waitingID):
         Waiting.hide(self._waitingID)
Esempio n. 47
0
 def showWaiting(self, messageID, isSingle=False):
     Waiting.show('tutorial-{0:>s}'.format(messageID), isSingle=isSingle)
Esempio n. 48
0
 def afterCreate(self):
     super(LobbyEntry, self).afterCreate()
     from gui.Scaleform.Waiting import Waiting
     Waiting.setWainingViewGetter(self.__getWaitingFromContainer)
Esempio n. 49
0
 def _dispose(self):
     if Waiting.isOpened('Flash'):
         Waiting.hide('Flash')
     self.stopPrbListening()
     super(TrainingsListBase, self)._dispose()
 def _clearLoginView(self, *args):
     Waiting.hide('login')
     if self.__loginQueueDialogShown:
         self.__closeLoginQueueDialog()
     if self.__loginRetryDialogShown:
         self.__closeLoginRetryDialog()
Esempio n. 51
0
 def requestTableData(self, nation, type, filter):
     Waiting.show('updateShop')
     AccountSettings.setFilter('shop_current', (nation, type))
     AccountSettings.setFilter('shop_' + type, filter)
     self._setTableData(filter, nation, type)
     Waiting.hide('updateShop')
Esempio n. 52
0
 def __nextWaiting(self):
     if self.__messages2Show:
         self.__hideWaiting()
         self.__currentMessage = self.__messages2Show.pop(0)
         Waiting.show(self.__currentMessage)
Esempio n. 53
0
 def __subViewTransferStart(self, alias):
     if alias in self.VIEW_WAITING:
         Waiting.show('loadPage')
 def fini(self, ctx):
     if Waiting.isOpened('login'):
         Waiting.hide('login')
     ctx.resetDsn()
     self._dsnDesc = None
     return
Esempio n. 55
0
 def _populate(self):
     super(TrainingsListBase, self)._populate()
     Waiting.show('Flash')
     self.startPrbListening()
     self.__setViewData()
     self.sendData([], 0)
 def _successHandler(self, code, ctx=None):
     res = super(BattlePassActivateChapterProcessor,
                 self)._successHandler(code, ctx)
     Waiting.hide(self.__WAITING_TEXT)
     self.__pushSuccessMessage()
     return res
Esempio n. 57
0
 def _response(self, code, callback, ctx=None, errStr=''):
     super(BuyAndInstallItemProcessor,
           self)._response(code, callback, errStr, ctx)
     from gui.Scaleform.Waiting import Waiting
     Waiting.hide('applyModule')
Esempio n. 58
0
 def wrapper(*kargs, **kwargs):
     Waiting.suspend()
     return async (func, 'callback')(*kargs, **kwargs)
 def __onSpaceCreateHandler(self):
     Waiting.hide('loadHangarSpace')
     self.refreshOutfit()
     self.__updateAnchorPositions()
Esempio n. 60
0
 def callback(result):
     Waiting.resume()
     cb(result)