Python gui.GUI_SETTINGS类代码示例

 def getURL(self, name, callback):
     urlSettings = GUI_SETTINGS.lookup(name)
     if urlSettings:
         url = yield self.__urlMarcos.parse(str(urlSettings))
     else:
         url = yield lambda callback: callback('')
     callback(url)

 def quality(self):
     boosterQualityValues = GUI_SETTINGS.lookup(self.boosterGuiType) or _BOOSTER_QUALITY_VALUES
     if self.effectValue >= boosterQualityValues[BOOSTER_QUALITY_NAMES.BIG]:
         return BOOSTER_QUALITY_NAMES.BIG
     elif self.effectValue >= boosterQualityValues[BOOSTER_QUALITY_NAMES.MEDIUM]:
         return BOOSTER_QUALITY_NAMES.MEDIUM
     else:
         return BOOSTER_QUALITY_NAMES.SMALL

def _getClubEmblemUrl(emblemID, size):
    try:
        urlPattern = GUI_SETTINGS.lookup('clubEmblems')
        if urlPattern and emblemID:
            return urlPattern % {'emblemID': emblemID,
             'size': size}
    except:
        LOG_CURRENT_EXCEPTION()

 def showSecurityMessage(self):
     if self.__securityMsgType is not None:
         securityLink = ''
         if not GUI_SETTINGS.isEmpty('securitySettingsURL'):
             linkText = makeString(SYSTEM_MESSAGES.SECURITYMESSAGE_CHANGE_SETINGS)
             securityLink = makeHtmlString('html_templates:lobby/system_messages', 'link', {'text': linkText,
              'linkType': 'securityLink'})
         SystemMessages.pushI18nMessage('#system_messages:securityMessage/%s' % self.__securityMsgType, type=SystemMessages.SM_TYPE.Warning, link=securityLink)
         self.__securityMsgType = None

 def _showSecurityMessage(self, responseData):
     securityWarningType = responseData.get('security_msg')
     if securityWarningType is not None:
         securityLink = ''
         if not GUI_SETTINGS.isEmpty('securitySettingsURL'):
             securityLink = makeHtmlString('html_templates:lobby/system_messages', 'link', {'text': _ms(SYSTEM_MESSAGES.SECURITYMESSAGE_CHANGE_SETINGS),
              'linkType': 'securityLink'})
         SystemMessages.pushI18nMessage('#system_messages:securityMessage/%s' % securityWarningType, type=SystemMessages.SM_TYPE.Warning, link=securityLink)
     return

def createAppFactory():
    if GUI_SETTINGS.isGuiEnabled():
        if GUI_SETTINGS.useAS3Battle:
            factory = AS3_AppFactory()
        else:
            factory = AS3_AS2_AppFactory()
    else:
        factory = NoAppFactory()
    return factory

def init(loadingScreenGUI = None):
    global onShopResyncStarted
    global onAccountShowGUI
    global onScreenShotMade
    global onIGRTypeChanged
    global onAccountBecomeNonPlayer
    global onAvatarBecomePlayer
    global onAccountBecomePlayer
    global onKickedFromServer
    global onShopResync
    g_loginManager.init()
    miniclient.configure_state()
    connectionManager.onKickedFromServer += onKickedFromServer
    g_playerEvents.onAccountShowGUI += onAccountShowGUI
    g_playerEvents.onAccountBecomeNonPlayer += onAccountBecomeNonPlayer
    g_playerEvents.onAccountBecomePlayer += onAccountBecomePlayer
    g_playerEvents.onAvatarBecomePlayer += onAvatarBecomePlayer
    g_playerEvents.onClientUpdated += onClientUpdate
    g_playerEvents.onShopResyncStarted += onShopResyncStarted
    g_playerEvents.onShopResync += onShopResync
    g_playerEvents.onCenterIsLongDisconnected += onCenterIsLongDisconnected
    g_playerEvents.onIGRTypeChanged += onIGRTypeChanged
    if GUI_SETTINGS.isGuiEnabled():
        from gui.Scaleform.app_factory import AS3_AS2_AppFactory as AppFactory
    else:
        from gui.Scaleform.app_factory import NoAppFactory as AppFactory
    g_appLoader.init(AppFactory())
    game_control.g_instance.init()
    from gui.Scaleform import SystemMessagesInterface
    SystemMessages.g_instance = SystemMessagesInterface.SystemMessagesInterface()
    SystemMessages.g_instance.init()
    ParametersCache.g_instance.init()
    if loadingScreenGUI and loadingScreenGUI.script:
        loadingScreenGUI.script.active(False)
    g_prbLoader.init()
    LogitechMonitor.init()
    g_itemsCache.init()
    g_settingsCache.init()
    g_settingsCore.init()
    g_eventsCache.init()
    g_clanCache.init()
    g_clubsCtrl.init()
    g_clanCtrl.init()
    g_vehicleProgressCache.init()
    g_goodiesCache.init()
    BigWorld.wg_setScreenshotNotifyCallback(onScreenShotMade)
    from constants import IS_DEVELOPMENT
    if IS_DEVELOPMENT:
        try:
            from gui.development import init
        except ImportError:
            LOG_ERROR('Development features not found.')
            init = lambda : None

        init()
    guiModsInit()

 def canChangeWebSettings(self, profile, club = None):
     url = GUI_SETTINGS.lookup('clubSettings')
     if not url:
         return error(_CCR.DEFAULT)
     else:
         if club is not None:
             permissions = club.getPermissions()
             if not permissions.canChangeWebSettings():
                 return error(_CCR.DEFAULT)
             if club.getTotalDossier().getTotalStats().getBattlesCount() < CLUB_LIMITS.MIN_BATTLES_COUNT_TO_CHANGE_NAME:
                 return error(_CCR.NOT_ENOUGH_RATED_BATTLES)
         return success()

    def canChangeWebSettings(self, profile, club = None):
        url = GUI_SETTINGS.lookup('clubSettings')
        if not url:
            return error(_CCR.DEFAULT)
        if club is not None:
            for rID in {_CRT.CHANGE_CLUB_NAME, _CRT.CHANGE_CLUB_EMBLEM}:
                result = self._isClubRequestValid(rID, club, 'canChangeWebSettings')
                if result.success:
                    return result

            return error(_CCR.NOT_ENOUGH_RATED_BATTLES)
        return success()

