class GuiChangeLocalFighterAmountCommand(wx.Command):
def __init__(self, fitID, position, amount):
wx.Command.__init__(self, True, 'Change Local Fighter Amount')
self.internalHistory = InternalCommandHistory()
self.fitID = fitID
self.position = position
self.amount = amount
def Do(self):
if self.amount > 0:
cmd = CalcChangeFighterAmountCommand(fitID=self.fitID, projected=False, position=self.position, amount=self.amount)
else:
cmd = CalcRemoveLocalFighterCommand(fitID=self.fitID, position=self.position)
success = self.internalHistory.submit(cmd)
eos.db.flush()
sFit = Fit.getInstance()
sFit.recalc(self.fitID)
sFit.fill(self.fitID)
eos.db.commit()
wx.PostEvent(gui.mainFrame.MainFrame.getInstance(), GE.FitChanged(fitID=self.fitID))
return success
def Undo(self):
success = self.internalHistory.undoAll()
eos.db.flush()
sFit = Fit.getInstance()
sFit.recalc(self.fitID)
sFit.fill(self.fitID)
eos.db.commit()
wx.PostEvent(gui.mainFrame.MainFrame.getInstance(), GE.FitChanged(fitID=self.fitID))
return success
class GuiToggleBoosterSideEffectStateCommand(wx.Command):
def __init__(self, fitID, position, effectID):
wx.Command.__init__(self, True, 'Toggle Booster Side Effect State')
self.internalHistory = InternalCommandHistory()
self.fitID = fitID
self.position = position
self.effectID = effectID
def Do(self):
cmd = CalcToggleBoosterSideEffectStateCommand(fitID=self.fitID, position=self.position, effectID=self.effectID)
success = self.internalHistory.submit(cmd)
eos.db.flush()
sFit = Fit.getInstance()
sFit.recalc(self.fitID)
sFit.fill(self.fitID)
eos.db.commit()
wx.PostEvent(gui.mainFrame.MainFrame.getInstance(), GE.FitChanged(fitID=self.fitID))
return success
def Undo(self):
success = self.internalHistory.undoAll()
eos.db.flush()
sFit = Fit.getInstance()
sFit.recalc(self.fitID)
sFit.fill(self.fitID)
eos.db.commit()
wx.PostEvent(gui.mainFrame.MainFrame.getInstance(), GE.FitChanged(fitID=self.fitID))
return success
class GuiChangeShipModeCommand(wx.Command):
def __init__(self, fitID, itemID):
wx.Command.__init__(self, True, 'Change Ship Mode')
self.internalHistory = InternalCommandHistory()
self.fitID = fitID
self.itemID = itemID
def Do(self):
cmd = CalcChangeShipModeCommand(fitID=self.fitID, itemID=self.itemID)
success = self.internalHistory.submit(cmd)
eos.db.flush()
sFit = Fit.getInstance()
sFit.recalc(self.fitID)
sFit.fill(self.fitID)
eos.db.commit()
wx.PostEvent(gui.mainFrame.MainFrame.getInstance(), GE.FitChanged(fitID=self.fitID))
return success
def Undo(self):
success = self.internalHistory.undoAll()
eos.db.flush()
sFit = Fit.getInstance()
sFit.recalc(self.fitID)
sFit.fill(self.fitID)
eos.db.commit()
wx.PostEvent(gui.mainFrame.MainFrame.getInstance(), GE.FitChanged(fitID=self.fitID))
return success
class GuiRemoveBoostersCommand(wx.Command):
def __init__(self, fitID, positions):
wx.Command.__init__(self, True, 'Remove Boosters')
self.internalHistory = InternalCommandHistory()
self.fitID = fitID
self.positions = positions
def Do(self):
results = []
for position in sorted(self.positions, reverse=True):
cmd = CalcRemoveBoosterCommand(fitID=self.fitID, position=position)
results.append(self.internalHistory.submit(cmd))
success = any(results)
eos.db.flush()
sFit = Fit.getInstance()
sFit.recalc(self.fitID)
sFit.fill(self.fitID)
eos.db.commit()
wx.PostEvent(gui.mainFrame.MainFrame.getInstance(), GE.FitChanged(fitID=self.fitID))
return success
def Undo(self):
success = self.internalHistory.undoAll()
eos.db.flush()
sFit = Fit.getInstance()
sFit.recalc(self.fitID)
sFit.fill(self.fitID)
eos.db.commit()
wx.PostEvent(gui.mainFrame.MainFrame.getInstance(), GE.FitChanged(fitID=self.fitID))
return success
class GuiToggleCommandFitStatesCommand(wx.Command):
def __init__(self, fitID, mainCommandFitID, commandFitIDs):
wx.Command.__init__(self, True, 'Toggle Command Fit States')
self.internalHistory = InternalCommandHistory()
self.fitID = fitID
self.mainCommandFitID = mainCommandFitID
self.commandFitIDs = commandFitIDs
def Do(self):
cmd = CalcToggleCommandFitStatesCommand(
fitID=self.fitID,
mainCommandFitID=self.mainCommandFitID,
commandFitIDs=self.commandFitIDs)
success = self.internalHistory.submit(cmd)
eos.db.flush()
sFit = Fit.getInstance()
sFit.recalc(self.fitID)
sFit.fill(self.fitID)
eos.db.commit()
wx.PostEvent(gui.mainFrame.MainFrame.getInstance(), GE.FitChanged(fitID=self.fitID))
return success
def Undo(self):
success = self.internalHistory.undoAll()
eos.db.flush()
sFit = Fit.getInstance()
sFit.recalc(self.fitID)
sFit.fill(self.fitID)
eos.db.commit()
wx.PostEvent(gui.mainFrame.MainFrame.getInstance(), GE.FitChanged(fitID=self.fitID))
return success
class GuiRemoveCargosCommand(wx.Command):
def __init__(self, fitID, itemIDs):
wx.Command.__init__(self, True, 'Remove Cargos')
self.internalHistory = InternalCommandHistory()
self.fitID = fitID
self.itemIDs = itemIDs
def Do(self):
results = []
for itemID in self.itemIDs:
cmd = CalcRemoveCargoCommand(
fitID=self.fitID,
cargoInfo=CargoInfo(itemID=itemID, amount=math.inf))
results.append(self.internalHistory.submit(cmd))
success = any(results)
eos.db.commit()
wx.PostEvent(gui.mainFrame.MainFrame.getInstance(), GE.FitChanged(fitID=self.fitID))
return success
def Undo(self):
success = self.internalHistory.undoAll()
eos.db.commit()
wx.PostEvent(gui.mainFrame.MainFrame.getInstance(), GE.FitChanged(fitID=self.fitID))
return success
class GuiAddProjectedDroneCommand(wx.Command):
def __init__(self, fitID, itemID):
wx.Command.__init__(self, True, 'Add Projected Drone')
self.internalHistory = InternalCommandHistory()
self.fitID = fitID
self.itemID = itemID
def Do(self):
cmd = CalcAddProjectedDroneCommand(fitID=self.fitID, droneInfo=DroneInfo(itemID=self.itemID, amount=1, amountActive=1))
success = self.internalHistory.submit(cmd)
eos.db.flush()
sFit = Fit.getInstance()
sFit.recalc(self.fitID)
sFit.fill(self.fitID)
eos.db.commit()
wx.PostEvent(gui.mainFrame.MainFrame.getInstance(), GE.FitChanged(fitID=self.fitID))
return success
def Undo(self):
success = self.internalHistory.undoAll()
eos.db.flush()
sFit = Fit.getInstance()
sFit.recalc(self.fitID)
sFit.fill(self.fitID)
eos.db.commit()
wx.PostEvent(gui.mainFrame.MainFrame.getInstance(), GE.FitChanged(fitID=self.fitID))
return success
class GuiChangeProjectedDroneAmountCommand(wx.Command):
def __init__(self, fitID, itemID, amount):
wx.Command.__init__(self, True, 'Change Projected Drone Amount')
self.internalHistory = InternalCommandHistory()
self.fitID = fitID
self.itemID = itemID
self.amount = amount
def Do(self):
if self.amount > 0:
cmd = CalcChangeProjectedDroneAmountCommand(fitID=self.fitID, itemID=self.itemID, amount=self.amount)
else:
cmd = CalcRemoveProjectedDroneCommand(fitID=self.fitID, itemID=self.itemID, amount=math.inf)
success = self.internalHistory.submit(cmd)
eos.db.flush()
sFit = Fit.getInstance()
sFit.recalc(self.fitID)
sFit.fill(self.fitID)
eos.db.commit()
wx.PostEvent(gui.mainFrame.MainFrame.getInstance(), GE.FitChanged(fitID=self.fitID))
return success
def Undo(self):
success = self.internalHistory.undoAll()
eos.db.flush()
sFit = Fit.getInstance()
sFit.recalc(self.fitID)
sFit.fill(self.fitID)
eos.db.commit()
wx.PostEvent(gui.mainFrame.MainFrame.getInstance(), GE.FitChanged(fitID=self.fitID))
return success
class GuiChangeLocalModuleSpoolCommand(wx.Command):
def __init__(self, fitID, position, spoolType, spoolAmount):
wx.Command.__init__(self, True, 'Change Local Module Spool')
self.internalHistory = InternalCommandHistory()
self.fitID = fitID
self.position = position
self.spoolType = spoolType
self.spoolAmount = spoolAmount
def Do(self):
cmd = CalcChangeModuleSpoolCommand(
fitID=self.fitID,
projected=False,
position=self.position,
spoolType=self.spoolType,
spoolAmount=self.spoolAmount)
success = self.internalHistory.submit(cmd)
eos.db.flush()
sFit = Fit.getInstance()
sFit.recalc(self.fitID)
sFit.fill(self.fitID)
eos.db.commit()
wx.PostEvent(gui.mainFrame.MainFrame.getInstance(), GE.FitChanged(fitID=self.fitID))
return success
def Undo(self):
success = self.internalHistory.undoAll()
eos.db.flush()
sFit = Fit.getInstance()
sFit.recalc(self.fitID)
sFit.fill(self.fitID)
eos.db.commit()
wx.PostEvent(gui.mainFrame.MainFrame.getInstance(), GE.FitChanged(fitID=self.fitID))
return success
class GuiChangeLocalModuleChargesCommand(wx.Command):
def __init__(self, fitID, positions, chargeItemID):
wx.Command.__init__(self, True, 'Change Local Module Charges')
self.internalHistory = InternalCommandHistory()
self.fitID = fitID
self.positions = positions
self.chargeItemID = chargeItemID
def Do(self):
cmd = CalcChangeModuleChargesCommand(fitID=self.fitID, projected=False, chargeMap={p: self.chargeItemID for p in self.positions})
success = self.internalHistory.submit(cmd)
eos.db.flush()
sFit = Fit.getInstance()
sFit.recalc(self.fitID)
sFit.fill(self.fitID)
eos.db.commit()
wx.PostEvent(gui.mainFrame.MainFrame.getInstance(), GE.FitChanged(fitID=self.fitID))
return success
def Undo(self):
success = self.internalHistory.undoAll()
eos.db.flush()
sFit = Fit.getInstance()
sFit.recalc(self.fitID)
sFit.fill(self.fitID)
eos.db.commit()
wx.PostEvent(gui.mainFrame.MainFrame.getInstance(), GE.FitChanged(fitID=self.fitID))
return success
class GuiChangeBoosterMetaCommand(wx.Command):
def __init__(self, fitID, position, newItemID):
wx.Command.__init__(self, True, 'Change Booster Meta')
self.internalHistory = InternalCommandHistory()
self.fitID = fitID
self.position = position
self.newItemID = newItemID
def Do(self):
sFit = Fit.getInstance()
fit = sFit.getFit(self.fitID)
booster = fit.boosters[self.position]
if booster.itemID == self.newItemID:
return False
info = BoosterInfo.fromBooster(booster)
info.itemID = self.newItemID
cmd = CalcAddBoosterCommand(fitID=self.fitID, boosterInfo=info)
success = self.internalHistory.submit(cmd)
eos.db.flush()
sFit.recalc(self.fitID)
sFit.fill(self.fitID)
eos.db.commit()
wx.PostEvent(gui.mainFrame.MainFrame.getInstance(), GE.FitChanged(fitID=self.fitID))
return success
def Undo(self):
success = self.internalHistory.undoAll()
eos.db.flush()
sFit = Fit.getInstance()
sFit.recalc(self.fitID)
sFit.fill(self.fitID)
eos.db.commit()
wx.PostEvent(gui.mainFrame.MainFrame.getInstance(), GE.FitChanged(fitID=self.fitID))
return success
class GuiAddImplantSetCommand(wx.Command):
def __init__(self, fitID, itemIDs):
wx.Command.__init__(self, True, 'Add Implant Set')
self.internalHistory = InternalCommandHistory()
self.fitID = fitID
self.itemIDs = itemIDs
def Do(self):
results = []
for itemID in self.itemIDs:
cmd = CalcAddImplantCommand(fitID=self.fitID, implantInfo=ImplantInfo(itemID=itemID))
results.append(self.internalHistory.submit(cmd))
eos.db.flush()
sFit = Fit.getInstance()
sFit.recalc(self.fitID)
sFit.fill(self.fitID)
eos.db.commit()
wx.PostEvent(gui.mainFrame.MainFrame.getInstance(), GE.FitChanged(fitID=self.fitID))
# Some might fail, as we already might have these implants
return any(results)
def Undo(self):
success = self.internalHistory.undoAll()
eos.db.flush()
sFit = Fit.getInstance()
sFit.recalc(self.fitID)
sFit.fill(self.fitID)
eos.db.commit()
wx.PostEvent(gui.mainFrame.MainFrame.getInstance(), GE.FitChanged(fitID=self.fitID))
return success
class GuiAddProjectedFitCommand(wx.Command):
def __init__(self, fitID, projectedFitID, amount):
wx.Command.__init__(self, True, 'Add Projected Fit')
self.internalHistory = InternalCommandHistory()
self.fitID = fitID
self.projectedFitID = projectedFitID
self.amount = amount
def Do(self):
cmd = CalcAddProjectedFitCommand(fitID=self.fitID, projectedFitID=self.projectedFitID, amount=self.amount)
success = self.internalHistory.submit(cmd)
sFit = Fit.getInstance()
eos.db.flush()
sFit.recalc(self.fitID)
sFit.fill(self.fitID)
eos.db.commit()
wx.PostEvent(gui.mainFrame.MainFrame.getInstance(), GE.FitChanged(fitID=self.fitID))
return success
def Undo(self):
success = self.internalHistory.undoAll()
sFit = Fit.getInstance()
eos.db.flush()
sFit.recalc(self.fitID)
sFit.fill(self.fitID)
eos.db.commit()
wx.PostEvent(gui.mainFrame.MainFrame.getInstance(), GE.FitChanged(fitID=self.fitID))
return success
class GuiRemoveCommandFitsCommand(wx.Command):
def __init__(self, fitID, commandFitIDs):
wx.Command.__init__(self, True, 'Remove Command Fits')
self.internalHistory = InternalCommandHistory()
self.fitID = fitID
self.commandFitIDs = commandFitIDs
def Do(self):
results = []
for commandFitID in self.commandFitIDs:
cmd = CalcRemoveCommandFitCommand(fitID=self.fitID, commandFitID=commandFitID)
results.append(self.internalHistory.submit(cmd))
success = any(results)
eos.db.flush()
sFit = Fit.getInstance()
sFit.recalc(self.fitID)
sFit.fill(self.fitID)
eos.db.commit()
wx.PostEvent(gui.mainFrame.MainFrame.getInstance(), GE.FitChanged(fitID=self.fitID))
return success
def Undo(self):
success = self.internalHistory.undoAll()
eos.db.flush()
sFit = Fit.getInstance()
sFit.recalc(self.fitID)
sFit.fill(self.fitID)
eos.db.commit()
wx.PostEvent(gui.mainFrame.MainFrame.getInstance(), GE.FitChanged(fitID=self.fitID))
return success
class GuiChangeLocalModuleMutationCommand(wx.Command):
def __init__(self, fitID, position, mutation, oldMutation=None):
wx.Command.__init__(self, True, 'Change Local Module Mutation')
self.internalHistory = InternalCommandHistory()
self.fitID = fitID
self.position = position
self.mutation = mutation
self.oldMutation = oldMutation
def Do(self):
cmd = CalcChangeLocalModuleMutationCommand(
fitID=self.fitID,
position=self.position,
mutation=self.mutation,
oldMutation=self.oldMutation)
success = self.internalHistory.submit(cmd)
eos.db.flush()
sFit = Fit.getInstance()
sFit.recalc(self.fitID)
sFit.fill(self.fitID)
eos.db.commit()
wx.PostEvent(gui.mainFrame.MainFrame.getInstance(), GE.FitChanged(fitID=self.fitID))
return success
def Undo(self):
success = self.internalHistory.undoAll()
eos.db.flush()
sFit = Fit.getInstance()
sFit.recalc(self.fitID)
sFit.fill(self.fitID)
eos.db.commit()
wx.PostEvent(gui.mainFrame.MainFrame.getInstance(), GE.FitChanged(fitID=self.fitID))
return success
class GuiRemoveProjectedItemsCommand(wx.Command):
def __init__(self, fitID, items, amount):
wx.Command.__init__(self, True, 'Remove Projected Items')
self.internalHistory = InternalCommandHistory()
self.fitID = fitID
self.amount = amount
self.pModPositions = []
self.pDroneItemIDs = []
self.pFighterPositions = []
self.pFitIDs = []
fit = Fit.getInstance().getFit(fitID)
for item in items:
if isinstance(item, EosModule):
if item in fit.projectedModules:
self.pModPositions.append(fit.projectedModules.index(item))
elif isinstance(item, EosDrone):
self.pDroneItemIDs.append(item.itemID)
elif isinstance(item, EosFighter):
if item in fit.projectedFighters:
self.pFighterPositions.append(fit.projectedFighters.index(item))
elif isinstance(item, EosFit):
self.pFitIDs.append(item.ID)
def Do(self):
results = []
for pModPosition in sorted(self.pModPositions, reverse=True):
cmd = CalcRemoveProjectedModuleCommand(fitID=self.fitID, position=pModPosition)
results.append(self.internalHistory.submit(cmd))
for pDroneItemID in self.pDroneItemIDs:
cmd = CalcRemoveProjectedDroneCommand(fitID=self.fitID, itemID=pDroneItemID, amount=self.amount)
results.append(self.internalHistory.submit(cmd))
for pFighterPosition in sorted(self.pFighterPositions, reverse=True):
cmd = CalcRemoveProjectedFighterCommand(fitID=self.fitID, position=pFighterPosition)
results.append(self.internalHistory.submit(cmd))
for pFitID in self.pFitIDs:
cmd = CalcRemoveProjectedFitCommand(fitID=self.fitID, projectedFitID=pFitID, amount=self.amount)
results.append(self.internalHistory.submit(cmd))
success = any(results)
eos.db.flush()
sFit = Fit.getInstance()
sFit.recalc(self.fitID)
sFit.fill(self.fitID)
eos.db.commit()
wx.PostEvent(gui.mainFrame.MainFrame.getInstance(), GE.FitChanged(fitID=self.fitID))
return success
def Undo(self):
success = self.internalHistory.undoAll()
eos.db.flush()
sFit = Fit.getInstance()
sFit.recalc(self.fitID)
sFit.fill(self.fitID)
eos.db.commit()
wx.PostEvent(gui.mainFrame.MainFrame.getInstance(), GE.FitChanged(fitID=self.fitID))
return success
class GuiFillWithClonedLocalModulesCommand(wx.Command):
def __init__(self, fitID, position):
wx.Command.__init__(self, True, 'Fill with Cloned Local Modules')
self.internalHistory = InternalCommandHistory()
self.fitID = fitID
self.position = position
self.savedItemID = None
self.savedRemovedDummies = None
def Do(self):
sFit = Fit.getInstance()
fit = sFit.getFit(self.fitID)
mod = fit.modules[self.position]
self.savedItemID = mod.itemID
info = ModuleInfo.fromModule(mod)
added_modules = 0
while True:
cmd = CalcAddLocalModuleCommand(fitID=self.fitID, newModInfo=info)
if not self.internalHistory.submit(cmd):
break
added_modules += 1
eos.db.flush()
sFit.recalc(self.fitID)
self.savedRemovedDummies = sFit.fill(self.fitID)
eos.db.commit()
success = added_modules > 0
wx.PostEvent(
gui.mainFrame.MainFrame.getInstance(),
GE.FitChanged(fitID=self.fitID, action='modadd', typeID=self.savedItemID)
if success else
GE.FitChanged(fitID=self.fitID))
return success
def Undo(self):
sFit = Fit.getInstance()
fit = sFit.getFit(self.fitID)
restoreRemovedDummies(fit, self.savedRemovedDummies)
success = self.internalHistory.undoAll()
eos.db.flush()
sFit.recalc(self.fitID)
sFit.fill(self.fitID)
eos.db.commit()
wx.PostEvent(
gui.mainFrame.MainFrame.getInstance(),
GE.FitChanged(fitID=self.fitID, action='moddel', typeID=self.savedItemID)
if success else
GE.FitChanged(fitID=self.fitID))
return success
def __init__(self, fitID, mainPosition, positions, effectID):
wx.Command.__init__(self, True, 'Toggle Projected Fighter Ability State')
self.internalHistory = InternalCommandHistory()
self.fitID = fitID
self.mainPosition = mainPosition
self.positions = positions
self.effectID = effectID
def __init__(self, fitID, position, mutaplasmid):
wx.Command.__init__(self, True, 'Convert Local Module to Mutated')
self.internalHistory = InternalCommandHistory()
self.fitID = fitID
self.position = position
self.itemID = mutaplasmid.resultingItem.ID
self.mutaplasmidID = mutaplasmid.ID
def __init__(self, fitID, position, mutation, oldMutation=None):
wx.Command.__init__(self, True, 'Change Local Module Mutation')
self.internalHistory = InternalCommandHistory()
self.fitID = fitID
self.position = position
self.mutation = mutation
self.oldMutation = oldMutation
def __init__(self, fitID, position):
wx.Command.__init__(self, True, 'Fill with Cloned Local Modules')
self.internalHistory = InternalCommandHistory()
self.fitID = fitID
self.position = position
self.savedItemID = None
self.savedRemovedDummies = None
def __init__(self, fitID, mainItem, items, click):
wx.Command.__init__(self, True, 'Change Projected Item States')
self.internalHistory = InternalCommandHistory()
self.fitID = fitID
self.pModPositions = []
self.pDroneItemIDs = []
self.pFighterPositions = []
self.pFitIDs = []
fit = Fit.getInstance().getFit(fitID)
for item in items:
if isinstance(item, EosModule):
if item in fit.projectedModules:
self.pModPositions.append(fit.projectedModules.index(item))
elif isinstance(item, EosDrone):
self.pDroneItemIDs.append(item.itemID)
elif isinstance(item, EosFighter):
if item in fit.projectedFighters:
self.pFighterPositions.append(fit.projectedFighters.index(item))
elif isinstance(item, EosFit):
self.pFitIDs.append(item.ID)
self.proposedState = None
if click == 'right' and isinstance(mainItem, EosModule):
self.proposedState = 'overheat'
elif click == 'left':
if isinstance(mainItem, EosModule):
modProposedState = EosModule.getProposedState(mainItem, click)
self.proposedState = 'inactive' if modProposedState == FittingModuleState.OFFLINE else 'active'
elif isinstance(mainItem, EosDrone):
self.proposedState = 'active' if mainItem.amountActive == 0 else 'inactive'
elif isinstance(mainItem, EosFighter):
self.proposedState = 'inactive' if mainItem.active else 'active'
elif isinstance(mainItem, EosFit):
projectionInfo = mainItem.getProjectionInfo(self.fitID)
if projectionInfo is not None:
self.proposedState = 'inactive' if projectionInfo.active else 'active'
def __init__(self, fitID, position, spoolType, spoolAmount):
wx.Command.__init__(self, True, 'Change Local Module Spool')
self.internalHistory = InternalCommandHistory()
self.fitID = fitID
self.position = position
self.spoolType = spoolType
self.spoolAmount = spoolAmount
def __init__(self, fitID, positions):
wx.Command.__init__(self, True, 'Remove Local Module')
self.internalHistory = InternalCommandHistory()
self.fitID = fitID
self.positions = positions
self.savedTypeIDs = None
self.savedRemovedDummies = None
class GuiConvertMutatedLocalModuleCommand(wx.Command):
def __init__(self, fitID, position, mutaplasmid):
wx.Command.__init__(self, True, 'Convert Local Module to Mutated')
self.internalHistory = InternalCommandHistory()
self.fitID = fitID
self.position = position
self.itemID = mutaplasmid.resultingItem.ID
self.mutaplasmidID = mutaplasmid.ID
def Do(self):
sFit = Fit.getInstance()
fit = sFit.getFit(self.fitID)
mod = fit.modules[self.position]
if mod.isEmpty:
return False
if mod.isMutated:
return False
cmd = CalcReplaceLocalModuleCommand(
fitID=self.fitID,
position=self.position,
newModInfo=ModuleInfo(
itemID=self.itemID,
baseItemID=mod.item.ID,
mutaplasmidID=self.mutaplasmidID,
mutations={},
chargeID=mod.chargeID,
state=mod.state,
spoolType=mod.spoolType,
spoolAmount=mod.spoolAmount))
success = self.internalHistory.submit(cmd)
eos.db.flush()
sFit.recalc(self.fitID)
sFit.fill(self.fitID)
eos.db.commit()
wx.PostEvent(gui.mainFrame.MainFrame.getInstance(), GE.FitChanged(fitID=self.fitID))
return success
def Undo(self):
success = self.internalHistory.undoAll()
eos.db.flush()
sFit = Fit.getInstance()
sFit.recalc(self.fitID)
sFit.fill(self.fitID)
eos.db.commit()
wx.PostEvent(gui.mainFrame.MainFrame.getInstance(), GE.FitChanged(fitID=self.fitID))
return success
def __init__(self, fitID, mainPosition, positions, click):
wx.Command.__init__(self, True, 'Change Local Module States')
self.internalHistory = InternalCommandHistory()
self.fitID = fitID
self.mainPosition = mainPosition
self.positions = positions
self.click = click
self.savedRemovedDummies = None
class GuiChangeLocalDroneMetasCommand(wx.Command):
def __init__(self, fitID, positions, newItemID):
wx.Command.__init__(self, True, 'Change Local Drone Meta')
self.internalHistory = InternalCommandHistory()
self.fitID = fitID
self.positions = positions
self.newItemID = newItemID
def Do(self):
sFit = Fit.getInstance()
fit = sFit.getFit(self.fitID)
results = []
for position in sorted(self.positions, reverse=True):
drone = fit.drones[position]
if drone.itemID == self.newItemID:
continue
info = DroneInfo.fromDrone(drone)
info.itemID = self.newItemID
cmdRemove = CalcRemoveLocalDroneCommand(
fitID=self.fitID,
position=position,
amount=math.inf)
cmdAdd = CalcAddLocalDroneCommand(
fitID=self.fitID,
droneInfo=info,
forceNewStack=True,
ignoreRestrictions=True)
results.append(self.internalHistory.submitBatch(cmdRemove, cmdAdd))
success = any(results)
eos.db.flush()
sFit.recalc(self.fitID)
sFit.fill(self.fitID)
eos.db.commit()
wx.PostEvent(gui.mainFrame.MainFrame.getInstance(), GE.FitChanged(fitID=self.fitID))
return success
def Undo(self):
success = self.internalHistory.undoAll()
eos.db.flush()
sFit = Fit.getInstance()
sFit.recalc(self.fitID)
sFit.fill(self.fitID)
eos.db.commit()
wx.PostEvent(gui.mainFrame.MainFrame.getInstance(), GE.FitChanged(fitID=self.fitID))
return success
def __init__(self, fitID, srcPosition, dstPosition):
wx.Command.__init__(self, True, 'Clone Local Module')
self.internalHistory = InternalCommandHistory()
self.fitID = fitID
self.srcPosition = srcPosition
self.dstPosition = dstPosition
self.savedItemID = None
self.savedRemovedDummies = None
class GuiReplaceLocalModuleCommand(wx.Command):
def __init__(self, fitID, itemID, positions):
wx.Command.__init__(self, True, 'Replace Local Module')
self.internalHistory = InternalCommandHistory()
self.fitID = fitID
self.itemID = itemID
self.positions = positions
self.savedRemovedDummies = None
def Do(self):
results = []
for position in self.positions:
cmd = CalcReplaceLocalModuleCommand(
fitID=self.fitID,
position=position,
newModInfo=ModuleInfo(itemID=self.itemID))
results.append(self.internalHistory.submit(cmd))
success = any(results)
eos.db.flush()
sFit = Fit.getInstance()
sFit.recalc(self.fitID)
self.savedRemovedDummies = sFit.fill(self.fitID)
eos.db.commit()
wx.PostEvent(
gui.mainFrame.MainFrame.getInstance(),
GE.FitChanged(fitID=self.fitID, action='modadd', typeID=self.itemID)
if success else
GE.FitChanged(fitID=self.fitID))
return success
def Undo(self):
sFit = Fit.getInstance()
fit = sFit.getFit(self.fitID)
restoreRemovedDummies(fit, self.savedRemovedDummies)
success = self.internalHistory.undoAll()
eos.db.flush()
sFit.recalc(self.fitID)
sFit.fill(self.fitID)
eos.db.commit()
wx.PostEvent(
gui.mainFrame.MainFrame.getInstance(),
GE.FitChanged(fitID=self.fitID, action='moddel', typeID=self.itemID)
if success else
GE.FitChanged(fitID=self.fitID))
return success
class GuiMergeLocalDroneStacksCommand(wx.Command):
def __init__(self, fitID, srcPosition, dstPosition):
wx.Command.__init__(self, True, 'Merge Local Drone Stacks')
self.internalHistory = InternalCommandHistory()
self.fitID = fitID
self.srcPosition = srcPosition
self.dstPosition = dstPosition
def Do(self):
if self.srcPosition == self.dstPosition:
return False
sFit = Fit.getInstance()
fit = sFit.getFit(self.fitID)
srcDrone = fit.drones[self.srcPosition]
dstDrone = fit.drones[self.dstPosition]
if srcDrone.itemID != dstDrone.itemID:
return False
srcAmount = srcDrone.amount
commands = []
commands.append(CalcChangeLocalDroneAmountCommand(
fitID=self.fitID,
position=self.dstPosition,
amount=dstDrone.amount + srcAmount))
commands.append(CalcRemoveLocalDroneCommand(
fitID=self.fitID,
position=self.srcPosition,
amount=srcAmount))
success = self.internalHistory.submitBatch(*commands)
eos.db.flush()
sFit.recalc(self.fitID)
sFit.fill(self.fitID)
eos.db.commit()
wx.PostEvent(gui.mainFrame.MainFrame.getInstance(), GE.FitChanged(fitID=self.fitID))
return success
def Undo(self):
success = self.internalHistory.undoAll()
eos.db.flush()
sFit = Fit.getInstance()
sFit.recalc(self.fitID)
sFit.fill(self.fitID)
eos.db.commit()
wx.PostEvent(gui.mainFrame.MainFrame.getInstance(), GE.FitChanged(fitID=self.fitID))
return success
def __init__(self, fitID, itemID):
wx.Command.__init__(self, True, 'Add Local Fighter')
self.internalHistory = InternalCommandHistory()
self.fitID = fitID
self.itemID = itemID
def __init__(self, fitID, itemIDs, newItemID):
wx.Command.__init__(self, True, 'Change Cargo Meta')
self.internalHistory = InternalCommandHistory()
self.fitID = fitID
self.itemIDs = itemIDs
self.newItemID = newItemID
class GuiRebaseItemsCommand(wx.Command):
def __init__(self, fitID, rebaseMap):
wx.Command.__init__(self, True, 'Rebase Items')
self.internalHistory = InternalCommandHistory()
self.fitID = fitID
self.rebaseMap = rebaseMap
def Do(self):
sFit = Fit.getInstance()
fit = sFit.getFit(self.fitID)
# Here we assume that item attribs do not change and item state will not change
for mod in fit.modules:
if mod.itemID in self.rebaseMap:
cmd = CalcRebaseItemCommand(fitID=self.fitID,
containerName='modules',
position=fit.modules.index(mod),
itemID=self.rebaseMap[mod.itemID])
self.internalHistory.submit(cmd)
if mod.chargeID in self.rebaseMap:
cmd = CalcChangeModuleChargesCommand(
fitID=self.fitID,
projected=False,
chargeMap={
fit.modules.index(mod): self.rebaseMap[mod.chargeID]
},
recalc=False)
self.internalHistory.submit(cmd)
for containerName in ('drones', 'fighters', 'implants', 'boosters'):
container = getattr(fit, containerName)
for obj in container:
if obj.itemID in self.rebaseMap:
cmd = CalcRebaseItemCommand(
fitID=self.fitID,
containerName=containerName,
position=container.index(obj),
itemID=self.rebaseMap[obj.itemID])
self.internalHistory.submit(cmd)
# Need to process cargo separately as we want to merge items when needed,
# e.g. FN iron and CN iron into single stack of CN iron
for cargo in fit.cargo:
if cargo.itemID in self.rebaseMap:
amount = cargo.amount
cmdRemove = CalcRemoveCargoCommand(fitID=self.fitID,
cargoInfo=CargoInfo(
itemID=cargo.itemID,
amount=amount))
cmdAdd = CalcAddCargoCommand(
fitID=self.fitID,
cargoInfo=CargoInfo(itemID=self.rebaseMap[cargo.itemID],
amount=amount))
self.internalHistory.submitBatch(cmdRemove, cmdAdd)
eos.db.flush()
sFit.recalc(fit)
sFit.fill(self.fitID)
eos.db.commit()
wx.PostEvent(gui.mainFrame.MainFrame.getInstance(),
GE.FitChanged(fitIDs=(self.fitID, )))
return len(self.internalHistory) > 0
def Undo(self):
sFit = Fit.getInstance()
success = self.internalHistory.undoAll()
eos.db.flush()
sFit.recalc(self.fitID)
sFit.fill(self.fitID)
eos.db.commit()
wx.PostEvent(gui.mainFrame.MainFrame.getInstance(),
GE.FitChanged(fitIDs=(self.fitID, )))
return success
def __init__(self, fitID, positions, amount):
wx.Command.__init__(self, True, 'Remove Local Drones')
self.internalHistory = InternalCommandHistory()
self.fitID = fitID
self.positions = positions
self.amount = amount
def __init__(self, fitID, position, effectID):
wx.Command.__init__(self, True, 'Toggle Booster Side Effect State')
self.internalHistory = InternalCommandHistory()
self.fitID = fitID
self.position = position
self.effectID = effectID
def __init__(self, fitID, position, newItemID):
wx.Command.__init__(self, True, 'Change Booster Meta')
self.internalHistory = InternalCommandHistory()
self.fitID = fitID
self.position = position
self.newItemID = newItemID
def __init__(self, fitID, position1, position2):
wx.Command.__init__(self, True, 'Swap Local Modules')
self.internalHistory = InternalCommandHistory()
self.fitID = fitID
self.position1 = position1
self.position2 = position2
def __init__(self, fitID, positions, newItemID):
wx.Command.__init__(self, True, 'Change Projected Module Metas')
self.internalHistory = InternalCommandHistory()
self.fitID = fitID
self.positions = positions
self.newItemID = newItemID
def __init__(self, fitID, rebaseMap):
wx.Command.__init__(self, True, 'Rebase Items')
self.internalHistory = InternalCommandHistory()
self.fitID = fitID
self.rebaseMap = rebaseMap
def __init__(self, fitID, fighters):
wx.Command.__init__(self, True, 'Import Local Fighters')
self.internalHistory = InternalCommandHistory()
self.fitID = fitID
self.fighters = [(i, a) for i, a, m in fighters]
def __init__(self, fitID, source):
wx.Command.__init__(self, True, 'Change Implant Location')
self.internalHistory = InternalCommandHistory()
self.fitID = fitID
self.source = source
def __init__(self, fitID, positions):
wx.Command.__init__(self, True, 'Remove Boosters')
self.internalHistory = InternalCommandHistory()
self.fitID = fitID
self.positions = positions
def __init__(self, fitID, position):
wx.Command.__init__(self, True, 'Fill with Cloned Local Modules')
self.internalHistory = InternalCommandHistory()
self.fitID = fitID
self.position = position
self.savedItemID = None
def __init__(self, fitID, position):
wx.Command.__init__(self, True, 'Revert Local Drone from Mutated')
self.internalHistory = InternalCommandHistory()
self.fitID = fitID
self.position = position
def __init__(self, fitID, positions, chargeItemID):
wx.Command.__init__(self, True, 'Change Projected Module Charges')
self.internalHistory = InternalCommandHistory()
self.fitID = fitID
self.positions = positions
self.chargeItemID = chargeItemID
def __init__(self, fitID, itemID, amount):
wx.Command.__init__(self, True, 'Add Cargo')
self.internalHistory = InternalCommandHistory()
self.fitID = fitID
self.itemID = itemID
self.amount = amount
def __init__(self, fitID, position, amount):
wx.Command.__init__(self, True, 'Change Local Fighter Amount')
self.internalHistory = InternalCommandHistory()
self.fitID = fitID
self.position = position
self.amount = amount
def __init__(self, fitID, itemIDs):
wx.Command.__init__(self, True, 'Add Implant Set')
self.internalHistory = InternalCommandHistory()
self.fitID = fitID
self.itemIDs = itemIDs
class GuiChangeLocalModuleMetasCommand(wx.Command):
def __init__(self, fitID, positions, newItemID):
wx.Command.__init__(self, True, 'Change Local Module Metas')
self.internalHistory = InternalCommandHistory()
self.fitID = fitID
self.positions = positions
self.newItemID = newItemID
self.relacedItemIDs = None
self.savedRemovedDummies = None
def Do(self):
sFit = Fit.getInstance()
fit = sFit.getFit(self.fitID)
commands = []
self.replacedItemIDs = set()
for position in self.positions:
module = fit.modules[position]
if module.isEmpty:
continue
if module.itemID == self.newItemID:
continue
self.replacedItemIDs.add(module.itemID)
info = ModuleInfo.fromModule(module)
info.itemID = self.newItemID
cmd = CalcReplaceLocalModuleCommand(fitID=self.fitID,
position=position,
newModInfo=info,
unloadInvalidCharges=True)
commands.append(cmd)
if not commands:
return False
success = self.internalHistory.submitBatch(*commands)
if commands[-1].needsGuiRecalc:
eos.db.flush()
sFit.recalc(self.fitID)
self.savedRemovedDummies = sFit.fill(self.fitID)
eos.db.commit()
events = []
if success and self.replacedItemIDs:
events.append(
GE.FitChanged(fitIDs=(self.fitID, ),
action='moddel',
typeID=self.replacedItemIDs))
if success:
events.append(
GE.FitChanged(fitIDs=(self.fitID, ),
action='modadd',
typeID=self.newItemID))
if not events:
events.append(GE.FitChanged(fitIDs=(self.fitID, )))
for event in events:
wx.PostEvent(gui.mainFrame.MainFrame.getInstance(), event)
return success
def Undo(self):
sFit = Fit.getInstance()
fit = sFit.getFit(self.fitID)
restoreRemovedDummies(fit, self.savedRemovedDummies)
success = self.internalHistory.undoAll()
eos.db.flush()
sFit.recalc(self.fitID)
sFit.fill(self.fitID)
eos.db.commit()
events = []
if success:
events.append(
GE.FitChanged(fitIDs=(self.fitID, ),
action='moddel',
typeID=self.newItemID))
if success and self.replacedItemIDs:
events.append(
GE.FitChanged(fitIDs=(self.fitID, ),
action='modadd',
typeID=self.replacedItemIDs))
if not events:
events.append(GE.FitChanged(fitIDs=(self.fitID, )))
for event in events:
wx.PostEvent(gui.mainFrame.MainFrame.getInstance(), event)
return success
class GuiChangeProjectedItemsProjectionRangeCommand(wx.Command):
def __init__(self, fitID, items, projectionRange):
wx.Command.__init__(self, True,
'Change Projected Items Projection Range')
self.internalHistory = InternalCommandHistory()
self.fitID = fitID
self.projectionRange = projectionRange
self.pModPositions = []
self.pDroneItemIDs = []
self.pFighterPositions = []
self.pFitIDs = []
fit = Fit.getInstance().getFit(fitID)
for item in items:
if isinstance(item, EosModule):
if item in fit.projectedModules and not getattr(
item, 'isExclusiveSystemEffect', False):
self.pModPositions.append(fit.projectedModules.index(item))
elif isinstance(item, EosDrone):
self.pDroneItemIDs.append(item.itemID)
elif isinstance(item, EosFighter):
if item in fit.projectedFighters:
self.pFighterPositions.append(
fit.projectedFighters.index(item))
elif isinstance(item, EosFit):
self.pFitIDs.append(item.ID)
def Do(self):
results = []
needRecalc = True
for pModPosition in self.pModPositions:
cmd = CalcChangeProjectedModuleProjectionRangeCommand(
fitID=self.fitID,
position=pModPosition,
projectionRange=self.projectionRange)
results.append(self.internalHistory.submit(cmd))
needRecalc = cmd.needsGuiRecalc
for pDroneItemID in self.pDroneItemIDs:
cmd = CalcChangeProjectedDroneProjectionRangeCommand(
fitID=self.fitID,
itemID=pDroneItemID,
projectionRange=self.projectionRange)
results.append(self.internalHistory.submit(cmd))
needRecalc = True
for pFighterPosition in self.pFighterPositions:
cmd = CalcChangeProjectedFighterProjectionRangeCommand(
fitID=self.fitID,
position=pFighterPosition,
projectionRange=self.projectionRange)
results.append(self.internalHistory.submit(cmd))
needRecalc = True
for pFitID in self.pFitIDs:
cmd = CalcChangeProjectedFitProjectionRangeCommand(
fitID=self.fitID,
projectedFitID=pFitID,
projectionRange=self.projectionRange)
results.append(self.internalHistory.submit(cmd))
needRecalc = cmd.needsGuiRecalc
success = any(results)
sFit = Fit.getInstance()
if needRecalc:
eos.db.flush()
sFit.recalc(self.fitID)
sFit.fill(self.fitID)
eos.db.commit()
wx.PostEvent(gui.mainFrame.MainFrame.getInstance(),
GE.FitChanged(fitIDs=(self.fitID, )))
return success
def Undo(self):
success = self.internalHistory.undoAll()
eos.db.flush()
sFit = Fit.getInstance()
sFit.recalc(self.fitID)
sFit.fill(self.fitID)
eos.db.commit()
wx.PostEvent(gui.mainFrame.MainFrame.getInstance(),
GE.FitChanged(fitIDs=(self.fitID, )))
return success
def __init__(self, fitID, commandFitIDs):
wx.Command.__init__(self, True, 'Remove Command Fits')
self.internalHistory = InternalCommandHistory()
self.fitID = fitID
self.commandFitIDs = commandFitIDs
def __init__(self, fitID, mainPosition, positions):
wx.Command.__init__(self, True, 'Toggle Implant States')
self.internalHistory = InternalCommandHistory()
self.fitID = fitID
self.mainPosition = mainPosition
self.positions = positions
class GuiLocalModuleToCargoCommand(wx.Command):
def __init__(self, fitID, modPosition, cargoItemID, copy):
wx.Command.__init__(self, True, 'Local Module to Cargo')
self.internalHistory = InternalCommandHistory()
self.fitID = fitID
self.srcModPosition = modPosition
self.dstCargoItemID = cargoItemID
self.copy = copy
self.removedModItemID = None
self.addedModItemID = None
self.savedRemovedDummies = None
def Do(self):
fit = Fit.getInstance().getFit(self.fitID)
srcMod = fit.modules[self.srcModPosition]
if srcMod.isEmpty:
return False
srcModItemID = srcMod.itemID
dstCargo = next(
(c for c in fit.cargo if c.itemID == self.dstCargoItemID), None)
success = False
# Attempt to swap if we're moving our module onto a module in the cargo hold
if not self.copy and dstCargo is not None and dstCargo.item.isModule:
if srcModItemID == self.dstCargoItemID:
return False
srcModSlot = srcMod.slot
newModInfo = ModuleInfo.fromModule(srcMod, unmutate=True)
newModInfo.itemID = self.dstCargoItemID
srcModChargeItemID = srcMod.chargeID
srcModChargeAmount = srcMod.numCharges
commands = []
commands.append(
CalcRemoveCargoCommand(fitID=self.fitID,
cargoInfo=CargoInfo(
itemID=self.dstCargoItemID,
amount=1)))
commands.append(
CalcAddCargoCommand(
fitID=self.fitID,
# We cannot put mutated items to cargo, so use unmutated item ID
cargoInfo=CargoInfo(itemID=ModuleInfo.fromModule(
srcMod, unmutate=True).itemID,
amount=1)))
cmdReplace = CalcReplaceLocalModuleCommand(
fitID=self.fitID,
position=self.srcModPosition,
newModInfo=newModInfo,
unloadInvalidCharges=True)
commands.append(cmdReplace)
# Submit batch now because we need to have updated info on fit to keep going
success = self.internalHistory.submitBatch(*commands)
if success:
newMod = fit.modules[self.srcModPosition]
# Process charge changes if module is moved to proper slot
if newMod.slot == srcModSlot:
# If we had to unload charge, add it to cargo
if cmdReplace.unloadedCharge and srcModChargeItemID is not None:
cmdAddCargoCharge = CalcAddCargoCommand(
fitID=self.fitID,
cargoInfo=CargoInfo(itemID=srcModChargeItemID,
amount=srcModChargeAmount))
success = self.internalHistory.submit(
cmdAddCargoCharge)
# If we did not unload charge and there still was a charge, see if amount differs and process it
elif not cmdReplace.unloadedCharge and srcModChargeItemID is not None:
# How many extra charges do we need to take from cargo
extraChargeAmount = newMod.numCharges - srcModChargeAmount
if extraChargeAmount > 0:
cmdRemoveCargoExtraCharge = CalcRemoveCargoCommand(
fitID=self.fitID,
cargoInfo=CargoInfo(itemID=srcModChargeItemID,
amount=extraChargeAmount))
# Do not check if operation was successful or not, we're okay if we have no such
# charges in cargo
self.internalHistory.submit(
cmdRemoveCargoExtraCharge)
elif extraChargeAmount < 0:
cmdAddCargoExtraCharge = CalcAddCargoCommand(
fitID=self.fitID,
cargoInfo=CargoInfo(
itemID=srcModChargeItemID,
amount=abs(extraChargeAmount)))
success = self.internalHistory.submit(
cmdAddCargoExtraCharge)
if success:
# Store info to properly send events later
self.removedModItemID = srcModItemID
self.addedModItemID = self.dstCargoItemID
# If drag happened to module which cannot be fit into current slot - consider it as failure
else:
success = False
# And in case of any failures, cancel everything to try to do move instead
if not success:
self.internalHistory.undoAll()
# Just dump module and its charges into cargo when copying or moving to cargo
if not success:
commands = []
commands.append(
CalcAddCargoCommand(fitID=self.fitID,
cargoInfo=CargoInfo(
itemID=ModuleInfo.fromModule(
srcMod, unmutate=True).itemID,
amount=1)))
if srcMod.chargeID is not None:
commands.append(
CalcAddCargoCommand(fitID=self.fitID,
cargoInfo=CargoInfo(
itemID=srcMod.chargeID,
amount=srcMod.numCharges)))
if not self.copy:
commands.append(
CalcRemoveLocalModulesCommand(
fitID=self.fitID, positions=[self.srcModPosition]))
success = self.internalHistory.submitBatch(*commands)
eos.db.flush()
sFit = Fit.getInstance()
sFit.recalc(self.fitID)
self.savedRemovedDummies = sFit.fill(self.fitID)
eos.db.commit()
events = []
if self.removedModItemID is not None:
events.append(
GE.FitChanged(fitIDs=(self.fitID, ),
action='moddel',
typeID=self.removedModItemID))
if self.addedModItemID is not None:
events.append(
GE.FitChanged(fitIDs=(self.fitID, ),
action='modadd',
typeID=self.addedModItemID))
if not events:
events.append(GE.FitChanged(fitIDs=(self.fitID, )))
for event in events:
wx.PostEvent(gui.mainFrame.MainFrame.getInstance(), event)
return success
def Undo(self):
sFit = Fit.getInstance()
fit = sFit.getFit(self.fitID)
restoreRemovedDummies(fit, self.savedRemovedDummies)
success = self.internalHistory.undoAll()
eos.db.flush()
sFit.recalc(self.fitID)
sFit.fill(self.fitID)
eos.db.commit()
events = []
if self.addedModItemID is not None:
events.append(
GE.FitChanged(fitIDs=(self.fitID, ),
action='moddel',
typeID=self.addedModItemID))
if self.removedModItemID is not None:
events.append(
GE.FitChanged(fitIDs=(self.fitID, ),
action='modadd',
typeID=self.removedModItemID))
if not events:
events.append(GE.FitChanged(fitIDs=(self.fitID, )))
for event in events:
wx.PostEvent(gui.mainFrame.MainFrame.getInstance(), event)
return success
def __init__(self, fitID, position, amount):
wx.Command.__init__(self, True, 'Split Local Drone Stack')
self.internalHistory = InternalCommandHistory()
self.fitID = fitID
self.position = position
self.amount = amount
def __init__(self, fitID, positions, newItemID):
wx.Command.__init__(self, True, 'Change Local Fighter Metas')
self.internalHistory = InternalCommandHistory()
self.fitID = fitID
self.positions = positions
self.newItemID = newItemID
def __init__(self, fitID, itemID):
wx.Command.__init__(self, True, 'Fill with New Local Modules')
self.internalHistory = InternalCommandHistory()
self.fitID = fitID
self.itemID = itemID
def __init__(self, fitID, srcPosition, dstPosition):
wx.Command.__init__(self, True, 'Merge Local Drone Stacks')
self.internalHistory = InternalCommandHistory()
self.fitID = fitID
self.srcPosition = srcPosition
self.dstPosition = dstPosition
def __init__(self, fitID, projectedFitID, amount):
wx.Command.__init__(self, True, 'Add Projected Fit')
self.internalHistory = InternalCommandHistory()
self.fitID = fitID
self.projectedFitID = projectedFitID
self.amount = amount
def __init__(self, fitID, itemID):
wx.Command.__init__(self, True, 'Add Projected Module')
self.internalHistory = InternalCommandHistory()
self.fitID = fitID
self.itemID = itemID
