diff --git a/gui/builtinAdditionPanes/droneView.py b/gui/builtinAdditionPanes/droneView.py
index d05b85515..19a4cf1ac 100644
--- a/gui/builtinAdditionPanes/droneView.py
+++ b/gui/builtinAdditionPanes/droneView.py
@@ -215,7 +215,7 @@ class DroneView(Display):
             event.Skip()
             return
 
-        if self.mainFrame.command.Submit(cmd.GuiAddDroneCommand(fitID, event.itemID)):
+        if self.mainFrame.command.Submit(cmd.GuiAddLocalDroneCommand(fitID=fitID, itemID=event.itemID, amount=1)):
             self.mainFrame.additionsPane.select("Drones")
 
         event.Skip()
@@ -230,11 +230,11 @@ class DroneView(Display):
 
     def removeDrone(self, drone):
         fitID = self.mainFrame.getActiveFit()
-        self.mainFrame.command.Submit(cmd.GuiRemoveDroneCommand(fitID, self.original.index(drone), 1))
+        self.mainFrame.command.Submit(cmd.GuiRemoveLocalDroneCommand(fitID, self.original.index(drone), 1))
 
     def removeDroneStack(self, drone):
         fitID = self.mainFrame.getActiveFit()
-        self.mainFrame.command.Submit(cmd.GuiRemoveDroneCommand(fitID, self.original.index(drone), math.inf))
+        self.mainFrame.command.Submit(cmd.GuiRemoveLocalDroneCommand(fitID, self.original.index(drone), math.inf))
 
     def click(self, event):
         event.Skip()
@@ -244,7 +244,7 @@ class DroneView(Display):
             if col == self.getColIndex(State):
                 fitID = self.mainFrame.getActiveFit()
                 drone = self.drones[row]
-                self.mainFrame.command.Submit(cmd.GuiToggleDroneStateCommand(fitID, self.original.index(drone)))
+                self.mainFrame.command.Submit(cmd.GuiToggleLocalDroneStateCommand(fitID, self.original.index(drone)))
 
     def spawnMenu(self, event):
         sel = self.GetFirstSelected()
diff --git a/gui/builtinAdditionPanes/fighterView.py b/gui/builtinAdditionPanes/fighterView.py
index 5be649ac9..0e17d98f6 100644
--- a/gui/builtinAdditionPanes/fighterView.py
+++ b/gui/builtinAdditionPanes/fighterView.py
@@ -259,7 +259,7 @@ class FighterDisplay(d.Display):
     def addItem(self, event):
         fitID = self.mainFrame.getActiveFit()
 
-        if self.mainFrame.command.Submit(cmd.GuiAddFighterCommand(fitID, event.itemID)):
+        if self.mainFrame.command.Submit(cmd.GuiAddLocalFighterCommand(fitID, event.itemID)):
             self.mainFrame.additionsPane.select("Fighters")
 
         event.Skip()
@@ -274,7 +274,7 @@ class FighterDisplay(d.Display):
 
     def removeFighter(self, fighter):
         fitID = self.mainFrame.getActiveFit()
-        self.mainFrame.command.Submit(cmd.GuiRemoveFighterCommand(fitID, self.original.index(fighter)))
+        self.mainFrame.command.Submit(cmd.GuiRemoveLocalFighterCommand(fitID, self.original.index(fighter)))
 
     def click(self, event):
         event.Skip()
@@ -284,7 +284,7 @@ class FighterDisplay(d.Display):
             if col == self.getColIndex(State):
                 fitID = self.mainFrame.getActiveFit()
                 fighter = self.fighters[row]
-                self.mainFrame.command.Submit(cmd.GuiToggleFighterCommand(fitID, self.original.index(fighter)))
+                self.mainFrame.command.Submit(cmd.GuiToggleLocalFighterStateCommand(fitID, self.original.index(fighter)))
 
     def spawnMenu(self, event):
         sel = self.GetFirstSelected()
diff --git a/gui/builtinAdditionPanes/notesView.py b/gui/builtinAdditionPanes/notesView.py
index a4a807509..755fef64d 100644
--- a/gui/builtinAdditionPanes/notesView.py
+++ b/gui/builtinAdditionPanes/notesView.py
@@ -8,6 +8,7 @@ from gui.utils.helpers_wxPython import HandleCtrlBackspace
 
 
 class NotesView(wx.Panel):
+
     def __init__(self, parent):
         wx.Panel.__init__(self, parent)
         self.lastFitId = None
diff --git a/gui/builtinAdditionPanes/projectedView.py b/gui/builtinAdditionPanes/projectedView.py
index 720681e27..69d2ae419 100644
--- a/gui/builtinAdditionPanes/projectedView.py
+++ b/gui/builtinAdditionPanes/projectedView.py
@@ -17,6 +17,8 @@
 # along with pyfa.  If not, see <http://www.gnu.org/licenses/>.
 # =============================================================================
 
+import math
+
 # noinspection PyPackageRequirements
 import wx
 from logbook import Logger
@@ -26,6 +28,7 @@ import gui.display as d
 import gui.globalEvents as GE
 from eos.saveddata.drone import Drone as es_Drone
 from eos.saveddata.fighter import Fighter as es_Fighter
+from eos.saveddata.fit import Fit as es_Fit
 from eos.saveddata.module import Module as es_Module
 from gui.builtinViewColumns.state import State
 from gui.contextMenu import ContextMenu
