def RefreshSites(self):
trustScrollList = []
ignoreScrollList = []
for key, value in self.sitesSvc.GetTrustedSites().iteritems():
if value.auto:
continue
trustScrollList.append(
ScrollEntryNode(decoClass=SE_GenericCore,
label=key,
retval=key,
trustData=value,
GetMenu=self.OnGetTrustMenu))
for key, value in self.sitesSvc.GetIgnoredSites().iteritems():
if value.auto:
continue
ignoreScrollList.append(
ScrollEntryNode(decoClass=SE_GenericCore,
label=key,
retval=key,
trustData=value,
GetMenu=self.OnGetTrustMenu))
self.trustScroll.Load(contentList=trustScrollList)
self.ignoreScroll.Load(contentList=ignoreScrollList)
def ApplyAttributes(self, attributes):
super(EntityMonitor, self).ApplyAttributes(attributes)
self.SetMinSize([self.default_width, self.default_height])
self.SetHeight(self.default_height)
self.entityID = attributes.get('entID', 0)
self.SetCaption('Entity Monitor for %d' % self.entityID)
self.entityClient = sm.GetService('entityClient')
self.sr.content.scroll = Scroll(parent=self.sr.content,
top=14,
padding=5)
self.componentNodes = {}
self.componentDataNodes = {}
clientNodeData = {
'decoClass': SE_ListGroupCore,
'GetSubContent': self.GetClientNodes,
'label': 'Client',
'id': ('location', 'Client'),
'showicon': 'hide',
'showlen': False,
'state': 'locked'
}
self.clientNode = ScrollEntryNode(**clientNodeData)
serverNodeData = {
'decoClass': SE_ListGroupCore,
'GetSubContent': self.GetServerNodes,
'label': 'Server',
'id': ('location', 'Server'),
'showicon': 'hide',
'showlen': False,
'state': 'locked'
}
self.serverNode = ScrollEntryNode(**serverNodeData)
self.thread = uthread.new(self.LoadEntityThread)
def PrepareResultScrollEntries(self, results, *args):
scrollList = []
if not results:
scrollList.append(
ScrollEntryNode(label=GetByLabel(
'UI/Search/UniversalSearch/NoResultsReturned')))
else:
for groupEntry in results:
entryType, typeList = groupEntry['groupItems']
for entryData in typeList:
scrollList.append(
ScrollEntryNode(decoClass=SearchResultEntry,
**entryData))
return scrollList
def PopulateAttributes(self):
resManAttrs = [
('Pending loads', lambda: blue.resMan.pendingLoads),
('Pending prepares', lambda: blue.resMan.pendingPrepares),
('Prepares handled last tick',
lambda: blue.resMan.preparesHandledLastTick),
('Maximum prepares handled per tick',
lambda: blue.resMan.preparesHandledPerTickMax),
('Maximum time on main thread per tick',
lambda: FormatTime(blue.resMan.mainThreadMaxTime)),
('Average time in load queue',
lambda: FormatTime(blue.resMan.loadQueueTimeAverage)),
('Maximum time in load queue',
lambda: FormatTime(blue.resMan.loadQueueTimeMax)),
('Average time in prepare queue',
lambda: FormatTime(blue.resMan.prepareQueueTimeAverage)),
('Maximum time in prepare queue',
lambda: FormatTime(blue.resMan.prepareQueueTimeMax))
]
contentList = []
for attrDesc in resManAttrs:
text, getvalue = attrDesc
node = ScrollEntryNode(decoClass=NumberAttribute,
text=text,
getvalue=getvalue)
contentList.append(node)
self.attributes.Load(contentList=contentList)
def LoadHistory(self):
self.selected = None
scrolllist = []
for each in sm.GetService('urlhistory').GetHistory():
if each is not None:
try:
label = localization.GetByLabel(
'UI/Browser/BrowserHistory/Row',
title=each.title,
url=each.url,
date=each.ts)
scrolllist.append(
ScrollEntryNode(decoClass=SE_GenericCore,
label=label,
retval=each,
OnClick=self.OnEntryClick,
OnDblClick=self.OnEntryDblClick))
except:
continue
self.scroll.sr.id = 'history_window_scroll_id'
self.scroll.Load(
contentList=scrolllist,
headers=[
localization.GetByLabel('UI/Browser/BrowserHistory/Title'),
localization.GetByLabel('UI/Browser/BrowserHistory/URL'),
localization.GetByLabel('UI/Browser/BrowserHistory/Date')
])
def GetSceneListEntries(self, data, *args):
scene = data['scene']
self.sceneDataNodes[scene.sceneID] = {}
for entityID, entity in scene.entities.iteritems():
for componentName in self.componentFilters:
if not entity.HasComponent(componentName):
break
else:
name = self.GetEntityName(entity)
spawnID = self.GetEntitySpawnID(entity)
recipeID = self.GetEntityRecipeID(entity)
data = {
'decoClass':
SE_EntityBrowserEntry,
'label':
'%s<t>%s<t>%s<t>%s<t>%s' %
(entityID, name,
const.cef.ENTITY_STATE_NAMES[entity.state], spawnID,
recipeID),
'entityID':
entityID,
'OnDblClick':
self.DblClickEntry
}
node = ScrollEntryNode(**data)
self.sceneDataNodes[scene.sceneID][entityID] = node
return self.sceneDataNodes[scene.sceneID].values()
def RebuildScrollContents(self, objects, filter):
contentList = []
for key, value in objects.iteritems():
if filter and filter not in key.lower():
continue
label, delta = self.GetLabelForEntry(key, value)
listEntry = ScrollEntryNode(decoClass=SE_GenericCore,
id=id,
name=key,
label=label,
OnDblClick=self.ClassEntryDetails)
listEntry.Set('sort_Delta', delta)
contentList.append(listEntry)
self.scroll.Load(contentList=contentList,
headers=['Name', 'Delta', 'Count', 'Peak'])
def GetReferees(self, data, *args):
refList = []
object = data.instanceData
referrers = gc.get_referrers(object)
myref = stackless.getcurrent().frame
known = [
gc.garbage,
stackless.getcurrent().frame, object, data, self.scroll
]
for ref in referrers:
if ref not in known:
try:
objectName = self.GetObjectName(ref)
listEntry = ScrollEntryNode(decoClass=SE_GenericCore,
id=id,
name=objectName,
label=objectName,
sublevel=1)
refList.append(listEntry)
except Exception as e:
log.LogError(
'Failed naming reference! Need to do something about this error'
)
return refList
def GetScrollList(self):
scrolllist = []
if self.noChoiceLabel and len(self.entries) == 1:
data = KeyVal(label='<color=gray>%s' % self.noChoiceLabel,
icon=None,
selectable=False)
scrollEntry = ScrollEntryNode(**data.__dict__)
scrolllist.append(scrollEntry)
else:
for each in self.entries:
label = each[0]
if not label:
continue
data, returnValue = self.GetScrollEntry(*each)
scrollEntry = ScrollEntryNode(**data.__dict__)
scrolllist.append(scrollEntry)
return scrolllist
def LoadEntries(self, entries):
scrolllist = []
for entryName, entryValue, selected in entries:
scrolllist.append(
ScrollEntryNode(label=entryName,
value=entryValue,
isSelected=selected))
self.LoadContent(contentList=scrolllist)
def PopulateScroll(self, *args):
scrolllist = []
for ct in base.outstandingCallTimers:
method = ct[0]
t = ct[1]
label = '%s<t>%s<t>%s' % (method, util.FmtDate(t, 'nl'), util.FmtTime(blue.os.GetWallclockTimeNow() - t))
scrolllist.append(ScrollEntryNode(decoClass=SE_GenericCore, label=label))
self.scroll.Load(contentList=scrolllist, headers=['method', 'time', 'dt'])
def RefreshSites(self):
self.selected = None
scrolllist = []
for bookmark in sm.GetService('sites').GetBookmarks():
if bookmark is not None:
label = localization.GetByLabel('UI/Browser/EditBookmarks/Row', name=bookmark.name, url=bookmark.url)
scrolllist.append(ScrollEntryNode(decoClass=SE_GenericCore, label=label, retval=bookmark, OnClick=self.OnEntryClick))
self.scroll.Load(contentList=scrolllist, headers=[localization.GetByLabel('UI/Browser/EditBookmarks/TableLabel'), localization.GetByLabel('UI/Browser/EditBookmarks/TableURL')], noContentHint=localization.GetByLabel('UI/Browser/EditBookmarks/NoBookmarksFound'))
def LoadEntity(self):
entity = self.entityClient.FindEntityByID(self.entityID)
if not entity:
self.SetCaption('Entity Monitor for %d (NOT FOUND)' %
self.entityID)
self.componentNodes = {}
self.componentDataNodes = {}
self.sr.content.scroll.LoadContent(contentList=[])
return
newComponents = {}
newComponents['client'] = entity.components.keys()
newComponents['server'] = []
if not self.entityClient.IsClientSideOnly(entity.scene.sceneID):
newComponents['server'] = sm.RemoteSvc(
'entityServer').GetServerComponentNames(
self.entityID) or newComponents['server']
requiresUpdate = False
for componentLocation in newComponents:
for componentName in newComponents[componentLocation]:
nodeName = '%s - %s' % (componentName,
componentLocation.upper())
if nodeName not in self.componentNodes:
requiresUpdate = True
data = {
'decoClass': SE_ListGroupCore,
'GetSubContent': self.GetComponentListEntries,
'label': componentName,
'id': ('component', nodeName),
'showicon': 'hide',
'showlen': False,
'componentName': componentName,
'location': componentLocation,
'sublevel': 1,
'state': 'locked'
}
node = ScrollEntryNode(**data)
self.componentNodes[nodeName] = node
if nodeName in self.componentDataNodes:
if componentLocation == 'client':
state = self.entityClient.GetComponentStateByID(
self.entityID, componentName)
elif componentLocation == 'server':
state = self.entityClient.ServerReportState(
self.entityID, componentName)
if state:
for name, value in state.iteritems():
label = '%s<t>%s' % (name, value)
if name in self.componentDataNodes[nodeName]:
if self.componentDataNodes[nodeName][
name].panel:
self.componentDataNodes[nodeName][
name].panel.sr.label.SetText(label)
if requiresUpdate:
self.sr.content.scroll.LoadContent(
contentList=[self.clientNode, self.serverNode],
headers=['name', 'value'])
def _AddUIObject(self, uiObject, scrollList, lvl, isExpanded = False, objectLabel = None, isExpandable = False):
if len(scrollList) > 1 and lvl:
for i in xrange(1, len(scrollList) - 1):
last = scrollList[-i]
if last.level < lvl:
break
if lvl not in last.connectLevels:
last.connectLevels.append(lvl)
node = ScrollEntryNode(decoClass=UITreeEntry, uiObject=uiObject, level=lvl, isExpanded=isExpanded, objectLabel=objectLabel, isExpandable=isExpandable, connectLevels=[lvl])
scrollList.append(node)
def GetEntryForObject(self, wr, filename, isCachedStr):
typename = type(wr.object).__name__
memory = 0
if hasattr(wr.object, 'GetMemoryUsage'):
memory = wr.object.GetMemoryUsage()
pyRC, blueRC = wr.object.GetRefCounts()
label = '%s<t>%s<t>%s<t>%s<t>%s<t>%s' % (filename, typename, memory,
isCachedStr, blueRC, pyRC)
listEntry = ScrollEntryNode(decoClass=SE_GenericCore,
id=id,
label=label,
object_ref=wr)
return listEntry
def GetSearchData(self, searchString):
self.scrollListResult = []
searchString = Encode(searchString)
searchString = searchString.lstrip()
settings.char.ui.Set('mapView_searchString', searchString)
if len(searchString) >= 64:
self.scrollListResult.append(
ScrollEntryNode(
label=GetByLabel('UI/Common/SearchStringTooLong')))
elif len(searchString) >= const.searchMinWildcardLength:
self.searchInput.SetValue(searchString, docallback=False)
results = Search(searchString, self.searchFor, getWindow=False)
self.scrollListResult = self.PrepareResultScrollEntries(results)
return self.scrollListResult
def LoadScroll(self):
scrolllist = []
for funcName in dir(uicore.animations):
if funcName.startswith('_'):
continue
func = getattr(uicore.animations, funcName)
if not callable(func):
continue
node = ScrollEntryNode(decoClass=TestAnimationsCheckbox,
label=funcName,
animFunc=func)
scrolllist.append(node)
self.scroll.Load(contentList=scrolllist)
def _GetAvailableEncounters(self):
encounters = self.encounterSpawnServer.GetMyEncounters()
contentList = []
for encounter in encounters:
data = {
'text': encounter['encounterName'],
'label': encounter['encounterName'],
'id': encounter['encounterID'],
'encounterID': encounter['encounterID'],
'disableToggle': True,
'hint': encounter['encounterName']
}
contentList.append(ScrollEntryNode(**data))
return contentList
def AddCheckBox(self, config, scrolllist, group=None, sublevel=0):
cfgname, retval, desc, default = config
data = {}
data['label'] = desc
data['checked'] = default
data['cfgname'] = cfgname
data['retval'] = retval
data['group'] = group
data['OnChange'] = self.OnColorModeScrollCheckBoxChange
data['entryWidth'] = COLORMODE_MENU_WIDTH
data['decoClass'] = MapViewCheckbox
scrollNode = ScrollEntryNode(**data)
if scrolllist is not None:
scrolllist.append(scrollNode)
else:
return scrollNode
def GetNodesFromLogMessage(self, timestamp, facility, level, log_object,
msg):
s = LOGTYPE_MAPPING.get(level, ('Unknown', '0xffeeeeee'))
lineno = 0
nodes = []
timestampAsString = util.FmtDate(timestamp, 'nl')
for line in msg.split('\n'):
label = '%s<t>%s<t>%s::%s<t><color=%s>%s</color><t>%s' % (
str(timestamp + lineno)[-15:], timestampAsString, facility,
log_object, s[1], s[0], line.replace('<', '<'))
nodes.append(ScrollEntryNode(decoClass=SE_GenericCore,
label=label))
lineno += 1
if self.logSaveHandle:
txt = '%s\t%s::%s\t%s\t%s\n' % (timestampAsString, facility,
log_object, s[0], msg)
self.logSaveHandle.Write(txt)
return nodes
def PopulateScroll(self, *args):
contentList = []
history = list(base.methodCallHistory)
history.reverse()
filter = self.filterEdit.text
count = 0
for ct in history:
method = ct[0]
if filter and filter not in method.lower():
continue
t = ct[1]
label = '%s<t>%s<t>%s' % (method, util.FmtDate(
t, 'nl'), ct[2] / const.MSEC)
contentList.append(
ScrollEntryNode(decoClass=SE_GenericCore, label=label))
count += 1
if count == 100:
break
self.scroll.Load(contentList=contentList,
headers=['method', 'time', 'ms'])
def PopulateScroll(self, *args):
typesIncluded = []
if self.showTimersChk.GetValue():
typesIncluded.append('time')
if self.showMemoryChk.GetValue():
typesIncluded.append('memory')
if self.showLowCountersChk.GetValue():
typesIncluded.append('counterLow')
if self.showHighCountersChk.GetValue():
typesIncluded.append('counterHigh')
stats = blue.statistics.GetValues()
desc = blue.statistics.GetDescriptions()
contentList = []
for key, value in desc.iteritems():
type = value[1]
if type in typesIncluded:
peak = stats[key][1]
if type == 'memory':
label = '%s<t>%s<t>%s' % (key, FormatMemory(peak),
value[0])
elif type.startswith('counter'):
label = '%s<t>%s<t>%s' % (key, niceNum(peak, 1), value[0])
elif type == 'time':
label = '%s<t>%s<t>%s' % (key, niceNum(peak,
1e-10), value[0])
listEntry = ScrollEntryNode(
decoClass=SE_GenericCore,
id=id,
name=key,
peak=peak,
desc=value[0],
label=label,
GetMenu=self.GetListEntryMenu,
OnDblClick=self.OnListEntryDoubleClicked)
contentList.append(listEntry)
self.scroll.Load(contentList=contentList,
headers=['Name', 'Peak', 'Description'],
noContentHint='No Data available')
def GetComponentListEntries(self, data, *args):
componentName = data['componentName']
location = data['location']
nodeName = '%s - %s' % (componentName, location.upper())
self.componentDataNodes[nodeName] = {}
if location == 'client':
state = self.entityClient.GetComponentStateByID(
self.entityID, componentName)
elif location == 'server':
state = self.entityClient.ServerReportState(
self.entityID, componentName)
if state:
for name, value in state.iteritems():
data = {
'label': '%s<t>%s' % (name, value),
'sublevel': 1,
'id': (nodeName, name)
}
node = ScrollEntryNode(**data)
self.componentDataNodes[nodeName][name] = node
return self.componentDataNodes[nodeName].values()
def LoadScenes(self, forceUpdate=False):
newScenes = self.entityClient.scenes.iteritems()
requiresUpdate = False
if forceUpdate or len(
set(self.sceneNodes.keys()) -
set(self.entityClient.scenes.keys())) != 0:
self.sceneNodes = {}
for sceneID, scene in newScenes:
if sceneID not in self.sceneNodes:
requiresUpdate = True
name = self.GetSceneName(sceneID)
data = {
'decoClass': SE_EntityBrowserGroup,
'GetSubContent': self.GetSceneListEntries,
'label':
'%d<t>%s (%s)' % (sceneID, name, len(scene.entities)),
'id': ('scene', sceneID),
'state': 'locked',
'showlen': False,
'scene': scene
}
node = ScrollEntryNode(**data)
self.sceneNodes[sceneID] = node
if sceneID in self.sceneDataNodes:
if len(scene.entities) != len(self.sceneDataNodes[sceneID]):
requiresUpdate = True
else:
for entityID in scene.entities:
if entityID not in self.sceneDataNodes[sceneID]:
requiresUpdate = True
break
if requiresUpdate or forceUpdate:
self.sr.content.scroll.LoadContent(
contentList=self.sceneNodes.values(),
headers=['ID', 'Name', 'State', 'SpawnID', 'RecipeID'])
def ShowPropertiesForObject(self, uiObject):
if uiObject is None:
return
try:
len(uiObject)
self.attributeScroll.LoadContent(contentList=[])
return
except:
pass
self._selectedObject = weakref.ref(uiObject)
level = 0
newNodes = []
if isinstance(uiObject, Base):
combined = []
if hasattr(uiObject, 'color'):
combined.append(
('color', ('color.r', 'color.g', 'color.b', 'color.a')))
for propertyName, subs in combined:
propertyNode = ScrollEntryNode(decoClass=UITreePropertyEntry,
uiObject=uiObject,
level=level,
propertyName=propertyName,
combineProperties=subs)
newNodes.append(propertyNode)
basics = [
'name', 'pos', 'opacity', 'padding', 'displayRect', 'display',
'pickState', 'align', 'clipChildren', 'pickRadius',
'absoluteCoordinates', 'cacheContents', 'text', 'blendMode',
'spriteEffect', 'effectAmount', 'effectAmount2', 'glowColor',
'glowFactor', 'glowExpand', 'useSizeFromTexture', 'rotation',
'rotationCenter', 'scale', 'scalingCenter', 'scalingRotation',
'', '__guid__', '__class__'
]
for propertyName in basics:
prop = getattr(uiObject, propertyName, '_!_')
if prop == '_!_':
continue
propertyNode = ScrollEntryNode(decoClass=UITreePropertyEntry,
uiObject=uiObject,
level=level,
propertyName=propertyName)
newNodes.append(propertyNode)
else:
for attr in dir(uiObject):
if attr[0] == attr[0].upper():
continue
if attr[0] == '_':
continue
if attr in ('children', 'background'):
continue
propertyNode = ScrollEntryNode(decoClass=UITreePropertyEntry,
uiObject=uiObject,
level=level,
propertyName=attr)
newNodes.append((attr, propertyNode))
newNodes = SortListOfTuples(newNodes)
self.ReloadUIRoots()
self.attributeScroll.LoadContent(contentList=newNodes)
