Rewrite almost all functionality of market browser to work with reworked service
This commit is contained in:
DarkPhoenix
@@ -60,7 +60,7 @@ class AttributeDisplay(ViewColumn):
|
||||
sMarket = service.Market.getInstance()
|
||||
#Hack into our master view and add a callback for ourselves to know when to query
|
||||
def refresh(stuff):
|
||||
self.directInfo = sMarket.directRequest(stuff, info.ID) if stuff else None
|
||||
self.directInfo = sMarket.directAttrRequest(stuff, info.ID) if stuff else None
|
||||
originalRefresh(stuff)
|
||||
|
||||
fittingView.refresh = refresh
|
||||
|
||||
@@ -19,7 +19,7 @@
|
||||
|
||||
import wx
|
||||
import service
|
||||
import wx.lib.mixins.listctrl as listmix
|
||||
import wx.lib.mixins.listctrl as listmix
|
||||
import gui.display as d
|
||||
from gui.cachingImageList import CachingImageList
|
||||
from gui.contextMenu import ContextMenu
|
||||
@@ -33,11 +33,11 @@ class MarketBrowser(wx.Panel):
|
||||
vbox = wx.BoxSizer(wx.VERTICAL)
|
||||
self.SetSizer(vbox)
|
||||
|
||||
#Add a search button on top
|
||||
# Add a search button on top
|
||||
|
||||
#Add a WHOLE panel for ONE SINGLE search button
|
||||
#We have to be able to give the search more size, which can't be done in another way.
|
||||
#(That I found)
|
||||
# Add a WHOLE panel for ONE SINGLE search button
|
||||
# We have to be able to give the search more size, which can't be done in another way.
|
||||
# (That I found)
|
||||
p = wx.Panel(self)
|
||||
sizer = wx.BoxSizer(wx.HORIZONTAL)
|
||||
p.SetSizer(sizer)
|
||||
@@ -50,13 +50,15 @@ class MarketBrowser(wx.Panel):
|
||||
self.splitter = wx.SplitterWindow(self, style = wx.SP_LIVE_UPDATE)
|
||||
vbox.Add(self.splitter, 1, wx.EXPAND)
|
||||
|
||||
# Grab market service instance and create child objects
|
||||
self.sMarket = service.Market.getInstance()
|
||||
self.searchMode = False
|
||||
self.marketView = MarketTree(self.splitter, self)
|
||||
self.itemView = ItemView(self.splitter, self)
|
||||
|
||||
self.splitter.SplitHorizontally(self.marketView, self.itemView)
|
||||
self.splitter.SetMinimumPaneSize(250)
|
||||
|
||||
cMarket = service.Market.getInstance()
|
||||
# Setup our buttons for metaGroup selection
|
||||
# Same fix as for search box on macs,
|
||||
# need some pixels of extra space or everything clips and is ugly
|
||||
@@ -64,45 +66,42 @@ class MarketBrowser(wx.Panel):
|
||||
box = wx.BoxSizer(wx.HORIZONTAL)
|
||||
p.SetSizer(box)
|
||||
vbox.Add(p, 0, wx.EXPAND)
|
||||
for name in ("normal", "faction", "complex", "officer"):
|
||||
self.metaButtons = []
|
||||
for name in self.sMarket.META_MAP.keys():
|
||||
btn = wx.ToggleButton(p, wx.ID_ANY, name.capitalize(), style=wx.BU_EXACTFIT)
|
||||
setattr(self, name, btn)
|
||||
box.Add(btn, 1, wx.ALIGN_CENTER)
|
||||
btn.Bind(wx.EVT_TOGGLEBUTTON, self.toggleMetagroup)
|
||||
btn.Bind(wx.EVT_TOGGLEBUTTON, self.toggleMetaButton)
|
||||
btn.metaName = name
|
||||
self.metaButtons.append(btn)
|
||||
self.itemView.setToggles()
|
||||
|
||||
self.normal.SetValue(True)
|
||||
cMarket.activateMetaGroup("normal")
|
||||
p.SetMinSize((wx.SIZE_AUTO_WIDTH, btn.GetSize()[1] + 5))
|
||||
|
||||
def toggleMetagroup(self, event):
|
||||
def toggleMetaButton(self, event):
|
||||
ctrl = wx.GetMouseState().ControlDown()
|
||||
cMarket = service.Market.getInstance()
|
||||
btn = event.EventObject
|
||||
ebtn = event.EventObject
|
||||
if not ctrl:
|
||||
for name in ("normal", "faction", "complex", "officer"):
|
||||
button = getattr(self, name)
|
||||
button.SetValue(False)
|
||||
button.Enable(True)
|
||||
|
||||
cMarket.disableMetaGroup(name)
|
||||
|
||||
btn.SetValue(True)
|
||||
cMarket.activateMetaGroup(btn.metaName)
|
||||
for btn in self.metaButtons:
|
||||
if btn.Enabled:
|
||||
if btn == ebtn:
|
||||
btn.SetValue(True)
|
||||
else:
|
||||
btn.SetValue(False)
|
||||
else:
|
||||
# Note: using the old value might seem weird,
|
||||
# But the button hasn't been toggled by wx yet
|
||||
target = btn.GetValue()
|
||||
btn.SetValue(target)
|
||||
if target:
|
||||
cMarket.activateMetaGroup(btn.metaName)
|
||||
else:
|
||||
cMarket.disableMetaGroup(btn.metaName)
|
||||
# Note: using the 'wrong' value for clicked button might seem weird,
|
||||
# But the button is toggled by wx and we should deal with it
|
||||
activeBtns = set()
|
||||
for btn in self.metaButtons:
|
||||
if (btn.GetValue() and btn != ebtn) or (not btn.GetValue() and btn == ebtn):
|
||||
activeBtns.add(btn)
|
||||
# Do 'nothing' if we're trying to turn last active button off
|
||||
if len(activeBtns) == 1 and activeBtns.pop() == ebtn:
|
||||
# Keep button in the same state
|
||||
ebtn.SetValue(True)
|
||||
return
|
||||
|
||||
if self.itemView.searching:
|
||||
self.itemView.filteredSearchAdd()
|
||||
else:
|
||||
self.itemView.selectionMade(event)
|
||||
self.itemView.filterItemStore()
|
||||
|
||||
def jump(self, item):
|
||||
self.marketView.jump(item)
|
||||
@@ -116,96 +115,99 @@ class SearchBox(wx.SearchCtrl):
|
||||
class MarketTree(wx.TreeCtrl):
|
||||
def __init__(self, parent, marketBrowser):
|
||||
wx.TreeCtrl.__init__(self, parent, style=wx.TR_DEFAULT_STYLE | wx.TR_HIDE_ROOT)
|
||||
self.root = self.AddRoot("CHRISTMAS TREE!")
|
||||
self.marketBrowser = marketBrowser
|
||||
self.root = self.AddRoot("root")
|
||||
|
||||
self.imageList = CachingImageList(16, 16)
|
||||
self.SetImageList(self.imageList)
|
||||
|
||||
cMarket = service.Market.getInstance()
|
||||
self.sMarket = marketBrowser.sMarket
|
||||
|
||||
root = cMarket.getMarketRoot()
|
||||
for id, name, iconFile in root:
|
||||
iconId = self.addImage(iconFile)
|
||||
childId = self.AppendItem(self.root, name, iconId, data=wx.TreeItemData(id))
|
||||
sMkt = self.sMarket
|
||||
for mktGrp in sMkt.getMarketRoot():
|
||||
iconId = self.addImage(sMkt.getIconByMarketGroup(mktGrp))
|
||||
childId = self.AppendItem(self.root, mktGrp.name, iconId, data=wx.TreeItemData(mktGrp.ID))
|
||||
# All market groups which were never expanded are dummies
|
||||
self.AppendItem(childId, "dummy")
|
||||
|
||||
self.SortChildren(self.root)
|
||||
|
||||
#Bind our lookup method to when the tree gets expanded
|
||||
# Bind our lookup method to when the tree gets expanded
|
||||
self.Bind(wx.EVT_TREE_ITEM_EXPANDING, self.expandLookup)
|
||||
|
||||
def addImage(self, iconFile):
|
||||
if iconFile is None:
|
||||
return -1
|
||||
|
||||
return self.imageList.GetImageIndex(iconFile, "pack")
|
||||
|
||||
def expandLookup(self, event):
|
||||
root = event.Item
|
||||
child, cookie = self.GetFirstChild(root)
|
||||
child = self.GetFirstChild(root)[0]
|
||||
# If child of given market group is a dummy
|
||||
if self.GetItemText(child) == "dummy":
|
||||
cMarket = service.Market.getInstance()
|
||||
#A DUMMY! Keeeel!!! EBUL DUMMY MUST DIAF!
|
||||
# Delete it
|
||||
self.Delete(child)
|
||||
|
||||
#Add 'real stoof!' instead
|
||||
for id, name, iconFile, more in cMarket.getChildren(self.GetPyData(root)):
|
||||
iconId = self.addImage(iconFile)
|
||||
childId = self.AppendItem(root, name, iconId, data=wx.TreeItemData(id))
|
||||
if more:
|
||||
# And add real market group contents
|
||||
sMkt = self.sMarket
|
||||
currentMktGrp = sMkt.getMarketGroup(self.GetPyData(root))
|
||||
#for id, name, iconFile, more in sMkt.getMarketGroupChildren(mg):
|
||||
for childMktGrp in sMkt.getMarketGroupChildren(currentMktGrp):
|
||||
# If market should have items but it doesn't, do not show it
|
||||
if not sMkt.marketGroupValidityCheck(childMktGrp):
|
||||
continue
|
||||
iconId = self.addImage(sMkt.getIconByMarketGroup(childMktGrp))
|
||||
childId = self.AppendItem(root, childMktGrp.name, iconId, data=wx.TreeItemData(childMktGrp.ID))
|
||||
if not sMkt.marketGroupHasTypesCheck(childMktGrp):
|
||||
self.AppendItem(childId, "dummy")
|
||||
|
||||
self.SortChildren(root)
|
||||
|
||||
def jump(self, item):
|
||||
cMarket = service.Market.getInstance()
|
||||
mg = item.marketGroup
|
||||
if mg is None and (item.metaGroup is not None or item.ID in cMarket.FORCED_ITEM_MKTGRPS):
|
||||
if item.metaGroup is not None:
|
||||
mg = item.metaGroup.parent.marketGroup
|
||||
metaGroup = cMarket.getMetaName(item.metaGroup.ID)
|
||||
elif item.ID in cMarket.FORCED_ITEM_MKTGRPS:
|
||||
mgid = cMarket.FORCED_ITEM_MKTGRPS[item.ID][0]
|
||||
mg = cMarket.getMarketGroup(mgid)
|
||||
metaGroupID = cMarket.FORCED_ITEM_MKTGRPS[item.ID][1]
|
||||
metaGroupName = "normal"
|
||||
for metaGroupName, metaGroupIDs in cMarket.META_MAP.iteritems():
|
||||
if metaGroupID in metaGroupIDs:
|
||||
metaGroup = metaGroupName
|
||||
break
|
||||
for btn in ("normal", "faction", "complex", "officer"):
|
||||
getattr(self.marketBrowser, btn).SetValue(False)
|
||||
cMarket.disableMetaGroup(btn)
|
||||
|
||||
getattr(self.marketBrowser, metaGroup).SetValue(True)
|
||||
cMarket.activateMetaGroup(metaGroup)
|
||||
self.marketBrowser.itemView.searching = False
|
||||
if mg is None:
|
||||
return
|
||||
|
||||
jumpList = []
|
||||
while mg is not None:
|
||||
jumpList.append(mg.ID)
|
||||
mg = mg.parent
|
||||
|
||||
cMarket.MARKET_GROUPS
|
||||
for id in cMarket.MARKET_GROUPS:
|
||||
if id in jumpList:
|
||||
jumpList = jumpList[:jumpList.index(id)+1]
|
||||
|
||||
item = self.root
|
||||
for i in range(len(jumpList) -1, -1, -1):
|
||||
target = jumpList[i]
|
||||
child, cookie = self.GetFirstChild(item)
|
||||
while self.GetItemPyData(child) != target:
|
||||
child, cookie = self.GetNextChild(item, cookie)
|
||||
|
||||
item = child
|
||||
self.Expand(item)
|
||||
|
||||
self.SelectItem(item)
|
||||
self.marketBrowser.itemView.searching = False
|
||||
# def jump(self, item):
|
||||
# sMkt = self.sMarket
|
||||
# mg = item.marketGroup
|
||||
# if mg is None and (item.metaGroup is not None or item.ID in sMkt.FORCED_ITEM_MKTGRPS):
|
||||
# if item.metaGroup is not None:
|
||||
# mg = item.metaGroup.parent.marketGroup
|
||||
# metaGroup = sMkt.getMetaName(item.metaGroup.ID)
|
||||
# elif item.ID in sMkt.FORCED_ITEM_MKTGRPS:
|
||||
# mgid = sMkt.FORCED_ITEM_MKTGRPS[item.ID][0]
|
||||
# mg = sMkt.getMarketGroup(mgid)
|
||||
# metaGroupID = sMkt.FORCED_ITEM_MKTGRPS[item.ID][1]
|
||||
# metaGroupName = "normal"
|
||||
# for metaGroupName, metaGroupIDs in sMkt.META_MAP.iteritems():
|
||||
# if metaGroupID in metaGroupIDs:
|
||||
# metaGroup = metaGroupName
|
||||
# break
|
||||
# for btn in ("normal", "faction", "complex", "officer"):
|
||||
# getattr(self.marketBrowser, btn).SetValue(False)
|
||||
# sMkt.disableMetaGroup(btn)
|
||||
#
|
||||
# getattr(self.marketBrowser, metaGroup).SetValue(True)
|
||||
# sMkt.activateMetaGroup(metaGroup)
|
||||
# self.marketBrowser.itemView.searching = False
|
||||
# if mg is None:
|
||||
# return
|
||||
#
|
||||
# jumpList = []
|
||||
# while mg is not None:
|
||||
# jumpList.append(mg.ID)
|
||||
# mg = mg.parent
|
||||
#
|
||||
# sMkt.MARKET_GROUPS
|
||||
# for id in sMkt.MARKET_GROUPS:
|
||||
# if id in jumpList:
|
||||
# jumpList = jumpList[:jumpList.index(id)+1]
|
||||
#
|
||||
# item = self.root
|
||||
# for i in range(len(jumpList) -1, -1, -1):
|
||||
# target = jumpList[i]
|
||||
# child, cookie = self.GetFirstChild(item)
|
||||
# while self.GetItemPyData(child) != target:
|
||||
# child, cookie = self.GetNextChild(item, cookie)
|
||||
#
|
||||
# item = child
|
||||
# self.Expand(item)
|
||||
#
|
||||
# self.SelectItem(item)
|
||||
# self.marketBrowser.itemView.searching = False
|
||||
|
||||
class ItemView(d.Display):
|
||||
DEFAULT_COLS = ["Base Icon",
|
||||
@@ -217,104 +219,122 @@ class ItemView(d.Display):
|
||||
d.Display.__init__(self, parent)
|
||||
marketBrowser.Bind(wx.EVT_TREE_SEL_CHANGED, self.selectionMade)
|
||||
|
||||
self.searching = False
|
||||
self.unfilteredStore = set()
|
||||
self.filteredStore = set()
|
||||
self.sMarket = marketBrowser.sMarket
|
||||
self.searchMode = marketBrowser.searchMode
|
||||
|
||||
self.marketBrowser = marketBrowser
|
||||
self.marketView = marketBrowser.marketView
|
||||
|
||||
#Make sure our search actualy does intresting stuff
|
||||
# Make sure our search actually does interesting stuff
|
||||
self.marketBrowser.search.Bind(wx.EVT_TEXT_ENTER, self.scheduleSearch)
|
||||
self.marketBrowser.search.Bind(wx.EVT_SEARCHCTRL_SEARCH_BTN, self.scheduleSearch)
|
||||
self.marketBrowser.search.Bind(wx.EVT_SEARCHCTRL_CANCEL_BTN, self.clearSearch)
|
||||
self.marketBrowser.search.Bind(wx.EVT_TEXT, self.scheduleSearch)
|
||||
|
||||
#Make sure WE do intresting stuff TOO
|
||||
# Make sure WE do interesting stuff too
|
||||
self.Bind(wx.EVT_CONTEXT_MENU, self.contextMenu)
|
||||
self.Bind(wx.EVT_LIST_ITEM_ACTIVATED, self.itemActivated)
|
||||
|
||||
def itemActivated(self, event):
|
||||
#Check if something is selected, if so, spawn the menu for it
|
||||
# Check if something is selected, if so, spawn the menu for it
|
||||
sel = self.GetFirstSelected()
|
||||
if sel == -1:
|
||||
return
|
||||
|
||||
wx.PostEvent(self.mainFrame, ItemSelected(itemID=self.active[sel].ID))
|
||||
|
||||
def selectionMade(self, event):
|
||||
if self.searching:
|
||||
self.clearSearch(None, False)
|
||||
|
||||
self.marketBrowser.searchMode = False
|
||||
root = self.marketView.GetSelection()
|
||||
if root.IsOk():
|
||||
if self.marketView.GetChildrenCount(root) != 0:
|
||||
return
|
||||
sMkt = self.sMarket
|
||||
root = self.marketView.GetPyData(root)
|
||||
if root is not None:
|
||||
# Get current market group
|
||||
mg = sMkt.getMarketGroup(root)
|
||||
# Get all its items
|
||||
items = sMkt.getItemsByMarketGroup(mg)
|
||||
else:
|
||||
# If method was called but selection wasn't actually made
|
||||
items = set()
|
||||
# Fill store
|
||||
self.updateItemStore(items)
|
||||
# Set toggle buttons
|
||||
self.setToggles()
|
||||
# Update filtered items
|
||||
self.filterItemStore()
|
||||
|
||||
cMarket = service.Market.getInstance()
|
||||
items, usedMetas = cMarket.getVariations(self.marketView.GetPyData(root))
|
||||
self.update(items)
|
||||
self.toggleButtons(usedMetas)
|
||||
def updateItemStore(self, items):
|
||||
self.unfilteredStore = items
|
||||
|
||||
def clearSearch(self, event=None, clear=True):
|
||||
self.DeleteAllItems()
|
||||
if clear:
|
||||
self.marketBrowser.search.Clear()
|
||||
def filterItemStore(self):
|
||||
sMkt = self.sMarket
|
||||
selectedMetas = set()
|
||||
for btn in self.marketBrowser.metaButtons:
|
||||
if btn.GetValue():
|
||||
selectedMetas.update(sMkt.META_MAP[btn.metaName])
|
||||
self.filteredStore = sMkt.filterItemsByMeta(self.unfilteredStore, selectedMetas)
|
||||
self.update(list(self.filteredStore))
|
||||
|
||||
cMarket = service.Market.getInstance()
|
||||
for name in ("normal", "faction", "complex", "officer"):
|
||||
btn = getattr(self.marketBrowser, name)
|
||||
btn.Enable(True)
|
||||
btn.SetValue(False)
|
||||
cMarket.disableMetaGroup(btn.metaName)
|
||||
|
||||
cMarket.activateMetaGroup("normal")
|
||||
self.marketBrowser.normal.SetValue(True)
|
||||
|
||||
self.searching = False
|
||||
def setToggles(self):
|
||||
metaIDs = set()
|
||||
sMkt = self.sMarket
|
||||
for item in self.unfilteredStore:
|
||||
metaIDs.add(sMkt.getMetaGroupIdByItem(item))
|
||||
anySelection = False
|
||||
for btn in self.marketBrowser.metaButtons:
|
||||
if len(metaIDs.intersection(sMkt.META_MAP[btn.metaName])) > 0:
|
||||
btn.Enable(True)
|
||||
# Select all available buttons if we're searching
|
||||
if self.marketBrowser.searchMode:
|
||||
btn.SetValue(True)
|
||||
else:
|
||||
btn.Enable(False)
|
||||
btn.SetValue(False)
|
||||
if btn.GetValue():
|
||||
anySelection = True
|
||||
# If no buttons are pressed, press first active
|
||||
if not anySelection:
|
||||
for btn in self.marketBrowser.metaButtons:
|
||||
if btn.Enabled:
|
||||
btn.SetValue(True)
|
||||
break
|
||||
|
||||
def scheduleSearch(self, event):
|
||||
search = self.marketBrowser.search.GetLineText(0)
|
||||
if len(search) < 3:
|
||||
# Re-select market group if search query has zero length
|
||||
if len(search) == 0:
|
||||
self.selectionMade(event)
|
||||
return
|
||||
# Show nothing if query is too short
|
||||
elif len(search) < 3:
|
||||
self.clearSearch(event, False)
|
||||
return
|
||||
|
||||
cMarket = service.Market.getInstance()
|
||||
if not self.searching:
|
||||
for name in ("normal", "faction", "complex", "officer"):
|
||||
getattr(self.marketBrowser, name).SetValue(True)
|
||||
cMarket.activateMetaGroup(name)
|
||||
self.marketBrowser.searchMode = True
|
||||
self.sMarket.searchItems(search, self.populateSearch)
|
||||
|
||||
self.searching = True
|
||||
cMarket.searchItems(search, self.populateSearch)
|
||||
def clearSearch(self, event=None, clear=True):
|
||||
# Wipe item store and update everything to accomodate with it
|
||||
self.marketBrowser.searchMode = False
|
||||
self.updateItemStore(set())
|
||||
self.setToggles()
|
||||
self.filterItemStore()
|
||||
|
||||
def populateSearch(self, results):
|
||||
self.filteredSearchAdd(*results)
|
||||
|
||||
def itemFilter(self, item):
|
||||
pass
|
||||
|
||||
def filteredSearchAdd(self, items=None, usedMetas=None):
|
||||
if self.searching is False:
|
||||
def populateSearch(self, items):
|
||||
# If we're no longer searching, dump the results
|
||||
if self.marketBrowser.searchMode is False:
|
||||
return
|
||||
self.updateItemStore(items)
|
||||
self.setToggles()
|
||||
self.filterItemStore()
|
||||
|
||||
self.items = items if items is not None else self.items
|
||||
self.usedMetas = usedMetas if usedMetas is not None else self.usedMetas
|
||||
sMarket = service.Market.getInstance()
|
||||
|
||||
self.update(sMarket.filterItems(self.items))
|
||||
|
||||
#Gray out empty toggles
|
||||
self.toggleButtons(self.usedMetas)
|
||||
|
||||
def toggleButtons(self, usedMetas):
|
||||
cMarket = service.Market.getInstance()
|
||||
for name in ("normal", "faction", "complex", "officer"):
|
||||
btn = getattr(self.marketBrowser, name)
|
||||
btn.SetValue(False)
|
||||
btn.Enable(False)
|
||||
|
||||
for meta in usedMetas:
|
||||
btn = getattr(self.marketBrowser, cMarket.getMetaName(meta))
|
||||
btn.SetValue(cMarket.isMetaIdActive(meta))
|
||||
btn.Enable(True)
|
||||
def itemSort(self, item):
|
||||
if item.metaGroup is None:
|
||||
return (item.name, 0, item.name)
|
||||
else:
|
||||
return (item.metaGroup.parent.name, item.metaGroup.ID , item.name)
|
||||
|
||||
def contextMenu(self, event):
|
||||
#Check if something is selected, if so, spawn the menu for it
|
||||
@@ -326,25 +346,19 @@ class ItemView(d.Display):
|
||||
# We were searching, this means that our results come from the worker thread
|
||||
# Refetch items, else it'll try to reuse the object fetched in the other thread
|
||||
# Which makes it go BOOM CRACK DOOM
|
||||
if self.searching:
|
||||
if self.marketBrowser.searchMode:
|
||||
sMarket = service.Market.getInstance()
|
||||
item = sMarket.getItem(item.ID)
|
||||
|
||||
menu = ContextMenu.getMenu((item,), "item" if self.searching is False else "itemSearch")
|
||||
menu = ContextMenu.getMenu((item,), "item" if self.marketBrowser.searchMode is False else "itemSearch")
|
||||
self.PopupMenu(menu)
|
||||
|
||||
def itemSort(self, item):
|
||||
if item.metaGroup is None:
|
||||
return (item.name, 0, item.name)
|
||||
else:
|
||||
return (item.metaGroup.parent.name, item.metaGroup.ID , item.name)
|
||||
|
||||
def populate(self, stuff):
|
||||
self.deselectItems()
|
||||
stuff.sort(key=self.itemSort)
|
||||
self.active = stuff
|
||||
d.Display.populate(self, stuff)
|
||||
|
||||
def refresh(self, stuff):
|
||||
stuff.sort(key=self.itemSort)
|
||||
d.Display.refresh(self, stuff)
|
||||
# def refresh(self, stuff):
|
||||
# stuff.sort(key=self.itemSort)
|
||||
# d.Display.refresh(self, stuff)
|
||||
|
||||
@@ -18,12 +18,9 @@
|
||||
#===============================================================================
|
||||
|
||||
import threading
|
||||
import traceback
|
||||
import wx
|
||||
|
||||
from sqlalchemy.orm.exc import NoResultFound
|
||||
import sqlalchemy.sql
|
||||
import sqlalchemy.orm
|
||||
import Queue
|
||||
|
||||
import eos.db
|
||||
@@ -42,7 +39,7 @@ class ShipBrowserWorkerThread(threading.Thread):
|
||||
def run(self):
|
||||
self.queue = Queue.Queue()
|
||||
self.cache = {}
|
||||
# Wait for full market initialization (otherwise there's high riskjy
|
||||
# Wait for full market initialization (otherwise there's high risky
|
||||
# this thread will attempt to init Market which is already being inited)
|
||||
mktRdy.wait(5)
|
||||
self.processRequests()
|
||||
@@ -113,18 +110,19 @@ class SearchWorkerThread(threading.Thread):
|
||||
request, callback = self.searchRequest
|
||||
self.searchRequest = None
|
||||
cv.release()
|
||||
filter = (eos.types.Category.name.in_(Market.SEARCH_CATEGORIES), eos.types.Item.published == True)
|
||||
sMarket = Market.getInstance()
|
||||
# Rely on category data provided by eos as we don't hardcode them much in service
|
||||
filter = eos.types.Category.name.in_(sMarket.SEARCH_CATEGORIES)
|
||||
results = eos.db.searchItems(request, where=filter,
|
||||
join=(eos.types.Item.group, eos.types.Group.category),
|
||||
eager=("icon", "group.category", "metaGroup", "metaGroup.parent"))
|
||||
|
||||
usedMetas = set()
|
||||
items = []
|
||||
items = set()
|
||||
# Return only published items, consult with Market service this time
|
||||
for item in results:
|
||||
usedMetas.add(item.metaGroup.ID if item.metaGroup else 1)
|
||||
items.append(item)
|
||||
|
||||
wx.CallAfter(callback, (items, usedMetas))
|
||||
if sMarket.getPublicityByItem(item):
|
||||
items.add(item)
|
||||
wx.CallAfter(callback, items)
|
||||
|
||||
def scheduleSearch(self, text, callback):
|
||||
self.cv.acquire()
|
||||
@@ -135,7 +133,6 @@ class SearchWorkerThread(threading.Thread):
|
||||
class Market():
|
||||
instance = None
|
||||
def __init__(self):
|
||||
#self.activeMetas = set()
|
||||
self.priceCache = {}
|
||||
|
||||
# Start price fetcher
|
||||
@@ -280,10 +277,15 @@ class Market():
|
||||
self.ITEMS_FORCEDMARKETGROUP_R = self.__makeRevDict(self.ITEMS_FORCEDMARKETGROUP)
|
||||
|
||||
# Misc definitions
|
||||
self.META_MAP = OrderedDict([("normal", (1, 2, 14)),
|
||||
("faction", (4, 3)),
|
||||
("complex", (6,)),
|
||||
("officer", (5,))])
|
||||
# 0 is for items w/o meta group
|
||||
self.META_MAP = OrderedDict([("normal", frozenset((0, 1, 2, 14))),
|
||||
("faction", frozenset((4, 3))),
|
||||
("complex", frozenset((6,))),
|
||||
("officer", frozenset((5,)))])
|
||||
# self.META_MAP_R = {}
|
||||
# for metaname, metaids in self.META_MAP.items():
|
||||
# for metaid in metaids:
|
||||
# self.META_MAP_R[metaid] = metaname
|
||||
self.SEARCH_CATEGORIES = ("Drone", "Module", "Subsystem", "Charge", "Implant")
|
||||
|
||||
# Tell other threads that Market is at their service
|
||||
@@ -392,7 +394,12 @@ class Market():
|
||||
metaGroup = item.metaGroup
|
||||
return metaGroup
|
||||
|
||||
def getMarketGroupByItem(self, item):
|
||||
def getMetaGroupIdByItem(self, item, fallback=0):
|
||||
"""Get meta group ID by item"""
|
||||
id = getattr(self.getMetaGroupByItem(item), "ID", fallback)
|
||||
return id
|
||||
|
||||
def getMarketGroupByItem(self, item, parentcheck=True):
|
||||
"""Get market group by item, its ID or name"""
|
||||
# Check if we force market group for given item
|
||||
if item.name in self.ITEMS_FORCEDMARKETGROUP:
|
||||
@@ -400,15 +407,18 @@ class Market():
|
||||
# Check if item itself has market group
|
||||
elif item.marketGroupID:
|
||||
mgid = item.marketGroupID
|
||||
# If item doesn't have marketgroup, check if it has parent
|
||||
# item and use its market group
|
||||
elif self.getMetaGroupByItem(item.ID):
|
||||
parent = self.getItem(self.getMetaGroupByItem(item.ID).parentTypeID)
|
||||
mgid = parent.marketGroupID
|
||||
elif parentcheck:
|
||||
# If item doesn't have marketgroup, check if it has parent
|
||||
# item and use its market group
|
||||
if self.getMetaGroupByItem(item):
|
||||
parent = self.getItem(self.getMetaGroupByItem(item).parentTypeID)
|
||||
mgid = parent.marketGroupID
|
||||
else:
|
||||
mgid = None
|
||||
mg = self.getMarketGroup(mgid)
|
||||
return mg
|
||||
if mgid is not None:
|
||||
return self.getMarketGroup(mgid)
|
||||
else:
|
||||
return None
|
||||
|
||||
def getParentItemByItem(self, item):
|
||||
"""Get parent item by item"""
|
||||
@@ -425,13 +435,13 @@ class Market():
|
||||
# Get parent item
|
||||
parent = self.getParentItemByItem(item)
|
||||
# All its variations
|
||||
vars = eos.db.getVariations(parent)
|
||||
# Combine both in the same list
|
||||
vars.insert(0, parent)
|
||||
vars = set(eos.db.getVariations(parent))
|
||||
# Combine both in the same set
|
||||
vars.add(parent)
|
||||
# Check for overrides and add them if any
|
||||
if parent.name in self.ITEMS_FORCEDMETAGROUP_R:
|
||||
for itmn in self.ITEMS_FORCEDMETAGROUP_R[parent.name]:
|
||||
vars.append(self.getItem(itmn))
|
||||
vars.add(self.getItem(itmn))
|
||||
return vars
|
||||
|
||||
def getGroupsByCategory(self, cat):
|
||||
@@ -445,13 +455,14 @@ class Market():
|
||||
Returns a list, where each element is:
|
||||
(id, name, icon, does it has child market groups or not)
|
||||
"""
|
||||
children = []
|
||||
children = set()
|
||||
for child in mg.children:
|
||||
children.append((child.ID, child.name, self.getIconByMarketGroup(child), not child.hasTypes))
|
||||
children.add(child)
|
||||
return children
|
||||
|
||||
def getItemsByMarketGroup(self, mg):
|
||||
"""Get items in the given market group"""
|
||||
# TODO: probably it's better to compose list of parents first, then request variations due to performance reasons
|
||||
res = set()
|
||||
baseitms = mg.items
|
||||
if mg.ID in self.ITEMS_FORCEDMARKETGROUP_R:
|
||||
@@ -460,9 +471,32 @@ class Market():
|
||||
res.add(item)
|
||||
vars = self.getVariationsByItem(item)
|
||||
for var in vars:
|
||||
res.add(var)
|
||||
# There's no poin int additional requests if we already added item to results
|
||||
if var in res:
|
||||
continue
|
||||
# Exclude items with their own explicitly defined market groups
|
||||
if self.getMarketGroupByItem(var, parentcheck=False) is None:
|
||||
res.add(var)
|
||||
return res
|
||||
|
||||
def marketGroupHasTypesCheck(self, mg):
|
||||
"""If market group has any items, return true"""
|
||||
if mg.ID in self.ITEMS_FORCEDMARKETGROUP_R:
|
||||
return True
|
||||
elif not mg.hasTypes:
|
||||
return False
|
||||
elif len(mg.items) > 0:
|
||||
return True
|
||||
else:
|
||||
return False
|
||||
|
||||
def marketGroupValidityCheck(self, mg):
|
||||
"""Check market group validity"""
|
||||
if mg.hasTypes and not self.marketGroupHasTypesCheck(mg):
|
||||
return False
|
||||
else:
|
||||
return True
|
||||
|
||||
def getIconByMarketGroup(self, mg):
|
||||
"""Return icon associated to marketgroup"""
|
||||
if mg.icon:
|
||||
@@ -499,12 +533,12 @@ class Market():
|
||||
root.append((grp.ID, grp.name))
|
||||
return root
|
||||
|
||||
ROOT_MARKET_GROUPS = (9, #Modules
|
||||
1111, #Rigs
|
||||
157, #Drones
|
||||
11, #Ammo
|
||||
1112, #Subsystems
|
||||
24) #Implants & Boosters
|
||||
ROOT_MARKET_GROUPS = (9, # Modules
|
||||
1111, # Rigs
|
||||
157, # Drones
|
||||
11, # Ammo
|
||||
1112, # Subsystems
|
||||
24) # Implants & Boosters
|
||||
|
||||
def getMarketRoot(self):
|
||||
"""
|
||||
@@ -512,10 +546,10 @@ class Market():
|
||||
Returns a list, where each element is a tuple containing:
|
||||
the ID, the name and the icon of the group
|
||||
"""
|
||||
root = []
|
||||
root = set()
|
||||
for id in self.ROOT_MARKET_GROUPS:
|
||||
mg = self.getMarketGroup(id, eager="icon")
|
||||
root.append((id, mg.name, self.getIconByMarketGroup(mg)))
|
||||
root.add(mg)
|
||||
|
||||
return root
|
||||
|
||||
@@ -557,32 +591,10 @@ class Market():
|
||||
"""Return implant market group children"""
|
||||
return self.getMarketGroupChildren(27)
|
||||
|
||||
# def activateMetaGroup(self, name):
|
||||
# for meta in self.META_MAP[name]:
|
||||
# self.activeMetas.add(meta)
|
||||
#
|
||||
# def disableMetaGroup(self, name):
|
||||
# for meta in self.META_MAP[name]:
|
||||
# if meta in self.activeMetas:
|
||||
# self.activeMetas.remove(meta)
|
||||
#
|
||||
# def isMetaIdActive(self, meta):
|
||||
# return meta in self.activeMetas
|
||||
#
|
||||
# def filterItems(self, items):
|
||||
# filtered = []
|
||||
# activeMetas = self.activeMetas
|
||||
# for it in items:
|
||||
# if (it.metaGroup.ID if it.metaGroup is not None else 1) in activeMetas:
|
||||
# filtered.append(it)
|
||||
#
|
||||
# return filtered
|
||||
#
|
||||
# def getMetaName(self, metaId):
|
||||
# for name, ids in self.META_MAP.items():
|
||||
# for id in ids:
|
||||
# if metaId == id:
|
||||
# return name
|
||||
def filterItemsByMeta(self, items, metas):
|
||||
"""Filter items by meta lvl"""
|
||||
filtered = set(filter(lambda item: self.getMetaGroupIdByItem(item) in metas, items))
|
||||
return filtered
|
||||
|
||||
#################################
|
||||
# Price stuff, didn't modify it #
|
||||
|
||||
Reference in New Issue
Block a user