def createAim(type):
    if not GUI_SETTINGS.isGuiEnabled():
        from gui.development.no_gui.battle import Aim
        return Aim()
    if type == 'strategic':
        return StrategicAim((0, 0.0))
    if type == 'arcade':
        return ArcadeAim((0, 0.15), False)
    if type == 'sniper':
        return ArcadeAim((0, 0.0), True)
    if type == 'postmortem':
        return PostMortemAim((0, 0.0))
    LOG_ERROR('Undefined aim type. <%s>' % type)

 def showSecurityMessage(self):
     if self.__securityMsgType is not None:
         securityLink = ""
         if not GUI_SETTINGS.isEmpty("securitySettingsURL"):
             linkText = makeString(SYSTEM_MESSAGES.SECURITYMESSAGE_CHANGE_SETINGS)
             securityLink = makeHtmlString(
                 "html_templates:lobby/system_messages", "link", {"text": linkText, "linkType": "securityLink"}
             )
         SystemMessages.pushI18nMessage(
             "#system_messages:securityMessage/%s" % self.__securityMsgType,
             type=SystemMessages.SM_TYPE.Warning,
             link=securityLink,
         )
         self.__securityMsgType = None
     return

 def __init__(self, proxy):
     super(EncyclopediaController, self).__init__(proxy)
     self.__activated = False
     self.__recommendations = []
     self.__eventManager = Event.EventManager()
     self.__urlMacros = URLMarcos()
     self.__isLobbyStarted = False
     self.__hasNewRecommendations = False
     if GUI_SETTINGS.lookup('encyclopedia'):
         self.__baseUrl = GUI_SETTINGS.encyclopedia['url']
         self.__isSuitableLanguage = GUI_SETTINGS.encyclopedia['enabled']
     else:
         self.__baseUrl = None
         self.__isSuitableLanguage = False
     self.onNewRecommendationReceived = Event.Event(self.__eventManager)
     self.onStateChanged = Event.Event(self.__eventManager)
     self.__isStateSynced = False
     return

        self.window.fireEvent(LoadViewEvent(eventType), scope=EVENT_BUS_SCOPE.LOBBY)
        return

    def showPostMortem(self):
        LogitechMonitor.onScreenChange('postmortem')
        if self.__battleWindow:
            self.__battleWindow.showPostmortemTips()

    def showBotsMenu(self):
        try:
            from gui.development.ui.BotsMenu import BotsMenu
            BotsMenu(self.__battleWindow).active(True)
        except ImportError:
            from debug_utils import LOG_ERROR
            LOG_ERROR('BotsMenu not found.')

    def __onAppStarted(self, event):
        if BattleReplay.g_replayCtrl.autoStartBattleReplay() or connectionManager.isConnected():
            return
        if not self.__startVideoShown:
            self.__startVideoShown = True
            if self.showStartGameVideo():
                return
        self.showLogin()


if GUI_SETTINGS.isGuiEnabled():
    g_windowsManager = WindowsManager()
else:
    from gui.development.no_gui.WindowsManager import WindowsManager
    g_windowsManager = WindowsManager()

 def changeAccount(self):
     self.__rememberMe = False
     self.as_setDefaultValuesS('', '', False, GUI_SETTINGS.rememberPassVisible, GUI_SETTINGS.igrCredentialsReset, not GUI_SETTINGS.isEmpty('recoveryPswdURL'))
     self.__showRequiredLoginScreen()
     self.as_setErrorMessageS(self.__socialNetworkLogin.getLogoutWarning(self.__lastLoginType), 0)
     self.__loginPreferences.writeString('login', '')
     self.__loginPreferences.writeBool('rememberPwd', False)
     self.__loginPreferences.writeString('lastLoginType', 'basic')
     self.__loginPreferences.writeString('token2', '')
     self.__loginPreferences.writeString('user', '')

 def onHandleInvalidPasswordWithToken(self, user, rememberPwd):
     self.__showRequiredLoginScreen()
     self.as_setDefaultValuesS(user, '', rememberPwd, GUI_SETTINGS.rememberPassVisible, GUI_SETTINGS.igrCredentialsReset, not GUI_SETTINGS.isEmpty('recoveryPswdURL'))