@@ -96,40 +99,49 @@ class ProjectedView(d.Display):
             data[0] is hard-coded str of originating source
             data[1] is typeID or index of data we want to manipulate
         """
-        sFit = Fit.getInstance()
         fitID = self.mainFrame.getActiveFit()
-        fit = sFit.getFit(self.mainFrame.getActiveFit())
-
-        if data[0] == "projected":
-            # if source is coming from projected, we are trying to combine drones.
-            pass
-            # removing merge functionality - if people complain about it, can add it back as a command
-            # self.mergeDrones(x, y, int(data[1]))
-        elif data[0] == "fitting":
+        fit = Fit.getInstance().getFit(fitID)
+        if data[0] == 'fitting':
             dstRow, _ = self.HitTest((x, y))
             # Gather module information to get position
-            module = fit.modules[int(data[1])]
-            self.mainFrame.command.Submit(cmd.GuiAddProjectedCommand(fitID, module.itemID, 'item'))
-        elif data[0] == "market":
-            self.mainFrame.command.Submit(cmd.GuiAddProjectedCommand(fitID, int(data[1]), 'item'))
+            self.mainFrame.command.Submit(cmd.GuiAddProjectedModuleCommand(
+                fitID=fitID, itemID=fit.modules[int(data[1])].itemID))
+        elif data[0] == 'market':
+            itemID = int(data[1])
+            category = Market.getInstance().getItem(itemID, eager=("group.category")).category.name
+            if category == 'Module':
+                self.mainFrame.command.Submit(cmd.GuiAddProjectedModuleCommand(fitID=fitID, itemID=itemID))
+            elif category == 'Drone':
+                self.mainFrame.command.Submit(cmd.GuiAddProjectedDroneCommand(fitID=fitID, itemID=itemID))
+            elif category == 'Fighter':
+                self.mainFrame.command.Submit(cmd.GuiAddProjectedFighterCommand(fitID=fitID, itemID=itemID))
 
     def kbEvent(self, event):
         keycode = event.GetKeyCode()
-        if keycode == wx.WXK_DELETE or keycode == wx.WXK_NUMPAD_DELETE:
-            fitID = self.mainFrame.getActiveFit()
-            sFit = Fit.getInstance()
+        if keycode  in (wx.WXK_DELETE, wx.WXK_NUMPAD_DELETE):
             row = self.GetFirstSelected()
             if row != -1:
+                fitID = self.mainFrame.getActiveFit()
                 thing = self.get(row)
-                if thing:
-                    self.mainFrame.command.Submit(cmd.GuiRemoveProjectedCommand(fitID, self.get(row)))
+                if isinstance(thing, es_Fit):
+                    self.mainFrame.command.Submit(cmd.GuiRemoveProjectedFitCommand(
+                        fitID=fitID, projectedFitID=thing.ID))
+                elif isinstance(thing, es_Module):
+                    self.mainFrame.command.Submit(cmd.GuiRemoveProjectedModuleCommand(
+                        fitID=fitID, position=Fit.getInstance().getFit(fitID).projectedModules.index(thing)))
+                elif isinstance(thing, es_Drone):
+                    self.mainFrame.command.Submit(cmd.GuiRemoveProjectedDroneCommand(
+                        fitID=fitID, itemID=thing.itemID, amount=math.inf))
+                elif isinstance(thing, es_Fighter):
+                    self.mainFrame.command.Submit(cmd.GuiRemoveProjectedFighterCommand(
+                        fitID=fitID, position=Fit.getInstance().getFit(fitID).projectedFighters.index(thing)))
 
     def handleDrag(self, type, fitID):
         # Those are drags coming from pyfa sources, NOT builtin wx drags
         if type == "fit":
             activeFit = self.mainFrame.getActiveFit()
             if activeFit:
-                self.mainFrame.command.Submit(cmd.GuiAddProjectedCommand(activeFit, fitID, 'fit'))
+                self.mainFrame.command.Submit(cmd.GuiAddProjectedFitCommand(fitID=activeFit, projectedFitID=fitID))
 
     def startDrag(self, event):
         row = event.GetIndex()
@@ -194,20 +206,20 @@ class ProjectedView(d.Display):
         stuff = []
         if fit is not None:
             # pyfalog.debug("    Collecting list of stuff to display in ProjectedView")
+            self.fits = fit.projectedFits[:]
             self.modules = fit.projectedModules[:]
             self.drones = fit.projectedDrones[:]
             self.fighters = fit.projectedFighters[:]
-            self.fits = fit.projectedFits[:]
 
+            self.fits.sort(key=self.fitSort)
             self.modules.sort(key=self.moduleSort)
             self.drones.sort(key=self.droneSort)
             self.fighters.sort(key=self.fighterSort)
-            self.fits.sort(key=self.fitSort)
 
+            stuff.extend(self.fits)
             stuff.extend(self.modules)
             stuff.extend(self.drones)
             stuff.extend(self.fighters)
-            stuff.extend(self.fits)
 
         if event.fitID != self.lastFitId:
             self.lastFitId = event.fitID
@@ -230,22 +242,22 @@ class ProjectedView(d.Display):
         if row == -1:
             return None
 
+        numFits = len(self.fits)
         numMods = len(self.modules)
         numDrones = len(self.drones)
         numFighters = len(self.fighters)
-        numFits = len(self.fits)
 
-        if (numMods + numDrones + numFighters + numFits) == 0:
+        if (numFits + numMods + numDrones + numFighters) == 0:
             return None
 
-        if row < numMods:
-            stuff = self.modules[row]
-        elif row - numMods < numDrones:
-            stuff = self.drones[row - numMods]
-        elif row - numMods - numDrones < numFighters:
-            stuff = self.fighters[row - numMods - numDrones]
+        if row < numFits:
+            stuff = self.fits[row]
+        elif row - numFits < numMods:
+            stuff = self.modules[row - numFits]
+        elif row - numFits - numMods < numDrones:
+            stuff = self.drones[row - numFits - numMods]
         else:
-            stuff = self.fits[row - numMods - numDrones - numFighters]
+            stuff = self.fighters[row - numFits - numMods - numDrones]
 
         return stuff
 
@@ -253,13 +265,24 @@ class ProjectedView(d.Display):
         event.Skip()
         row, _ = self.HitTest(event.Position)
         if row != -1:
-            item = self.get(row)
             col = self.getColumn(event.Position)
             if col == self.getColIndex(State):
-                self.mainFrame.command.Submit(cmd.GuiToggleProjectedCommand(
-                    fitID=self.mainFrame.getActiveFit(),
-                    thing=item,
-                    click="right" if event.Button == 3 else "left"))
+                fitID = self.mainFrame.getActiveFit()
+                thing = self.get(row)
+                if isinstance(thing, es_Fit):
+                    self.mainFrame.command.Submit(cmd.GuiToggleProjectedFitStateCommand(
+                        fitID=fitID, projectedFitID=thing.ID))
+                elif isinstance(thing, es_Module):
+                    self.mainFrame.command.Submit(cmd.GuiChangeProjectedModuleStateCommand(
+                        fitID=fitID,
+                        position=Fit.getInstance().getFit(fitID).projectedModules.index(thing),
+                        click='right' if event.Button == 3 else 'left'))
+                elif isinstance(thing, es_Drone):
+                    self.mainFrame.command.Submit(cmd.GuiToggleProjectedDroneStateCommand(
+                        fitID=fitID, itemID=thing.itemID))
+                elif isinstance(thing, es_Fighter):
+                    self.mainFrame.command.Submit(cmd.GuiToggleProjectedFighterStateCommand(
+                        fitID=fitID, position=Fit.getInstance().getFit(fitID).projectedFighters.index(thing)))
 
     def spawnMenu(self, event):
         fitID = self.mainFrame.getActiveFit()
@@ -310,5 +333,15 @@ class ProjectedView(d.Display):
             if col != self.getColIndex(State):
                 fitID = self.mainFrame.getActiveFit()
                 thing = self.get(row)
-                if thing:  # thing doesn't exist if it's the dummy value
-                    self.mainFrame.command.Submit(cmd.GuiRemoveProjectedCommand(fitID, thing))
+                if isinstance(thing, es_Fit):
+                    self.mainFrame.command.Submit(cmd.GuiRemoveProjectedFitCommand(
+                        fitID=fitID, projectedFitID=thing.ID))
+                elif isinstance(thing, es_Module):
+                    self.mainFrame.command.Submit(cmd.GuiRemoveProjectedModuleCommand(
+                        fitID=fitID, position=Fit.getInstance().getFit(fitID).projectedModules.index(thing)))
+                elif isinstance(thing, es_Drone):
+                    self.mainFrame.command.Submit(cmd.GuiRemoveProjectedDroneCommand(
+                        fitID=fitID, itemID=thing.itemID, amount=1))
+                elif isinstance(thing, es_Fighter):
+                    self.mainFrame.command.Submit(cmd.GuiRemoveProjectedFighterCommand(
+                        fitID=fitID, position=Fit.getInstance().getFit(fitID).projectedFighters.index(thing)))
diff --git a/gui/builtinContextMenus/amount.py b/gui/builtinContextMenus/amount.py
index f9a33be88..76d2366a9 100644
--- a/gui/builtinContextMenus/amount.py
+++ b/gui/builtinContextMenus/amount.py
@@ -1,16 +1,17 @@
-from gui.contextMenu import ContextMenu
-from eos.saveddata.fit import Fit as es_Fit
-import gui.mainFrame
-import gui.globalEvents as GE
+import re
+
 # noinspection PyPackageRequirements
 import wx
-import re
-from service.fit import Fit
-from eos.saveddata.drone import Drone
-from eos.saveddata.cargo import Cargo as es_Cargo
-from eos.saveddata.fighter import Fighter as es_Fighter
-from service.settings import ContextMenuSettings
+
 import gui.fitCommands as cmd
+import gui.mainFrame
+from eos.saveddata.cargo import Cargo as es_Cargo
+from eos.saveddata.drone import Drone
+from eos.saveddata.fighter import Fighter as es_Fighter
+from eos.saveddata.fit import Fit as es_Fit
+from gui.contextMenu import ContextMenu
+from service.fit import Fit
+from service.settings import ContextMenuSettings
 
 
 class ChangeAmount(ContextMenu):
@@ -39,7 +40,7 @@ class ChangeAmount(ContextMenu):
         else:
             value = thing.amount
 
-        dlg = AmountChanger(self.mainFrame, value)
+        dlg = AmountChanger(self.mainFrame, value, (0, 20)) if isinstance(thing, es_Fit) else AmountChanger(self.mainFrame, value)
         if dlg.ShowModal() == wx.ID_OK:
 
             if dlg.input.GetLineText(0).strip() == '':
@@ -53,30 +54,31 @@ class ChangeAmount(ContextMenu):
                 self.mainFrame.command.Submit(cmd.GuiChangeCargoAmountCommand(fitID, thing.itemID, cleanInput))
             elif isinstance(thing, Drone):
                 if srcContext == "projectedDrone":
-                    self.mainFrame.command.Submit(cmd.GuiChangeProjectedDroneQtyCommand(fitID, thing.itemID, cleanInput))
+                    self.mainFrame.command.Submit(cmd.GuiChangeProjectedDroneAmountCommand(fitID, thing.itemID, cleanInput))
                 else:
-                    self.mainFrame.command.Submit(cmd.GuiChangeDroneAmountCommand(fitID, fit.drones.index(thing), cleanInput))
+                    self.mainFrame.command.Submit(cmd.GuiChangeLocalDroneAmountCommand(fitID, fit.drones.index(thing), cleanInput))
             elif isinstance(thing, es_Fit):
-                self.mainFrame.command.Submit(cmd.GuiChangeProjectedFitQtyCommand(fitID, thing.ID, cleanInput))
+                self.mainFrame.command.Submit(cmd.GuiChangeProjectedFitAmountCommand(fitID, thing.ID, cleanInput))
             elif isinstance(thing, es_Fighter):
                 if srcContext == "projectedFighter":
                     self.mainFrame.command.Submit(cmd.GuiChangeProjectedFighterAmountCommand(fitID, fit.projectedFighters.index(thing), cleanInput))
                 else:
-                    self.mainFrame.command.Submit(cmd.GuiChangeFighterAmountCommand(fitID, fit.fighters.index(thing), cleanInput))
+                    self.mainFrame.command.Submit(cmd.GuiChangeLocalFighterAmountCommand(fitID, fit.fighters.index(thing), cleanInput))
 
 
 ChangeAmount.register()
 
 
 class AmountChanger(wx.Dialog):
-    def __init__(self, parent, value):
+
+    def __init__(self, parent, value, limits=None):
         wx.Dialog.__init__(self, parent, title="Change Amount")
         self.SetMinSize((346, 156))
 
         bSizer1 = wx.BoxSizer(wx.VERTICAL)
 
         bSizer2 = wx.BoxSizer(wx.VERTICAL)
-        text = wx.StaticText(self, wx.ID_ANY, "New Amount:")
+        text = wx.StaticText(self, wx.ID_ANY, "New Amount:" if limits is None else "New Amount ({}-{})".format(*limits))
         bSizer2.Add(text, 0)
 
         bSizer1.Add(bSizer2, 0, wx.ALL, 10)
diff --git a/gui/builtinContextMenus/cargo.py b/gui/builtinContextMenus/cargo.py
index d7586b842..9a7627d50 100644
--- a/gui/builtinContextMenus/cargo.py
+++ b/gui/builtinContextMenus/cargo.py
@@ -1,7 +1,6 @@
 import gui.fitCommands as cmd
 import gui.mainFrame
 from gui.contextMenu import ContextMenu
-# noinspection PyPackageRequirements
 from service.fit import Fit
 from service.settings import ContextMenuSettings
 
@@ -28,7 +27,7 @@ class Cargo(ContextMenu):
         return True
 
     def getText(self, itmContext, selection):
-        return "Add {0} to Cargo".format(itmContext)
+        return "Add {} to Cargo".format(itmContext)
 
     def activate(self, fullContext, selection, i):
         fitID = self.mainFrame.getActiveFit()
diff --git a/gui/builtinContextMenus/changeAffectingSkills.py b/gui/builtinContextMenus/changeAffectingSkills.py
index 148c18218..19a11b651 100644
--- a/gui/builtinContextMenus/changeAffectingSkills.py
+++ b/gui/builtinContextMenus/changeAffectingSkills.py
@@ -1,13 +1,13 @@
-# -*- coding: utf-8 -*-
-from gui.contextMenu import ContextMenu
-import gui.mainFrame
 # noinspection PyPackageRequirements
 import wx
-from gui.bitmap_loader import BitmapLoader
-from eos.saveddata.character import Skill
+
 import gui.globalEvents as GE
-from service.fit import Fit
+import gui.mainFrame
+from eos.saveddata.character import Skill
+from gui.bitmap_loader import BitmapLoader
+from gui.contextMenu import ContextMenu
 from service.character import Character
+from service.fit import Fit
 from service.settings import ContextMenuSettings
 
 
diff --git a/gui/builtinContextMenus/damagePattern.py b/gui/builtinContextMenus/damagePattern.py
index 03cde1794..6cc1979ef 100644
--- a/gui/builtinContextMenus/damagePattern.py
+++ b/gui/builtinContextMenus/damagePattern.py
@@ -1,14 +1,15 @@
-from gui.contextMenu import ContextMenu
-import gui.mainFrame
-import gui.globalEvents as GE
+from collections import OrderedDict
+
 # noinspection PyPackageRequirements
 import wx
-from gui.bitmap_loader import BitmapLoader
-from service.fit import Fit
-from service.damagePattern import DamagePattern as import_DamagePattern
-from service.settings import ContextMenuSettings
 
-from collections import OrderedDict
+import gui.globalEvents as GE
+import gui.mainFrame
+from gui.bitmap_loader import BitmapLoader
+from gui.contextMenu import ContextMenu
+from service.damagePattern import DamagePattern as import_DamagePattern
+from service.fit import Fit
+from service.settings import ContextMenuSettings
 
 
 class DamagePattern(ContextMenu):
diff --git a/gui/builtinContextMenus/droneRemoveStack.py b/gui/builtinContextMenus/droneRemoveStack.py
index b73e2cd62..f3e43dcb6 100644
--- a/gui/builtinContextMenus/droneRemoveStack.py
+++ b/gui/builtinContextMenus/droneRemoveStack.py
@@ -3,7 +3,6 @@ import math
 import gui.fitCommands as cmd
 import gui.mainFrame
 from gui.contextMenu import ContextMenu
-# noinspection PyPackageRequirements
 from service.fit import Fit
 from service.settings import ContextMenuSettings
 
@@ -16,19 +15,22 @@ class ItemRemove(ContextMenu):
     def display(self, srcContext, selection):
         if not self.settings.get('droneRemoveStack'):
             return False
-
-        return srcContext == "droneItem"
+        if srcContext not in ('droneItem', 'projectedDrone'):
+            return False
+        return True
 
     def getText(self, itmContext, selection):
-        return "Remove {0} Stack".format(itmContext)
+        return "Remove {} Stack".format(itmContext)
 
     def activate(self, fullContext, selection, i):
-        sFit = Fit.getInstance()
+        drone = selection[0]
         fitID = self.mainFrame.getActiveFit()
-        fit = sFit.getFit(fitID)
-
-        position = fit.drones.index(selection[0])
-        self.mainFrame.command.Submit(cmd.GuiRemoveDroneCommand(fitID, position, math.inf))
+        if 'droneItem' in fullContext:
+            self.mainFrame.command.Submit(cmd.GuiRemoveLocalDroneCommand(
+                fitID=fitID, position=Fit.getInstance().getFit(fitID).drones.index(drone), amount=math.inf))
+        if 'projectedDrone' in fullContext:
+            self.mainFrame.command.Submit(cmd.GuiRemoveProjectedDroneCommand(
+                fitID=fitID, itemID=drone.itemID, amount=math.inf))
 
 
 ItemRemove.register()
diff --git a/gui/builtinContextMenus/droneSplit.py b/gui/builtinContextMenus/droneSplit.py
index 462bd7198..c34af2f7b 100644
--- a/gui/builtinContextMenus/droneSplit.py
+++ b/gui/builtinContextMenus/droneSplit.py
@@ -1,11 +1,13 @@
-from gui.contextMenu import ContextMenu
-import gui.mainFrame
-import gui.globalEvents as GE
-from service.fit import Fit
+import re
+
 # noinspection PyPackageRequirements
 import wx
+
+import gui.globalEvents as GE
+import gui.mainFrame
+from gui.contextMenu import ContextMenu
+from service.fit import Fit
 from service.settings import ContextMenuSettings
-import re
 
 
 class DroneSplit(ContextMenu):
@@ -17,7 +19,7 @@ class DroneSplit(ContextMenu):
         if not self.settings.get('droneSplit'):
             return False
 
-        return srcContext in ("droneItem", "projectedDrone") and selection[0].amount > 1
+        return srcContext == "droneItem" and selection[0].amount > 1
 
     def getText(self, itmContext, selection):
         return "Split {0} Stack".format(itmContext)
diff --git a/gui/builtinContextMenus/droneStack.py b/gui/builtinContextMenus/droneStack.py
index 99a253796..e0f2d48e4 100644
--- a/gui/builtinContextMenus/droneStack.py
+++ b/gui/builtinContextMenus/droneStack.py
@@ -1,12 +1,11 @@
-from gui.contextMenu import ContextMenu
+import gui.fitCommands as cmd
 import gui.mainFrame
-import gui.globalEvents as GE
-import wx
+from gui.contextMenu import ContextMenu
 from service.settings import ContextMenuSettings
-from service.fit import Fit
 
 
 class DroneStack(ContextMenu):
+
     def __init__(self):
         self.mainFrame = gui.mainFrame.MainFrame.getInstance()
         self.settings = ContextMenuSettings.getInstance()
@@ -15,7 +14,7 @@ class DroneStack(ContextMenu):
         if not self.settings.get('droneStack'):
             return False
 
-        if srcContext not in ("marketItemGroup", "marketItemMisc") or self.mainFrame.getActiveFit() is None:
+        if srcContext not in ('marketItemGroup', 'marketItemMisc') or self.mainFrame.getActiveFit() is None:
             return False
 
         for selected_item in selection:
@@ -30,13 +29,9 @@ class DroneStack(ContextMenu):
         return "Add {0} to Drone Bay (x5)".format(itmContext)
 
     def activate(self, fullContext, selection, i):
-        sFit = Fit.getInstance()
-        fitID = self.mainFrame.getActiveFit()
-
-        typeID = int(selection[0].ID)
-        sFit.addDrone(fitID, typeID, 5)
-        self.mainFrame.additionsPane.select("Drones")
-        wx.PostEvent(self.mainFrame, GE.FitChanged(fitID=fitID))
+        self.mainFrame.command.Submit(cmd.GuiAddLocalDroneCommand(
+            fitID=self.mainFrame.getActiveFit(), itemID=int(selection[0].ID), amount=5))
+        self.mainFrame.additionsPane.select('Drones')
 
 
 DroneStack.register()
diff --git a/gui/builtinContextMenus/factorReload.py b/gui/builtinContextMenus/factorReload.py
index 2049b6e63..333b18b4c 100644
--- a/gui/builtinContextMenus/factorReload.py
+++ b/gui/builtinContextMenus/factorReload.py
@@ -1,8 +1,9 @@
-from gui.contextMenu import ContextMenu
-import gui.mainFrame
-import gui.globalEvents as GE
 # noinspection PyPackageRequirements
 import wx
+
+import gui.globalEvents as GE
+import gui.mainFrame
+from gui.contextMenu import ContextMenu
 from service.fit import Fit
 from service.settings import ContextMenuSettings
 
diff --git a/gui/builtinContextMenus/fighterAbilities.py b/gui/builtinContextMenus/fighterAbilities.py
index 038e1b5fc..4dccce834 100644
--- a/gui/builtinContextMenus/fighterAbilities.py
+++ b/gui/builtinContextMenus/fighterAbilities.py
@@ -1,11 +1,9 @@
 # noinspection PyPackageRequirements
 import wx
 
-
-import gui.globalEvents as GE
 import gui.mainFrame
-from gui.contextMenu import ContextMenu
 from gui import fitCommands as cmd
+from gui.contextMenu import ContextMenu
 from service.fit import Fit
 from service.settings import ContextMenuSettings
 
@@ -63,10 +61,12 @@ class FighterAbility(ContextMenu):
         fitID = self.mainFrame.getActiveFit()
         fit = Fit.getInstance().getFit(fitID)
         if self.isProjected:
-            index = fit.projectedFighters.index(self.fighter)
+            self.mainFrame.command.Submit(cmd.GuiToggleProjectedFighterAbilityStateCommand(
+                fitID=fitID, position=fit.projectedFighters.index(self.fighter), effectID=ability.effectID))
         else:
-            index = fit.fighters.index(self.fighter)
-        self.mainFrame.command.Submit(cmd.GuiToggleFighterAbilityCommand(fitID, index, ability.effectID))
+            self.mainFrame.command.Submit(cmd.GuiToggleLocalFighterAbilityStateCommand(
+                fitID=fitID, position=fit.fighters.index(self.fighter), effectID=ability.effectID))
+
 
 
 FighterAbility.register()
diff --git a/gui/builtinContextMenus/fillWithModule.py b/gui/builtinContextMenus/fillWithModule.py
index c6be3fe2e..a05bd79df 100644
--- a/gui/builtinContextMenus/fillWithModule.py
+++ b/gui/builtinContextMenus/fillWithModule.py
@@ -1,10 +1,11 @@
-from gui.contextMenu import ContextMenu
-import gui.mainFrame
 # noinspection PyPackageRequirements
 import wx
-import gui.globalEvents as GE
-from service.settings import ContextMenuSettings
+
 import gui.fitCommands as cmd
+import gui.globalEvents as GE
+import gui.mainFrame
+from gui.contextMenu import ContextMenu
+from service.settings import ContextMenuSettings
 
 
 class FillWithModule(ContextMenu):
@@ -26,7 +27,7 @@ class FillWithModule(ContextMenu):
         fitID = self.mainFrame.getActiveFit()
 
         if srcContext == "fittingModule":
-            self.mainFrame.command.Submit(cmd.GuiFillWithModulesCommand(fitID, selection[0].itemID))
+            self.mainFrame.command.Submit(cmd.GuiFillWithLocalModulesCommand(fitID, selection[0].itemID))
             return  # the command takes care of the PostEvent
         wx.PostEvent(self.mainFrame, GE.FitChanged(fitID=fitID))
 
diff --git a/gui/builtinContextMenus/implantSets.py b/gui/builtinContextMenus/implantSets.py
index 1eb12d1c3..cacae2f7e 100644
--- a/gui/builtinContextMenus/implantSets.py
+++ b/gui/builtinContextMenus/implantSets.py
@@ -1,11 +1,12 @@
-from gui.contextMenu import ContextMenu
-import gui.mainFrame
-import gui.globalEvents as GE
 # noinspection PyPackageRequirements
 import wx
-from service.implantSet import ImplantSets as s_ImplantSets
+
+import gui.globalEvents as GE
+import gui.mainFrame
+from gui.contextMenu import ContextMenu
 from service.character import Character
 from service.fit import Fit
+from service.implantSet import ImplantSets as s_ImplantSets
 from service.settings import ContextMenuSettings
 
 
diff --git a/gui/builtinContextMenus/itemRemove.py b/gui/builtinContextMenus/itemRemove.py
index aa157cb59..f6d6744ca 100644
--- a/gui/builtinContextMenus/itemRemove.py
+++ b/gui/builtinContextMenus/itemRemove.py
@@ -1,11 +1,8 @@
-from gui.contextMenu import ContextMenu
+import gui.fitCommands as cmd
 import gui.mainFrame
-# noinspection PyPackageRequirements
-import wx
-import gui.globalEvents as GE
+from gui.contextMenu import ContextMenu
 from service.fit import Fit
 from service.settings import ContextMenuSettings
-import gui.fitCommands as cmd
 
 
 class ItemRemove(ContextMenu):
@@ -36,34 +33,42 @@ class ItemRemove(ContextMenu):
         fit = sFit.getFit(fitID)
 
         if srcContext == "fittingModule":
-            modules = [module for module in selection if module is not None]
-            self.mainFrame.command.Submit(cmd.GuiRemoveModuleCommand(fitID, modules))
-            return  # the command takes care of the PostEvent
-        elif srcContext in ("fittingCharge", "projectedCharge"):
-            self.mainFrame.command.Submit(cmd.GuiChangeModuleChargesCommand(fitID, None, selection))
-            return
+            self.mainFrame.command.Submit(cmd.GuiRemoveLocalModuleCommand(
+                fitID=fitID, modules=[module for module in selection if module is not None]))
+        elif srcContext == "fittingCharge":
+            self.mainFrame.command.Submit(cmd.GuiChangeLocalModuleChargesCommand(
+                fitID=fitID, modules=selection, chargeItemID=None))
         elif srcContext == "droneItem":
-            self.mainFrame.command.Submit(cmd.GuiRemoveDroneCommand(fitID, fit.drones.index(selection[0]), 1))
-            return
+            self.mainFrame.command.Submit(cmd.GuiRemoveLocalDroneCommand(
+                fitID=fitID, position=fit.drones.index(selection[0]), amount=1))
         elif srcContext == "fighterItem":
-            self.mainFrame.command.Submit(cmd.GuiRemoveFighterCommand(fitID, fit.fighters.index(selection[0])))
-            return  # the command takes care of the PostEvent
+            self.mainFrame.command.Submit(cmd.GuiRemoveLocalFighterCommand(
+                fitID=fitID, position=fit.fighters.index(selection[0])))
         elif srcContext == "implantItem":
-            self.mainFrame.command.Submit(cmd.GuiRemoveImplantCommand(fitID, fit.implants.index(selection[0])))
-            return  # the command takes care of the PostEvent
+            self.mainFrame.command.Submit(cmd.GuiRemoveImplantCommand(
+                fitID=fitID, position=fit.implants.index(selection[0])))
         elif srcContext == "boosterItem":
-            self.mainFrame.command.Submit(cmd.GuiRemoveBoosterCommand(fitID, fit.boosters.index(selection[0])))
-            return  # the command takes care of the PostEvent
+            self.mainFrame.command.Submit(cmd.GuiRemoveBoosterCommand(
+                fitID=fitID, position=fit.boosters.index(selection[0])))
         elif srcContext == "cargoItem":
-            self.mainFrame.command.Submit(cmd.GuiRemoveCargoCommand(fitID, selection[0].itemID))
-            return  # the command takes care of the PostEvent
-        elif srcContext in ("projectedFit", "projectedModule", "projectedDrone", "projectedFighter"):
-            self.mainFrame.command.Submit(cmd.GuiRemoveProjectedCommand(fitID, selection[0]))
-            return  # the command takes care of the PostEvent
+            self.mainFrame.command.Submit(cmd.GuiRemoveCargoCommand(
+                fitID=fitID, itemID=selection[0].itemID))
+        elif srcContext == "projectedFit":
+            self.mainFrame.command.Submit(cmd.GuiRemoveProjectedFitCommand(
+                fitID=fitID, projectedFitID=selection[0].ID))
+        elif srcContext == "projectedModule":
+            self.mainFrame.command.Submit(cmd.GuiRemoveProjectedModuleCommand(
+                fitID=fitID, position=fit.projectedModules.index(selection[0])))
+        elif srcContext == "projectedDrone":
+            self.mainFrame.command.Submit(cmd.GuiRemoveProjectedDroneCommand(
+                fitID=fitID, itemID=selection[0].itemID, amount=1))
+        elif srcContext == "projectedFighter":
+            self.mainFrame.command.Submit(cmd.GuiRemoveProjectedFighterCommand(
+                fitID=fitID, position=fit.projectedFighters.index(selection[0])))
+        elif srcContext == "projectedCharge":
+            self.mainFrame.command.Submit(cmd.GuiChangeProjectedModuleChargesCommand(fitID, [selection[0]], None))
         elif srcContext == "commandFit":
             self.mainFrame.command.Submit(cmd.GuiRemoveCommandFitCommand(fitID, selection[0].ID))
-            return  # the command takes care of the PostEvent
-        wx.PostEvent(self.mainFrame, GE.FitChanged(fitID=fitID))
 
 
 ItemRemove.register()
diff --git a/gui/builtinContextMenus/itemStats.py b/gui/builtinContextMenus/itemStats.py
index 46b87226f..b1cef2204 100644
--- a/gui/builtinContextMenus/itemStats.py
+++ b/gui/builtinContextMenus/itemStats.py
@@ -1,8 +1,9 @@
-from gui.contextMenu import ContextMenu
-from gui.itemStats import ItemStatsDialog
-import gui.mainFrame
 # noinspection PyPackageRequirements
 import wx
+
+import gui.mainFrame
+from gui.contextMenu import ContextMenu
+from gui.itemStats import ItemStatsDialog
 from service.fit import Fit
 from service.settings import ContextMenuSettings
 
diff --git a/gui/builtinContextMenus/marketJump.py b/gui/builtinContextMenus/marketJump.py
index ee8a635e3..7feb261fa 100644
--- a/gui/builtinContextMenus/marketJump.py
+++ b/gui/builtinContextMenus/marketJump.py
@@ -1,5 +1,5 @@
-from gui.contextMenu import ContextMenu
 import gui.mainFrame
+from gui.contextMenu import ContextMenu
 from service.market import Market
 from service.settings import ContextMenuSettings
 
diff --git a/gui/builtinContextMenus/metaSwap.py b/gui/builtinContextMenus/metaSwap.py
index edab076bf..a1422c8d6 100644
--- a/gui/builtinContextMenus/metaSwap.py
+++ b/gui/builtinContextMenus/metaSwap.py
@@ -1,14 +1,12 @@
-# coding: utf-8
-
 # noinspection PyPackageRequirements
 import wx
 
 import gui.fitCommands as cmd
 import gui.mainFrame
 from gui.contextMenu import ContextMenu
+from service.fit import Fit
 from service.market import Market
 from service.settings import ContextMenuSettings
-from service.fit import Fit
 
 
 class MetaSwap(ContextMenu):
diff --git a/gui/builtinContextMenus/moduleAmmoPicker.py b/gui/builtinContextMenus/moduleAmmoPicker.py
index cf9ac6842..fa29b3c16 100644
--- a/gui/builtinContextMenus/moduleAmmoPicker.py
+++ b/gui/builtinContextMenus/moduleAmmoPicker.py
@@ -1,5 +1,3 @@
-# coding: utf-8
-
 # noinspection PyPackageRequirements
 import wx
 
@@ -50,6 +48,7 @@ class ModuleAmmoPicker(ContextMenu):
 
         self.modules = modules
         self.charges = list([charge for charge in validCharges if Market.getInstance().getPublicityByItem(charge)])
+        self.context = srcContext
         return len(self.charges) > 0
 
     def getText(self, itmContext, selection):
@@ -228,7 +227,12 @@ class ModuleAmmoPicker(ContextMenu):
             return
 
         fitID = self.mainFrame.getActiveFit()
-        self.mainFrame.command.Submit(cmd.GuiChangeModuleChargesCommand(fitID, charge.ID if charge is not None else None, self.modules))
+        if self.context == 'fittingModule':
+            self.mainFrame.command.Submit(cmd.GuiChangeLocalModuleChargesCommand(
+                fitID=fitID, modules=self.modules, chargeItemID=charge.ID if charge is not None else None))
+        elif self.context == 'projectedModule':
+            self.mainFrame.command.Submit(cmd.GuiChangeProjectedModuleChargesCommand(
+                fitID=fitID, modules=self.modules, chargeItemID=charge.ID if charge is not None else None))
 
 
 ModuleAmmoPicker.register()
diff --git a/gui/builtinContextMenus/moduleGlobalAmmoPicker.py b/gui/builtinContextMenus/moduleGlobalAmmoPicker.py
index e2e729e03..d65bf8c27 100644
--- a/gui/builtinContextMenus/moduleGlobalAmmoPicker.py
+++ b/gui/builtinContextMenus/moduleGlobalAmmoPicker.py
@@ -1,13 +1,12 @@
-# -*- coding: utf-8 -*-
 import gui.fitCommands as cmd
 import gui.mainFrame
-from eos.db.saveddata.queries import getFit as db_getFit
-# noinspection PyPackageRequirements
 from gui.builtinContextMenus.moduleAmmoPicker import ModuleAmmoPicker
+from service.fit import Fit
 from service.settings import ContextMenuSettings
 
 
 class ModuleGlobalAmmoPicker(ModuleAmmoPicker):
+
     def __init__(self):
         super(ModuleGlobalAmmoPicker, self).__init__()
         self.mainFrame = gui.mainFrame.MainFrame.getInstance()
@@ -27,18 +26,19 @@ class ModuleGlobalAmmoPicker(ModuleAmmoPicker):
             return
 
         fitID = self.mainFrame.getActiveFit()
-        fit = db_getFit(fitID)
+        fit = Fit.getInstance().getFit(fitID)
 
         selectedModule = self.modules[0]
-        source = fit.modules if not selectedModule.isProjected else fit.projectedModules
-        allModules = []
-        for mod in source:
-            if mod.itemID is None:
-                continue
-            if mod.itemID == selectedModule.itemID:
-                allModules.append(mod)
-
-        self.mainFrame.command.Submit(cmd.GuiChangeModuleChargesCommand(fitID, charge.ID if charge is not None else None, allModules))
+        if self.context == 'fittingModule':
+            self.mainFrame.command.Submit(cmd.GuiChangeLocalModuleChargesCommand(
+                fitID=fitID,
+                modules=[m for m in fit.modules if m.itemID is not None and m.itemID == selectedModule.itemID],
+                chargeItemID=charge.ID if charge is not None else None))
+        elif self.context == 'projectedModule':
+            self.mainFrame.command.Submit(cmd.GuiChangeProjectedModuleChargesCommand(
+                fitID=fitID,
+                modules=[m for m in fit.projectedModules if m.itemID is not None and m.itemID == selectedModule.itemID],
+                chargeItemID=charge.ID if charge is not None else None))
 
     def display(self, srcContext, selection):
         if not self.settings.get('moduleGlobalAmmoPicker'):
diff --git a/gui/builtinContextMenus/mutaplasmids.py b/gui/builtinContextMenus/mutaplasmids.py
index 9dd363e8a..c01feab69 100644
--- a/gui/builtinContextMenus/mutaplasmids.py
+++ b/gui/builtinContextMenus/mutaplasmids.py
@@ -1,11 +1,9 @@
 # noinspection PyPackageRequirements
 import wx
 
-import gui.globalEvents as GE
 import gui.mainFrame
-from gui.fitCommands import GuiConvertMutatedModuleCommand, GuiRevertMutatedModuleCommand
 from gui.contextMenu import ContextMenu
-from service.fit import Fit
+from gui.fitCommands import GuiConvertMutatedLocalModuleCommand, GuiRevertMutatedLocalModuleCommand
 from service.settings import ContextMenuSettings
 
 
@@ -58,14 +56,14 @@ class MutaplasmidCM(ContextMenu):
     def handleMenu(self, event):
         mutaplasmid, mod = self.eventIDs[event.Id]
 
-        self.mainFrame.command.Submit(GuiConvertMutatedModuleCommand(
+        self.mainFrame.command.Submit(GuiConvertMutatedLocalModuleCommand(
             fitID=self.mainFrame.getActiveFit(),
             position=mod.modPosition,
             mutaplasmid=mutaplasmid))
 
     def activate(self, fullContext, selection, i):
         mod = selection[0]
-        self.mainFrame.command.Submit(GuiRevertMutatedModuleCommand(
+        self.mainFrame.command.Submit(GuiRevertMutatedLocalModuleCommand(
             fitID=self.mainFrame.getActiveFit(),
             position=mod.modPosition))
 
diff --git a/gui/builtinContextMenus/openFit.py b/gui/builtinContextMenus/openFit.py
index 6d6b4ac1f..6abbc8479 100644
--- a/gui/builtinContextMenus/openFit.py
+++ b/gui/builtinContextMenus/openFit.py
@@ -1,8 +1,9 @@
-from gui.contextMenu import ContextMenu
-import gui.mainFrame
 # noinspection PyPackageRequirements
 import wx
+
+import gui.mainFrame
 from gui.builtinShipBrowser.events import FitSelected
+from gui.contextMenu import ContextMenu
 from service.settings import ContextMenuSettings
 
 
diff --git a/gui/builtinContextMenus/priceOptions.py b/gui/builtinContextMenus/priceOptions.py
index 41736e4bc..69b1397b6 100644
--- a/gui/builtinContextMenus/priceOptions.py
+++ b/gui/builtinContextMenus/priceOptions.py
@@ -1,4 +1,4 @@
-from abc import abstractmethod, ABCMeta
+from abc import ABCMeta, abstractmethod
 
 import wx
 
diff --git a/gui/builtinContextMenus/project.py b/gui/builtinContextMenus/project.py
index 2a334eca2..70290efaf 100644
--- a/gui/builtinContextMenus/project.py
+++ b/gui/builtinContextMenus/project.py
@@ -1,7 +1,6 @@
 import gui.fitCommands as cmd
 import gui.mainFrame
 from gui.contextMenu import ContextMenu
-# noinspection PyPackageRequirements
 from service.fit import Fit
 from service.settings import ContextMenuSettings
 
@@ -33,8 +32,17 @@ class Project(ContextMenu):
 
     def activate(self, fullContext, selection, i):
         fitID = self.mainFrame.getActiveFit()
-        if self.mainFrame.command.Submit(cmd.GuiAddProjectedCommand(fitID, selection[0].ID, 'item')):
-            self.mainFrame.additionsPane.select("Projected")
+        category = selection[0].category.name
+        if category == 'Module':
+            success = self.mainFrame.command.Submit(cmd.GuiAddProjectedModuleCommand(fitID=fitID, itemID=selection[0].ID))
+        elif category == 'Drone':
+            success = self.mainFrame.command.Submit(cmd.GuiAddProjectedDroneCommand(fitID=fitID, itemID=selection[0].ID))
+        elif category == 'Fighter':
+            success = self.mainFrame.command.Submit(cmd.GuiAddProjectedFighterCommand(fitID=fitID, itemID=selection[0].ID))
+        else:
+            success = False
+        if success:
+            self.mainFrame.additionsPane.select('Projected')
 
 
 Project.register()
diff --git a/gui/builtinContextMenus/shipJump.py b/gui/builtinContextMenus/shipJump.py
index 367a477fb..43741e62b 100644
--- a/gui/builtinContextMenus/shipJump.py
+++ b/gui/builtinContextMenus/shipJump.py
@@ -1,8 +1,9 @@
 # noinspection PyPackageRequirements
 import wx
-from gui.contextMenu import ContextMenu
+
 import gui.mainFrame
 from gui.builtinShipBrowser.events import Stage3Selected
+from gui.contextMenu import ContextMenu
 from service.fit import Fit
 from service.settings import ContextMenuSettings
 
diff --git a/gui/builtinContextMenus/spoolUp.py b/gui/builtinContextMenus/spoolUp.py
index ae2934f6b..3a2ddc8c5 100644
--- a/gui/builtinContextMenus/spoolUp.py
+++ b/gui/builtinContextMenus/spoolUp.py
@@ -24,7 +24,7 @@ class SpoolUp(ContextMenu):
             return False
 
         self.mod = selection[0]
-        # self.context = srcContext
+        self.context = srcContext
 
         return self.mod.item.group.name in ("Precursor Weapon", "Mutadaptive Remote Armor Repairer")
 
@@ -75,11 +75,18 @@ class SpoolUp(ContextMenu):
             spoolAmount = self.cycleMap[event.Id]
         else:
             return
-        self.mainFrame.command.Submit(cmd.GuiChangeModuleSpoolCommand(
-            fitID=self.mainFrame.getActiveFit(),
-            position=self.mod.modPosition,
-            spoolType=spoolType,
-            spoolAmount=spoolAmount))
+        if self.context == 'fittingModule':
+            self.mainFrame.command.Submit(cmd.GuiChangeLocalModuleSpoolCommand(
+                fitID=self.mainFrame.getActiveFit(),
+                position=self.mod.modPosition,
+                spoolType=spoolType,
+                spoolAmount=spoolAmount))
+        elif self.context == 'projectedModule':
+            self.mainFrame.command.Submit(cmd.GuiChangeProjectedModuleSpoolCommand(
+                fitID=self.mainFrame.getActiveFit(),
+                position=self.mod.modPosition,
+                spoolType=spoolType,
+                spoolAmount=spoolAmount))
 
 
 SpoolUp.register()
diff --git a/gui/builtinContextMenus/tabbedFits.py b/gui/builtinContextMenus/tabbedFits.py
index 8002cd4e4..c913c1255 100644
--- a/gui/builtinContextMenus/tabbedFits.py
+++ b/gui/builtinContextMenus/tabbedFits.py
@@ -1,5 +1,3 @@
-# coding: utf-8
-
 # noinspection PyPackageRequirements
 import wx
 
@@ -56,9 +54,9 @@ class TabbedFits(ContextMenu):
         fit = self.fitLookup[event.Id]
 
         if self.context == 'commandView':
-            self.mainFrame.command.Submit(cmd.GuiAddCommandFitCommand(fitID, fit.ID))
+            self.mainFrame.command.Submit(cmd.GuiAddCommandFitCommand(fitID=fitID, commandFitID=fit.ID))
         elif self.context == 'projected':
-            self.mainFrame.command.Submit(cmd.GuiAddProjectedCommand(fitID, fit.ID, 'fit'))
+            self.mainFrame.command.Submit(cmd.GuiAddProjectedFitCommand(fitID=fitID, projectedFitID=fit.ID))
 
 
 TabbedFits.register()
diff --git a/gui/builtinContextMenus/targetResists.py b/gui/builtinContextMenus/targetResists.py
index 03478b8d2..9827bf34a 100644
--- a/gui/builtinContextMenus/targetResists.py
+++ b/gui/builtinContextMenus/targetResists.py
@@ -1,13 +1,15 @@
-from gui.contextMenu import ContextMenu
-import gui.mainFrame
-import gui.globalEvents as GE
+from collections import OrderedDict
+
 # noinspection PyPackageRequirements
 import wx
+
+import gui.globalEvents as GE
+import gui.mainFrame
 from gui.bitmap_loader import BitmapLoader
-from service.targetResists import TargetResists as svc_TargetResists
+from gui.contextMenu import ContextMenu
 from service.fit import Fit
 from service.settings import ContextMenuSettings
-from collections import OrderedDict
+from service.targetResists import TargetResists as svc_TargetResists
 
 
 class TargetResists(ContextMenu):
diff --git a/gui/builtinContextMenus/whProjector.py b/gui/builtinContextMenus/whProjector.py
index 5b824e8eb..6c71f9238 100644
--- a/gui/builtinContextMenus/whProjector.py
+++ b/gui/builtinContextMenus/whProjector.py
@@ -89,7 +89,7 @@ class WhProjector(ContextMenu):
             return
 
         fitID = self.mainFrame.getActiveFit()
-        self.mainFrame.command.Submit(cmd.GuiAddProjectedCommand(fitID, swObj.ID, 'item'))
+        self.mainFrame.command.Submit(cmd.GuiAddProjectedModuleCommand(fitID, swObj.ID))
 
     def buildMenu(self, grouped_data, flat_data, local_menu, rootMenu, msw):
 
diff --git a/gui/builtinViews/fittingView.py b/gui/builtinViews/fittingView.py
index 4b478992a..f5f510523 100644
--- a/gui/builtinViews/fittingView.py
+++ b/gui/builtinViews/fittingView.py
@@ -369,9 +369,9 @@ class FittingView(d.Display):
                         sel = self.GetNextSelected(sel)
 
                     if len(modules) > 0:
-                        self.mainFrame.command.Submit(cmd.GuiChangeModuleChargesCommand(fitID, itemID, modules))
+                        self.mainFrame.command.Submit(cmd.GuiChangeLocalModuleChargesCommand(fitID, modules, itemID))
                 else:
-                    self.mainFrame.command.Submit(cmd.GuiAddModuleCommand(fitID, itemID))
+                    self.mainFrame.command.Submit(cmd.GuiAddLocalModuleCommand(fitID, itemID))
 
         event.Skip()
 
@@ -393,7 +393,7 @@ class FittingView(d.Display):
         if not isinstance(modules, list):
             modules = [modules]
 
-        self.mainFrame.command.Submit(cmd.GuiRemoveModuleCommand(self.activeFitID, modules))
+        self.mainFrame.command.Submit(cmd.GuiRemoveLocalModuleCommand(self.activeFitID, modules))
 
     def addModule(self, x, y, itemID):
         """Add a module from the market browser (from dragging it)"""
@@ -405,7 +405,7 @@ class FittingView(d.Display):
             if not isinstance(mod, Module):  # make sure we're not adding something to a T3D Mode
                 return
 
-            self.mainFrame.command.Submit(cmd.GuiAddModuleCommand(fitID, itemID, self.mods[dstRow].modPosition))
+            self.mainFrame.command.Submit(cmd.GuiAddLocalModuleCommand(fitID, itemID, self.mods[dstRow].modPosition))
 
     def swapCargo(self, x, y, srcIdx):
         """Swap a module from cargo to fitting window"""
@@ -610,7 +610,7 @@ class FittingView(d.Display):
             ctrl = event.cmdDown or event.middleIsDown
             click = "ctrl" if ctrl is True else "right" if event.GetButton() == 3 else "left"
 
-            self.mainFrame.command.Submit(cmd.GuiChangeModuleStatesCommand(
+            self.mainFrame.command.Submit(cmd.GuiChangeLocalModuleStatesCommand(
                 fitID=fitID,
                 mainPosition=self.mods[self.GetItemData(row)].modPosition,
                 positions=[mod.modPosition for mod in mods],
diff --git a/gui/contextMenu.py b/gui/contextMenu.py
index 8b8819dff..a3ac6b155 100644
--- a/gui/contextMenu.py
+++ b/gui/contextMenu.py
@@ -216,18 +216,18 @@ from gui.builtinContextMenus import (  # noqa: E402,F401
     fillWithModule,
     droneRemoveStack,
     ammoPattern,
-    project,
     factorReload,
-    whProjector,
+    droneStack,
     cargo,
+    cargoAmmo,
+    project,
+    whProjector,
     shipJump,
     changeAffectingSkills,
     tacticalMode,
     targetResists,
     priceOptions,
     amount,
-    cargoAmmo,
-    # droneStack,
     metaSwap,
     implantSets,
     fighterAbilities,
diff --git a/gui/fitCommands/__init__.py b/gui/fitCommands/__init__.py
index 77b26e119..e3263147c 100644
--- a/gui/fitCommands/__init__.py
+++ b/gui/fitCommands/__init__.py
@@ -8,38 +8,50 @@ from .cargo.remove import GuiRemoveCargoCommand
 from .commandFit.add import GuiAddCommandFitCommand
 from .commandFit.remove import GuiRemoveCommandFitCommand
 from .commandFit.toggleState import GuiToggleCommandFitStateCommand
-from .drone.add import GuiAddDroneCommand
-from .drone.changeAmount import GuiChangeDroneAmountCommand
-from .drone.remove import GuiRemoveDroneCommand
-from .drone.toggleState import GuiToggleDroneStateCommand
-from .fighter.abilityToggleState import GuiToggleFighterAbilityCommand
-from .fighter.add import GuiAddFighterCommand
-from .fighter.changeAmount import GuiChangeFighterAmountCommand
-from .fighter.remove import GuiRemoveFighterCommand
-from .fighter.toggleState import GuiToggleFighterCommand
-from .guiAddProjected import GuiAddProjectedCommand
+from .localDrone.add import GuiAddLocalDroneCommand
+from .localDrone.changeAmount import GuiChangeLocalDroneAmountCommand
+from .localDrone.remove import GuiRemoveLocalDroneCommand
+from .localDrone.toggleState import GuiToggleLocalDroneStateCommand
+from .localFighter.abilityToggleState import GuiToggleLocalFighterAbilityStateCommand
+from .localFighter.add import GuiAddLocalFighterCommand
+from .localFighter.changeAmount import GuiChangeLocalFighterAmountCommand
+from .localFighter.remove import GuiRemoveLocalFighterCommand
+from .localFighter.toggleState import GuiToggleLocalFighterStateCommand
 from .guiCargoToModule import GuiCargoToModuleCommand
-from .guiChangeProjectedDroneQty import GuiChangeProjectedDroneQtyCommand
-from .guiChangeProjectedFighterAmount import GuiChangeProjectedFighterAmountCommand
-from .guiChangeProjectedFitQty import GuiChangeProjectedFitQtyCommand
 from .guiFitRename import GuiFitRenameCommand
 from .guiMetaSwap import GuiMetaSwapCommand
 from .guiModuleToCargo import GuiModuleToCargoCommand
 from .guiRebaseItems import GuiRebaseItemsCommand
-from .guiRemoveProjected import GuiRemoveProjectedCommand
 from .guiSetMode import GuiSetModeCommand
 from .guiSwapCloneModule import GuiModuleSwapOrCloneCommand
-from .guiToggleProjected import GuiToggleProjectedCommand
 from .implant.add import GuiAddImplantCommand
 from .implant.changeLocation import GuiChangeImplantLocationCommand
 from .implant.remove import GuiRemoveImplantCommand
 from .implant.toggleState import GuiToggleImplantStateCommand
-from .module.add import GuiAddModuleCommand
-from .module.changeCharges import GuiChangeModuleChargesCommand
-from .module.changeSpool import GuiChangeModuleSpoolCommand
-from .module.changeStates import GuiChangeModuleStatesCommand
-from .module.fill import GuiFillWithModulesCommand
-from .module.mutatedConvert import GuiConvertMutatedModuleCommand
-from .module.mutatedImport import GuiImportMutatedModuleCommand
-from .module.mutatedRevert import GuiRevertMutatedModuleCommand
-from .module.remove import GuiRemoveModuleCommand
+from .localModule.add import GuiAddLocalModuleCommand
+from .localModule.changeCharges import GuiChangeLocalModuleChargesCommand
+from .localModule.changeSpool import GuiChangeLocalModuleSpoolCommand
+from .localModule.changeStates import GuiChangeLocalModuleStatesCommand
+from .localModule.fill import GuiFillWithLocalModulesCommand
+from .localModule.mutatedConvert import GuiConvertMutatedLocalModuleCommand
+from .localModule.mutatedImport import GuiImportLocalMutatedModuleCommand
+from .localModule.mutatedRevert import GuiRevertMutatedLocalModuleCommand
+from .localModule.remove import GuiRemoveLocalModuleCommand
+from .projectedDrone.add import GuiAddProjectedDroneCommand
+from .projectedDrone.changeAmount import GuiChangeProjectedDroneAmountCommand
+from .projectedDrone.remove import GuiRemoveProjectedDroneCommand
+from .projectedDrone.toggleState import GuiToggleProjectedDroneStateCommand
+from .projectedFighter.abilityToggleState import GuiToggleProjectedFighterAbilityStateCommand
+from .projectedFighter.add import GuiAddProjectedFighterCommand
+from .projectedFighter.changeAmount import GuiChangeProjectedFighterAmountCommand
+from .projectedFighter.remove import GuiRemoveProjectedFighterCommand
+from .projectedFighter.toggleState import GuiToggleProjectedFighterStateCommand
+from .projectedFit.add import GuiAddProjectedFitCommand
+from .projectedFit.changeAmount import GuiChangeProjectedFitAmountCommand
+from .projectedFit.remove import GuiRemoveProjectedFitCommand
+from .projectedFit.toggleState import GuiToggleProjectedFitStateCommand
+from .projectedModule.add import GuiAddProjectedModuleCommand
+from .projectedModule.changeCharges import GuiChangeProjectedModuleChargesCommand
+from .projectedModule.changeSpool import GuiChangeProjectedModuleSpoolCommand
+from .projectedModule.changeState import GuiChangeProjectedModuleStateCommand
+from .projectedModule.remove import GuiRemoveProjectedModuleCommand
diff --git a/gui/fitCommands/calcCommands/fitRename.py b/gui/fitCommands/calcCommands/fitRename.py
index d472bc8b6..edd4051d9 100644
--- a/gui/fitCommands/calcCommands/fitRename.py
+++ b/gui/fitCommands/calcCommands/fitRename.py
@@ -18,7 +18,7 @@ class CalcFitRenameCommand(wx.Command):
 
     def Do(self):
         pyfalog.debug('Doing renaming of fit {} to {}'.format(self.fitID, self.name))
-        fit = Fit.getInstance().getFit(self.fitID)
+        fit = Fit.getInstance().getFit(self.fitID, basic=True)
         if fit.name == self.name:
             return False
         self.savedName = fit.name
diff --git a/gui/fitCommands/calcCommands/projectedFit/add.py b/gui/fitCommands/calcCommands/projectedFit/add.py
index 80c602fb9..6d7375cc7 100644
--- a/gui/fitCommands/calcCommands/projectedFit/add.py
+++ b/gui/fitCommands/calcCommands/projectedFit/add.py
@@ -10,7 +10,7 @@ pyfalog = Logger(__name__)
 
 class CalcAddProjectedFitCommand(wx.Command):
 
-    def __init__(self, fitID, projectedFitID, state):
+    def __init__(self, fitID, projectedFitID, state=None):
         wx.Command.__init__(self, True, 'Add Projected Fit')
         self.fitID = fitID
         self.projectedFitID = projectedFitID
@@ -20,7 +20,7 @@ class CalcAddProjectedFitCommand(wx.Command):
         pyfalog.debug('Doing addition of projected fit {} for fit {}'.format(self.projectedFitID, self.fitID))
         sFit = Fit.getInstance()
         fit = sFit.getFit(self.fitID)
-        projectedFit = sFit.getFit(self.projectedFitID)
+        projectedFit = sFit.getFit(self.projectedFitID, projected=True)
 
         # Projected fit could have been deleted if we are redoing
         if projectedFit is None:
@@ -51,7 +51,7 @@ class CalcAddProjectedFitCommand(wx.Command):
         pyfalog.debug('Undoing addition of projected fit {} for fit {}'.format(self.projectedFitID, self.fitID))
         # Can't find the projected fit, it must have been deleted. Just skip, as deleted fit
         # means that someone else just did exactly what we wanted to do
-        projectedFit = Fit.getInstance().getFit(self.projectedFitID)
+        projectedFit = Fit.getInstance().getFit(self.projectedFitID, projected=True)
         if projectedFit is None:
             return True
         from .remove import CalcRemoveProjectedFitCommand
diff --git a/gui/fitCommands/calcCommands/projectedFit/changeAmount.py b/gui/fitCommands/calcCommands/projectedFit/changeAmount.py
index 9f18451b0..ceb1bfe76 100644
--- a/gui/fitCommands/calcCommands/projectedFit/changeAmount.py
+++ b/gui/fitCommands/calcCommands/projectedFit/changeAmount.py
@@ -19,7 +19,7 @@ class CalcChangeProjectedFitAmountCommand(wx.Command):
 
     def Do(self):
         pyfalog.debug('Doing change of projected fit {} amount to {} for fit {}'.format(self.projectedFitID, self.amount, self.fitID))
-        projectedFit = Fit.getInstance().getFit(self.projectedFitID)
+        projectedFit = Fit.getInstance().getFit(self.projectedFitID, projected=True)
         # Projected fit could have been deleted if we are redoing
         if projectedFit is None:
             pyfalog.debug('Projected fit is not available')
diff --git a/gui/fitCommands/calcCommands/projectedFit/remove.py b/gui/fitCommands/calcCommands/projectedFit/remove.py
index ea4c6d5c9..71405dd7a 100644
--- a/gui/fitCommands/calcCommands/projectedFit/remove.py
+++ b/gui/fitCommands/calcCommands/projectedFit/remove.py
@@ -20,7 +20,7 @@ class CalcRemoveProjectedFitCommand(wx.Command):
         pyfalog.debug('Doing removal of projected fit {} for fit {}'.format(self.projectedFitID, self.fitID))
         sFit = Fit.getInstance()
         fit = sFit.getFit(self.fitID)
-        projectedFit = sFit.getFit(self.projectedFitID)
+        projectedFit = sFit.getFit(self.projectedFitID, projected=True)
 
         # Can be removed by the time we're redoing it
         if projectedFit is None:
diff --git a/gui/fitCommands/calcCommands/projectedFit/toggleState.py b/gui/fitCommands/calcCommands/projectedFit/toggleState.py
index 3736cec2a..0eeb62d26 100644
--- a/gui/fitCommands/calcCommands/projectedFit/toggleState.py
+++ b/gui/fitCommands/calcCommands/projectedFit/toggleState.py
@@ -19,7 +19,7 @@ class CalcToggleProjectedFitCommand(wx.Command):
 
     def Do(self):
         pyfalog.debug('Doing toggling of projected fit {} state for fit {}'.format(self.projectedFitID, self.fitID))
-        projectedFit = Fit.getInstance().getFit(self.projectedFitID)
+        projectedFit = Fit.getInstance().getFit(self.projectedFitID, projected=True)
         # Projected fit could have been deleted if we are redoing
         if projectedFit is None:
             pyfalog.debug('Projected fit is not available')
diff --git a/gui/fitCommands/guiAddProjected.py b/gui/fitCommands/guiAddProjected.py
deleted file mode 100644
index 0558e9035..000000000
--- a/gui/fitCommands/guiAddProjected.py
+++ /dev/null
@@ -1,55 +0,0 @@
-import wx
-from service.fit import Fit
-
-import gui.mainFrame
-from gui import globalEvents as GE
-from gui.fitCommands.helpers import ModuleInfo, DroneInfo, FighterInfo
-from .calcCommands.module.projectedAdd import CalcAddProjectedModuleCommand
-from .calcCommands.projectedFit.add import CalcAddProjectedFitCommand
-from .calcCommands.fighter.projectedAdd import CalcAddProjectedFighterCommand
-from .calcCommands.drone.projectedAdd import CalcAddProjectedDroneCommand
-from logbook import Logger
-import eos.db
-pyfalog = Logger(__name__)
-
-
-class GuiAddProjectedCommand(wx.Command):
-    def __init__(self, fitID, id, type='item'):
-        wx.Command.__init__(self, True, "Projected Add")
-        self.internalHistory = wx.CommandProcessor()
-        self.fitID = fitID
-        self.id = id
-        self.type = type
-
-    def Do(self):
-        result = False
-        # since we can project various types, we need to switch of the fit command. We can't do this switch easily in
-        # the fit command since each type might have a different kind of undo, easier to split it out
-        if self.type == 'item':
-            item = eos.db.getItem(self.id, eager=("attributes", "group.category"))
-
-            if item.category.name == "Drone":
-                result = self.internalHistory.Submit(CalcAddProjectedDroneCommand(
-                    fitID=self.fitID,
-                    droneInfo=DroneInfo(itemID=self.id, amount=1, amountActive=1)))
-            elif item.category.name == "Fighter":
-                result = self.internalHistory.Submit(CalcAddProjectedFighterCommand(self.fitID, fighterInfo=FighterInfo(itemID=self.id)))
-            else:
-                result = self.internalHistory.Submit(CalcAddProjectedModuleCommand(
-                    fitID=self.fitID,
-                    modInfo=ModuleInfo(itemID=self.id)))
-        elif self.type == 'fit':
-            result = self.internalHistory.Submit(CalcAddProjectedFitCommand(self.fitID, self.id, None))
-
-        if result:
-            Fit.getInstance().recalc(self.fitID)
-            wx.PostEvent(gui.mainFrame.MainFrame.getInstance(), GE.FitChanged(fitID=self.fitID))
-            return True
-        return False
-
-    def Undo(self):
-        for _ in self.internalHistory.Commands:
-            self.internalHistory.Undo()
-        Fit.getInstance().recalc(self.fitID)
-        wx.PostEvent(gui.mainFrame.MainFrame.getInstance(), GE.FitChanged(fitID=self.fitID))
-        return True
diff --git a/gui/fitCommands/guiChangeProjectedDroneQty.py b/gui/fitCommands/guiChangeProjectedDroneQty.py
deleted file mode 100644
index 9b5d89147..000000000
--- a/gui/fitCommands/guiChangeProjectedDroneQty.py
+++ /dev/null
@@ -1,32 +0,0 @@
-import wx
-import gui.mainFrame
-from gui import globalEvents as GE
-from .calcCommands.drone.projectedChangeAmount import CalcChangeProjectedDroneAmountCommand
-from service.fit import Fit
-from logbook import Logger
-pyfalog = Logger(__name__)
-
-
-class GuiChangeProjectedDroneQtyCommand(wx.Command):
-    def __init__(self, fitID, itemID, amount=1):
-        wx.Command.__init__(self, True, "")
-        self.fitID = fitID
-        self.itemID = itemID
-        self.amount = amount
-        self.internalHistory = wx.CommandProcessor()
-
-    def Do(self):
-        cmd = CalcChangeProjectedDroneAmountCommand(self.fitID, self.itemID, self.amount)
-        if self.internalHistory.Submit(cmd):
-            Fit.getInstance().recalc(self.fitID)
-            wx.PostEvent(gui.mainFrame.MainFrame.getInstance(), GE.FitChanged(fitID=self.fitID))
-            return True
-        return False
-
-    def Undo(self):
-        pyfalog.debug("{} Undo()".format(self))
-        for _ in self.internalHistory.Commands:
-            self.internalHistory.Undo()
-        Fit.getInstance().recalc(self.fitID)
-        wx.PostEvent(gui.mainFrame.MainFrame.getInstance(), GE.FitChanged(fitID=self.fitID))
-        return True
diff --git a/gui/fitCommands/guiChangeProjectedFighterAmount.py b/gui/fitCommands/guiChangeProjectedFighterAmount.py
deleted file mode 100644
index 192df296d..000000000
--- a/gui/fitCommands/guiChangeProjectedFighterAmount.py
+++ /dev/null
@@ -1,33 +0,0 @@
-import wx
-import gui.mainFrame
-from gui import globalEvents as GE
-from .calcCommands.fighter.changeAmount import CalcChangeFighterAmountCommand
-from service.fit import Fit
-from logbook import Logger
-pyfalog = Logger(__name__)
-
-
-class GuiChangeProjectedFighterAmountCommand(wx.Command):
-
-    def __init__(self, fitID, position, amount):
-        wx.Command.__init__(self, True, "")
-        self.fitID = fitID
-        self.position = position
-        self.amount = amount
-        self.internalHistory = wx.CommandProcessor()
-
-    def Do(self):
-        cmd = CalcChangeFighterAmountCommand(self.fitID, True, self.position, self.amount)
-        if self.internalHistory.Submit(cmd):
-            Fit.getInstance().recalc(self.fitID)
-            wx.PostEvent(gui.mainFrame.MainFrame.getInstance(), GE.FitChanged(fitID=self.fitID))
-            return True
-        return False
-
-    def Undo(self):
-        pyfalog.debug("{} Undo()".format(self))
-        for _ in self.internalHistory.Commands:
-            self.internalHistory.Undo()
-        Fit.getInstance().recalc(self.fitID)
-        wx.PostEvent(gui.mainFrame.MainFrame.getInstance(), GE.FitChanged(fitID=self.fitID))
-        return True
diff --git a/gui/fitCommands/guiChangeProjectedFitQty.py b/gui/fitCommands/guiChangeProjectedFitQty.py
deleted file mode 100644
index 0a2a8043e..000000000
--- a/gui/fitCommands/guiChangeProjectedFitQty.py
+++ /dev/null
@@ -1,32 +0,0 @@
-import wx
-import gui.mainFrame
-from gui import globalEvents as GE
-from .calcCommands.projectedFit.changeAmount import CalcChangeProjectedFitAmountCommand
-from service.fit import Fit
-from logbook import Logger
-pyfalog = Logger(__name__)
-
-
-class GuiChangeProjectedFitQtyCommand(wx.Command):
-    def __init__(self, fitID, pfitID, amount=1):
-        wx.Command.__init__(self, True, "")
-        self.fitID = fitID
-        self.pfitID = pfitID
-        self.amount = amount
-        self.internalHistory = wx.CommandProcessor()
-
-    def Do(self):
-        cmd = CalcChangeProjectedFitAmountCommand(self.fitID, self.pfitID, self.amount)
-        if self.internalHistory.Submit(cmd):
-            Fit.getInstance().recalc(self.fitID)
-            wx.PostEvent(gui.mainFrame.MainFrame.getInstance(), GE.FitChanged(fitID=self.fitID))
-            return True
-        return False
-
-    def Undo(self):
-        pyfalog.debug("{} Undo()".format(self))
-        for _ in self.internalHistory.Commands:
-            self.internalHistory.Undo()
-        Fit.getInstance().recalc(self.fitID)
-        wx.PostEvent(gui.mainFrame.MainFrame.getInstance(), GE.FitChanged(fitID=self.fitID))
-        return True
diff --git a/gui/fitCommands/guiRemoveProjected.py b/gui/fitCommands/guiRemoveProjected.py
deleted file mode 100644
index 697ae8b3d..000000000
--- a/gui/fitCommands/guiRemoveProjected.py
+++ /dev/null
@@ -1,69 +0,0 @@
-import wx
-from service.fit import Fit
-
-import gui.mainFrame
-from gui import globalEvents as GE
-from .calcCommands.module.projectedRemove import CalcRemoveProjectedModuleCommand
-from .calcCommands.projectedFit.remove import CalcRemoveProjectedFitCommand
-from .calcCommands.fighter.projectedRemove import CalcRemoveProjectedFighterCommand
-from logbook import Logger
-from .calcCommands.drone.projectedRemove import CalcRemoveProjectedDroneCommand
-
-from gui.fitCommands.helpers import DroneInfo
-from eos.saveddata.drone import Drone
-from eos.saveddata.module import Module
-from eos.saveddata.fighter import Fighter
-
-pyfalog = Logger(__name__)
-
-
-class GuiRemoveProjectedCommand(wx.Command):
-    mapping = {
-        'fit': CalcRemoveProjectedFitCommand,
-        'module': CalcRemoveProjectedModuleCommand,
-        'fighter': CalcRemoveProjectedFighterCommand,
-        'drone': CalcRemoveProjectedDroneCommand
-    }
-
-    def __init__(self, fitID, thing):
-        wx.Command.__init__(self, True, "Projected Remove")
-        self.internalHistory = wx.CommandProcessor()
-        self.fitID = fitID
-        fit = Fit.getInstance().getFit(fitID)
-
-        if isinstance(thing, Drone):
-            self.data = DroneInfo(itemID=thing.itemID, amount=1, amountActive=1)
-            self.type = 'drone'
-        elif isinstance(thing, Module):
-            self.type = 'module'
-            self.data = fit.projectedModules.index(thing)
-        elif isinstance(thing, Fighter):
-            self.data = fit.projectedFighters.index(thing)
-            self.type = 'fighter'
-        else:
-            # todo: fix!
-            self.data = thing.ID
-            self.type = 'fit'
-
-    def Do(self):
-        result = False
-        # since we can project various types, we need to switch of the fit command. We can't do this switch easily in
-        # the fit command since each type might have a different kind of undo, easier to split it out
-
-        cls = self.mapping.get(self.type, None)
-        if cls:
-            cmd = cls(self.fitID, self.data)
-            result = self.internalHistory.Submit(cmd)
-
-        if result:
-            Fit.getInstance().recalc(self.fitID)
-            wx.PostEvent(gui.mainFrame.MainFrame.getInstance(), GE.FitChanged(fitID=self.fitID))
-            return True
-        return False
-
-    def Undo(self):
-        for _ in self.internalHistory.Commands:
-            self.internalHistory.Undo()
-        Fit.getInstance().recalc(self.fitID)
-        wx.PostEvent(gui.mainFrame.MainFrame.getInstance(), GE.FitChanged(fitID=self.fitID))
-        return True
diff --git a/gui/fitCommands/guiToggleProjected.py b/gui/fitCommands/guiToggleProjected.py
deleted file mode 100644
index e4bbc14fd..000000000
--- a/gui/fitCommands/guiToggleProjected.py
+++ /dev/null
@@ -1,55 +0,0 @@
-import wx
-
-import gui.mainFrame
-from eos.saveddata.drone import Drone as DroneType
-from eos.saveddata.fighter import Fighter as FighterType
-from eos.saveddata.fit import Fit as FitType
-from eos.saveddata.module import Module as ModuleType
-from gui import globalEvents as GE
-from service.fit import Fit
-from .calcCommands.drone.projectedToggleState import CalcToggleProjectedDroneStateCommand
-from .calcCommands.fighter.toggleState import CalcToggleFighterStateCommand
-from .calcCommands.projectedFit.toggleState import CalcToggleProjectedFitCommand
-from .calcCommands.module.projectedChangeState import CalcChangeProjectedModuleStateCommand
-
-
-class GuiToggleProjectedCommand(wx.Command):
-
-    def __init__(self, fitID, thing, click):
-        wx.Command.__init__(self, True, "Toggle Projected Item")
-        self.internalHistory = wx.CommandProcessor()
-        self.fitID = fitID
-        fit = Fit.getInstance().getFit(self.fitID)
-        if isinstance(thing, FitType):
-            self.commandType = CalcToggleProjectedFitCommand
-            self.args = (self.fitID, thing.ID)
-        elif isinstance(thing, ModuleType):
-            position = fit.projectedModules.index(thing)
-            self.commandType = CalcChangeProjectedModuleStateCommand
-            self.args = (self.fitID, position, click)
-        elif isinstance(thing, DroneType):
-            self.commandType = CalcToggleProjectedDroneStateCommand
-            self.args = (self.fitID, thing.itemID)
-        elif isinstance(thing, FighterType):
-            position = fit.projectedFighters.index(thing)
-            self.commandType = CalcToggleFighterStateCommand
-            self.args = (self.fitID, True, position)
-        else:
-            self.commandType = None
-            self.args = ()
-
-    def Do(self):
-        if self.commandType is None:
-            return False
-        if not self.internalHistory.Submit(self.commandType(*self.args)):
-            return False
-        Fit.getInstance().recalc(self.fitID)
-        wx.PostEvent(gui.mainFrame.MainFrame.getInstance(), GE.FitChanged(fitID=self.fitID))
-        return True
-
-    def Undo(self):
-        for _ in self.internalHistory.Commands:
-            self.internalHistory.Undo()
-        Fit.getInstance().recalc(self.fitID)
-        wx.PostEvent(gui.mainFrame.MainFrame.getInstance(), GE.FitChanged(fitID=self.fitID))
-        return True
diff --git a/gui/fitCommands/drone/__init__.py b/gui/fitCommands/localDrone/__init__.py
similarity index 100%
rename from gui/fitCommands/drone/__init__.py
rename to gui/fitCommands/localDrone/__init__.py
diff --git a/gui/fitCommands/drone/add.py b/gui/fitCommands/localDrone/add.py
similarity index 78%
rename from gui/fitCommands/drone/add.py
rename to gui/fitCommands/localDrone/add.py
index d4f3d1267..2097f475b 100644
--- a/gui/fitCommands/drone/add.py
+++ b/gui/fitCommands/localDrone/add.py
@@ -7,16 +7,17 @@ from gui.fitCommands.helpers import DroneInfo, InternalCommandHistory
 from service.fit import Fit
 
 
-class GuiAddDroneCommand(wx.Command):
+class GuiAddLocalDroneCommand(wx.Command):
 
-    def __init__(self, fitID, itemID):
-        wx.Command.__init__(self, True, 'Add Drone')
+    def __init__(self, fitID, itemID, amount):
+        wx.Command.__init__(self, True, 'Add Local Drone')
         self.internalHistory = InternalCommandHistory()
         self.fitID = fitID
         self.itemID = itemID
+        self.amount = amount
 
     def Do(self):
-        cmd = CalcAddLocalDroneCommand(fitID=self.fitID, droneInfo=DroneInfo(itemID=self.itemID, amount=1, amountActive=0))
+        cmd = CalcAddLocalDroneCommand(fitID=self.fitID, droneInfo=DroneInfo(itemID=self.itemID, amount=self.amount, amountActive=0))
         if self.internalHistory.submit(cmd):
             Fit.getInstance().recalc(self.fitID)
             wx.PostEvent(gui.mainFrame.MainFrame.getInstance(), GE.FitChanged(fitID=self.fitID))
diff --git a/gui/fitCommands/drone/changeAmount.py b/gui/fitCommands/localDrone/changeAmount.py
similarity index 92%
rename from gui/fitCommands/drone/changeAmount.py
rename to gui/fitCommands/localDrone/changeAmount.py
index 886570c98..e0da9c824 100644
--- a/gui/fitCommands/drone/changeAmount.py
+++ b/gui/fitCommands/localDrone/changeAmount.py
@@ -10,10 +10,10 @@ from gui.fitCommands.helpers import InternalCommandHistory
 from service.fit import Fit
 
 
-class GuiChangeDroneAmountCommand(wx.Command):
+class GuiChangeLocalDroneAmountCommand(wx.Command):
 
     def __init__(self, fitID, position, amount):
-        wx.Command.__init__(self, True, 'Change Drone Amount')
+        wx.Command.__init__(self, True, 'Change Local Drone Amount')
         self.internalHistory = InternalCommandHistory()
         self.fitID = fitID
         self.position = position
diff --git a/gui/fitCommands/drone/remove.py b/gui/fitCommands/localDrone/remove.py
similarity index 90%
rename from gui/fitCommands/drone/remove.py
rename to gui/fitCommands/localDrone/remove.py
index 5fd70b0d8..9cc5b03bf 100644
--- a/gui/fitCommands/drone/remove.py
+++ b/gui/fitCommands/localDrone/remove.py
@@ -7,10 +7,10 @@ from gui.fitCommands.helpers import InternalCommandHistory
 from service.fit import Fit
 
 
-class GuiRemoveDroneCommand(wx.Command):
+class GuiRemoveLocalDroneCommand(wx.Command):
 
     def __init__(self, fitID, position, amount):
-        wx.Command.__init__(self, True, 'Remove Drone')
+        wx.Command.__init__(self, True, 'Remove Local Drone')
         self.internalHistory = InternalCommandHistory()
         self.fitID = fitID
         self.position = position
diff --git a/gui/fitCommands/drone/toggleState.py b/gui/fitCommands/localDrone/toggleState.py
similarity index 89%
rename from gui/fitCommands/drone/toggleState.py
rename to gui/fitCommands/localDrone/toggleState.py
index 73cfafac3..c1e2b9a4c 100644
--- a/gui/fitCommands/drone/toggleState.py
+++ b/gui/fitCommands/localDrone/toggleState.py
@@ -7,10 +7,10 @@ from gui.fitCommands.helpers import InternalCommandHistory
 from service.fit import Fit
 
 
-class GuiToggleDroneStateCommand(wx.Command):
+class GuiToggleLocalDroneStateCommand(wx.Command):
 
     def __init__(self, fitID, position):
-        wx.Command.__init__(self, True, 'Toggle Drone State')
+        wx.Command.__init__(self, True, 'Toggle Local Drone State')
         self.internalHistory = InternalCommandHistory()
         self.fitID = fitID
         self.position = position
diff --git a/gui/fitCommands/fighter/__init__.py b/gui/fitCommands/localFighter/__init__.py
similarity index 100%
rename from gui/fitCommands/fighter/__init__.py
rename to gui/fitCommands/localFighter/__init__.py
diff --git a/gui/fitCommands/fighter/abilityToggleState.py b/gui/fitCommands/localFighter/abilityToggleState.py
similarity index 88%
rename from gui/fitCommands/fighter/abilityToggleState.py
rename to gui/fitCommands/localFighter/abilityToggleState.py
index 8453bc7e7..7f7489ad4 100644
--- a/gui/fitCommands/fighter/abilityToggleState.py
+++ b/gui/fitCommands/localFighter/abilityToggleState.py
@@ -7,10 +7,10 @@ from gui.fitCommands.helpers import InternalCommandHistory
 from service.fit import Fit
 
 
-class GuiToggleFighterAbilityCommand(wx.Command):
+class GuiToggleLocalFighterAbilityStateCommand(wx.Command):
 
     def __init__(self, fitID, position, effectID):
-        wx.Command.__init__(self, True, 'Toggle Fighter Ability State')
+        wx.Command.__init__(self, True, 'Toggle Local Fighter Ability State')
         self.internalHistory = InternalCommandHistory()
         self.fitID = fitID
         self.position = position
diff --git a/gui/fitCommands/fighter/add.py b/gui/fitCommands/localFighter/add.py
similarity index 90%
rename from gui/fitCommands/fighter/add.py
rename to gui/fitCommands/localFighter/add.py
index eb842563d..608ad8951 100644
--- a/gui/fitCommands/fighter/add.py
+++ b/gui/fitCommands/localFighter/add.py
@@ -7,10 +7,10 @@ from gui.fitCommands.helpers import FighterInfo, InternalCommandHistory
 from service.fit import Fit
 
 
-class GuiAddFighterCommand(wx.Command):
+class GuiAddLocalFighterCommand(wx.Command):
 
     def __init__(self, fitID, itemID):
-        wx.Command.__init__(self, True, 'Add Fighter')
+        wx.Command.__init__(self, True, 'Add Local Fighter')
         self.internalHistory = InternalCommandHistory()
         self.fitID = fitID
         self.itemID = itemID
diff --git a/gui/fitCommands/fighter/changeAmount.py b/gui/fitCommands/localFighter/changeAmount.py
similarity index 92%
rename from gui/fitCommands/fighter/changeAmount.py
rename to gui/fitCommands/localFighter/changeAmount.py
index 38231857f..e18da0087 100644
--- a/gui/fitCommands/fighter/changeAmount.py
+++ b/gui/fitCommands/localFighter/changeAmount.py
@@ -8,10 +8,10 @@ from gui.fitCommands.helpers import InternalCommandHistory
 from service.fit import Fit
 
 
-class GuiChangeFighterAmountCommand(wx.Command):
+class GuiChangeLocalFighterAmountCommand(wx.Command):
 
     def __init__(self, fitID, position, amount):
-        wx.Command.__init__(self, True, 'Change Fighter Amount')
+        wx.Command.__init__(self, True, 'Change Local Fighter Amount')
         self.internalHistory = InternalCommandHistory()
         self.fitID = fitID
         self.position = position
diff --git a/gui/fitCommands/fighter/remove.py b/gui/fitCommands/localFighter/remove.py
similarity index 89%
rename from gui/fitCommands/fighter/remove.py
rename to gui/fitCommands/localFighter/remove.py
index 0430e3069..ade856990 100644
--- a/gui/fitCommands/fighter/remove.py
+++ b/gui/fitCommands/localFighter/remove.py
@@ -7,10 +7,10 @@ from gui.fitCommands.helpers import InternalCommandHistory
 from service.fit import Fit
 
 
-class GuiRemoveFighterCommand(wx.Command):
+class GuiRemoveLocalFighterCommand(wx.Command):
 
     def __init__(self, fitID, position):
-        wx.Command.__init__(self, True, 'Remove Fighter')
+        wx.Command.__init__(self, True, 'Remove Local Fighter')
         self.internalHistory = InternalCommandHistory()
         self.fitID = fitID
         self.position = position
diff --git a/gui/fitCommands/fighter/toggleState.py b/gui/fitCommands/localFighter/toggleState.py
similarity index 88%
rename from gui/fitCommands/fighter/toggleState.py
rename to gui/fitCommands/localFighter/toggleState.py
index 940c0d1f3..6a7f63433 100644
--- a/gui/fitCommands/fighter/toggleState.py
+++ b/gui/fitCommands/localFighter/toggleState.py
@@ -7,10 +7,10 @@ from gui.fitCommands.helpers import InternalCommandHistory
 from service.fit import Fit
 
 
-class GuiToggleFighterCommand(wx.Command):
+class GuiToggleLocalFighterStateCommand(wx.Command):
 
     def __init__(self, fitID, position):
-        wx.Command.__init__(self, True, 'Toggle Fighter State')
+        wx.Command.__init__(self, True, 'Toggle Local Fighter State')
         self.internalHistory = InternalCommandHistory()
         self.fitID = fitID
         self.position = position
diff --git a/gui/fitCommands/module/__init__.py b/gui/fitCommands/localModule/__init__.py
similarity index 100%
rename from gui/fitCommands/module/__init__.py
rename to gui/fitCommands/localModule/__init__.py
diff --git a/gui/fitCommands/module/add.py b/gui/fitCommands/localModule/add.py
similarity index 95%
rename from gui/fitCommands/module/add.py
rename to gui/fitCommands/localModule/add.py
index daa464491..5f518d86b 100644
--- a/gui/fitCommands/module/add.py
+++ b/gui/fitCommands/localModule/add.py
@@ -10,10 +10,10 @@ from service.fit import Fit
 from service.market import Market
 
 
-class GuiAddModuleCommand(wx.Command):
+class GuiAddLocalModuleCommand(wx.Command):
 
     def __init__(self, fitID, itemID, position=None):
-        wx.Command.__init__(self, True, 'Add Module')
+        wx.Command.__init__(self, True, 'Add Local Module')
         self.internalHistory = InternalCommandHistory()
         self.fitID = fitID
         self.itemID = itemID
diff --git a/gui/fitCommands/module/changeCharges.py b/gui/fitCommands/localModule/changeCharges.py
similarity index 76%
rename from gui/fitCommands/module/changeCharges.py
rename to gui/fitCommands/localModule/changeCharges.py
index edf2b37dd..c325dc844 100644
--- a/gui/fitCommands/module/changeCharges.py
+++ b/gui/fitCommands/localModule/changeCharges.py
@@ -7,17 +7,17 @@ from gui.fitCommands.helpers import InternalCommandHistory
 from service.fit import Fit
 
 
-class GuiChangeModuleChargesCommand(wx.Command):
+class GuiChangeLocalModuleChargesCommand(wx.Command):
 
-    def __init__(self, fitID, itemID, modules):
-        wx.Command.__init__(self, True, 'Change Module Charges')
+    def __init__(self, fitID, modules, chargeItemID):
+        wx.Command.__init__(self, True, 'Change Local Module Charges')
         self.internalHistory = InternalCommandHistory()
         self.fitID = fitID
-        self.itemID = itemID
         self.positions = [mod.modPosition for mod in modules]
+        self.chargeItemID = chargeItemID
 
     def Do(self):
-        cmd = CalcChangeModuleChargesCommand(fitID=self.fitID, projected=False, chargeMap={p: self.itemID for p in self.positions})
+        cmd = CalcChangeModuleChargesCommand(fitID=self.fitID, projected=False, chargeMap={p: self.chargeItemID for p in self.positions})
         if self.internalHistory.submit(cmd):
             Fit.getInstance().recalc(self.fitID)
             wx.PostEvent(gui.mainFrame.MainFrame.getInstance(), GE.FitChanged(fitID=self.fitID))
diff --git a/gui/fitCommands/module/changeSpool.py b/gui/fitCommands/localModule/changeSpool.py
similarity index 90%
rename from gui/fitCommands/module/changeSpool.py
rename to gui/fitCommands/localModule/changeSpool.py
index 56c4ea68c..17973008e 100644
--- a/gui/fitCommands/module/changeSpool.py
+++ b/gui/fitCommands/localModule/changeSpool.py
@@ -7,10 +7,10 @@ from gui.fitCommands.helpers import InternalCommandHistory
 from service.fit import Fit
 
 
-class GuiChangeModuleSpoolCommand(wx.Command):
+class GuiChangeLocalModuleSpoolCommand(wx.Command):
 
     def __init__(self, fitID, position, spoolType, spoolAmount):
-        wx.Command.__init__(self, True, 'Change Module Spool')
+        wx.Command.__init__(self, True, 'Change Local Module Spool')
         self.internalHistory = InternalCommandHistory()
         self.fitID = fitID
         self.position = position
diff --git a/gui/fitCommands/module/changeStates.py b/gui/fitCommands/localModule/changeStates.py
similarity index 90%
rename from gui/fitCommands/module/changeStates.py
rename to gui/fitCommands/localModule/changeStates.py
index 8db0647f9..100826178 100644
--- a/gui/fitCommands/module/changeStates.py
+++ b/gui/fitCommands/localModule/changeStates.py
@@ -7,10 +7,10 @@ from gui.fitCommands.helpers import InternalCommandHistory
 from service.fit import Fit
 
 
-class GuiChangeModuleStatesCommand(wx.Command):
+class GuiChangeLocalModuleStatesCommand(wx.Command):
 
     def __init__(self, fitID, mainPosition, positions, click):
-        wx.Command.__init__(self, True, 'Change Module States')
+        wx.Command.__init__(self, True, 'Change Local Module States')
         self.internalHistory = InternalCommandHistory()
         self.fitID = fitID
         self.mainPosition = mainPosition
diff --git a/gui/fitCommands/module/fill.py b/gui/fitCommands/localModule/fill.py
similarity index 90%
rename from gui/fitCommands/module/fill.py
rename to gui/fitCommands/localModule/fill.py
index 97d47b53e..0af5b4373 100644
--- a/gui/fitCommands/module/fill.py
+++ b/gui/fitCommands/localModule/fill.py
@@ -7,10 +7,10 @@ from gui.fitCommands.helpers import InternalCommandHistory, ModuleInfo
 from service.fit import Fit
 
 
-class GuiFillWithModulesCommand(wx.Command):
+class GuiFillWithLocalModulesCommand(wx.Command):
 
     def __init__(self, fitID, itemID):
-        wx.Command.__init__(self, True, 'Fill with Modules')
+        wx.Command.__init__(self, True, 'Fill with Local Modules')
         self.internalHistory = InternalCommandHistory()
         self.fitID = fitID
         self.itemID = itemID
diff --git a/gui/fitCommands/module/mutatedConvert.py b/gui/fitCommands/localModule/mutatedConvert.py
similarity index 92%
rename from gui/fitCommands/module/mutatedConvert.py
rename to gui/fitCommands/localModule/mutatedConvert.py
index b768c723c..f13ce3e50 100644
--- a/gui/fitCommands/module/mutatedConvert.py
+++ b/gui/fitCommands/localModule/mutatedConvert.py
@@ -7,10 +7,10 @@ from gui.fitCommands.helpers import InternalCommandHistory, ModuleInfo
 from service.fit import Fit
 
 
-class GuiConvertMutatedModuleCommand(wx.Command):
+class GuiConvertMutatedLocalModuleCommand(wx.Command):
 
     def __init__(self, fitID, position, mutaplasmid):
-        wx.Command.__init__(self, True, 'Convert Module to Mutated')
+        wx.Command.__init__(self, True, 'Convert Local Module to Mutated')
         self.internalHistory = InternalCommandHistory()
         self.fitID = fitID
         self.position = position
diff --git a/gui/fitCommands/module/mutatedImport.py b/gui/fitCommands/localModule/mutatedImport.py
similarity index 91%
rename from gui/fitCommands/module/mutatedImport.py
rename to gui/fitCommands/localModule/mutatedImport.py
index be629c115..0ae755432 100644
--- a/gui/fitCommands/module/mutatedImport.py
+++ b/gui/fitCommands/localModule/mutatedImport.py
@@ -7,10 +7,10 @@ from gui.fitCommands.helpers import InternalCommandHistory, ModuleInfo
 from service.fit import Fit
 
 
-class GuiImportMutatedModuleCommand(wx.Command):
+class GuiImportLocalMutatedModuleCommand(wx.Command):
 
     def __init__(self, fitID, baseItem, mutaplasmid, mutations):
-        wx.Command.__init__(self, True, 'Import Mutated Module')
+        wx.Command.__init__(self, True, 'Import Local Mutated Module')
         self.internalHistory = InternalCommandHistory()
         self.fitID = fitID
         self.newModInfo = ModuleInfo(
diff --git a/gui/fitCommands/module/mutatedRevert.py b/gui/fitCommands/localModule/mutatedRevert.py
similarity index 91%
rename from gui/fitCommands/module/mutatedRevert.py
rename to gui/fitCommands/localModule/mutatedRevert.py
index 1278aebe2..1265687b7 100644
--- a/gui/fitCommands/module/mutatedRevert.py
+++ b/gui/fitCommands/localModule/mutatedRevert.py
@@ -7,10 +7,10 @@ from gui.fitCommands.helpers import InternalCommandHistory, ModuleInfo
 from service.fit import Fit
 
 
-class GuiRevertMutatedModuleCommand(wx.Command):
+class GuiRevertMutatedLocalModuleCommand(wx.Command):
 
     def __init__(self, fitID, position):
-        wx.Command.__init__(self, True, 'Revert Module from Mutated')
+        wx.Command.__init__(self, True, 'Revert Local Module from Mutated')
         self.internalHistory = InternalCommandHistory()
         self.fitID = fitID
         self.position = position
diff --git a/gui/fitCommands/module/remove.py b/gui/fitCommands/localModule/remove.py
similarity index 92%
rename from gui/fitCommands/module/remove.py
rename to gui/fitCommands/localModule/remove.py
index e40fc5831..eb3fe57b0 100644
--- a/gui/fitCommands/module/remove.py
+++ b/gui/fitCommands/localModule/remove.py
@@ -7,10 +7,10 @@ from gui.fitCommands.helpers import InternalCommandHistory, ModuleInfo
 from service.fit import Fit
 
 
-class GuiRemoveModuleCommand(wx.Command):
+class GuiRemoveLocalModuleCommand(wx.Command):
 
     def __init__(self, fitID, modules):
-        wx.Command.__init__(self, True, 'Remove Module')
+        wx.Command.__init__(self, True, 'Remove Local Module')
         self.internalHistory = InternalCommandHistory()
         self.fitID = fitID
         self.modCache = {mod.modPosition: ModuleInfo.fromModule(mod) for mod in modules if not mod.isEmpty}
diff --git a/gui/fitCommands/projectedDrone/__init__.py b/gui/fitCommands/projectedDrone/__init__.py
new file mode 100644
index 000000000..e69de29bb
diff --git a/gui/fitCommands/projectedDrone/add.py b/gui/fitCommands/projectedDrone/add.py
new file mode 100644
index 000000000..7f765691f
--- /dev/null
+++ b/gui/fitCommands/projectedDrone/add.py
@@ -0,0 +1,30 @@
+import wx
+
+import gui.mainFrame
+from gui import globalEvents as GE
+from gui.fitCommands.calcCommands.drone.projectedAdd import CalcAddProjectedDroneCommand
+from gui.fitCommands.helpers import DroneInfo, InternalCommandHistory
+from service.fit import Fit
+
+
+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))
+        if self.internalHistory.submit(cmd):
+            Fit.getInstance().recalc(self.fitID)
+            wx.PostEvent(gui.mainFrame.MainFrame.getInstance(), GE.FitChanged(fitID=self.fitID))
+            return True
+        return False
+
+    def Undo(self):
+        success = self.internalHistory.undoAll()
+        Fit.getInstance().recalc(self.fitID)
+        wx.PostEvent(gui.mainFrame.MainFrame.getInstance(), GE.FitChanged(fitID=self.fitID))
+        return success
diff --git a/gui/fitCommands/projectedDrone/changeAmount.py b/gui/fitCommands/projectedDrone/changeAmount.py
new file mode 100644
index 000000000..c415b1a4c
--- /dev/null
+++ b/gui/fitCommands/projectedDrone/changeAmount.py
@@ -0,0 +1,41 @@
+import math
+
+import wx
+
+import gui.mainFrame
+from gui import globalEvents as GE
+from gui.fitCommands.calcCommands.drone.projectedChangeAmount import CalcChangeProjectedDroneAmountCommand
+from gui.fitCommands.calcCommands.drone.projectedRemove import CalcRemoveProjectedDroneCommand
+from gui.fitCommands.helpers import DroneInfo, InternalCommandHistory
+from service.fit import Fit
+
+
+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)
+            if self.internalHistory.submit(cmd):
+                Fit.getInstance().recalc(self.fitID)
+                wx.PostEvent(gui.mainFrame.MainFrame.getInstance(), GE.FitChanged(fitID=self.fitID))
+                return True
+        else:
+            cmd = CalcRemoveProjectedDroneCommand(fitID=self.fitID, droneInfo=DroneInfo(itemID=self.itemID, amount=math.inf, amountActive=math.inf))
+            if self.internalHistory.submit(cmd):
+                Fit.getInstance().recalc(self.fitID)
+                wx.PostEvent(gui.mainFrame.MainFrame.getInstance(), GE.FitChanged(fitID=self.fitID))
+                return True
+        return False
+
+    def Undo(self):
+        success = self.internalHistory.undoAll()
+        Fit.getInstance().recalc(self.fitID)
+        wx.PostEvent(gui.mainFrame.MainFrame.getInstance(), GE.FitChanged(fitID=self.fitID))
+        return success
diff --git a/gui/fitCommands/projectedDrone/remove.py b/gui/fitCommands/projectedDrone/remove.py
new file mode 100644
index 000000000..8d115ac99
--- /dev/null
+++ b/gui/fitCommands/projectedDrone/remove.py
@@ -0,0 +1,31 @@
+import wx
+
+import gui.mainFrame
+from gui import globalEvents as GE
+from gui.fitCommands.calcCommands.drone.projectedRemove import CalcRemoveProjectedDroneCommand
+from gui.fitCommands.helpers import DroneInfo, InternalCommandHistory
+from service.fit import Fit
+
+
+class GuiRemoveProjectedDroneCommand(wx.Command):
+
+    def __init__(self, fitID, itemID, amount):
+        wx.Command.__init__(self, True, 'Remove Projected Drone')
+        self.internalHistory = InternalCommandHistory()
+        self.fitID = fitID
+        self.itemID = itemID
+        self.amount = amount
+
+    def Do(self):
+        cmd = CalcRemoveProjectedDroneCommand(fitID=self.fitID, droneInfo=DroneInfo(itemID=self.itemID, amount=self.amount, amountActive=self.amount))
+        if self.internalHistory.submit(cmd):
+            Fit.getInstance().recalc(self.fitID)
+            wx.PostEvent(gui.mainFrame.MainFrame.getInstance(), GE.FitChanged(fitID=self.fitID))
+            return True
+        return False
+
+    def Undo(self):
+        success = self.internalHistory.undoAll()
+        Fit.getInstance().recalc(self.fitID)
+        wx.PostEvent(gui.mainFrame.MainFrame.getInstance(), GE.FitChanged(fitID=self.fitID))
+        return success
diff --git a/gui/fitCommands/projectedDrone/toggleState.py b/gui/fitCommands/projectedDrone/toggleState.py
new file mode 100644
index 000000000..197b959b2
--- /dev/null
+++ b/gui/fitCommands/projectedDrone/toggleState.py
@@ -0,0 +1,30 @@
+import wx
+
+import gui.mainFrame
+from gui import globalEvents as GE
+from gui.fitCommands.calcCommands.drone.projectedToggleState import CalcToggleProjectedDroneStateCommand
+from gui.fitCommands.helpers import InternalCommandHistory
+from service.fit import Fit
+
+
+class GuiToggleProjectedDroneStateCommand(wx.Command):
+
+    def __init__(self, fitID, itemID):
+        wx.Command.__init__(self, True, 'Toggle Projected Drone State')
+        self.internalHistory = InternalCommandHistory()
+        self.fitID = fitID
+        self.itemID = itemID
+
+    def Do(self):
+        cmd = CalcToggleProjectedDroneStateCommand(fitID=self.fitID, itemID=self.itemID)
+        if self.internalHistory.submit(cmd):
+            Fit.getInstance().recalc(self.fitID)
+            wx.PostEvent(gui.mainFrame.MainFrame.getInstance(), GE.FitChanged(fitID=self.fitID))
+            return True
+        return False
+
+    def Undo(self):
+        success = self.internalHistory.undoAll()
+        Fit.getInstance().recalc(self.fitID)
+        wx.PostEvent(gui.mainFrame.MainFrame.getInstance(), GE.FitChanged(fitID=self.fitID))
+        return success
diff --git a/gui/fitCommands/projectedFighter/__init__.py b/gui/fitCommands/projectedFighter/__init__.py
new file mode 100644
index 000000000..e69de29bb
diff --git a/gui/fitCommands/projectedFighter/abilityToggleState.py b/gui/fitCommands/projectedFighter/abilityToggleState.py
new file mode 100644
index 000000000..2e1b76027
--- /dev/null
+++ b/gui/fitCommands/projectedFighter/abilityToggleState.py
@@ -0,0 +1,31 @@
+import wx
+
+import gui.mainFrame
+from gui import globalEvents as GE
+from gui.fitCommands.calcCommands.fighter.abilityToggleState import CalcToggleFighterAbilityStateCommand
+from gui.fitCommands.helpers import InternalCommandHistory
+from service.fit import Fit
+
+
+class GuiToggleProjectedFighterAbilityStateCommand(wx.Command):
+
+    def __init__(self, fitID, position, effectID):
+        wx.Command.__init__(self, True, 'Toggle Projected Fighter Ability State')
+        self.internalHistory = InternalCommandHistory()
+        self.fitID = fitID
+        self.position = position
+        self.effectID = effectID
+
+    def Do(self):
+        cmd = CalcToggleFighterAbilityStateCommand(fitID=self.fitID, projected=True, position=self.position, effectID=self.effectID)
+        if self.internalHistory.submit(cmd):
+            Fit.getInstance().recalc(self.fitID)
+            wx.PostEvent(gui.mainFrame.MainFrame.getInstance(), GE.FitChanged(fitID=self.fitID))
+            return True
+        return False
+
+    def Undo(self):
+        success = self.internalHistory.undoAll()
+        Fit.getInstance().recalc(self.fitID)
+        wx.PostEvent(gui.mainFrame.MainFrame.getInstance(), GE.FitChanged(fitID=self.fitID))
+        return success
diff --git a/gui/fitCommands/projectedFighter/add.py b/gui/fitCommands/projectedFighter/add.py
new file mode 100644
index 000000000..85c0f2146
--- /dev/null
+++ b/gui/fitCommands/projectedFighter/add.py
@@ -0,0 +1,30 @@
+import wx
+
+import gui.mainFrame
+from gui import globalEvents as GE
+from gui.fitCommands.calcCommands.fighter.projectedAdd import CalcAddProjectedFighterCommand
+from gui.fitCommands.helpers import FighterInfo, InternalCommandHistory
+from service.fit import Fit
+
+
+class GuiAddProjectedFighterCommand(wx.Command):
+
+    def __init__(self, fitID, itemID):
+        wx.Command.__init__(self, True, 'Add Projected Fighter')
+        self.internalHistory = InternalCommandHistory()
+        self.fitID = fitID
+        self.itemID = itemID
+
+    def Do(self):
+        cmd = CalcAddProjectedFighterCommand(fitID=self.fitID, fighterInfo=FighterInfo(itemID=self.itemID))
+        if self.internalHistory.submit(cmd):
+            Fit.getInstance().recalc(self.fitID)
+            wx.PostEvent(gui.mainFrame.MainFrame.getInstance(), GE.FitChanged(fitID=self.fitID))
+            return True
+        return False
+
+    def Undo(self):
+        success = self.internalHistory.undoAll()
+        Fit.getInstance().recalc(self.fitID)
+        wx.PostEvent(gui.mainFrame.MainFrame.getInstance(), GE.FitChanged(fitID=self.fitID))
+        return success
diff --git a/gui/fitCommands/projectedFighter/changeAmount.py b/gui/fitCommands/projectedFighter/changeAmount.py
new file mode 100644
index 000000000..3c72e63ec
--- /dev/null
+++ b/gui/fitCommands/projectedFighter/changeAmount.py
@@ -0,0 +1,39 @@
+import wx
+
+import gui.mainFrame
+from gui import globalEvents as GE
+from gui.fitCommands.calcCommands.fighter.changeAmount import CalcChangeFighterAmountCommand
+from gui.fitCommands.calcCommands.fighter.projectedRemove import CalcRemoveProjectedFighterCommand
+from gui.fitCommands.helpers import InternalCommandHistory
+from service.fit import Fit
+
+
+class GuiChangeProjectedFighterAmountCommand(wx.Command):
+
+    def __init__(self, fitID, position, amount):
+        wx.Command.__init__(self, True, 'Change Projected 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=True, position=self.position, amount=self.amount)
+            if self.internalHistory.submit(cmd):
+                Fit.getInstance().recalc(self.fitID)
+                wx.PostEvent(gui.mainFrame.MainFrame.getInstance(), GE.FitChanged(fitID=self.fitID))
+                return True
+        else:
+            cmd = CalcRemoveProjectedFighterCommand(fitID=self.fitID, position=self.position)
+            if self.internalHistory.submit(cmd):
+                Fit.getInstance().recalc(self.fitID)
+                wx.PostEvent(gui.mainFrame.MainFrame.getInstance(), GE.FitChanged(fitID=self.fitID))
+                return True
+        return False
+
+    def Undo(self):
+        success = self.internalHistory.undoAll()
+        Fit.getInstance().recalc(self.fitID)
+        wx.PostEvent(gui.mainFrame.MainFrame.getInstance(), GE.FitChanged(fitID=self.fitID))
+        return success
diff --git a/gui/fitCommands/projectedFighter/remove.py b/gui/fitCommands/projectedFighter/remove.py
new file mode 100644
index 000000000..579b7d890
--- /dev/null
+++ b/gui/fitCommands/projectedFighter/remove.py
@@ -0,0 +1,30 @@
+import wx
+
+import gui.mainFrame
+from gui import globalEvents as GE
+from gui.fitCommands.calcCommands.fighter.projectedRemove import CalcRemoveProjectedFighterCommand
+from gui.fitCommands.helpers import InternalCommandHistory
+from service.fit import Fit
+
+
+class GuiRemoveProjectedFighterCommand(wx.Command):
+
+    def __init__(self, fitID, position):
+        wx.Command.__init__(self, True, 'Remove Projected Fighter')
+        self.internalHistory = InternalCommandHistory()
+        self.fitID = fitID
+        self.position = position
+
+    def Do(self):
+        cmd = CalcRemoveProjectedFighterCommand(fitID=self.fitID, position=self.position)
+        if self.internalHistory.submit(cmd):
+            Fit.getInstance().recalc(self.fitID)
+            wx.PostEvent(gui.mainFrame.MainFrame.getInstance(), GE.FitChanged(fitID=self.fitID))
+            return True
+        return False
+
+    def Undo(self):
+        success = self.internalHistory.undoAll()
+        Fit.getInstance().recalc(self.fitID)
+        wx.PostEvent(gui.mainFrame.MainFrame.getInstance(), GE.FitChanged(fitID=self.fitID))
+        return success
diff --git a/gui/fitCommands/projectedFighter/toggleState.py b/gui/fitCommands/projectedFighter/toggleState.py
new file mode 100644
index 000000000..ba2d23abf
--- /dev/null
+++ b/gui/fitCommands/projectedFighter/toggleState.py
@@ -0,0 +1,30 @@
+import wx
+
+import gui.mainFrame
+from gui import globalEvents as GE
+from gui.fitCommands.calcCommands.fighter.toggleState import CalcToggleFighterStateCommand
+from gui.fitCommands.helpers import InternalCommandHistory
+from service.fit import Fit
+
+
+class GuiToggleProjectedFighterStateCommand(wx.Command):
+
+    def __init__(self, fitID, position):
+        wx.Command.__init__(self, True, 'Toggle Projected Fighter State')
+        self.internalHistory = InternalCommandHistory()
+        self.fitID = fitID
+        self.position = position
+
+    def Do(self):
+        cmd = CalcToggleFighterStateCommand(fitID=self.fitID, projected=True, position=self.position)
+        if self.internalHistory.submit(cmd):
+            Fit.getInstance().recalc(self.fitID)
+            wx.PostEvent(gui.mainFrame.MainFrame.getInstance(), GE.FitChanged(fitID=self.fitID))
+            return True
+        return False
+
+    def Undo(self):
+        success = self.internalHistory.undoAll()
+        Fit.getInstance().recalc(self.fitID)
+        wx.PostEvent(gui.mainFrame.MainFrame.getInstance(), GE.FitChanged(fitID=self.fitID))
+        return success
diff --git a/gui/fitCommands/projectedFit/__init__.py b/gui/fitCommands/projectedFit/__init__.py
new file mode 100644
index 000000000..e69de29bb
diff --git a/gui/fitCommands/projectedFit/add.py b/gui/fitCommands/projectedFit/add.py
new file mode 100644
index 000000000..f3e3c5883
--- /dev/null
+++ b/gui/fitCommands/projectedFit/add.py
@@ -0,0 +1,30 @@
+import wx
+
+import gui.mainFrame
+from gui import globalEvents as GE
+from gui.fitCommands.calcCommands.projectedFit.add import CalcAddProjectedFitCommand
+from gui.fitCommands.helpers import InternalCommandHistory
+from service.fit import Fit
+
+
+class GuiAddProjectedFitCommand(wx.Command):
+
+    def __init__(self, fitID, projectedFitID):
+        wx.Command.__init__(self, True, 'Add Projected Fit')
+        self.internalHistory = InternalCommandHistory()
+        self.fitID = fitID
+        self.projectedFitID = projectedFitID
+
+    def Do(self):
+        cmd = CalcAddProjectedFitCommand(fitID=self.fitID, projectedFitID=self.projectedFitID)
+        if self.internalHistory.submit(cmd):
+            Fit.getInstance().recalc(self.fitID)
+            wx.PostEvent(gui.mainFrame.MainFrame.getInstance(), GE.FitChanged(fitID=self.fitID))
+            return True
+        return False
+
+    def Undo(self):
+        success = self.internalHistory.undoAll()
+        Fit.getInstance().recalc(self.fitID)
+        wx.PostEvent(gui.mainFrame.MainFrame.getInstance(), GE.FitChanged(fitID=self.fitID))
+        return success
diff --git a/gui/fitCommands/projectedFit/changeAmount.py b/gui/fitCommands/projectedFit/changeAmount.py
new file mode 100644
index 000000000..fac64d9ff
--- /dev/null
+++ b/gui/fitCommands/projectedFit/changeAmount.py
@@ -0,0 +1,39 @@
+import wx
+
+import gui.mainFrame
+from gui import globalEvents as GE
+from gui.fitCommands.calcCommands.projectedFit.changeAmount import CalcChangeProjectedFitAmountCommand
+from gui.fitCommands.calcCommands.projectedFit.remove import CalcRemoveProjectedFitCommand
+from gui.fitCommands.helpers import InternalCommandHistory
+from service.fit import Fit
+
+
+class GuiChangeProjectedFitAmountCommand(wx.Command):
+
+    def __init__(self, fitID, projectedFitID, amount):
+        wx.Command.__init__(self, True, 'Change Projected Fit Amount')
+        self.internalHistory = InternalCommandHistory()
+        self.fitID = fitID
+        self.projectedFitID = projectedFitID
+        self.amount = amount
+
+    def Do(self):
+        if self.amount > 0:
+            cmd = CalcChangeProjectedFitAmountCommand(fitID=self.fitID, projectedFitID=self.projectedFitID, amount=self.amount)
+            if self.internalHistory.submit(cmd):
+                Fit.getInstance().recalc(self.fitID)
+                wx.PostEvent(gui.mainFrame.MainFrame.getInstance(), GE.FitChanged(fitID=self.fitID))
+                return True
+        else:
+            cmd = CalcRemoveProjectedFitCommand(fitID=self.fitID, projectedFitID=self.projectedFitID)
+            if self.internalHistory.submit(cmd):
+                Fit.getInstance().recalc(self.fitID)
+                wx.PostEvent(gui.mainFrame.MainFrame.getInstance(), GE.FitChanged(fitID=self.fitID))
+                return True
+        return False
+
+    def Undo(self):
+        success = self.internalHistory.undoAll()
+        Fit.getInstance().recalc(self.fitID)
+        wx.PostEvent(gui.mainFrame.MainFrame.getInstance(), GE.FitChanged(fitID=self.fitID))
+        return success
diff --git a/gui/fitCommands/projectedFit/remove.py b/gui/fitCommands/projectedFit/remove.py
new file mode 100644
index 000000000..0123c7546
--- /dev/null
+++ b/gui/fitCommands/projectedFit/remove.py
@@ -0,0 +1,30 @@
+import wx
+
+import gui.mainFrame
+from gui import globalEvents as GE
+from gui.fitCommands.calcCommands.projectedFit.remove import CalcRemoveProjectedFitCommand
+from gui.fitCommands.helpers import InternalCommandHistory
+from service.fit import Fit
+
+
+class GuiRemoveProjectedFitCommand(wx.Command):
+
+    def __init__(self, fitID, projectedFitID):
+        wx.Command.__init__(self, True, 'Remove Projected Fit')
+        self.internalHistory = InternalCommandHistory()
+        self.fitID = fitID
+        self.projectedFitID = projectedFitID
+
+    def Do(self):
+        cmd = CalcRemoveProjectedFitCommand(fitID=self.fitID, projectedFitID=self.projectedFitID)
+        if self.internalHistory.submit(cmd):
+            Fit.getInstance().recalc(self.fitID)
+            wx.PostEvent(gui.mainFrame.MainFrame.getInstance(), GE.FitChanged(fitID=self.fitID))
+            return True
+        return False
+
+    def Undo(self):
+        success = self.internalHistory.undoAll()
+        Fit.getInstance().recalc(self.fitID)
+        wx.PostEvent(gui.mainFrame.MainFrame.getInstance(), GE.FitChanged(fitID=self.fitID))
+        return success
diff --git a/gui/fitCommands/projectedFit/toggleState.py b/gui/fitCommands/projectedFit/toggleState.py
new file mode 100644
index 000000000..cb427e68f
--- /dev/null
+++ b/gui/fitCommands/projectedFit/toggleState.py
@@ -0,0 +1,30 @@
+import wx
+
+import gui.mainFrame
+from gui import globalEvents as GE
+from gui.fitCommands.calcCommands.projectedFit.toggleState import CalcToggleProjectedFitCommand
+from gui.fitCommands.helpers import InternalCommandHistory
+from service.fit import Fit
+
+
+class GuiToggleProjectedFitStateCommand(wx.Command):
+
+    def __init__(self, fitID, projectedFitID):
+        wx.Command.__init__(self, True, 'Toggle Projected Fit State')
+        self.internalHistory = InternalCommandHistory()
+        self.fitID = fitID
+        self.projectedFitID = projectedFitID
+
+    def Do(self):
+        cmd = CalcToggleProjectedFitCommand(fitID=self.fitID, projectedFitID=self.projectedFitID)
+        if self.internalHistory.submit(cmd):
+            Fit.getInstance().recalc(self.fitID)
+            wx.PostEvent(gui.mainFrame.MainFrame.getInstance(), GE.FitChanged(fitID=self.fitID))
+            return True
+        return False
+
+    def Undo(self):
+        success = self.internalHistory.undoAll()
+        Fit.getInstance().recalc(self.fitID)
+        wx.PostEvent(gui.mainFrame.MainFrame.getInstance(), GE.FitChanged(fitID=self.fitID))
+        return success
diff --git a/gui/fitCommands/projectedModule/__init__.py b/gui/fitCommands/projectedModule/__init__.py
new file mode 100644
index 000000000..e69de29bb
diff --git a/gui/fitCommands/projectedModule/add.py b/gui/fitCommands/projectedModule/add.py
new file mode 100644
index 000000000..e81f56290
--- /dev/null
+++ b/gui/fitCommands/projectedModule/add.py
@@ -0,0 +1,30 @@
+import wx
+
+import gui.mainFrame
+from gui import globalEvents as GE
+from gui.fitCommands.calcCommands.module.projectedAdd import CalcAddProjectedModuleCommand
+from gui.fitCommands.helpers import InternalCommandHistory, ModuleInfo
+from service.fit import Fit
+
+
+class GuiAddProjectedModuleCommand(wx.Command):
+
+    def __init__(self, fitID, itemID):
+        wx.Command.__init__(self, True, 'Add Projected Module')
+        self.internalHistory = InternalCommandHistory()
+        self.fitID = fitID
+        self.itemID = itemID
+
+    def Do(self):
+        cmd = CalcAddProjectedModuleCommand(fitID=self.fitID, modInfo=ModuleInfo(itemID=self.itemID))
+        if self.internalHistory.submit(cmd):
+            Fit.getInstance().recalc(self.fitID)
+            wx.PostEvent(gui.mainFrame.MainFrame.getInstance(), GE.FitChanged(fitID=self.fitID))
+            return True
+        return False
+
+    def Undo(self):
+        success = self.internalHistory.undoAll()
+        Fit.getInstance().recalc(self.fitID)
+        wx.PostEvent(gui.mainFrame.MainFrame.getInstance(), GE.FitChanged(fitID=self.fitID))
+        return success
diff --git a/gui/fitCommands/projectedModule/changeCharges.py b/gui/fitCommands/projectedModule/changeCharges.py
new file mode 100644
index 000000000..0c4e58719
--- /dev/null
+++ b/gui/fitCommands/projectedModule/changeCharges.py
@@ -0,0 +1,31 @@
+import wx
+
+import gui.mainFrame
+from gui import globalEvents as GE
+from gui.fitCommands.calcCommands.module.changeCharges import CalcChangeModuleChargesCommand
+from gui.fitCommands.helpers import InternalCommandHistory
+from service.fit import Fit
+
+
+class GuiChangeProjectedModuleChargesCommand(wx.Command):
+
+    def __init__(self, fitID, modules, chargeItemID):
+        wx.Command.__init__(self, True, 'Change Projected Module Charges')
+        self.internalHistory = InternalCommandHistory()
+        self.fitID = fitID
+        self.positions = [mod.modPosition for mod in modules]
+        self.chargeItemID = chargeItemID
+
+    def Do(self):
+        cmd = CalcChangeModuleChargesCommand(fitID=self.fitID, projected=True, chargeMap={p: self.chargeItemID for p in self.positions})
+        if self.internalHistory.submit(cmd):
+            Fit.getInstance().recalc(self.fitID)
+            wx.PostEvent(gui.mainFrame.MainFrame.getInstance(), GE.FitChanged(fitID=self.fitID))
+            return True
+        return False
+
+    def Undo(self):
+        success = self.internalHistory.undoAll()
+        Fit.getInstance().recalc(self.fitID)
+        wx.PostEvent(gui.mainFrame.MainFrame.getInstance(), GE.FitChanged(fitID=self.fitID))
+        return success
diff --git a/gui/fitCommands/projectedModule/changeSpool.py b/gui/fitCommands/projectedModule/changeSpool.py
new file mode 100644
index 000000000..5e731a65b
--- /dev/null
+++ b/gui/fitCommands/projectedModule/changeSpool.py
@@ -0,0 +1,37 @@
+import wx
+
+import gui.mainFrame
+from gui import globalEvents as GE
+from gui.fitCommands.calcCommands.module.changeSpool import CalcChangeModuleSpoolCommand
+from gui.fitCommands.helpers import InternalCommandHistory
+from service.fit import Fit
+
+
+class GuiChangeProjectedModuleSpoolCommand(wx.Command):
+
+    def __init__(self, fitID, position, spoolType, spoolAmount):
+        wx.Command.__init__(self, True, 'Change Projected 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=True,
+            position=self.position,
+            spoolType=self.spoolType,
+            spoolAmount=self.spoolAmount)
+        if self.internalHistory.submit(cmd):
+            Fit.getInstance().recalc(self.fitID)
+            wx.PostEvent(gui.mainFrame.MainFrame.getInstance(), GE.FitChanged(fitID=self.fitID))
+            return True
+        return False
+
+    def Undo(self):
+        success = self.internalHistory.undoAll()
+        Fit.getInstance().recalc(self.fitID)
+        wx.PostEvent(gui.mainFrame.MainFrame.getInstance(), GE.FitChanged(fitID=self.fitID))
+        return success
diff --git a/gui/fitCommands/projectedModule/changeState.py b/gui/fitCommands/projectedModule/changeState.py
new file mode 100644
index 000000000..1ee2d7723
--- /dev/null
+++ b/gui/fitCommands/projectedModule/changeState.py
@@ -0,0 +1,31 @@
+import wx
+
+import gui.mainFrame
+from gui import globalEvents as GE
+from gui.fitCommands.calcCommands.module.projectedChangeState import CalcChangeProjectedModuleStateCommand
+from gui.fitCommands.helpers import InternalCommandHistory
+from service.fit import Fit
+
+
+class GuiChangeProjectedModuleStateCommand(wx.Command):
+
+    def __init__(self, fitID, position, click):
+        wx.Command.__init__(self, True, 'Change Projected Module State')
+        self.internalHistory = InternalCommandHistory()
+        self.fitID = fitID
+        self.position = position
+        self.click = click
+
+    def Do(self):
+        cmd = CalcChangeProjectedModuleStateCommand(fitID=self.fitID, position=self.position, click=self.click)
+        if self.internalHistory.submit(cmd):
+            Fit.getInstance().recalc(self.fitID)
+            wx.PostEvent(gui.mainFrame.MainFrame.getInstance(), GE.FitChanged(fitID=self.fitID))
+            return True
+        return False
+
+    def Undo(self):
+        success = self.internalHistory.undoAll()
+        Fit.getInstance().recalc(self.fitID)
+        wx.PostEvent(gui.mainFrame.MainFrame.getInstance(), GE.FitChanged(fitID=self.fitID))
+        return success
diff --git a/gui/fitCommands/projectedModule/remove.py b/gui/fitCommands/projectedModule/remove.py
new file mode 100644
index 000000000..931e720c6
--- /dev/null
+++ b/gui/fitCommands/projectedModule/remove.py
@@ -0,0 +1,30 @@
+import wx
+
+import gui.mainFrame
+from gui import globalEvents as GE
+from gui.fitCommands.calcCommands.module.projectedRemove import CalcRemoveProjectedModuleCommand
+from gui.fitCommands.helpers import InternalCommandHistory
+from service.fit import Fit
+
+
+class GuiRemoveProjectedModuleCommand(wx.Command):
+
+    def __init__(self, fitID, position):
+        wx.Command.__init__(self, True, 'Remove Projected Module')
+        self.internalHistory = InternalCommandHistory()
+        self.fitID = fitID
+        self.position = position
+
+    def Do(self):
+        cmd = CalcRemoveProjectedModuleCommand(fitID=self.fitID, position=self.position)
+        if self.internalHistory.submit(cmd):
+            Fit.getInstance().recalc(self.fitID)
+            wx.PostEvent(gui.mainFrame.MainFrame.getInstance(), GE.FitChanged(fitID=self.fitID))
+            return True
+        return False
+
+    def Undo(self):
+        success = self.internalHistory.undoAll()
+        Fit.getInstance().recalc(self.fitID)
+        wx.PostEvent(gui.mainFrame.MainFrame.getInstance(), GE.FitChanged(fitID=self.fitID))
+        return success
diff --git a/gui/mainFrame.py b/gui/mainFrame.py
index 7de7499a6..b2ed58425 100644
--- a/gui/mainFrame.py
+++ b/gui/mainFrame.py
@@ -704,7 +704,7 @@ class MainFrame(wx.Frame):
             # If it's mutated item - make sure there's at least base item specified
             if importType == "MutatedItem":
                 # we've imported an Abyssal module, need to fire off the command to add it to the fit
-                self.command.Submit(cmd.GuiImportMutatedModuleCommand(activeFit, *importData[0]))
+                self.command.Submit(cmd.GuiImportLocalMutatedModuleCommand(activeFit, *importData[0]))
                 return  # no need to do anything else
         except:
             pyfalog.error("Attempt to import failed:\n{0}", clipboard)