Hallucinte some more buttons below market

gui/builtinMarketBrowser/itemView.py

@@ -5,6 +5,7 @@ import gui.builtinMarketBrowser.pfSearchBox as SBox
 import gui.globalEvents as GE
 from config import slotColourMap, slotColourMapDark
 from eos.saveddata.module import Module
+from eos.const import FittingSlot
 from gui.builtinMarketBrowser.events import ItemSelected, RECENTLY_USED_MODULES, CHARGES_FOR_FIT
 from gui.contextMenu import ContextMenu
 from gui.display import Display
@@ -197,13 +198,87 @@ class ItemView(Display):
             if btn.userSelected:
                 selectedMetas.update(sMkt.META_MAP[btn.metaName])
         filteredItems = sMkt.filterItemsByMeta(self.unfilteredStore, selectedMetas)
+        
+        # Apply slot/fits filters - works IDENTICALLY to meta buttons (filters CURRENT VIEW only)
+        activeSlotFilters = []
+        fitsFilterActive = False
+        for btn in self.marketBrowser.slotButtons:
+            if btn.userSelected:
+                if btn.filterType == "fits":
+                    fitsFilterActive = True
+                elif btn.filterType == "slot":
+                    activeSlotFilters.append(btn.slotType)
+        
+        # Apply fits filter
+        if fitsFilterActive:
+            filteredItems = self._filterByFits(filteredItems)
+        
+        # Apply slot filters
+        if activeSlotFilters:
+            filteredItems = [item for item in filteredItems if Module.calculateSlot(item) in activeSlotFilters]
+        
         return filteredItems
 
+    def _filterByFits(self, items):
+        """Filter items by remaining CPU/PG - filters CURRENT VIEW only"""
+        fitId = self.mainFrame.getActiveFit()
+        if fitId is None:
+            return []
+        
+        fit = self.sFit.getFit(fitId)
+        
+        # Get remaining CPU and power grid
+        cpuOutput = fit.ship.getModifiedItemAttr("cpuOutput")
+        powerOutput = fit.ship.getModifiedItemAttr("powerOutput")
+        cpuUsed = fit.cpuUsed
+        pgUsed = fit.pgUsed
+        cpuRemaining = cpuOutput - cpuUsed
+        pgRemaining = powerOutput - pgUsed
+        
+        fittingItems = []
+        for item in items:
+            # Check CPU and power requirements first (fastest check)
+            itemCpu = item.attributes.get("cpu")
+            itemPower = item.attributes.get("power")
+            
+            # Skip items without CPU or power (not modules)
+            if itemCpu is None and itemPower is None:
+                continue
+            
+            # Check CPU requirement
+            if itemCpu is not None:
+                itemCpuValue = itemCpu.value
+                if itemCpuValue > cpuRemaining:
+                    continue
+            
+            # Check power requirement
+            if itemPower is not None:
+                itemPowerValue = itemPower.value
+                if itemPowerValue > pgRemaining:
+                    continue
+            
+            # Check if item is a module (has a slot)
+            slot = Module.calculateSlot(item)
+            if slot is None:
+                continue
+            
+            # Check if item can fit on the ship (most expensive check, do last)
+            if not fit.canFit(item):
+                continue
+            
+            fittingItems.append(item)
+        
+        return fittingItems
+
     def setToggles(self):
         metaIDs = set()
+        slotIDs = set()
         sMkt = self.sMkt
         for item in self.unfilteredStore:
             metaIDs.add(sMkt.getMetaGroupIdByItem(item))
+            slot = Module.calculateSlot(item)
+            if slot is not None:
+                slotIDs.add(slot)
 
         for btn in self.marketBrowser.metaButtons:
             btn.reset()
@@ -212,6 +287,20 @@ class ItemView(Display):
                 btn.setMetaAvailable(True)
             else:
                 btn.setMetaAvailable(False)
+        
+        # Set toggles for slot/fits buttons
+        for btn in self.marketBrowser.slotButtons:
+            btn.reset()
+            if btn.filterType == "fits":
+                # Fits button is available if there's an active fit
+                fitId = self.mainFrame.getActiveFit()
+                btn.setMetaAvailable(fitId is not None)
+            elif btn.filterType == "slot":
+                # Slot button is available if items with that slot exist in current view
+                if btn.slotType in slotIDs:
+                    btn.setMetaAvailable(True)
+                else:
+                    btn.setMetaAvailable(False)
 
     def scheduleSearch(self, event=None):
         self.searchTimer.Stop()  # Cancel any pending timers