def _populate(self):
super(QuestsSeasonAwardsWindow, self)._populate()
basicAwards = []
season = g_eventsCache.potapov.getSeasons()[self.__seasonID]
for tile in season.getTiles().itervalues():
vehicle = tile.getVehicleBonus()
if vehicle is not None:
basicAwards.append(self.__packVehicleAward(vehicle))
self.as_setDataS({'windowTitle': _ms(QUESTS.SEASONAWARDSWINDOW_TITLE),
'basicAwardsTitle': text_styles.highTitle(_ms(QUESTS.SEASONAWARDSWINDOW_BASICAWARDS_TITLE)),
'extraAwardsTitle': text_styles.highTitle(_ms(QUESTS.SEASONAWARDSWINDOW_EXTRAAWARDS_TITLE)),
'basicAwards': basicAwards,
'extraAwards': [self.__packFemaleTankmanAward(), self.__packCommendationListsAward()]})
def __updateTileData(self, vehType, questState, selectItemID = -1):
self._navInfo.changePQFilters(vehType, questState)
questsByChains = self.__getQuestsByChains(vehType, questState)
chains = []
newSelectedItemID = -1
for _, chainID, quests in questsByChains:
completedQuestsCount = len(self.__tile.getQuestsInChainByFilter(chainID, lambda q: q.isCompleted()))
chain = {'name': text_styles.highTitle(self.__getChainUserName(chainID)),
'progressText': text_styles.main('%d/%d' % (completedQuestsCount, self.__tile.getChainSize())),
'tasks': [],
'enabled': True}
for quest in sorted(quests, key=operator.methodcaller('getID')):
stateName, stateIcon = self.__getQuestStatusData(quest)
questID = quest.getID()
chain['tasks'].append({'name': text_styles.main(quest.getUserName()),
'stateName': stateName,
'stateIconPath': stateIcon,
'arrowIconPath': RES_ICONS.MAPS_ICONS_LIBRARY_ARROWORANGERIGHTICON8X8,
'tooltip': TOOLTIPS.PRIVATEQUESTS_TASKLISTITEM_BODY,
'id': questID,
'enabled': True})
if questID == selectItemID:
newSelectedItemID = questID
chains.append(chain)
self.as_updateTileDataS({'statistics': {'label': text_styles.main(_ms(QUESTS.TILECHAINSVIEW_STATISTICSLABEL_TEXT)),
'arrowIconPath': RES_ICONS.MAPS_ICONS_LIBRARY_ARROWORANGERIGHTICON8X8,
'tooltip': TOOLTIPS.PRIVATEQUESTS_TASKLISTITEM_BODY},
'chains': chains})
if selectItemID == -1:
self.getChainProgress()
else:
self.as_updateChainProgressS(self.__makeChainsProgressData())
self.as_setSelectedTaskS(newSelectedItemID)
def __updateStatus(self):
prefix = i18n.makeString(FORTIFICATIONS.SETTINGSDEFENCEHOURPOPOVER_DEFENCEHOURTITLE)
prefix = text_styles.highTitle(prefix)
if self._isFortFrozen():
toolTip = i18n.makeString(TOOLTIPS.FORTIFICATION_FORTSETTINGSWINDOW_STATUSSTRING_FREEZED)
icon = RES_ICONS.MAPS_ICONS_LIBRARY_ERRORICON_1
imageSource = icons.makeImageTag(icon, 16, 16, -4, 0)
currentStatus = text_styles.error(i18n.makeString(FORTIFICATIONS.SETTINGSWINDOW_STATUSMSG_FREEZED))
currentStatus = imageSource + " " + currentStatus
elif self.__defencePeriod:
toolTip = i18n.makeString(TOOLTIPS.FORTIFICATION_FORTSETTINGSWINDOW_STATUSSTRING_ACTIVATED)
currentStatus = "".join(
(
icons.checkmark(),
text_styles.success(" " + i18n.makeString(FORTIFICATIONS.SETTINGSWINDOW_STATUSMSG_ACTIVATED)),
)
)
elif self.__checkConditions():
toolTip = i18n.makeString(TOOLTIPS.FORTIFICATION_FORTSETTINGSWINDOW_STATUSSTRING_CANBEACTIVATED)
currentStatus = "".join(
(
icons.alert(),
text_styles.alert(" " + i18n.makeString(FORTIFICATIONS.SETTINGSWINDOW_STATUSMSG_NOTACTIVATED)),
)
)
else:
toolTip = i18n.makeString(TOOLTIPS.FORTIFICATION_FORTSETTINGSWINDOW_STATUSSTRING_CANNOTBEACTIVATED)
currentStatus = "".join(
(
icons.notAvailable(),
text_styles.standard(" " + i18n.makeString(FORTIFICATIONS.SETTINGSWINDOW_STATUSMSG_NOTAVAILABLE)),
)
)
self.as_setMainStatusS(prefix, currentStatus, toolTip)
def __makeDivisionsData(self, list):
result = []
for item in list:
divisionType = {}
title = i18n.makeString(item['label'])
profit = fort_formatters.getDefRes(item['profit'])
divisionID = item['level']
divisionType['divisionName'] = highTitle(i18n.makeString(I18N_FORTIFICATIONS.CHOICEDIVISION_DIVISIONFULLNAME, divisionType=title))
divisionType['divisionProfit'] = standard(i18n.makeString(I18N_FORTIFICATIONS.CHOICEDIVISION_DIVISIONPROFIT, defResCount=profit))
minVehLvl, maxVehLvl = item['vehLvls']
if maxVehLvl == minVehLvl:
vehicleLevel = i18n.makeString(I18N_FORTIFICATIONS.CHOICEDIVISION_VEHICLELEVELSINGLE, level=_getTextLevels(maxVehLvl))
else:
vehicleLevel = i18n.makeString(I18N_FORTIFICATIONS.CHOICEDIVISION_VEHICLELEVEL, minLevel=_getTextLevels(minVehLvl), maxLevel=_getTextLevels(maxVehLvl))
divisionType['vehicleLevel'] = standard(vehicleLevel)
divisionType['divisionID'] = divisionID
if divisionID == SORTIE_DIVISION.MIDDLE:
minCount, maxCount = self.playersRange[0]
elif divisionID == SORTIE_DIVISION.CHAMPION:
minCount, maxCount = self.playersRange[1]
else:
minCount, maxCount = self.playersRange[2]
divisionType['playerRange'] = main('{0}-{1}'.format(str(minCount), str(maxCount)))
result.append(divisionType)
return result
def construct(self):
item = self.item
block = []
title = item.userName
desc = item.getUserType()
block.append(formatters.packImageTextBlockData(title=text_styles.highTitle(title), desc=text_styles.main(desc), img=item.icon, imgPadding=formatters.packPadding(left=12), txtGap=-4, txtOffset=100 - self.leftPadding))
return block
def __packStaticHeaderData(self, club):
profile = self.clubsCtrl.getProfile()
limits = self.clubsState.getLimits()
if limits.canDestroyClub(profile, club).success:
btnDestroyText = _ms(CYBERSPORT.STATICFORMATION_STAFFVIEW_DESTROYSTATIC_TEXT)
elif limits.canLeaveClub(profile, club).success:
btnDestroyText = _ms(CYBERSPORT.STATICFORMATION_STAFFVIEW_EXITSTATIC_TEXT)
else:
btnDestroyText = ''
if club.canParticipateBattles():
lblStaffedText = ''.join([text_styles.success(CYBERSPORT.STATICFORMATION_STAFFVIEW_LBLSTAFFED_TEXT),
text_styles.standard(' ('),
text_styles.main(str(len(club.getMembers()))),
text_styles.standard('/%d)' % CLUB_LIMITS.MAX_MEMBERS)])
else:
lblStaffedText = ''
return {'lblTitleText': text_styles.highTitle(CYBERSPORT.STATICFORMATION_STAFFVIEW_TITLE_TEXT),
'lblDescriptionText': text_styles.standard(_ms(CYBERSPORT.STATICFORMATION_STAFFVIEW_DESCRIPTION_OTHER_TEXT, clubName=club.getUserName())),
'btnRecruitmentText': _ms(CYBERSPORT.STATICFORMATION_STAFFVIEW_RECRUITMENTBTN_TEXT, count=len(club.getApplicants(onlyActive=True))),
'btnRecruitmentTooltip': TOOLTIPS.STATICFORMATIONSTAFFVIEW_RECRUITMENTBTN,
'btnInviteText': _ms(CYBERSPORT.STATICFORMATION_STAFFVIEW_INVITEBTN_TEXT),
'btnRemoveText': btnDestroyText,
'cbOpenedText': _ms(CYBERSPORT.STATICFORMATION_STAFFVIEW_RECRUITMENTOPENEDCHKBX_TEXT),
'lblStaffedText': lblStaffedText,
'lblStaffedTooltip': TOOLTIPS.STATICFORMATIONSTAFFVIEW_LBLSTAFFED,
'tableHeader': _packTableHeaders()}
def _packBlocks(self, uid, level):
description = _ms(FORTIFICATIONS.buildingsprocess_longdescr(uid))
self._description = _ms(CLANS.SECTION_FORT_BUILDING_TOOLTIP_BODY, level=text_styles.stats(int2roman(level)), description=description)
self._title = _ms(FORTIFICATIONS.buildings_buildingname(uid))
items = super(ClanProfileFortBuildingTooltipData, self)._packBlocks()
items.append(formatters.packTitleDescBlock(text_styles.highTitle(self._title), desc=text_styles.main(self._description) if self._description else None))
return items
def construct(self):
shell = self.shell
block = []
title = shell.userName
desc = '#item_types:shell/kinds/' + shell.type
block.append(formatters.packImageTextBlockData(title=text_styles.highTitle(title), desc=text_styles.standard(desc), img=shell.icon, imgPadding=formatters.packPadding(left=7), txtGap=-4, txtOffset=100 - self.leftPadding))
return block
def _populate(self):
super(FortIntelligenceClanFilterPopover, self)._populate()
headerText = text_styles.highTitle(_ms(FORTIFICATIONS.FORTINTELLIGENCE_CLANFILTERPOPOVER_HEADER))
clanLevelText = text_styles.standard(_ms(FORTIFICATIONS.FORTINTELLIGENCE_CLANFILTERPOPOVER_CLANLEVEL))
startHourRangeText = text_styles.standard(_ms(FORTIFICATIONS.FORTINTELLIGENCE_CLANFILTERPOPOVER_STARTHOURRANGE))
self.as_setDescriptionsTextS(headerText, clanLevelText, startHourRangeText)
defaultButtonText = _ms(FORTIFICATIONS.FORTINTELLIGENCE_CLANFILTERPOPOVER_DEFAULTBUTTONTEXT)
applyButtonText = _ms(FORTIFICATIONS.FORTINTELLIGENCE_CLANFILTERPOPOVER_APPLYBUTTONTEXT)
cancelButtonText = _ms(FORTIFICATIONS.FORTINTELLIGENCE_CLANFILTERPOPOVER_CANCELBUTTONTEXT)
self.as_setButtonsTextS(defaultButtonText, applyButtonText, cancelButtonText)
defaultButtonTooltip = TOOLTIPS.FORTIFICATION_FORTINTELLIGENCECLANFILTERPOPOVER_DEFAULT
applyButtonTooltip = TOOLTIPS.FORTIFICATION_FORTINTELLIGENCECLANFILTERPOPOVER_APPLY
self.as_setButtonsTooltipsS(defaultButtonTooltip, applyButtonTooltip)
minClanLevel = FORTIFICATION_ALIASES.CLAN_FILTER_MIN_LEVEL
maxClanLevel = FORTIFICATION_ALIASES.CLAN_FILTER_MAX_LEVEL
startDefenseHour = FORTIFICATION_ALIASES.CLAN_FILTER_MIN_HOUR
startDefenseMin = 0
cache = self.fortCtrl.getPublicInfoCache()
if cache:
minClanLevel, maxClanLevel, startDefenseHour, availability = cache.getDefaultFilterData()
selectedDate = time.localtime(time_utils.getTimeForLocal(time_utils.getCurrentTimestamp(), max(0, startDefenseHour)))
startDefenseMin = selectedDate.tm_min
data = {'minClanLevel': minClanLevel,
'maxClanLevel': maxClanLevel,
'startDefenseHour': startDefenseHour,
'startDefenseMinutes': startDefenseMin,
'isTwelveHoursFormat': self.app.utilsManager.isTwelveHoursFormat(),
'isWrongLocalTime': self._isWrongLocalTime(),
'skipValues': adjustDefenceHoursListToLocal(g_lobbyContext.getServerSettings().getForbiddenFortDefenseHours())}
defenceStart, _ = self.fortCtrl.getFort().getLocalDefenceHour()
if defenceStart != NOT_ACTIVATED:
data['yourOwnClanStartDefenseHour'] = defenceStart
self.as_setDataS(data)
def createInitVO(self):
isTypeNotCamouflage = self.__filter.currentType != CUSTOMIZATION_TYPE.CAMOUFLAGE
groupsUserNames = []
groupsList = []
for groupData in self.__groupsMap[self.__filter.currentType]:
groupsUserNames.append(groupData[1])
groupsList.append(groupData[0])
if isTypeNotCamouflage:
groupsSelectIndex = groupsList.index(self.__filter.currentGroup)
else:
groupsSelectIndex = 0
return {'lblTitle': text_styles.highTitle(CUSTOMIZATION.FILTER_POPOVER_TITLE),
'lblBonusType': text_styles.standard(CUSTOMIZATION.FILTER_POPOVER_BONUSTYPE_TITLE),
'lblCustomizationType': text_styles.standard(CUSTOMIZATION.FILTER_POPOVER_GROUPS_TITLE),
'lblPurchaseType': text_styles.standard(CUSTOMIZATION.FILTER_POPOVER_WAYSTOBUY_TITLE),
'btnDefault': CUSTOMIZATION.FILTER_POPOVER_GETDEFAULTSETTINGS,
'bonusTypeId': FILTER_TYPE.QUALIFIER,
'bonusType': self.__getBonusTypeVO(),
'customizationBonusTypeVisible': isTypeNotCamouflage,
'customizationTypeId': FILTER_TYPE.GROUP,
'customizationType': groupsUserNames,
'customizationTypeSelectedIndex': groupsSelectIndex,
'customizationTypeVisible': isTypeNotCamouflage,
'bonusTypeDisableTooltip': makeTooltip(CUSTOMIZATION.TOOLTIP_FILTER_GROUPS_DISABLED_HEADER, CUSTOMIZATION.TOOLTIP_FILTER_GROUPS_DISABLED_BODY),
'refreshTooltip': makeTooltip(TOOLTIPS.CUSTOMIZATION_FILTERPOPOVER_REFRESH_HEADER, TOOLTIPS.CUSTOMIZATION_FILTERPOPOVER_REFRESH_BODY),
'purchaseTypeId': FILTER_TYPE.PURCHASE_TYPE,
'purchaseType': self.__getPurchaseTypeVO(),
'purchaseTypeSelectedIndex': self.__purchaseTypeList.index(self.__filter.purchaseType)}
def _setTipsInfo(self):
arena = arena_info.getClientArena()
arenaDP = self._battleCtx.getArenaDP()
if arena_info.hasResourcePoints():
bgUrl = RES_ICONS.MAPS_ICONS_EVENTINFOPANEL_FALLOUTRESOURCEPOINTSEVENT
elif arena_info.hasFlags():
bgUrl = RES_ICONS.MAPS_ICONS_EVENTINFOPANEL_FALLOUTFLAGSEVENT
else:
bgUrl = ''
if self.__isFallout:
self.as_setEventInfoPanelDataS({'bgUrl': bgUrl,
'items': getHelpTextAsDicts(arena_info.getArenaType())})
self.as_setVisualTipInfoS(self.__makeVisualTipVO(arenaDP, arena))
elif not self.__isTipInited:
battlesCount = DEFAULT_BATTLES_COUNT
if g_lobbyContext.getBattlesCount() is not None:
battlesCount = g_lobbyContext.getBattlesCount()
classTag, vLvl, nation = arenaDP.getVehicleInfo().getTypeInfo()
criteria = tips.getTipsCriteria(arena)
criteria.setBattleCount(battlesCount)
criteria.setClassTag(classTag)
criteria.setLevel(vLvl)
criteria.setNation(nation)
tip = criteria.find()
self.as_setTipTitleS(text_styles.highTitle(tip.status))
self.as_setTipS(text_styles.playerOnline(tip.body))
self.as_setVisualTipInfoS(self.__makeVisualTipVO(arenaDP, arena, tip))
self.__isTipInited = True
return
def __setDetails(self, unitID, vo, clubExtraData = None):
if clubExtraData is not None:
linkage = CYBER_SPORT_ALIASES.COMMNAD_DETAILS_LINKAGE_JOIN_TO_STATIC_AS_LEGIONARY
icon = None
name = clubExtraData.clubName
clubID = clubExtraData.clubDBID
division = clubExtraData.divisionID
description = vo['description']
self.requestClubEmblem64x64(clubID, clubExtraData.getEmblem64x64(), partial(self.__onClubEmblem64x64Received, unitID))
buttonLabel = CYBERSPORT.WINDOW_UNITLISTVIEW_ENTERBTN_LEGIONARY
buttonInfo = CYBERSPORT.WINDOW_UNITLISTVIEW_ENTERTEXT_LEGIONARY
buttonTooltip = TOOLTIPS.CYBERSPORT_UNITLIST_JOINTOSTATICASLEGIONARY
if self.clubsState.getStateID() == CLIENT_CLUB_STATE.HAS_CLUB and self.clubsState.getClubDbID() == clubID:
buttonLabel = CYBERSPORT.WINDOW_UNITLISTVIEW_ENTERBTN_MEMBER
buttonInfo = CYBERSPORT.WINDOW_UNITLISTVIEW_ENTERTEXT_MEMBER
buttonTooltip = None
vo.update({'joinBtnLabel': buttonLabel,
'joinInfo': text_styles.standard(_ms(buttonInfo)),
'joinBtnTooltip': buttonTooltip,
'rallyInfo': {'icon': icon,
'name': text_styles.highTitle(name),
'profileBtnLabel': CYBERSPORT.RALLYINFO_PROFILEBTN_LABEL,
'profileBtnTooltip': TOOLTIPS.RALLYINFO_PROFILEBTN,
'description': text_styles.main(description),
'ladderIcon': getLadderChevron64x64(division),
'id': clubID,
'showLadder': True}})
self.as_setDetailsS({'viewLinkage': linkage,
'data': vo})
else:
linkage = CYBER_SPORT_ALIASES.COMMNAD_DETAILS_LINKAGE_JOIN_TO_NONSTATIC
self.as_setDetailsS({'viewLinkage': linkage,
'data': vo})
self.__updateVehicleLabel()
return
def __makeData(self):
result = {}
result['listItems'] = self.__makeListData()
result['availableCount'] = self.__makeMainLabel()
result['windowTitle'] = FORTIFICATIONS.BUILDINGSPROCESS_WINDOWTITLE
result['textInfo'] = text_styles.highTitle(i18n.makeString(FORTIFICATIONS.BUILDINGSPROCESS_TEXTINFO))
self.as_setDataS(result)
def _packBlocks(self, paramName):
extendedData = self.context.getComparator().getExtendedData(paramName)
self.__paramName = extendedData.name
title = text_styles.highTitle(MENU.tank_params(paramName))
if param_formatter.isRelativeParameter(paramName):
value = param_formatter.colorizedFormatParameter(extendedData, self.context.formatters)
title += ' ' + text_styles.warning(_ms(TOOLTIPS.VEHICLEPARAMS_TITLE_VALUETEMPLATE, value=value))
else:
title += ' ' + text_styles.middleTitle(MEASURE_UNITS.get(paramName, ''))
desc = _ms(TOOLTIPS.tank_params_desc(paramName))
possibleBonuses = sorted(extendedData.possibleBonuses, _bonusCmp)
if possibleBonuses is not None and len(possibleBonuses) > 0:
desc += ' ' + _ms(TOOLTIPS.VEHICLEPARAMS_POSSIBLEBONUSES_DESC)
desc += '\n' + self.__createBonusesStr(possibleBonuses)
blocks = [formatters.packTitleDescBlock(title, text_styles.main(desc))]
bonuses = sorted(extendedData.bonuses, _bonusCmp)
if bonuses is not None and len(bonuses) > 0:
blocks.append(formatters.packTitleDescBlock(text_styles.middleTitle(TOOLTIPS.VEHICLEPARAMS_BONUSES_TITLE), text_styles.main(self.__createBonusesStr(bonuses))))
penalties = extendedData.penalties
actualPenalties, nullPenaltyTypes = self.__getNumNotNullPenaltyTankman(penalties)
penaltiesLen = len(penalties)
numNotNullPenaltyTankman = len(actualPenalties)
if numNotNullPenaltyTankman > 0:
blocks.append(formatters.packTitleDescBlock(text_styles.critical(TOOLTIPS.VEHICLEPARAMS_PENALTIES_TITLE), text_styles.main(self.__createPenaltiesStr(actualPenalties))))
if penaltiesLen > numNotNullPenaltyTankman:
blocks.append(formatters.packImageTextBlockData(self.__createTankmanIsOutStr(nullPenaltyTypes), img=RES_ICONS.MAPS_ICONS_LIBRARY_ATTENTIONICONFILLED, imgPadding=formatters.packPadding(top=2, left=3, right=6)))
return blocks
def __setBottomPanelData(self, *args):
if self.__isCarouselHidden:
occupiedSlotsNum, totalSlotsNum = self.__controller.slots.getSummary()
label = text_styles.highTitle(_ms(VEHICLE_CUSTOMIZATION.TYPESWITCHSCREEN_SLOTSUMMARY, occupiedSlotsNum=occupiedSlotsNum, totalSlotsNum=totalSlotsNum))
else:
label = text_styles.middleTitle(_ms('#vehicle_customization:typeSwitchScreen/typeName/plural/{0}'.format(self.__controller.slots.currentType)))
totalGold = self.__controller.cart.totalPriceGold
totalCredits = self.__controller.cart.totalPriceCredits
notEnoughGoldTooltip = notEnoughCreditsTooltip = ''
enoughGold = g_itemsCache.items.stats.gold >= totalGold
enoughCredits = g_itemsCache.items.stats.credits >= totalCredits
if not enoughGold:
diff = text_styles.gold(totalGold - g_itemsCache.items.stats.gold)
notEnoughGoldTooltip = makeTooltip(_ms(VEHICLE_CUSTOMIZATION.CUSTOMIZATION_NOTENOUGHRESOURCES_HEADER), _ms(VEHICLE_CUSTOMIZATION.CUSTOMIZATION_NOTENOUGHRESOURCES_BODY, count='{0}{1}'.format(diff, icons.gold())))
if not enoughCredits:
diff = text_styles.credits(totalCredits - g_itemsCache.items.stats.credits)
notEnoughCreditsTooltip = makeTooltip(_ms(VEHICLE_CUSTOMIZATION.CUSTOMIZATION_NOTENOUGHRESOURCES_HEADER), _ms(VEHICLE_CUSTOMIZATION.CUSTOMIZATION_NOTENOUGHRESOURCES_BODY, count='{0}{1}'.format(diff, icons.credits())))
self.as_setBottomPanelHeaderS({'newHeaderText': label,
'buyBtnLabel': _ms(MENU.CUSTOMIZATION_BUTTONS_APPLY, count=len(self.__controller.cart.items)),
'pricePanel': {'totalPriceCredits': formatPriceCredits(totalCredits),
'totalPriceGold': formatPriceGold(totalGold),
'enoughGold': enoughGold,
'enoughCredits': enoughCredits,
'notEnoughGoldTooltip': notEnoughGoldTooltip,
'notEnoughCreditsTooltip': notEnoughCreditsTooltip}})
def __makeClanInfo(self):
enemyClanDBID = g_clanCache.clanDBID
tID = "clanInfo%d" % enemyClanDBID
self.__imageID = yield g_clanCache.getClanEmblemTextureID(enemyClanDBID, True, tID)
creationDate = BigWorld.wg_getLongDateFormat(
self.fortCtrl.getFort().getFortDossier().getGlobalStats().getCreationTime()
)
clanTag = g_clanCache.clanTag
clanTagLocal = i18n.makeString(FORTIFICATIONS.SETTINGSWINDOW_CLANINFO_CLANTAG, clanTag=clanTag)
clanTag = text_styles.highTitle(clanTagLocal)
creationDateLocalize = i18n.makeString(
FORTIFICATIONS.SETTINGSWINDOW_CLANINFO_CREATIONDATE, creationDate=creationDate
)
creationDate = text_styles.neutral(creationDateLocalize)
buildingsCount = len(self.fortCtrl.getFort().getBuildingsCompleted())
buildingsCount = text_styles.neutral(buildingsCount)
buildingsCountLocalize = i18n.makeString(
FORTIFICATIONS.SETTINGSWINDOW_CLANINFO_BUILDINGSCOUNT, buildingsCount=str(buildingsCount)
)
buildingsCountLocalize = text_styles.standard(buildingsCountLocalize)
FortSettingsClanInfoVO = {
"clanTag": clanTag,
"clanIcon": self.__imageID,
"creationDate": creationDate,
"buildingCount": buildingsCountLocalize,
}
self.as_setFortClanInfoS(FortSettingsClanInfoVO)
def _populate(self):
super(FittingSelectPopover, self)._populate()
if self._slotType == 'optionalDevice':
title = MENU.OPTIONALDEVICEFITS_TITLE
rendererName = FITTING_TYPES.OPTIONAL_DEVICE_FITTING_ITEM_RENDERER
rendererDataClass = FITTING_TYPES.OPTIONAL_DEVICE_RENDERER_DATA_CLASS_NAME
width = FITTING_TYPES.LARGE_POPOVER_WIDTH
else:
title = _ms(MENU.MODULEFITS_TITLE, moduleName=getTypeInfoByName(self._slotType)['userString'], vehicleName=self.__vehicle.userName)
rendererDataClass = FITTING_TYPES.MODULE_FITTING_RENDERER_DATA_CLASS_NAME
if self._slotType in ('vehicleChassis', 'vehicleEngine'):
rendererName = FITTING_TYPES.ENGINE_CHASSIS_FITTING_ITEM_RENDERER
width = FITTING_TYPES.MEDUIM_POPOVER_WIDTH
elif self._slotType == 'vehicleRadio':
rendererName = FITTING_TYPES.RADIO_FITTING_ITEM_RENDERER
width = FITTING_TYPES.SHORT_POPOVER_WIDTH
else:
rendererName = FITTING_TYPES.GUN_TURRET_FITTING_ITEM_RENDERER
width = FITTING_TYPES.LARGE_POPOVER_WIDTH
self.as_updateS({'title': text_styles.highTitle(title),
'rendererName': rendererName,
'rendererDataClass': rendererDataClass,
'selectedIndex': self.__logicProvider.getSelectedIdx(),
'availableDevices': self.__logicProvider.getDevices(),
'minAvailableHeight': FITTING_TYPES.HANGAR_POPOVER_MIN_AVAILABLE_HEIGHT,
'width': width})
def __makeGlobalMapBlock(self, globalMapStats, ratings):
hasGlobalMap = globalMapStats.hasGlobalMap()
if hasGlobalMap:
notActual = ratings.getGlobalMapBattlesFor28Days() <= 0
stats = [{'local': 'rageLevel10',
'value': formatField(getter=ratings.getGlobalMapEloRating10, formatter=BigWorld.wg_getIntegralFormat),
'timeExpired': notActual,
'tooltip': CLANS.CLANPROFILE_SUMMARYVIEW_TOOLTIP_GMAP_ELO_RAGE_10_BODY},
{'local': 'rageLevel8',
'value': formatField(getter=ratings.getGlobalMapEloRating8, formatter=BigWorld.wg_getIntegralFormat),
'timeExpired': notActual,
'tooltip': CLANS.CLANPROFILE_SUMMARYVIEW_TOOLTIP_GMAP_ELO_RAGE_8_BODY},
{'local': 'rageLevel6',
'value': formatField(getter=ratings.getGlobalMapEloRating6, formatter=BigWorld.wg_getIntegralFormat),
'timeExpired': notActual,
'tooltip': CLANS.CLANPROFILE_SUMMARYVIEW_TOOLTIP_GMAP_ELO_RAGE_6_BODY},
{'local': 'battlesCount',
'value': formatField(getter=ratings.getGlobalMapBattlesFor28Days, formatter=BigWorld.wg_getIntegralFormat),
'tooltip': CLANS.CLANPROFILE_SUMMARYVIEW_TOOLTIP_GMAP_BATTLES_COUNT_BODY},
{'local': 'provinces',
'value': formatField(getter=globalMapStats.getCurrentProvincesCount, formatter=BigWorld.wg_getIntegralFormat),
'tooltip': CLANS.CLANPROFILE_SUMMARYVIEW_TOOLTIP_GMAP_PROVINCE_BODY}]
statsBlock = self.__makeStatsBlock(stats)
emptyLbl = ''
else:
statsBlock = ()
if isValueAvailable(globalMapStats.hasGlobalMap):
emptyLbl = text_styles.standard(CLANS.CLANPROFILE_SUMMARYVIEW_BLOCKLBL_EMPTYGLOBALMAP)
else:
emptyLbl = '%s %s' % (icons.alert(), text_styles.standard(CLANS.CLANPROFILE_SUMMARYVIEW_NODATA))
return {'isShowHeader': True,
'header': text_styles.highTitle(CLANS.CLANPROFILE_MAINWINDOWTAB_GLOBALMAP),
'statBlocks': statsBlock,
'emptyLbl': emptyLbl,
'isActivated': hasGlobalMap}
def setProxy(self, proxy, clanDossier):
proxy.showWaiting()
provinces = yield clanDossier.requestProvinces()
isMyClan = clanDossier.isMyClan()
hasProvinces = len(provinces) > 0
if self.isDisposed():
return
headers = self._prepareHeaders(clanDossier.isMyClan(), hasProvinces)
if isMyClan:
listItemRendererLinkage = CLANS_ALIASES.CLAN_PROFILE_SELF_PROVINCE_RENDERER
else:
listItemRendererLinkage = CLANS_ALIASES.CLAN_PROFILE_PROVINCE_RENDERER
data = {'rendererLinkage': listItemRendererLinkage,
'headers': headers,
'isListVisible': hasProvinces,
'additionalText': text_styles.standard(_ms(CLANS.GLOBALMAPVIEW_TOTALINCOME, icon=icons.gold(), value=text_styles.gold(BigWorld.wg_getIntegralFormat(sum(map(operator.methodcaller('getRevenue'), provinces)))))),
'isAdditionalTextVisible': hasProvinces and isMyClan,
'noDataText': text_styles.highTitle(_ms(CLANS.GLOBALMAPVIEW_NOPROVINCE)),
'isNoDataTextVisible': not hasProvinces}
if hasProvinces:
data['defaultSortField'] = _SORT_IDS.PROVINCE
data['defaultSortDirection'] = 'ascending'
self.as_setDataS(data)
self.__provincesDP = _ClanProfileProvinceDataProvider(isMyClan)
self.__provincesDP.setFlashObject(self.as_getDPS())
self.__provincesDP.buildList(provinces)
proxy.hideWaiting()
def __createInitialVO(self):
isTypeNotCamouflage = self.__filter.currentType != CUSTOMIZATION_TYPE.CAMOUFLAGE
groupsUserNames = []
for _, groupName in self.__groupsMap[self.__filter.currentType]:
groupsUserNames.append(groupName)
updateVO = self.__createUpdateVO()
return {'lblTitle': text_styles.highTitle(VEHICLE_CUSTOMIZATION.FILTER_POPOVER_TITLE),
'lblBonusType': text_styles.standard(VEHICLE_CUSTOMIZATION.FILTER_POPOVER_BONUSTYPE_TITLE),
'lblCustomizationType': text_styles.standard(VEHICLE_CUSTOMIZATION.FILTER_POPOVER_GROUPS_TITLE),
'lblPurchaseType': text_styles.standard(VEHICLE_CUSTOMIZATION.FILTER_POPOVER_WAYSTOBUY_TITLE),
'btnDefault': VEHICLE_CUSTOMIZATION.FILTER_POPOVER_GETDEFAULTSETTINGS,
'bonusTypeId': FILTER_TYPE.QUALIFIER,
'bonusType': _getBonusTypeVO(self.__filter.selectedBonuses),
'customizationBonusTypeVisible': isTypeNotCamouflage,
'enableGroupFilter': updateVO['enableGroupFilter'],
'customizationTypeId': FILTER_TYPE.GROUP,
'customizationType': groupsUserNames,
'customizationTypeSelectedIndex': updateVO['groupsSelectIndex'],
'customizationTypeVisible': isTypeNotCamouflage,
'bonusTypeDisableTooltip': makeTooltip(VEHICLE_CUSTOMIZATION.TOOLTIP_FILTER_GROUPS_DISABLED_HEADER, VEHICLE_CUSTOMIZATION.TOOLTIP_FILTER_GROUPS_DISABLED_BODY),
'refreshTooltip': makeTooltip(VEHICLE_CUSTOMIZATION.CUSTOMIZATION_FILTERPOPOVER_REFRESH_HEADER, VEHICLE_CUSTOMIZATION.CUSTOMIZATION_FILTERPOPOVER_REFRESH_BODY),
'purchaseTypeId': FILTER_TYPE.PURCHASE_TYPE,
'purchaseType': _getPurchaseTypeVO(),
'purchaseTypeSelectedIndex': PURCHASE_TYPE.ALL.index(self.__filter.purchaseType)}
def __createTexts(self):
self.__textsCreated = True
return {
'windowLbl':
FORTIFICATIONS.PERIODDEFENCEWINDOW_HEADERLBL,
'headerLbl':
text_styles.highTitle(FORTIFICATIONS.PERIODDEFENCEWINDOW_READY),
'peripheryLbl':
text_styles.neutral(FORTIFICATIONS.PERIODDEFENCEWINDOW_PERIPHERY),
'peripheryDescr':
text_styles.standard(
FORTIFICATIONS.PERIODDEFENCEWINDOW_PERIPHERY_DESCRIPTION),
'hourDefenceLbl':
text_styles.neutral(
FORTIFICATIONS.PERIODDEFENCEWINDOW_HOURDEFENCE),
'hourDefenceDescr':
text_styles.standard(
FORTIFICATIONS.PERIODDEFENCEWINDOW_HOURDEFENCE_DESCRIPTION),
'holidayLbl':
text_styles.neutral(FORTIFICATIONS.PERIODDEFENCEWINDOW_HOLIDAY),
'holidayDescr':
text_styles.standard(
FORTIFICATIONS.PERIODDEFENCEWINDOW_HOLIDAY_DESCRIPTION),
'acceptBtn':
FORTIFICATIONS.PERIODDEFENCEWINDOW_BTN_ACTIVATE,
'cancelBtn':
FORTIFICATIONS.PERIODDEFENCEWINDOW_BTN_NOTNOW
}
def __updateNextBattleCount(self):
cache = self.fortCtrl.getFortBattlesCache()
if cache is None:
return
currentBattlesCount = BigWorld.wg_getNiceNumberFormat(len(self._searchDP.collection))
result = text_styles.highTitle(currentBattlesCount)
self.as_upateClanBattlesCountS(result)
def _populate(self):
super(FittingSelectPopover, self)._populate()
if self._slotType == "optionalDevice":
title = MENU.OPTIONALDEVICEFITS_TITLE
rendererName = FITTING_TYPES.OPTIONAL_DEVICE_FITTING_ITEM_RENDERER
rendererDataClass = FITTING_TYPES.OPTIONAL_DEVICE_RENDERER_DATA_CLASS_NAME
width = FITTING_TYPES.LARGE_POPOVER_WIDTH
else:
title = _ms(
MENU.MODULEFITS_TITLE,
moduleName=getTypeInfoByName(self._slotType)["userString"],
vehicleName=self.__vehicle.userName,
)
rendererDataClass = FITTING_TYPES.MODULE_FITTING_RENDERER_DATA_CLASS_NAME
if self._slotType in ("vehicleChassis", "vehicleEngine"):
rendererName = FITTING_TYPES.ENGINE_CHASSIS_FITTING_ITEM_RENDERER
width = FITTING_TYPES.MEDUIM_POPOVER_WIDTH
elif self._slotType == "vehicleRadio":
rendererName = FITTING_TYPES.RADIO_FITTING_ITEM_RENDERER
width = FITTING_TYPES.SHORT_POPOVER_WIDTH
else:
rendererName = FITTING_TYPES.GUN_TURRET_FITTING_ITEM_RENDERER
width = FITTING_TYPES.LARGE_POPOVER_WIDTH
self.as_updateS(
{
"title": text_styles.highTitle(title),
"rendererName": rendererName,
"rendererDataClass": rendererDataClass,
"selectedIndex": self.__logicProvider.getSelectedIdx(),
"availableDevices": self.__logicProvider.getDevices(),
"width": width,
}
)
def setProxy(self, proxy, clanDossier):
proxy.showWaiting()
provinces = yield clanDossier.requestProvinces()
showTreasury = clanDossier.isMyClan() and g_clanCtrl.getLimits().canSeeTreasury(clanDossier).success
hasProvinces = len(provinces) > 0
if self.isDisposed():
return
headers = self._prepareHeaders(showTreasury, hasProvinces)
if showTreasury:
listItemRendererLinkage = CLANS_ALIASES.CLAN_PROFILE_SELF_PROVINCE_RENDERER
else:
listItemRendererLinkage = CLANS_ALIASES.CLAN_PROFILE_PROVINCE_RENDERER
data = {'rendererLinkage': listItemRendererLinkage,
'headers': headers,
'isListVisible': hasProvinces,
'noDataText': text_styles.highTitle(_ms(CLANS.GLOBALMAPVIEW_NOPROVINCE)),
'isNoDataTextVisible': not hasProvinces}
if hasProvinces:
data['defaultSortField'] = _SORT_IDS.PROVINCE
data['defaultSortDirection'] = 'ascending'
self.as_setDataS(data)
self.__provincesDP = _ClanProfileProvinceDataProvider(showTreasury)
self.__provincesDP.setFlashObject(self.as_getDPS())
self.__provincesDP.buildList(provinces)
self.as_setAdditionalTextS(hasProvinces and showTreasury, text_styles.standard(_ms(CLANS.GLOBALMAPVIEW_TOTALINCOME, icon=icons.gold(), value=text_styles.gold(BigWorld.wg_getIntegralFormat(self.__provincesDP.getCommonRevenue())))))
proxy.hideWaiting()
def __packLadderData(self, clubs):
formations = []
club = self.clubsCtrl.getClub(self._clubDbID)
ladderInfo = club.getLadderInfo()
if club and ladderInfo.isInLadder():
for clubInfo in sorted(clubs, key=lambda club: club.ladderRank):
self.requestClubEmblem32x32(clubInfo.clubDBID, clubInfo.clubEmblemUrl)
battlesCount = BigWorld.wg_getNiceNumberFormat(clubInfo.battlesCount)
winsPercent = 0
if clubInfo.battlesCount > 0:
winsPercent = clubInfo.winsCount / float(clubInfo.battlesCount) * 100
winsPercentStr = BigWorld.wg_getNiceNumberFormat(winsPercent) + '%'
clubName = clubInfo.clubName
ladderPoints = clubInfo.getRatingPoints(ladderInfo.getDivision())
emblem = self._clubEmblems.get(clubInfo.clubDBID, None)
texturePath = self.getMemoryTexturePath(emblem) if emblem else ''
formations.append({'formationId': str(clubInfo.clubDBID),
'showProfileBtnText': _ms(CYBERSPORT.STATICFORMATION_LADDERVIEW_SHOWFORMATIONPROFILEBTN_TEXT),
'showProfileBtnTooltip': TOOLTIPS.STATICFORMATIONLADDERVIEW_SHOWFORMATIONPROFILEBTN,
'emblemIconPath': texturePath,
'place': text_styles.standard(str(clubInfo.ladderRank)),
'placeSortValue': clubInfo.ladderRank,
'points': text_styles.middleTitle(str(ladderPoints)),
'pointsSortValue': ladderPoints,
'formationName': text_styles.highTitle(clubName),
'formationNameSortValue': clubName,
'battlesCount': text_styles.stats(battlesCount),
'battlesCountSortValue': clubInfo.battlesCount,
'winPercent': text_styles.stats(winsPercentStr),
'winPercentSortValue': winsPercent,
'isCurrentTeam': self._clubDbID == clubInfo.clubDBID})
return {'formations': formations}
def _setTipsInfo(self):
arena = getClientArena()
isFallout = arena.guiType == constants.ARENA_GUI_TYPE.EVENT_BATTLES
arenaDP = self._battleCtx.getArenaDP()
if hasResourcePoints():
bgUrl = RES_ICONS.MAPS_ICONS_EVENTINFOPANEL_FALLOUTRESOURCEPOINTSEVENT
elif hasFlags():
bgUrl = RES_ICONS.MAPS_ICONS_EVENTINFOPANEL_FALLOUTFLAGSEVENT
else:
bgUrl = ''
if isFallout:
self.as_setEventInfoPanelDataS({'bgUrl': bgUrl,
'items': getHelpTextAsDicts(arena.arenaType)})
elif not self.__isTipInited:
battlesCount = DEFAULT_BATTLES_COUNT
if g_lobbyContext.getBattlesCount() is not None:
battlesCount = g_lobbyContext.getBattlesCount()
vType, vLvl, nation = arenaDP.getVehicleInfo().getTypeInfo()
tipsIterator = tips.getTipsIterator(arena.guiType, battlesCount, vType, nation, vLvl)
statusStr, tipStr = ('', '')
if tipsIterator is not None:
statusStr, tipStr = next(tipsIterator)
else:
LOG_ERROR('No required tips found')
self.as_setTipTitleS(text_styles.highTitle(statusStr))
self.as_setTipS(text_styles.playerOnline(tipStr))
self.__isTipInited = True
return
def _updateControlsState(self):
isNotInCooldown = not self._cooldown.isInCooldown()
foundClans = clans_fmts.formatDataToString(self.__clanFinder.getTotalCount())
self.as_setStateDataS({'foundClans': text_styles.highTitle(_ms(CLANS.SEARCH_CLANSLIST if self.__clanFinder.isRecommended() else CLANS.SEARCH_FOUNDCLANS, value=foundClans)),
'nextBtnEnabled': self.__clanFinder.canMoveRight() and isNotInCooldown,
'previousBtnEnabled': self.__clanFinder.canMoveLeft() and isNotInCooldown,
'searchBtnEnabled': isNotInCooldown,
'searchInputEnabled': isNotInCooldown})
def __getActiveText(self):
return text_styles.highTitle(
_ms(
MENU.BOOSTERSWINDOW_ACTIVEBOOSTERS,
activeNo=self.__tabsContainer.getActiveBoostersCount(),
allNo=MAX_ACTIVE_BOOSTERS_COUNT,
)
)
def __initData(self):
ms = i18n.makeString
igrIcon = RES_ICONS.MAPS_ICONS_LIBRARY_PREMIUM_SMALL
icon = icons.makeImageTag(igrIcon, 34, 16, -4)
self.as_setWindowTitleS(ms(MENU.PROMOPREMIUMIGRWINDOW_WINDOWTITLE))
self.as_setTitleS(text_styles.highTitle(ms(MENU.PROMOPREMIUMIGRWINDOW_TITLE)))
self.as_setTextS(text_styles.standard(ms(MENU.PROMOPREMIUMIGRWINDOW_TEXT, iconIgr=icon)))
self.as_setApplyButtonLabelS(ms(MENU.PROMOPREMIUMIGRWINDOW_APPLYBUTTONLABEL))
def __setBuyingPanelInitData(self):
self.as_setBuyingPanelInitDataS({'totalPriceLabel': text_styles.highTitle(MENU.CUSTOMIZATION_LABELS_TOTALPRICE),
'buyBtnLabel': MENU.CUSTOMIZATION_BUTTONS_APPLY,
'buyingListIcon': RES_ICONS.MAPS_ICONS_LIBRARY_ICON_BUTTON_LIST,
'goldIcon': RES_ICONS.MAPS_ICONS_LIBRARY_GOLDICON_1,
'creditsIcon': RES_ICONS.MAPS_ICONS_LIBRARY_CREDITSICON_1,
'purchasesBtnTooltip': makeTooltip(TOOLTIPS.CUSTOMIZATION_PURCHASESPOPOVERBTN_HEADER, TOOLTIPS.CUSTOMIZATION_PURCHASESPOPOVERBTN_BODY),
'buyingPanelVO': {'totalPriceCredits': text_styles.creditsTextBig(g_customizationController.carousel.slots.cart.totalPriceCredits),
'totalPriceGold': text_styles.goldTextBig(g_customizationController.carousel.slots.cart.totalPriceGold)}})
def _packTitleBlock():
return formatters.packImageTextBlockData(title=text_styles.highTitle(VEH_COMPARE.VEHCONF_TOOLTIPS_SKILLS_HEADER), padding={'top': 20})
def getHeader(self):
return text_styles.highTitle(
i18n.makeString(MENU.AWARDWINDOW_QUESTS_TOKENS_HEADER,
count=self.__tokenCount))
def __packRandomFragmentBlocks(self):
self._items.append(formatters.packImageTextBlockData(title=text_styles.highTitle(TOOLTIPS.BLUEPRINT_BLUEPRINTFRAGMENTTOOLTIP_RANDOM_HEADER), img=RES_ICONS.getBlueprintFragment('small', 'random'), imgPadding=formatters.packPadding(top=3), txtPadding=formatters.packPadding(left=21)))
descriptionBlock = formatters.packImageTextBlockData(desc=text_styles.main(TOOLTIPS.BLUEPRINT_BLUEPRINTFRAGMENTTOOLTIP_RANDOM_DESCRIPTION), img=RES_ICONS.MAPS_ICONS_BLUEPRINTS_PLUS, imgPadding=formatters.packPadding(top=0, right=5), padding=formatters.packPadding(left=40))
self._items.append(formatters.packBuildUpBlockData(blocks=[descriptionBlock, self.__packDiscountBlock()], gap=5, linkage=BLOCKS_TOOLTIP_TYPES.TOOLTIP_BUILDUP_BLOCK_WHITE_BG_LINKAGE))
def __createUpdateVO(self):
_filterBtns = [{
'value':
backport.image(R.images.gui.maps.icons.buttons.non_historical()),
'tooltip':
makeTooltip(
backport.text(R.strings.vehicle_customization.carousel.filter.
nonHistoricalBtn.header()),
backport.text(R.strings.vehicle_customization.carousel.filter.
nonHistoricalBtn.body())),
'selected':
self._nonHistoricToggleEnabled
}, {
'value':
backport.image(R.images.gui.maps.icons.buttons.hist_small()),
'tooltip':
makeTooltip(
backport.text(R.strings.vehicle_customization.carousel.filter.
historicalBtn.header()),
backport.text(R.strings.vehicle_customization.carousel.filter.
historicalBtn.body())),
'selected':
self._historicToggleEnabled
}, {
'value':
backport.image(
R.images.gui.maps.icons.customization.storage_icon()),
'tooltip':
makeTooltip(
backport.text(R.strings.vehicle_customization.carousel.filter.
storageBtn.header()),
backport.text(R.strings.vehicle_customization.carousel.filter.
storageBtn.body())),
'selected':
self._purchasedToggleEnabled
}, {
'value':
backport.image(R.images.gui.maps.icons.buttons.equipped_icon()),
'tooltip':
makeTooltip(
backport.text(R.strings.vehicle_customization.carousel.filter.
equippedBtn.header()),
backport.text(R.strings.vehicle_customization.carousel.filter.
equippedBtn.body())),
'selected':
self._appliedToggleEnabled
}]
self.__filterChangeHandlers = [
self.setShowOnlyNonHistoric, self.setShowOnlyHistoric,
self.setShowOnlyAcquired, self.setShowOnlyApplied
]
if self.__ctx.isProgressiveItemsExist:
progressionDecalsBtnTooltip = makeTooltip(
backport.text(R.strings.vehicle_customization.customization.
filterPopover.progressionDecalsBtn.header()),
backport.text(R.strings.vehicle_customization.customization.
filterPopover.progressionDecalsBtn.body()))
_filterBtns.append({
'value':
backport.image(R.images.gui.maps.icons.buttons.progression()),
'tooltip':
progressionDecalsBtnTooltip,
'selected':
self._showOnlyProgressionDecalsEnabled
})
self.__filterChangeHandlers.append(
self.setShowOnlyProgressionDecals)
if self.__ctx.modeId == CustomizationModes.STYLED:
editableStylesBtnTooltip = makeTooltip(
backport.text(R.strings.vehicle_customization.customization.
filterPopover.editableStylesBtn.header()),
backport.text(R.strings.vehicle_customization.customization.
filterPopover.editableStylesBtn.body()))
_filterBtns.append({
'value':
backport.image(
R.images.gui.maps.icons.buttons.editable_small()),
'tooltip':
editableStylesBtnTooltip,
'selected':
self._showOnlyEditableStylesEnabled
})
self.__filterChangeHandlers.append(self.setShowOnlyEditableStyles)
nonEditableStylesBtnTooltip = makeTooltip(
backport.text(R.strings.vehicle_customization.customization.
filterPopover.nonEditableStylesBtn.header()),
backport.text(R.strings.vehicle_customization.customization.
filterPopover.nonEditableStylesBtn.body()))
_filterBtns.append({
'value':
backport.image(R.images.gui.maps.icons.buttons.non_editable()),
'tooltip':
nonEditableStylesBtnTooltip,
'selected':
self._showOnlyNonEditableStylesEnabled
})
self.__filterChangeHandlers.append(
self.setShowOnlyNonEditableStyles)
_formsBtns = [{
'value':
self.PROJECTION_DECAL_IMAGE_FORM_TAG[formType],
'selected':
value,
'tooltip':
makeTooltip(
'{} {}'.format(
backport.text(R.strings.vehicle_customization.popover.
tooltip.form()),
PROJECTION_DECAL_TEXT_FORM_TAG[formType]),
backport.text(
R.strings.vehicle_customization.popover.tooltip.form.body(
),
value=backport.text(
R.strings.vehicle_customization.form.dyn(formType)())))
} for formType, value in self._formfactorTypes.iteritems()]
formsBtnsLbl = ''
if self._formfactorTypes:
formsBtnsLbl = text_styles.standard(
backport.text(R.strings.vehicle_customization.filter.popover.
formfilters.title()))
additionalCheckBoxLabel = backport.text(
R.strings.vehicle_customization.filter.popover.showonlyfilters.
onAnotherVeh())
additionalCheckBoxTooltip = makeTooltip(
backport.text(R.strings.vehicle_customization.customization.
filterPopover.additionalCheckBox.header()),
backport.text(R.strings.vehicle_customization.customization.
filterPopover.additionalCheckBox.body()))
return FiltersPopoverVO(
lblTitle=text_styles.highTitle(
backport.text(
R.strings.vehicle_customization.filter.popover.title())),
lblGroups=text_styles.standard(
backport.text(R.strings.vehicle_customization.filter.popover.
groups.title())),
lblShowOnlyFilters=text_styles.standard(
backport.text(R.strings.vehicle_customization.filter.popover.
showonlyfilters.title())),
lblAdditional=text_styles.standard(
backport.text(R.strings.vehicle_customization.filter.popover.
showonlyfilters.additional())),
additionalCheckBoxData={
'label': additionalCheckBoxLabel,
'tooltip': additionalCheckBoxTooltip,
'selected': self._hideOnAnotherVehEnabled
},
btnDefault=backport.text(R.strings.vehicle_customization.filter.
popover.getDefaultSettings()),
groupType=self._groups if self._groupCount > 1 else None,
btnDefaultTooltip=makeTooltip(
backport.text(R.strings.vehicle_customization.customization.
filterPopover.refresh.header()),
backport.text(R.strings.vehicle_customization.customization.
filterPopover.refresh.body())),
groupTypeSelectedIndex=self._selectedGroup,
filterBtns=_filterBtns,
additionalEnabled=self.__ctx.isItemsOnAnotherVeh,
formsBtnsLbl=formsBtnsLbl,
formsBtns=_formsBtns)
def __makeGlobalMapBlock(self, globalMapStats, ratings):
hasGlobalMap = globalMapStats.hasGlobalMap()
if hasGlobalMap:
notActual = ratings.getGlobalMapBattlesFor28Days() <= 0
stats = [{
'local':
'rageLevel10',
'value':
formatField(getter=ratings.getGlobalMapEloRating10,
formatter=backport.getIntegralFormat),
'timeExpired':
notActual,
'tooltip':
CLANS.CLANPROFILE_SUMMARYVIEW_TOOLTIP_GMAP_ELO_RAGE_10_BODY
}, {
'local':
'rageLevel8',
'value':
formatField(getter=ratings.getGlobalMapEloRating8,
formatter=backport.getIntegralFormat),
'timeExpired':
notActual,
'tooltip':
CLANS.CLANPROFILE_SUMMARYVIEW_TOOLTIP_GMAP_ELO_RAGE_8_BODY
}, {
'local':
'rageLevel6',
'value':
formatField(getter=ratings.getGlobalMapEloRating6,
formatter=backport.getIntegralFormat),
'timeExpired':
notActual,
'tooltip':
CLANS.CLANPROFILE_SUMMARYVIEW_TOOLTIP_GMAP_ELO_RAGE_6_BODY
}, {
'local':
'battlesCount',
'value':
formatField(getter=ratings.getGlobalMapBattlesFor28Days,
formatter=backport.getIntegralFormat),
'tooltip':
CLANS.CLANPROFILE_SUMMARYVIEW_TOOLTIP_GMAP_BATTLES_COUNT_BODY
}, {
'local':
'provinces',
'value':
formatField(getter=globalMapStats.getCurrentProvincesCount,
formatter=backport.getIntegralFormat),
'tooltip':
CLANS.CLANPROFILE_SUMMARYVIEW_TOOLTIP_GMAP_PROVINCE_BODY
}]
statsBlock = self.__makeStatsBlock(stats)
emptyLbl = ''
else:
statsBlock = ()
if isValueAvailable(globalMapStats.hasGlobalMap):
emptyLbl = text_styles.standard(
CLANS.CLANPROFILE_SUMMARYVIEW_BLOCKLBL_EMPTYGLOBALMAP)
else:
emptyLbl = '%s %s' % (
icons.alert(),
text_styles.standard(CLANS.CLANPROFILE_SUMMARYVIEW_NODATA))
return {
'isShowHeader':
True,
'header':
text_styles.highTitle(CLANS.CLANPROFILE_MAINWINDOWTAB_GLOBALMAP),
'statBlocks':
statsBlock,
'emptyLbl':
emptyLbl,
'isActivated':
hasGlobalMap
}
def __packIntelFragmentBlocks(self):
self._items.append(formatters.packImageTextBlockData(title=text_styles.highTitle(TOOLTIPS.BLUEPRINT_BLUEPRINTFRAGMENTTOOLTIP_INTELFRAGMENT), img=RES_ICONS.getBlueprintFragment('small', 'intelligence'), imgPadding=formatters.packPadding(top=5), txtPadding=formatters.packPadding(top=5, left=19)))
descriptionBlock = formatters.packImageTextBlockData(desc=text_styles.main(TOOLTIPS.BLUEPRINT_BLUEPRINTFRAGMENTTOOLTIP_INTELDESCRIPTION), img=RES_ICONS.MAPS_ICONS_BLUEPRINTS_PLUS, imgPadding=formatters.packPadding(top=0, right=5), padding=formatters.packPadding(left=40))
self._items.append(formatters.packBuildUpBlockData(blocks=[descriptionBlock], linkage=BLOCKS_TOOLTIP_TYPES.TOOLTIP_BUILDUP_BLOCK_WHITE_BG_LINKAGE, padding=formatters.packPadding(bottom=-4)))
fragmentsCount = self.context.getUniversalCount()
self._items.append(self.__packInStorageBlock(fragmentsCount))
def __packLadderData(self, clubs):
formations = []
clubsState = self.clubsCtrl.getState()
if clubsState.getStateID() == CLIENT_CLUB_STATE.HAS_CLUB:
myClubDbID = clubsState.getClubDbID()
else:
myClubDbID = None
club = self.clubsCtrl.getClub(self._clubDbID)
ladderInfo = club.getLadderInfo()
if club and ladderInfo.isInLadder():
for clubInfo in sorted(clubs, key=lambda club: club.ladderRank):
self.requestClubEmblem32x32(clubInfo.clubDBID,
clubInfo.clubEmblemUrl)
battlesCount = BigWorld.wg_getNiceNumberFormat(
clubInfo.battlesCount)
winsPercent = 0
if clubInfo.battlesCount > 0:
winsPercent = clubInfo.winsCount / float(
clubInfo.battlesCount) * 100
winsPercentStr = BigWorld.wg_getNiceNumberFormat(
winsPercent) + '%'
clubName = clubInfo.clubName
ladderPoints = clubInfo.getRatingPoints(
ladderInfo.getDivision())
emblem = self._clubEmblems.get(clubInfo.clubDBID, None)
texturePath = self.getMemoryTexturePath(
emblem) if emblem else ''
formations.append({
'formationId':
clubInfo.clubDBID,
'showProfileBtnText':
_ms(CYBERSPORT.
STATICFORMATION_LADDERVIEW_SHOWFORMATIONPROFILEBTN_TEXT
),
'showProfileBtnTooltip':
TOOLTIPS.STATICFORMATIONLADDERVIEW_SHOWFORMATIONPROFILEBTN,
'emblemIconPath':
texturePath,
'place':
text_styles.standard(str(clubInfo.ladderRank)),
'placeSortValue':
clubInfo.ladderRank,
'points':
text_styles.middleTitle(str(ladderPoints)),
'pointsSortValue':
ladderPoints,
'formationName':
text_styles.highTitle(clubName),
'formationNameSortValue':
clubName,
'battlesCount':
text_styles.stats(battlesCount),
'battlesCountSortValue':
clubInfo.battlesCount,
'winPercent':
text_styles.stats(winsPercentStr),
'winPercentSortValue':
winsPercent,
'isCurrentTeam':
self._clubDbID == clubInfo.clubDBID,
'isMyClub':
myClubDbID == clubInfo.clubDBID
})
return {'formations': formations}
def getHeader(self):
return text_styles.highTitle(_ms(
MENU.AWARDWINDOW_QUESTS_MEDALS_HEADER))
def __updateStrongholdBlock(self, stats):
self.as_updateFortBlockS({'isShowHeader': True,
'header': text_styles.highTitle(CLANS.CLANPROFILE_MAINWINDOWTAB_FORTIFICATION),
'statBlocks': self.__makeStatsBlock(stats),
'emptyLbl': '',
'isActivated': True})
def __showDismissedTankmen(self, criteria):
tankmen = self.restore.getDismissedTankmen()
tankmenList = list()
for tankman in tankmen:
if not criteria(tankman):
continue
skillsList = []
for skill in tankman.skills:
skillsList.append({
'tankmanID': tankman.invID,
'id': str(tankman.skills.index(skill)),
'name': skill.userName,
'desc': skill.description,
'icon': skill.icon,
'level': skill.level,
'active': skill.isEnable and skill.isActive
})
newSkillsCount, lastNewSkillLvl = tankman.newSkillCount
if newSkillsCount > 0:
skillsList.append({
'buy': True,
'buyCount': newSkillsCount - 1,
'tankmanID': tankman.invID,
'level': lastNewSkillLvl
})
restoreInfo = getTankmenRestoreInfo(tankman)
actionBtnTooltip = makeTooltip(
TOOLTIPS.BARRACKS_TANKMEN_RECOVERYBTN_HEADER,
getRecoveryStatusText(restoreInfo))
tankmanData = _packTankmanData(tankman)
tankmanData.update({
'isRankNameVisible':
False,
'recoveryPeriodText':
_makeRecoveryPeriodText(restoreInfo),
'actionBtnLabel':
MENU.BARRACKS_BTNRECOVERY,
'actionBtnTooltip':
actionBtnTooltip,
'skills':
skillsList,
'isSkillsVisible':
True
})
tankmenList.append(tankmanData)
tankmenCountStr = _ms(MENU.BARRACKS_DISMISSEDTANKMENCOUNT,
curValue=len(tankmenList),
total=len(tankmen))
placeCount = self.restore.getMaxTankmenBufferLength()
placeCountStr = _ms(MENU.BARRACKS_RECOVERYCOUNT,
total=placeCount,
info=icons.info())
noInfoData = None
hasNoInfoData = len(tankmenList) == 0
if hasNoInfoData:
if not tankmen:
tankmenRestoreConfig = self.itemsCache.items.shop.tankmenRestoreConfig
freeDays = tankmenRestoreConfig.freeDuration / time_utils.ONE_DAY
billableDays = tankmenRestoreConfig.billableDuration / time_utils.ONE_DAY - freeDays
noInfoData = {
'title':
text_styles.highTitle(
MENU.BARRACKS_NORECOVERYTANKMEN_TITLE),
'message':
text_styles.main(
_ms(MENU.BARRACKS_NORECOVERYTANKMEN_MESSAGE,
price=moneyWithIcon(tankmenRestoreConfig.cost),
totalDays=freeDays + billableDays,
freeDays=freeDays,
paidDays=billableDays))
}
else:
noInfoData = {
'message':
text_styles.main(
MENU.BARRACKS_NOFILTEREDRECOVERYTANKMEN_MESSAGE)
}
placesCountTooltip = makeTooltip(
TOOLTIPS.BARRACKS_PLACESCOUNT_DISMISS_HEADER,
_ms(TOOLTIPS.BARRACKS_PLACESCOUNT_DISMISS_BODY,
placeCount=placeCount))
self.as_setTankmenS({
'tankmenCount':
text_styles.playerOnline(tankmenCountStr),
'placesCount':
text_styles.playerOnline(placeCountStr),
'placesCountTooltip':
placesCountTooltip,
'tankmenData':
tankmenList,
'hasNoInfoData':
hasNoInfoData,
'noInfoData':
noInfoData
})
return
def packMoneyAndXpBlocks(tooltipBlocks,
btnType,
valueBlocks,
alternativeData=None,
hideActionBlock=False):
titleBlocks = list()
alternativeData = alternativeData or {}
titleBlocks.append(
packTitleDescBlock(text_styles.highTitle(
TOOLTIPS.getHeaderBtnTitle(
alternativeData.get('title') or btnType)),
None,
padding=packPadding(bottom=15)))
tooltipBlocks.append(packBuildUpBlockData(titleBlocks))
if valueBlocks is not None:
tooltipBlocks.append(
packBuildUpBlockData(valueBlocks,
linkage=BLOCKS_TOOLTIP_TYPES.
TOOLTIP_BUILDUP_BLOCK_WHITE_BG_LINKAGE))
decsBlocks = list()
descLinkage = BLOCKS_TOOLTIP_TYPES.TOOLTIP_BUILDUP_BLOCK_LINKAGE
if btnType == CURRENCIES_CONSTANTS.CRYSTAL:
descLinkage = BLOCKS_TOOLTIP_TYPES.TOOLTIP_BUILD_BLOCK_VIOLET_BIG_LINKAGE
padding = packPadding(bottom=8)
decsBlocks.append(
packTextBlockData(text_styles.middleTitle(
backport.text(R.strings.tooltips.header.buttons.crystal.
descriptionTitle())),
padding=padding))
descVehicle = text_styles.vehicleStatusInfoText(
backport.text(R.strings.tooltips.header.buttons.crystal.
descriptionVehicle()))
decsBlocks.append(
packTextBlockData(text_styles.main(
backport.text(
R.strings.tooltips.header.buttons.crystal.description0(),
vehicle=descVehicle)),
padding=padding))
decsBlocks.append(
packTextBlockData(text_styles.main(
backport.text(
R.strings.tooltips.header.buttons.crystal.description1())),
padding=packPadding(bottom=20)))
else:
decsBlocks.append(
packTextBlockData(text_styles.main(
TOOLTIPS.getHeaderBtnDesc(
alternativeData.get('btnDesc') or btnType)),
padding=packPadding(bottom=15)))
tooltipBlocks.append(packBuildUpBlockData(decsBlocks, linkage=descLinkage))
if not hideActionBlock:
if btnType != CURRENCIES_CONSTANTS.CRYSTAL:
actionBlocks = list()
actionBlocks.append(
packAlignedTextBlockData(
text=text_styles.standard(
TOOLTIPS.getHeaderBtnClickDesc(
alternativeData.get('btnClickDesc') or btnType)),
align=alternativeData.get('btnClickDescAlign')
or BLOCKS_TOOLTIP_TYPES.ALIGN_CENTER))
tooltipBlocks.append(packBuildUpBlockData(actionBlocks))
return tooltipBlocks
def getAwardInfo(self):
return {'title': text_styles.highTitle(_ms(EVENT_BOARDS.BLOCK_AWARD)),
'label': _ms(EVENT_BOARDS.BUTTON_AWARDS),
'buttonTooltip': makeTooltip(EVENT_BOARDS.BUTTON_AWARDS, EVENT_BOARDS.BUTTON_AWARDS_TOOLTIP),
'iconTooltip': makeTooltip(body=EVENT_BOARDS.TOOLTIP_AWARDICON),
'uiIcon': self._event.getPromoBonuses()}
def __packTitleBlock():
return formatters.packImageTextBlockData(title=text_styles.highTitle(VEH_COMPARE.VEHCONF_TOOLTIPS_CAMOTITLE), padding={'top': -5})
def __makeQuestDetailsInfo(self, questID):
quest = old_events_helpers.getPotapovQuestsCache().getQuests()[questID]
questInfoData = old_events_helpers.getEventInfoData(quest)
self._navInfo.selectPotapovQuest(self.__tile.getID(), questID)
vehMinLevel, vehClasses = quest.getVehMinLevel(
), quest.getVehicleClasses()
if vehMinLevel > 1:
reqsHeader = text_styles.middleTitle(
_ms(QUESTS.QUESTTASKDETAILSVIEW_REQUIREMENTS))
if quest.getQuestBranch() == PQ_BRANCH.REGULAR:
reqs = _ms(QUESTS.QUESTTASKDETAILSVIEW_REQUIREMENTS_TEXT,
level=int2roman(vehMinLevel),
vehType=', '.join([
Vehicle.getTypeShortUserName(vc)
for vc in vehClasses
]))
elif vehMinLevel < 10:
reqs = _ms(QUESTS.QUESTTASKDETAILSVIEW_REQUIREMENTS_MORE8LVL)
else:
reqs = _ms(QUESTS.QUESTTASKDETAILSVIEW_REQUIREMENTS_ONLY10LVL)
else:
reqsHeader = reqs = ''
condition = makeHtmlString(
'html_templates:lobby/quests/potapov',
'questDetails',
ctx={
'mainCondHeader':
text_styles.middleTitle(
_ms(QUESTS.QUESTTASKDETAILSVIEW_MAINCONDITIONS)),
'mainCond':
quest.getUserMainCondition(),
'addCondHeader':
text_styles.middleTitle(
_ms(QUESTS.QUESTTASKDETAILSVIEW_ADDITIONALCONDITIONS)),
'addCond':
quest.getUserAddCondition(),
'requirementsHeader':
reqsHeader,
'requirements':
reqs,
'adviseHeader':
text_styles.middleTitle(
_ms(QUESTS.QUESTTASKDETAILSVIEW_DESCRIPTION)),
'advise':
quest.getUserAdvice(),
'descr':
quest.getUserDescription()
})
if not quest.isUnlocked():
btnInfo = _makeSelectBtn(
QUESTS.QUESTTASKDETAILSVIEW_BTNLABEL_BEGIN,
enabled=False,
descr=text_styles.error(icons.notAvailableRed() + ' ' +
_ms(self._lockedMessageStrKey)))
elif quest.needToGetReward():
btnInfo = _makeSelectBtn(
QUESTS.QUESTTASKDETAILSVIEW_BTNLABEL_TAKEAWARD,
TOOLTIPS.PRIVATEQUESTS_ACTIONPANNEL_RECEIVETHEAWARD,
_ms(QUESTS.QUESTTASKDETAILSVIEW_TASKDESCRIPTION_TAKEAWARD))
elif quest.isInProgress():
btnInfo = _makeRefuseBtn(
QUESTS.QUESTTASKDETAILSVIEW_BTNLABEL_CANCEL,
TOOLTIPS.PRIVATEQUESTS_ACTIONPANNEL_ABORT,
_ms(QUESTS.QUESTTASKDETAILSVIEW_TASKDESCRIPTION_INPROGRESS))
elif quest.isFullCompleted():
btnInfo = _makeNoBtn(
text_styles.success(icons.checkmark() + _ms(
QUESTS.QUESTTASKDETAILSVIEW_TASKDESCRIPTION_EXCELLENTDONE))
)
elif quest.isMainCompleted():
btnInfo = _makeSelectBtn(
QUESTS.QUESTTASKDETAILSVIEW_BTNLABEL_REPEAT,
TOOLTIPS.PRIVATEQUESTS_ACTIONPANNEL_REPEAT,
text_styles.success(
icons.checkmark() +
_ms(QUESTS.QUESTTASKDETAILSVIEW_TASKDESCRIPTION_DONE)))
else:
btnInfo = _makeSelectBtn(
QUESTS.QUESTTASKDETAILSVIEW_BTNLABEL_BEGIN,
TOOLTIPS.PRIVATEQUESTS_ACTIONPANNEL_PERFORM,
_ms(QUESTS.QUESTTASKDETAILSVIEW_TASKDESCRIPTION_AVAILABLE))
mainAwards, addAwards = questInfoData._getBonuses(
old_events_helpers.getPotapovQuestsCache().getQuests().values())
result = {
'taskID': questID,
'headerText': text_styles.highTitle(quest.getUserName()),
'conditionsText': condition,
'mainAwards': mainAwards,
'addAwards': addAwards
}
result.update(btnInfo._asdict())
return result
def _packHeaderBlock(self):
return formatters.packTitleDescBlock(title=text_styles.highTitle(RANKED_BATTLES.SELECTORTOOLTIP_TITLE), desc=text_styles.main(RANKED_BATTLES.SELECTORTOOLTIP_DESC))
def __updateTileData(self, vehType, questState, selectItemID=-1):
self._navInfo.changePQFilters(vehType, questState)
questsByChains = self.__getQuestsByChains(vehType, questState)
chains = []
newSelectedItemID = -1
for _, chainID, quests in questsByChains:
completedQuestsCount = len(
self.__tile.getQuestsInChainByFilter(
chainID, lambda q: q.isCompleted()))
chain = {
'name':
text_styles.highTitle(self.__getChainUserName(chainID)),
'progressText':
text_styles.main(
'%d/%d' %
(completedQuestsCount, self.__tile.getChainSize())),
'tasks': [],
'enabled':
True
}
for quest in sorted(quests, key=operator.methodcaller('getID')):
stateName, stateIcon = self.__getQuestStatusData(quest)
questID = quest.getID()
chain['tasks'].append({
'name':
text_styles.main(quest.getUserName()),
'stateName':
stateName,
'stateIconPath':
stateIcon,
'arrowIconPath':
RES_ICONS.MAPS_ICONS_LIBRARY_ARROWORANGERIGHTICON8X8,
'tooltip':
TOOLTIPS.PRIVATEQUESTS_TASKLISTITEM_BODY,
'id':
questID,
'enabled':
True
})
if questID == selectItemID:
newSelectedItemID = questID
chains.append(chain)
self.as_updateTileDataS({
'statistics': {
'label':
text_styles.main(
_ms(QUESTS.TILECHAINSVIEW_STATISTICSLABEL_TEXT)),
'arrowIconPath':
RES_ICONS.MAPS_ICONS_LIBRARY_ARROWORANGERIGHTICON8X8,
'tooltip':
TOOLTIPS.PRIVATEQUESTS_TASKLISTITEM_BODY
},
'chains': chains
})
if selectItemID == -1:
self.getChainProgress()
else:
self.as_updateChainProgressS(self.__makeChainsProgressData())
self.as_setSelectedTaskS(newSelectedItemID)
def _packTitleBlock(self, title):
return formatters.packTitleDescBlock(
title=text_styles.highTitle(title), padding={'top': -5})
def buildCustomizationItemDataVO(item,
count=None,
isApplied=False,
isDarked=False,
isUsedUp=False,
autoRentEnabled=False,
vehicle=None,
progressionLevel=None,
icon=None,
showDetailItems=True,
plainView=False,
showEditableHint=False,
showEditBtnHint=False,
isChained=False,
isUnsuitable=False):
if plainView:
hasBonus = False
locked = False
buyPrice = ITEM_PRICE_EMPTY
else:
hasBonus = item.bonus is not None
locked = isUsedUp or not item.isUnlocked
buyPrice = ITEM_PRICE_EMPTY if item.isHidden or item.buyCount <= 0 else item.getBuyPrice(
)
if isUnsuitable:
locked = True
if item.itemTypeID == GUI_ITEM_TYPE.PROJECTION_DECAL:
formFactor = PROJECTION_DECAL_FORM_TO_UI_ID[item.formfactor]
formIconSource = PROJECTION_DECAL_IMAGE_FORM_TAG[item.formfactor]
scale = _PROJECTION_DECAL_FORM_TO_IMAGE_SCALE[item.formfactor]
else:
formFactor = -1
formIconSource = ''
scale = _DEFAULT_IMAGE_SCALE
if item.isRentable and count <= 0:
rentalInfoText = R.strings.vehicle_customization.carousel.rentalBattles(
)
rentalInfoText = text_styles.main(
backport.text(rentalInfoText, battlesNum=item.rentCount))
else:
rentalInfoText = ''
if item.itemTypeID in (GUI_ITEM_TYPE.MODIFICATION, GUI_ITEM_TYPE.STYLE):
extraNames = (text_styles.bonusLocalText(item.userName),
text_styles.highTitle(item.userName))
else:
extraNames = None
if isUsedUp:
lockText = backport.text(
R.strings.vehicle_customization.customization.limited.onOther())
elif isUnsuitable:
lockText = backport.text(
R.strings.vehicle_customization.customization.unsuitable())
else:
lockText = backport.text(
R.strings.vehicle_customization.customization.UnsupportedForm())
showAlert = __isNeedToShowAlert(item)
imageCached = item.itemTypeID is not GUI_ITEM_TYPE.PROJECTION_DECAL
editingReason, editableIcon = __getEditableBlockData(item, vehicle)
editBtnEnabled = bool(editingReason)
showEditableHint = showEditableHint and bool(
editableIcon) and editBtnEnabled
showEditBtnHint = showEditBtnHint and editBtnEnabled
isSpecial = __isItemSpecial(item)
if vehicle is not None:
progressionLevel = progressionLevel or item.getLatestOpenedProgressionLevel(
vehicle)
noveltyCounter = item.getNoveltyCounter(vehicle)
else:
progressionLevel = progressionLevel or -1
noveltyCounter = 0
isProgressionRewindEnabled = item.itemTypeID == GUI_ITEM_TYPE.STYLE and item.isProgressionRewindEnabled
icon = icon or __getIcon(item, progressionLevel)
iconAlpha = _ICON_ALPHA_BY_GUI_ITEM_TYPE.get(item.itemTypeID, 1)
tooltip = VEHICLE_CUSTOMIZATION.CUSTOMIZATION_SLOT_EDITBTN_ENABLED
if editingReason.reason == EDITING_STYLE_REASONS.NOT_REACHED_LEVEL:
tooltip = VEHICLE_CUSTOMIZATION.CUSTOMIZATION_SLOT_EDITBTN_DISABLED_NOTREACHEDLEVEL
elif not editingReason:
tooltip = VEHICLE_CUSTOMIZATION.CUSTOMIZATION_SLOT_EDITBTN_DISABLED
isWithSerialNumber = item.itemTypeID == GUI_ITEM_TYPE.STYLE and item.isWithSerialNumber
return CustomizationCarouselRendererVO(
item=item,
icon=icon,
hasBonus=hasBonus,
locked=locked,
buyPrice=buyPrice,
quantity=count,
showDetailItems=showDetailItems,
isSpecial=isSpecial,
isDarked=isDarked,
isAlreadyUsed=isUsedUp,
showAlert=showAlert,
extraNames=extraNames,
isEquipped=isApplied,
rentalInfoText=rentalInfoText,
imageCached=imageCached,
autoRentEnabled=autoRentEnabled,
noveltyCounter=noveltyCounter,
formIconSource=formIconSource,
defaultIconAlpha=iconAlpha,
lockText=lockText,
formFactor=formFactor,
progressionLevel=progressionLevel,
editableIcon=editableIcon,
editBtnEnabled=editBtnEnabled,
showEditableHint=showEditableHint,
showEditBtnHint=showEditBtnHint,
imageScale=scale,
tooltip=tooltip,
isChained=isChained,
isUnsuitable=isUnsuitable,
isProgressionRewindEnabled=isProgressionRewindEnabled,
isWithSerialNumber=isWithSerialNumber).asDict()
def getHeader(self):
return text_styles.highTitle(
i18n.makeString(MENU.AWARDWINDOW_QUESTS_MEDALS_HEADER))
def __packTitleBlock():
return formatters.packTextBlockData(text=text_styles.highTitle(TOOLTIPS.BLUEPRINT_BLUEPRINTEMPTYSLOT_TITLE), padding=formatters.packPadding(top=5, bottom=3))
def getNextQuestHeader(self):
if self._nextQuest is not None:
return text_styles.highTitle(self._nextQuest.getUserName())
else:
return ''
return
def __packRandomFragmentBlocks(self):
self._items.append(formatters.packImageTextBlockData(title=text_styles.highTitle(backport.text(R.strings.tooltips.blueprint.randomNational.header())), img=backport.image(R.images.gui.maps.icons.blueprints.fragment.small.randomNational()), imgPadding=formatters.packPadding(top=5), txtPadding=formatters.packPadding(top=5, left=19), descLeading=-1))
descriptionBlock = formatters.packImageTextBlockData(desc=text_styles.main(backport.text(R.strings.tooltips.blueprint.randomNational.description())), img=backport.image(R.images.gui.maps.icons.blueprints.plus()), imgPadding=formatters.packPadding(top=0, right=5), padding=formatters.packPadding(left=40))
self._items.append(formatters.packBuildUpBlockData(blocks=[descriptionBlock, self.__packAdditionalInfoBlock()], gap=3, linkage=BLOCKS_TOOLTIP_TYPES.TOOLTIP_BUILDUP_BLOCK_WHITE_BG_LINKAGE, padding=formatters.packPadding(bottom=-3)))
self._items.append(formatters.packTextBlockData(text='', padding=formatters.packPadding(bottom=-12)))
def getCurrentQuestHeader(self):
return text_styles.highTitle(self._quest.getUserName())
def __packTitleBlock(self, isShortForm):
return formatters.packTitleDescBlock(title=text_styles.highTitle(TOOLTIPS.BLUEPRINT_VEHICLEBLUEPRINTTOOLTIP_HEADER), desc=self._getVehicleDescrStr(self.__vehicle), gap=0, descPadding=formatters.packPadding(top=-5, left=1), padding=formatters.packPadding(top=5, bottom=1 if isShortForm else 0))
def getHeader(self):
return text_styles.highTitle(
i18n.makeString(MENU.AWARDWINDOW_QUESTS_VEHICLE_HEADER,
vehicleName=self.__vehicle.userName))
def getHeader(self):
return text_styles.highTitle(_ms(MENU.AWARDWINDOW_REFERRAL_CREDITS_HEADER))
def getHeader(self):
return text_styles.highTitle(_ms(MENU.AWARDWINDOW_REFERRAL_VEHICLE_HEADER, vehicleName=self.__vehicle.userName))
