def _generateOptions(self, ctx=None):
options = []
vehicle = self.__getVehicle(self.vehCD)
self._manageStartOptions(options, vehicle)
if vehicle.isPurchased:
options.append(
self._makeItem(VEHICLE.SELL, MENU.contextmenu(VEHICLE.SELL),
{'enabled': vehicle.canSell}))
elif vehicle.isUnlocked:
items = g_itemsCache.items
label = MENU.CONTEXTMENU_RESTORE if vehicle.isRestoreAvailable(
) else MENU.CONTEXTMENU_BUY
options.append(
self._makeItem(
VEHICLE.BUY, label, {
'enabled':
vehicle.mayObtainWithMoneyExchange(
items.stats.money, items.shop.exchangeRate)
}))
else:
isAvailableToUnlock, _, _ = g_techTreeDP.isVehicleAvailableToUnlock(
self.vehCD)
options.append(
self._makeItem(VEHICLE.RESEARCH,
MENU.contextmenu(VEHICLE.RESEARCH),
{'enabled': isAvailableToUnlock}))
self._manageEndOptions(options, vehicle)
return options
def _addSquadInfo(self, options, isIgnored):
if not isIgnored and not self.isSquadCreator():
canCreate = self.prbDispatcher.getFunctionalCollection().canCreateSquad()
options.append(self._makeItem(USER.CREATE_SQUAD, MENU.contextmenu(USER.CREATE_SQUAD), optInitData={'enabled': canCreate}))
if g_eventsCache.isEventEnabled():
options.append(self._makeItem(USER.CREATE_EVENT_SQUAD, MENU.contextmenu(USER.CREATE_EVENT_SQUAD), optInitData={'enabled': canCreate}))
return options
def _generateOptions(self, ctx=None):
options = []
vehicle = self.__getVehicle(self.vehCD)
self._manageStartOptions(options, vehicle)
if vehicle.hasNationGroup:
isNew = not AccountSettings.getSettings(NATION_CHANGE_VIEWED)
options.append(self._makeItem(VEHICLE.NATION_CHANGE, MENU.CONTEXTMENU_NATIONCHANGE, {'enabled': vehicle.isNationChangeAvailable,
'isNew': isNew}))
if vehicle.isPurchased:
options.append(self._makeItem(VEHICLE.SELL, MENU.contextmenu(VEHICLE.SELL), {'enabled': vehicle.canSell}))
elif self.__isPurchaseEnabled(vehicle):
items = self.itemsCache.items
if vehicle.isRestoreAvailable():
label = MENU.CONTEXTMENU_RESTORE
elif vehicle.canTradeIn:
label = MENU.CONTEXTMENU_BUYORTRADEIN
else:
label = MENU.CONTEXTMENU_BUY
if vehicle.isCollectible and not self.__isCollectibleVehicleEnabled(vehicle):
btnEnabled = False
elif canBuyGoldForVehicleThroughWeb(vehicle):
btnEnabled = True
else:
btnEnabled = vehicle.mayObtainWithMoneyExchange(items.stats.money, items.shop.exchangeRate)
options.append(self._makeItem(VEHICLE.BUY, label, {'enabled': btnEnabled}))
elif self.__isResearchEnabled(vehicle):
isNextToUnlock, isXpEnough = g_techTreeDP.isVehicleAvailableToUnlock(self.vehCD)
isAvailableToUnlock = isNextToUnlock and isXpEnough
options.append(self._makeItem(VEHICLE.RESEARCH, MENU.contextmenu(VEHICLE.RESEARCH), {'enabled': isAvailableToUnlock}))
self._manageEndOptions(options, vehicle)
return options
def _makeAIBotOptions(self):
return [
self._makeItem(USER.VEHICLE_INFO,
MENU.contextmenu(USER.VEHICLE_INFO)),
self._makeItem(USER.VEHICLE_PREVIEW,
MENU.contextmenu(USER.VEHICLE_PREVIEW))
]
def _addSquadInfo(self, options, isIgnored):
if not isIgnored and not self.isSquadCreator(
) and self.prbDispatcher is not None:
canCreate = self.prbEntity.getPermissions().canCreateSquad()
options.append(
self._makeItem(USER.CREATE_SQUAD,
MENU.contextmenu(USER.CREATE_SQUAD),
optInitData={'enabled': canCreate}))
if self.eventsCache.isEventEnabled():
options.append(
self._makeItem(USER.CREATE_EVENT_SQUAD,
MENU.contextmenu(USER.CREATE_EVENT_SQUAD),
optInitData={
'enabled': canCreate,
'textColor': 13347959
}))
if self.__eventProgression.modeIsAvailable():
primeTimeStatus, _, _ = self.__eventProgression.getPrimeTimeStatus(
)
options.append(
self._makeItem(
USER.CREATE_BATTLE_ROYALE_SQUAD,
MENU.contextmenu(USER.CREATE_BATTLE_ROYALE_SQUAD),
optInitData={
'enabled':
canCreate
and primeTimeStatus == PrimeTimeStatus.AVAILABLE,
'textColor':
13347959
}))
return options
def _addFriendshipInfo(self, options, userCMInfo):
if not userCMInfo.isFriend:
options.append(self._makeItem(USER.ADD_TO_FRIENDS, MENU.contextmenu(USER.ADD_TO_FRIENDS), optInitData={'enabled': userCMInfo.isSameRealm}))
elif self.proto.contacts.isBidiFriendshipSupported():
if USER_TAG.SUB_NONE in userCMInfo.getTags():
options.append(self._makeItem(USER.REQUEST_FRIENDSHIP, MENU.contextmenu(USER.ADD_TO_FRIENDS_AGAIN), optInitData={'enabled': userCMInfo.isSameRealm}))
return options
def _generateOptions(self, ctx = None):
userCMInfo = self._getUseCmInfo()
if ctx is not None and not userCMInfo.hasClan:
try:
clanAbbrev = ctx.clanAbbrev
userCMInfo.hasClan = bool(clanAbbrev)
except:
LOG_DEBUG('ctx has no property "clanAbbrev"')
options = [self._makeItem(USER.INFO, MENU.contextmenu(USER.INFO))]
options = self._addClanProfileInfo(options, userCMInfo)
options = self._addFriendshipInfo(options, userCMInfo)
options = self._addChannelInfo(options, userCMInfo)
options.append(self._makeItem(USER.COPY_TO_CLIPBOARD, MENU.contextmenu(USER.COPY_TO_CLIPBOARD)))
options = self._addSquadInfo(options, userCMInfo.isIgnored)
options = self._addPrebattleInfo(options, userCMInfo)
options = self._addClubInfo(options, userCMInfo)
options = self._addContactsNoteInfo(options, userCMInfo)
options = self._addAppealInfo(options)
options = self._addIgnoreInfo(options, userCMInfo)
options = self._addMutedInfo(options, userCMInfo)
options = self._addRejectFriendshipInfo(options, userCMInfo)
options = self._addRemoveFromGroupInfo(options, userCMInfo)
options = self._addRemoveFriendInfo(options, userCMInfo)
options = self._addInviteClanInfo(options, userCMInfo)
return options
def _addStrongholdsInfo(self, userCMInfo):
if self.prbEntity.getEntityType() != PREBATTLE_TYPE.STRONGHOLD:
return []
options = []
if self._canTakeEquipmentCommander(SUPPORT_TYPE):
options.append(
self._makeItem(
TAKE_ARTILLERY_EQUIPMENT_COMMANDER,
MENU.contextmenu(TAKE_ARTILLERY_EQUIPMENT_COMMANDER)))
if self._canGiveEquipmentCommander(SUPPORT_TYPE):
options.append(
self._makeItem(
GIVE_ARTILLERY_EQUIPMENT_COMMANDER,
MENU.contextmenu(GIVE_ARTILLERY_EQUIPMENT_COMMANDER)))
if self._canTakeEquipmentCommander(BOOST_TYPE):
options.append(
self._makeItem(
TAKE_INSPIRE_EQUIPMENT_COMMANDER,
MENU.contextmenu(TAKE_INSPIRE_EQUIPMENT_COMMANDER)))
if self._canGiveEquipmentCommander(BOOST_TYPE):
options.append(
self._makeItem(
GIVE_INSPIRE_EQUIPMENT_COMMANDER,
MENU.contextmenu(GIVE_INSPIRE_EQUIPMENT_COMMANDER)))
return options
def __addDyncSquadInfo(self, options):
make = self._makeItem
ctx = self.sessionProvider.getCtx()
if not ctx.isInvitationEnabled() or ctx.hasSquadRestrictions():
return options
elif not self.__userInfo.isAlly:
return options
else:
contact = self.usersStorage.getUser(self.__userInfo.databaseID)
isIgnored = contact is not None and contact.isIgnored()
status = self.__vInfo.invitationDeliveryStatus
if status & _D_STATUS.FORBIDDEN_BY_RECEIVER > 0 or status & _D_STATUS.SENT_TO > 0 and not status & _D_STATUS.SENT_INACTIVE:
optionID = DYN_SQUAD_OPTION_ID.SENT_INVITATION
isEnabled = False
elif status & _D_STATUS.RECEIVED_FROM > 0 and not status & _D_STATUS.RECEIVED_INACTIVE:
optionID = None
elif self.__vInfo.isSquadMan():
optionID = DYN_SQUAD_OPTION_ID.IN_SQUAD
isEnabled = False
else:
optionID = DYN_SQUAD_OPTION_ID.SENT_INVITATION
isEnabled = not isIgnored
if optionID is not None:
options.append(self._makeItem(optionID, MENU.contextmenu(optionID), optInitData=self._getOptionInitData(optionID, isEnabled)))
if status & _D_STATUS.RECEIVED_FROM > 0 and not status & _D_STATUS.RECEIVED_INACTIVE:
options.append(make(DYN_SQUAD_OPTION_ID.ACCEPT_INVITATION, MENU.contextmenu(DYN_SQUAD_OPTION_ID.ACCEPT_INVITATION), optInitData=self._getOptionInitData(DYN_SQUAD_OPTION_ID.ACCEPT_INVITATION, not isIgnored)))
options.append(make(DYN_SQUAD_OPTION_ID.REJECT_INVITATION, MENU.contextmenu(DYN_SQUAD_OPTION_ID.REJECT_INVITATION), optInitData=self._getOptionInitData(DYN_SQUAD_OPTION_ID.REJECT_INVITATION, not isIgnored)))
return options
def _generateOptions(self, ctx = None):
options = [self._makeItem(MODULE.INFO, MENU.contextmenu(MODULE.INFO))]
if self._isCanceled:
options.append(self._makeItem(MODULE.CANCEL_BUY, MENU.contextmenu(MODULE.CANCEL_BUY)))
else:
options.append(self._makeItem(MODULE.UNLOAD, MENU.contextmenu(MODULE.UNLOAD)))
return options
def generateOptions(self):
options = [self._constructOptionVO(self.OPTIONS.MINIMIZE_ALL, MENU.contextmenu('messenger/minimizeAll')),
self._constructOptionVO(_SEPARATOR_ID),
self._constructOptionVO(self.OPTIONS.CLOSE_CURRENT, MENU.contextmenu('messenger/closeCurrent'), {'enabled': self._ctx.canCloseCurrent}),
self._constructOptionVO(_SEPARATOR_ID),
self._constructOptionVO(self.OPTIONS.CLOSE_ALL_EXCEPT_CURRENT, MENU.contextmenu('messenger/closeAllExceptCurrent'))]
return options
def _generateOptions(self, ctx=None):
userCMInfo = self._getUseCmInfo()
if ctx is not None and not userCMInfo.hasClan:
try:
clanAbbrev = ctx.clanAbbrev
userCMInfo.hasClan = bool(clanAbbrev)
except Exception:
LOG_DEBUG('ctx has no property "clanAbbrev"')
if userCMInfo.isBot:
return self._makeAIBotOptions()
else:
options = [self._makeItem(USER.INFO, MENU.contextmenu(USER.INFO))]
options = self._addVehicleInfo(options)
options = self._addClanProfileInfo(options, userCMInfo)
options = self._addFriendshipInfo(options, userCMInfo)
options = self._addChannelInfo(options, userCMInfo)
options.append(self._makeItem(USER.COPY_TO_CLIPBOARD, MENU.contextmenu(USER.COPY_TO_CLIPBOARD)))
options = self._addSquadInfo(options, userCMInfo.isIgnored)
options = self._addPrebattleInfo(options, userCMInfo)
options = self._addContactsNoteInfo(options, userCMInfo)
options = self._addAppealInfo(options)
options = self._addIgnoreInfo(options, userCMInfo)
if not IS_CHINA:
options = self._addMutedInfo(options, userCMInfo)
options = self._addRejectFriendshipInfo(options, userCMInfo)
options = self._addRemoveFromGroupInfo(options, userCMInfo)
options = self._addRemoveFriendInfo(options, userCMInfo)
options = self._addInviteClanInfo(options, userCMInfo)
return options
def _generateOptions(self, ctx = None):
options = [self._makeItem(MODULE.INFO, MENU.contextmenu(MODULE.INFO))]
if self._isCanceled:
options.append(self._makeItem(MODULE.CANCEL_BUY, MENU.contextmenu(MODULE.CANCEL_BUY)))
else:
options.append(self._makeItem(MODULE.UNLOAD, MENU.contextmenu(MODULE.UNLOAD)))
return options
def _generateOptions(self, ctx=None):
return [
self._makeItem(CREW.PERSONAL_CASE,
MENU.contextmenu('personalCase')),
self._makeSeparator(),
self._makeItem(CREW.UNLOAD, MENU.contextmenu('tankmanUnload'))
]
def _addFriendshipInfo(self, options, userCMInfo):
if not userCMInfo.isFriend:
options.append(self._makeItem(USER.ADD_TO_FRIENDS, MENU.contextmenu(USER.ADD_TO_FRIENDS), optInitData={'enabled': userCMInfo.isSameRealm}))
elif self.proto.contacts.isBidiFriendshipSupported():
if USER_TAG.SUB_NONE in userCMInfo.getTags():
options.append(self._makeItem(USER.REQUEST_FRIENDSHIP, MENU.contextmenu(USER.ADD_TO_FRIENDS_AGAIN), optInitData={'enabled': userCMInfo.isSameRealm}))
return options
def _generateOptions(self, ctx=None):
return [
self._makeItem(CLAN_CM_OPTIONS.CLAN_PROFILE,
MENU.contextmenu('viewClanProfile')),
self._makeItem(CLAN_CM_OPTIONS.COPY_TO_CB,
MENU.contextmenu('copyClanName'))
]
def _generateOptions(self, ctx=None):
options = []
vehicle = self.__getVehicle(self.vehCD)
self._manageStartOptions(options, vehicle)
if vehicle.isPurchased:
options.append(
self._makeItem(VEHICLE.SELL, MENU.contextmenu(VEHICLE.SELL),
{'enabled': vehicle.canSell}))
elif vehicle.isUnlocked:
items = self.itemsCache.items
if vehicle.isRestoreAvailable():
label = MENU.CONTEXTMENU_RESTORE
elif vehicle.canTradeIn:
label = MENU.CONTEXTMENU_BUYORTRADEIN
else:
label = MENU.CONTEXTMENU_BUY
if canBuyGoldForVehicleThroughWeb(vehicle):
btnEnabled = True
else:
btnEnabled = vehicle.mayObtainWithMoneyExchange(
items.stats.money, items.shop.exchangeRate)
options.append(
self._makeItem(VEHICLE.BUY, label, {'enabled': btnEnabled}))
else:
isAvailableToUnlock, _, _ = g_techTreeDP.isVehicleAvailableToUnlock(
self.vehCD)
options.append(
self._makeItem(VEHICLE.RESEARCH,
MENU.contextmenu(VEHICLE.RESEARCH),
{'enabled': isAvailableToUnlock}))
self._manageEndOptions(options, vehicle)
return options
def __addDyncSquadInfo(self, options):
make = self._makeItem
ctx = g_sessionProvider.getCtx()
if not ctx.isInvitationEnabled() or ctx.hasSquadRestrictions():
return options
elif not self.__userInfo.isAlly:
return options
else:
contact = self.usersStorage.getUser(self.__userInfo.databaseID)
isIgnored = contact is not None and contact.isIgnored()
status = self.__vInfo.invitationDeliveryStatus
if status & _D_STATUS.FORBIDDEN_BY_RECEIVER > 0 or status & _D_STATUS.SENT_TO > 0 and not status & _D_STATUS.SENT_INACTIVE:
optionID = DYN_SQUAD_OPTION_ID.SENT_INVITATION
isEnabled = False
elif status & _D_STATUS.RECEIVED_FROM > 0 and not status & _D_STATUS.RECEIVED_INACTIVE:
optionID = None
elif self.__vInfo.isSquadMan():
optionID = DYN_SQUAD_OPTION_ID.IN_SQUAD
isEnabled = False
else:
optionID = DYN_SQUAD_OPTION_ID.SENT_INVITATION
isEnabled = not isIgnored
if optionID is not None:
options.append(self._makeItem(optionID, MENU.contextmenu(optionID), optInitData=self._getOptionInitData(optionID, isEnabled)))
if status & _D_STATUS.RECEIVED_FROM > 0 and not status & _D_STATUS.RECEIVED_INACTIVE:
options.append(make(DYN_SQUAD_OPTION_ID.ACCEPT_INVITATION, MENU.contextmenu(DYN_SQUAD_OPTION_ID.ACCEPT_INVITATION), optInitData=self._getOptionInitData(DYN_SQUAD_OPTION_ID.ACCEPT_INVITATION, not isIgnored)))
options.append(make(DYN_SQUAD_OPTION_ID.REJECT_INVITATION, MENU.contextmenu(DYN_SQUAD_OPTION_ID.REJECT_INVITATION), optInitData=self._getOptionInitData(DYN_SQUAD_OPTION_ID.REJECT_INVITATION, not isIgnored)))
return options
def _addSquadInfo(self, options, isIgnored):
if not isIgnored and not self.isSquadCreator():
canCreate = self.prbDispatcher.getFunctionalCollection().canCreateSquad()
options.append(self._makeItem(USER.CREATE_SQUAD, MENU.contextmenu(USER.CREATE_SQUAD), optInitData={'enabled': canCreate}))
if g_eventsCache.isEventEnabled():
options.append(self._makeItem(USER.CREATE_EVENT_SQUAD, MENU.contextmenu(USER.CREATE_EVENT_SQUAD), optInitData={'enabled': canCreate}))
return options
def _addPrebattleInfo(self, options, userCMInfo):
if self.prbEntity.getPermissions().canKick():
options.append(self._makeItem(KICK_FROM_UNIT, MENU.contextmenu(KICK_FROM_UNIT)))
if self._canGiveLeadership():
options.append(self._makeItem(GIVE_LEADERSHIP, MENU.contextmenu(GIVE_LEADERSHIP)))
if self._canTakeLeadership():
options.append(self._makeItem(TAKE_LEADERSHIP, MENU.contextmenu(TAKE_LEADERSHIP)))
return options
def _addSquadInfo(self, options, isIgnored):
if not isIgnored and not self.isSquadCreator() and self.prbDispatcher is not None:
canCreate = self.prbEntity.getPermissions().canCreateSquad()
options.append(self._makeItem(USER.CREATE_SQUAD, MENU.contextmenu(USER.CREATE_SQUAD), optInitData={'enabled': canCreate}))
if self.eventsCache.isEventEnabled():
options.append(self._makeItem(USER.CREATE_EVENT_SQUAD, MENU.contextmenu(USER.CREATE_EVENT_SQUAD), optInitData={'enabled': canCreate,
'textColor': 13347959}))
return options
def _addPrebattleInfo(self, options, userCMInfo):
if self.unitFunctional.getPermissions().canKick():
options.append(self._makeItem(KICK_FROM_UNIT, MENU.contextmenu(KICK_FROM_UNIT)))
if self._canGiveLeadership():
options.append(self._makeItem(GIVE_LEADERSHIP, MENU.contextmenu(GIVE_LEADERSHIP)))
if self._canTakeLeadership():
options.append(self._makeItem(TAKE_LEADERSHIP, MENU.contextmenu(TAKE_LEADERSHIP)))
return options
def _generateOptions(self, ctx=None):
return [
self._makeItem(CREW.PERSONAL_CASE,
MENU.contextmenu('personalCase')),
self._makeSeparator(),
self._makeItem(CREW.UNLOAD, MENU.contextmenu('tankmanUnload'),
{'enabled': not g_currentVehicle.isInBattle()})
]
def _generateOptions(self, ctx = None):
options = [self._makeItem(MODULE.INFO, MENU.contextmenu(MODULE.INFO)), self._makeSeparator(), self._makeItem(MODULE.UNLOCK, MENU.contextmenu(MODULE.UNLOCK), {'enabled': NODE_STATE.isAvailable2Unlock(self._nodeState)})]
if NODE_STATE.isUnlocked(self._nodeState):
if NODE_STATE.inInventory(self._nodeState) or NODE_STATE.isInstalled(self._nodeState):
options.extend([self._makeItem(MODULE.EQUIP, MENU.contextmenu(MODULE.EQUIP), {'enabled': self._isAvailable2Install()}), self._makeSeparator(), self._makeItem(MODULE.SELL, MENU.CONTEXTMENU_SELLFROMINVENTORY, {'enabled': not NODE_STATE.isInstalled(self._nodeState)})])
else:
options.extend([self._makeItem(MODULE.BUY_AND_EQUIP, MENU.CONTEXTMENU_BUYANDEQUIP, {'enabled': self._isAvailable2Buy()}), self._makeSeparator(), self._makeItem(MODULE.SELL, MENU.CONTEXTMENU_SELLFROMINVENTORY, {'enabled': NODE_STATE.isAvailable2Sell(self._nodeState)})])
else:
options.extend([self._makeItem(MODULE.BUY_AND_EQUIP, MENU.CONTEXTMENU_BUYANDEQUIP, {'enabled': False}), self._makeSeparator(), self._makeItem(MODULE.SELL, MENU.CONTEXTMENU_SELLFROMINVENTORY, {'enabled': False})])
return options
def _generateOptions(self, ctx=None):
options = []
if self._isCanceled:
options.append(
self._makeItem(MODULE.UNEQUIP,
MENU.contextmenu(MODULE.UNEQUIP)))
else:
options.append(
self._makeItem(MODULE.UNLOAD, MENU.contextmenu(MODULE.UNLOAD)))
return options
def _generateOptions(self, ctx = None):
options = [self._makeItem(MODULE.INFO, MENU.contextmenu(MODULE.INFO)), self._makeSeparator(), self._makeItem(MODULE.UNLOCK, MENU.contextmenu(MODULE.UNLOCK), {'enabled': NODE_STATE.isAvailable2Unlock(self._nodeState)})]
if NODE_STATE.isUnlocked(self._nodeState):
if NODE_STATE.inInventory(self._nodeState) or NODE_STATE.isInstalled(self._nodeState):
options.extend([self._makeItem(MODULE.EQUIP, MENU.contextmenu(MODULE.EQUIP), {'enabled': self._isAvailable2Install()}), self._makeSeparator(), self._makeItem(MODULE.SELL, MENU.CONTEXTMENU_SELLFROMINVENTORY, {'enabled': not NODE_STATE.isInstalled(self._nodeState)})])
else:
options.extend([self._makeItem(MODULE.BUY_AND_EQUIP, MENU.CONTEXTMENU_BUYANDEQUIP, {'enabled': self._isAvailable2Buy()}), self._makeSeparator(), self._makeItem(MODULE.SELL, MENU.CONTEXTMENU_SELLFROMINVENTORY, {'enabled': NODE_STATE.isAvailable2Sell(self._nodeState)})])
else:
options.extend([self._makeItem(MODULE.BUY_AND_EQUIP, MENU.CONTEXTMENU_BUYANDEQUIP, {'enabled': False}), self._makeSeparator(), self._makeItem(MODULE.SELL, MENU.CONTEXTMENU_SELLFROMINVENTORY, {'enabled': False})])
return options
def _addPrebattleInfo(self, options, userCMInfo):
if self._canKick():
options.append(self._makeItem(KICK_FROM_UNIT, MENU.contextmenu(KICK_FROM_UNIT)))
if self._canGiveLeadership():
options.append(self._makeItem(GIVE_LEADERSHIP, MENU.contextmenu(GIVE_LEADERSHIP)))
if self._canTakeLeadership():
options.append(self._makeItem(TAKE_LEADERSHIP, MENU.contextmenu(TAKE_LEADERSHIP)))
if self.prbEntity.getEntityType() == PREBATTLE_TYPE.STRONGHOLD:
options.extend(self._addStrongholdsInfo(userCMInfo))
return options
def _addVehicleInfo(self, options):
if self._vehicleCD > 0:
vehicle = g_itemsCache.items.getItemByCD(self._vehicleCD)
if not vehicle.isSecret:
if vehicle.isPreviewAllowed():
action = USER.VEHICLE_PREVIEW
label = MENU.contextmenu(USER.VEHICLE_PREVIEW)
else:
action = USER.VEHICLE_INFO
label = MENU.contextmenu(USER.VEHICLE_INFO)
options.append(self._makeItem(action, label))
return options
def _generateOptions(self, ctx=None):
return [
self._makeItem(CHANNEL.MINIMIZE_ALL,
MENU.contextmenu('messenger/minimizeAll')),
self._makeSeparator(),
self._makeItem(CHANNEL.CLOSE_CURRENT,
MENU.contextmenu('messenger/closeCurrent'),
{'enabled': self._canClose}),
self._makeSeparator(),
self._makeItem(CHANNEL.CLOSE_ALL_EXCEPT_CURRENT,
MENU.contextmenu('messenger/closeAllExceptCurrent'))
]
def _addVehicleInfo(self, options):
if self._vehicleCD > 0:
vehicle = g_itemsCache.items.getItemByCD(self._vehicleCD)
if not vehicle.isSecret:
if vehicle.isPreviewAllowed():
action = USER.VEHICLE_PREVIEW
label = MENU.contextmenu(USER.VEHICLE_PREVIEW)
else:
action = USER.VEHICLE_INFO
label = MENU.contextmenu(USER.VEHICLE_INFO)
options.append(self._makeItem(action, label))
return options
def _manageStartOptions(self, options, vehicle):
options.append(
self._makeItem(VEHICLE.INFO, MENU.contextmenu(VEHICLE.INFO)))
super(VehicleContextMenuHandler,
self)._manageStartOptions(options, vehicle)
if self.comparisonBasket.isEnabled():
options.append(
self._makeItem(
VEHICLE.COMPARE, MENU.contextmenu(VEHICLE.COMPARE), {
'enabled':
self.comparisonBasket.isReadyToAdd(
g_itemsCache.items.getItemByCD(self.vehCD))
}))
def _addStrongholdsInfo(self, userCMInfo):
if self.prbEntity.getEntityType() != PREBATTLE_TYPE.EXTERNAL:
return []
options = []
if self._canTakeEquipmentCommander():
options.append(
self._makeItem(TAKE_EQUIPMENT_COMMANDER,
MENU.contextmenu(TAKE_EQUIPMENT_COMMANDER)))
if self._canGiveEquipmentCommander():
options.append(
self._makeItem(GIVE_EQUIPMENT_COMMANDER,
MENU.contextmenu(GIVE_EQUIPMENT_COMMANDER)))
return options
def generateOptions(self):
options = []
vehicle = g_itemsCache.items.getVehicle(self._itemId)
vehicleWasInBattle = False
accDossier = g_itemsCache.items.getAccountDossier(None)
if accDossier:
wasInBattleSet = set(accDossier.getTotalStats().getVehicles().keys())
if vehicle.intCD in wasInBattleSet:
vehicleWasInBattle = True
if vehicle is not None:
options.append(self._constructOptionVO(self.VEHICLE.INFO, MENU.contextmenu(self.VEHICLE.INFO)))
options.append(self._constructOptionVO(self.VEHICLE.STATISTIC, MENU.contextmenu(self.VEHICLE.STATISTIC), {'enabled': vehicleWasInBattle}))
options.append(self._constructOptionVO(_SEPARATOR_ID))
if vehicle.isRented:
if not vehicle.isPremiumIGR:
money = g_itemsCache.items.stats.money
(canBuyOrRent, _,) = vehicle.mayRentOrBuy(money)
options.append(self._constructOptionVO(self.VEHICLE.BUY, MENU.contextmenu(self.VEHICLE.BUY), {'enabled': canBuyOrRent}))
options.append(self._constructOptionVO(self.VEHICLE.REMOVE, MENU.contextmenu(self.VEHICLE.REMOVE), {'enabled': vehicle.canSell and vehicle.rentalIsOver}))
else:
options.append(self._constructOptionVO(self.VEHICLE.SELL, MENU.contextmenu(self.VEHICLE.SELL), {'enabled': vehicle.canSell}))
options.append(self._constructOptionVO(_SEPARATOR_ID))
options.append(self._constructOptionVO(self.VEHICLE.RESEARCH, MENU.contextmenu(self.VEHICLE.RESEARCH)))
if vehicle.isFavorite:
options.append(self._constructOptionVO(self.VEHICLE.UNCHECK, MENU.contextmenu(self.VEHICLE.UNCHECK)))
else:
options.append(self._constructOptionVO(self.VEHICLE.CHECK, MENU.contextmenu(self.VEHICLE.CHECK)))
return options
def _addVehicleInfo(self, options):
if self._vehicleCD > 0:
vehicle = g_itemsCache.items.getItemByCD(self._vehicleCD)
if not vehicle.isSecret:
isEnabled = True
if vehicle.isPreviewAllowed():
isEnabled = not self.prbDispatcher.getFunctionalState().isNavigationDisabled()
action = USER.VEHICLE_PREVIEW
label = MENU.contextmenu(USER.VEHICLE_PREVIEW)
else:
action = USER.VEHICLE_INFO
label = MENU.contextmenu(USER.VEHICLE_INFO)
options.append(self._makeItem(action, label, optInitData={'enabled': isEnabled}))
return options
def _generateOptions(self, ctx=None):
options = []
options.append(
self._makeItem(VEHICLE.USER_INFO,
MENU.contextmenu(VEHICLE.USER_INFO)))
user = self.usersStorage.getUser(self.__playerDBId)
enabledInroaming = self.__isEnabledInRoaming(self.__playerDBId)
isFriend = user is not None and user.isFriend()
if enabledInroaming and not isFriend:
options.append(
self._makeItem(VEHICLE.ADD_TO_FRIEND,
MENU.contextmenu(VEHICLE.ADD_TO_FRIEND)))
options.append(
self._makeItem(VEHICLE.CREATE_PRIVATE_CHANNEL,
MENU.contextmenu(VEHICLE.CREATE_PRIVATE_CHANNEL)))
options.append(
self._makeItem(VEHICLE.COPY_TO_CLIP_BOARD,
MENU.contextmenu(VEHICLE.COPY_TO_CLIP_BOARD)))
options.append(
self._makeItem(VEHICLE.CREATE_BR_SQUAD,
MENU.contextmenu(VEHICLE.CREATE_BR_SQUAD)))
if enabledInroaming and user is not None and user.isIgnored():
options.append(
self._makeItem(VEHICLE.REMOVE_FROM_IGNORED,
MENU.contextmenu(VEHICLE.REMOVE_FROM_IGNORED)))
if enabledInroaming and isFriend:
options.append(
self._makeItem(VEHICLE.ADD_TO_IGNORED,
MENU.contextmenu(VEHICLE.ADD_TO_IGNORED)))
options.append(
self._makeItem(VEHICLE.REMOVE_FROM_FRIENDS,
MENU.contextmenu(VEHICLE.REMOVE_FROM_FRIENDS)))
return options
def _addVehicleInfo(self, options):
if self._vehicleCD > 0:
vehicle = self.itemsCache.items.getItemByCD(self._vehicleCD)
if not vehicle.isSecret:
isEnabled = True
if vehicle.isPreviewAllowed():
isEnabled = not self.prbDispatcher.getFunctionalState().isNavigationDisabled()
action = USER.VEHICLE_PREVIEW
label = MENU.contextmenu(USER.VEHICLE_PREVIEW)
else:
action = USER.VEHICLE_INFO
label = MENU.contextmenu(USER.VEHICLE_INFO)
options.append(self._makeItem(action, label, optInitData={'enabled': isEnabled}))
return options
def _generateOptions(self, ctx=None):
options = [self._makeItem(MODULE.INFO, MENU.contextmenu(MODULE.INFO))]
equipment = self.itemsCache.items.getItemByCD(int(self._equipmentCD))
if equipment is not None and equipment.isBuiltIn:
return options
else:
if self._isCanceled:
options.append(
self._makeItem(MODULE.CANCEL_BUY,
MENU.contextmenu(MODULE.CANCEL_BUY)))
else:
options.append(
self._makeItem(MODULE.UNLOAD,
MENU.contextmenu(MODULE.UNLOAD)))
return options
def _addClubInfo(self, options, userCMInfo):
club = self.clubsCtrl.getClub(self.__clubDbID)
if club is not None:
profile = self.clubsCtrl.getProfile()
limits = self.clubsState.getLimits()
member = club.getMember(self.databaseID)
if limits.canTransferOwnership(profile, club).success:
options.append(self._makeItem(GIVE_LEADERSHIP, MENU.contextmenu(GIVE_LEADERSHIP)))
if member.isPrivate():
if limits.canAssignOfficer(profile, club).success:
options.append(self._makeItem(ASSIGN_OFFICER, MENU.contextmenu(ASSIGN_OFFICER)))
if member.isOfficer():
if limits.canAssignPrivate(profile, club).success:
options.append(self._makeItem(ASSIGN_PRIVATE, MENU.contextmenu(ASSIGN_PRIVATE)))
return options
def _generateOptions(self, ctx = None):
options = []
vehicle = self.__getVehicle(self.vehCD)
self._manageStartOptions(options, vehicle)
if vehicle.isPurchased:
options.append(self._makeItem(VEHICLE.SELL, MENU.contextmenu(VEHICLE.SELL), {'enabled': vehicle.canSell}))
elif vehicle.isUnlocked:
items = g_itemsCache.items
label = MENU.CONTEXTMENU_RESTORE if vehicle.isRestoreAvailable() else MENU.CONTEXTMENU_BUY
options.append(self._makeItem(VEHICLE.BUY, label, {'enabled': vehicle.mayObtainWithMoneyExchange(items.stats.money, items.shop.exchangeRate)}))
else:
isAvailableToUnlock, _, _ = g_techTreeDP.isVehicleAvailableToUnlock(self.vehCD)
options.append(self._makeItem(VEHICLE.RESEARCH, MENU.contextmenu(VEHICLE.RESEARCH), {'enabled': isAvailableToUnlock}))
self._manageEndOptions(options, vehicle)
return options
def _getSubmenuData(self):
if self._isAlly or self._arenaGuiType in (ARENA_GUI_TYPE.UNKNOWN, ARENA_GUI_TYPE.TRAINING):
order = DENUNCIATIONS.ORDER
else:
order = DENUNCIATIONS.ENEMY_ORDER
make = self._makeItem
return [ make(denunciation, MENU.contextmenu(denunciation), optInitData={'enabled': self._isAppealsForTopicEnabled(denunciation)}) for denunciation in order ]
def _addSquadInfo(self, options, isIgnored):
if not isIgnored and not self.isSquadCreator() and self.prbDispatcher is not None:
canCreate = self.prbEntity.getPermissions().canCreateSquad()
options.append(self._makeItem(USER.CREATE_SQUAD, MENU.contextmenu(USER.CREATE_SQUAD), optInitData={'enabled': canCreate}))
if self.__eventBattlesCtrl.isEnabled():
options.append(self._makeItem(USER.CREATE_EVENT_SQUAD, MENU.contextmenu(USER.CREATE_EVENT_SQUAD), optInitData={'enabled': canCreate,
'textColor': 13347959}))
if self.__battleRoyale.isEnabled():
primeTimeStatus, _, _ = self.__battleRoyale.getPrimeTimeStatus()
options.append(self._makeItem(USER.CREATE_BATTLE_ROYALE_SQUAD, MENU.contextmenu(USER.CREATE_BATTLE_ROYALE_SQUAD), optInitData={'enabled': canCreate and primeTimeStatus == PrimeTimeStatus.AVAILABLE,
'textColor': 13347959}))
if self.__mapboxCtrl.isEnabled():
isOptionEnabled = canCreate and self.__mapboxCtrl.isActive() and self.__mapboxCtrl.isInPrimeTime()
options.append(self._makeItem(USER.CREATE_MAPBOX_SQUAD, backport.text(R.strings.menu.contextMenu.createMapboxSquad()), optInitData={'enabled': isOptionEnabled,
'textColor': 13347959}))
return options
def _addIgnoreInfo(self, options, userCMInfo):
ignoring = USER.REMOVE_FROM_IGNORED if userCMInfo.isIgnored else USER.ADD_TO_IGNORED
options.append(
self._makeItem(ignoring,
MENU.contextmenu(ignoring),
optInitData={'enabled': userCMInfo.isSameRealm}))
return options
def _manageVehCompareItem(self, optionsRef, vehicle):
"""
:param vehicle: instance of gui.shared.gui_items.Vehicle.Vehicle
:param optionsRef: reference to Context Menu items list
"""
if self.comparisonBasket.isEnabled():
optionsRef.append(self._makeItem(VEHICLE.COMPARE, MENU.contextmenu(VEHICLE.COMPARE), {'enabled': self.comparisonBasket.isReadyToAdd(vehicle)}))
def __addIgnoreInfo(self, options):
data = {'enabled': self.__userInfo.isSameRealm}
if self.__userInfo.isIgnored:
optionID = USER.REMOVE_FROM_IGNORED
else:
optionID = USER.ADD_TO_IGNORED
options.append(self._makeItem(optionID, MENU.contextmenu(optionID), optInitData=data))
return options
def __addFriendshipInfo(self, options):
isEnabled = self.__userInfo.isSameRealm
if self.__userInfo.isFriend:
optionID = USER.REMOVE_FROM_FRIENDS
else:
optionID = USER.ADD_TO_FRIENDS
options.append(self._makeItem(optionID, MENU.contextmenu(optionID), optInitData=self._getOptionInitData(optionID, isEnabled)))
return options
def __addFriendshipInfo(self, options):
data = {'enabled': self.__userInfo.isSameRealm}
if self.__userInfo.isFriend:
optionID = USER.REMOVE_FROM_FRIENDS
else:
optionID = USER.ADD_TO_FRIENDS
options.append(self._makeItem(optionID, MENU.contextmenu(optionID), optInitData=data))
return options
def _addContactsNoteInfo(self, options, userCMInfo):
if self.proto.contacts.isNoteSupported():
userNote = userCMInfo.getNote()
if userNote:
options.extend([self._makeItem(CONTACTS_ACTION_ID.EDIT_CONTACT_NOTE, MENU.contextmenu(CONTACTS_ACTION_ID.EDIT_CONTACT_NOTE)), self._makeItem(CONTACTS_ACTION_ID.REMOVE_CONTACT_NOTE, MENU.contextmenu(CONTACTS_ACTION_ID.REMOVE_CONTACT_NOTE))])
else:
options.append(self._makeItem(CONTACTS_ACTION_ID.CREATE_CONTACT_NOTE, MENU.contextmenu(CONTACTS_ACTION_ID.CREATE_CONTACT_NOTE)))
return options
def _generateOptions(self):
userCMInfo = self._getUseCmInfo()
ignoring = USER.REMOVE_FROM_IGNORED if userCMInfo.isIgnored else USER.ADD_TO_IGNORED
options = [self._makeItem(USER.INFO, MENU.contextmenu(USER.INFO))]
options = self._addFriendshipInfo(options, userCMInfo)
options = self._addChannelInfo(options, userCMInfo)
options.append(self._makeItem(USER.COPY_TO_CLIPBOARD, MENU.contextmenu(USER.COPY_TO_CLIPBOARD)))
options = self._addSquadInfo(options, userCMInfo.isIgnored)
options = self._addPrebattleInfo(options, userCMInfo)
options = self._addContactsNoteInfo(options, userCMInfo)
options = self._addAppealInfo(options)
options.append(self._makeItem(ignoring, MENU.contextmenu(ignoring)))
options = self._addMutedInfo(options, userCMInfo)
options = self._addRejectFriendshipInfo(options, userCMInfo)
options = self._addRemoveFromGroupInfo(options, userCMInfo)
options = self._addRemoveFriendInfo(options, userCMInfo)
return options
def _manageVehCompareItem(self, optionsRef, vehicle):
"""
:param vehicle: instance of gui.shared.gui_items.Vehicle.Vehicle
:param optionsRef: reference to Context Menu items list
"""
comparisonBasket = getVehicleComparisonBasketCtrl()
if comparisonBasket.isEnabled():
optionsRef.append(self._makeItem(VEHICLE.COMPARE, MENU.contextmenu(VEHICLE.COMPARE), {'enabled': comparisonBasket.isReadyToAdd(vehicle)}))
def _generateOptions(self, ctx = None):
userCMInfo = self._getUseCmInfo()
options = [self._makeItem(USER.INFO, MENU.contextmenu(USER.INFO))]
options = self._addFriendshipInfo(options, userCMInfo)
options = self._addChannelInfo(options, userCMInfo)
options.append(self._makeItem(USER.COPY_TO_CLIPBOARD, MENU.contextmenu(USER.COPY_TO_CLIPBOARD)))
options = self._addSquadInfo(options, userCMInfo.isIgnored)
options = self._addPrebattleInfo(options, userCMInfo)
options = self._addClubInfo(options, userCMInfo)
options = self._addContactsNoteInfo(options, userCMInfo)
options = self._addAppealInfo(options)
options = self._addIgnoreInfo(options, userCMInfo)
options = self._addMutedInfo(options, userCMInfo)
options = self._addRejectFriendshipInfo(options, userCMInfo)
options = self._addRemoveFromGroupInfo(options, userCMInfo)
options = self._addRemoveFriendInfo(options, userCMInfo)
return options
def _generateOptions(self, ctx = None):
options = []
vehicle = g_itemsCache.items.getVehicle(self.getVehInvID())
vehicleWasInBattle = False
accDossier = g_itemsCache.items.getAccountDossier(None)
if accDossier:
wasInBattleSet = set(accDossier.getTotalStats().getVehicles().keys())
if vehicle.intCD in wasInBattleSet:
vehicleWasInBattle = True
if vehicle is not None:
options.extend([self._makeItem(VEHICLE.INFO, MENU.contextmenu(VEHICLE.INFO)), self._makeItem(VEHICLE.STATS, MENU.contextmenu(VEHICLE.STATS), {'enabled': vehicleWasInBattle}), self._makeSeparator()])
if vehicle.isRented:
if not vehicle.isPremiumIGR:
money = g_itemsCache.items.stats.money
canBuyOrRent, _ = vehicle.mayRentOrBuy(money)
options.append(self._makeItem(VEHICLE.BUY, MENU.contextmenu(VEHICLE.BUY), {'enabled': canBuyOrRent}))
options.append(self._makeItem(VEHICLE.SELL, MENU.contextmenu(VEHICLE.REMOVE), {'enabled': vehicle.canSell and vehicle.rentalIsOver}))
else:
options.append(self._makeItem(VEHICLE.SELL, MENU.contextmenu(VEHICLE.SELL), {'enabled': vehicle.canSell}))
options.extend([self._makeSeparator(), self._makeItem(VEHICLE.RESEARCH, MENU.contextmenu(VEHICLE.RESEARCH))])
if vehicle.isFavorite:
options.append(self._makeItem(VEHICLE.UNCHECK, MENU.contextmenu(VEHICLE.UNCHECK)))
else:
options.append(self._makeItem(VEHICLE.CHECK, MENU.contextmenu(VEHICLE.CHECK)))
return options
def _generateOptions(self, ctx = None):
vehicle = g_itemsCache.items.getItemByCD(self.__vehCD)
options = []
if not vehicle.isSecret or vehicle.isInInventory:
options.append(self._makeItem(PROFILE.VEHICLE_INFO, MENU.CONTEXTMENU_VEHICLEINFOEX))
comparisonBasket = getVehicleComparisonBasketCtrl()
if comparisonBasket.isEnabled():
options.append(self._makeItem(PROFILE.VEHICLE_COMPARE, MENU.contextmenu(PROFILE.VEHICLE_COMPARE), {'enabled': comparisonBasket.isReadyToAdd(vehicle)}))
return options
def _getSubmenuData(self):
return [self._makeItem(DENUICATIONS.OFFEND, MENU.contextmenu(DENUICATIONS.OFFEND)),
self._makeItem(DENUICATIONS.FLOOD, MENU.contextmenu(DENUICATIONS.FLOOD)),
self._makeItem(DENUICATIONS.BLACKMAIL, MENU.contextmenu(DENUICATIONS.BLACKMAIL)),
self._makeItem(DENUICATIONS.SWINDLE, MENU.contextmenu(DENUICATIONS.SWINDLE)),
self._makeItem(DENUICATIONS.NOT_FAIR_PLAY, MENU.contextmenu(DENUICATIONS.NOT_FAIR_PLAY)),
self._makeItem(DENUICATIONS.FORBIDDEN_NICK, MENU.contextmenu(DENUICATIONS.FORBIDDEN_NICK)),
self._makeItem(DENUICATIONS.BOT, MENU.contextmenu(DENUICATIONS.BOT))]
def __addMutedInfo(self, options):
isVisible = self.bwProto.voipController.isVOIPEnabled() and (self.__userInfo.isAlly or self.arenaGuiType.isTrainingBattle())
isEnabled = not self.__userInfo.isIgnored or self.__userInfo.isTemporaryIgnored
if self.__userInfo.isMuted:
optionID = USER.UNSET_MUTED
else:
optionID = USER.SET_MUTED
if isVisible:
options.append(self._makeItem(optionID, MENU.contextmenu(optionID), optInitData=self._getOptionInitData(optionID, isEnabled)))
return options
def __addDenunciationsInfo(self, options):
make = self._makeItem
if self.__userInfo.isAlly or self.arenaGuiType.isTrainingBattle():
order = DENUNCIATIONS.ORDER
else:
order = DENUNCIATIONS.ENEMY_ORDER
sub = [ make(denunciation, MENU.contextmenu(denunciation), optInitData={'enabled': self.__isAppealsForTopicEnabled(denunciation)}) for denunciation in order ]
label = '{} {}/{}'.format(i18n.makeString(MENU.CONTEXTMENU_APPEAL), self.__denunciator.getDenunciationsLeft(), DENUNCIATIONS_PER_DAY)
options.append(make(DENUNCIATIONS.APPEAL, label, optInitData={'enabled': self.__denunciator.isAppealsEnabled()}, optSubMenu=sub))
return options
def __addIgnoreInfo(self, options):
isEnabled = self.__userInfo.isSameRealm
if self.__userInfo.isTemporaryIgnored:
optionID = USER.ADD_TO_IGNORED
isEnabled = False
elif self.__userInfo.isIgnored:
optionID = USER.REMOVE_FROM_IGNORED
else:
optionID = USER.ADD_TO_IGNORED
options.append(self._makeItem(optionID, MENU.contextmenu(optionID), optInitData=self._getOptionInitData(optionID, isEnabled)))
return options
def __addCommunicationInfo(self, options):
if self.__userInfo.isAlly and not self.arenaGuiType.isTrainingBattle():
isEnabled = self.__userInfo.isSameRealm
if self.__userInfo.isTemporaryIgnored:
optionID = BATTLE_CHAT_OPTION_ID.ENABLE_COMMUNICATIONS
elif not self.__userInfo.isIgnored:
optionID = BATTLE_CHAT_OPTION_ID.DISABLE_COMMUNICATIONS
else:
optionID = BATTLE_CHAT_OPTION_ID.DISABLE_COMMUNICATIONS
isEnabled = False
options.append(self._makeItem(optionID, MENU.contextmenu(optionID), optInitData=self._getOptionInitData(optionID, isEnabled)))
return options
def _generateOptions(self, ctx = None):
options = []
vehicle = g_itemsCache.items.getVehicle(self.getVehInvID())
vehicleWasInBattle = False
accDossier = g_itemsCache.items.getAccountDossier(None)
isEventVehicle = vehicle.isOnlyForEventBattles
if vehicle is None:
return options
else:
if accDossier:
wasInBattleSet = set(accDossier.getTotalStats().getVehicles().keys())
if vehicle.intCD in wasInBattleSet:
vehicleWasInBattle = True
if vehicle is not None:
options.extend([self._makeItem(VEHICLE.INFO, MENU.contextmenu(VEHICLE.INFO)), self._makeItem(VEHICLE.STATS, MENU.contextmenu(VEHICLE.STATS), {'enabled': vehicleWasInBattle}), self._makeSeparator()])
self._manageVehCompareOptions(options, vehicle)
options.append(self._makeItem(VEHICLE.RESEARCH, MENU.contextmenu(VEHICLE.RESEARCH)))
if vehicle.isRented:
if not vehicle.isPremiumIGR:
items = g_itemsCache.items
enabled = vehicle.mayObtainWithMoneyExchange(items.stats.money, items.shop.exchangeRate)
label = MENU.CONTEXTMENU_RESTORE if vehicle.isRestoreAvailable() else MENU.CONTEXTMENU_BUY
options.append(self._makeItem(VEHICLE.BUY, label, {'enabled': enabled}))
options.append(self._makeItem(VEHICLE.SELL, MENU.contextmenu(VEHICLE.REMOVE), {'enabled': vehicle.canSell and vehicle.rentalIsOver}))
else:
options.append(self._makeItem(VEHICLE.SELL, MENU.contextmenu(VEHICLE.SELL), {'enabled': vehicle.canSell and not isEventVehicle}))
if vehicle.isFavorite:
options.append(self._makeItem(VEHICLE.UNCHECK, MENU.contextmenu(VEHICLE.UNCHECK)))
else:
options.append(self._makeItem(VEHICLE.CHECK, MENU.contextmenu(VEHICLE.CHECK), {'enabled': not isEventVehicle}))
return options
def _addInviteClanInfo(self, options, userCMInfo):
if g_lobbyContext.getServerSettings().clanProfile.isEnabled() and not userCMInfo.hasClan:
profile = g_clanCtrl.getAccountProfile()
canHandleClanInvites = profile.getMyClanPermissions().canHandleClanInvites()
if profile.isInClan() and canHandleClanInvites:
isEnabled = g_clanCtrl.isAvailable()
canHandleClanInvites = profile.getMyClanPermissions().canHandleClanInvites()
if isEnabled:
profile = g_clanCtrl.getAccountProfile()
dossier = profile.getClanDossier()
isEnabled = canHandleClanInvites and not dossier.isClanInviteSent(userCMInfo.databaseID) and not dossier.hasClanApplication(userCMInfo.databaseID)
options.append(self._makeItem(USER.SEND_CLAN_INVITE, MENU.contextmenu(USER.SEND_CLAN_INVITE), optInitData={'enabled': isEnabled}))
return options
def _generateOptions(self, ctx = None):
return [self._makeItem(CREW.PERSONAL_CASE, MENU.contextmenu('personalCase')), self._makeSeparator(), self._makeItem(CREW.UNLOAD, MENU.contextmenu('tankmanUnload'))]
