def buildEdgeList(self):
''' populate the ui tree with the edges that can be extended'''
self.edgeList = []
treeExists = False
if self.edges_TW.topLevelItem(0):
treeExists = True
parentItem = self.edges_TW.topLevelItem(0)
else:
self.edges_TW.clear()
parentItem = QTreeWidgetItem()
faceName = self.face_LE.text()
parentItem.setText(0, faceName)
self.edges_TW.addTopLevelItem(parentItem)
self.edges_TW.expandItem(parentItem)
if not treeExists:
for edgeNum in self.helperFace.ExtendableEdges:
###### populate the edge tree ######
edgeItem = QTreeWidgetItem()
edgeItem.setText(0, str("Edge" + str(edgeNum)))
checked = QtCore.Qt.Unchecked
if edgeNum in self.helperFace.CheckedEdges:
checked = QtCore.Qt.Checked
edgeItem.setCheckState(0, checked)
parentItem.addChild(edgeItem)
self.loadTools()
class LoadThings(QUndoCommand):
def __init__(self, widget, thing):
super(LoadThings, self).__init__()
self.widget = widget
self.createdThing = thing
self.item = QTreeWidgetItem()
self.item.setText(0, thing.name)
typeName = type(thing).__name__
for i in range(self.widget.ui.treeWidget.topLevelItemCount()):
group = self.widget.ui.treeWidget.topLevelItem(i)
if group.text(0) == typeName:
self.group = group
break
else: # group not found
self.group = QTreeWidgetItem()
self.group.setText(0, typeName)
def redo(self):
if self.widget.ui.treeWidget.indexOfTopLevelItem(self.group) == -1:
self.widget.ui.treeWidget.addTopLevelItem(self.group)
self.group.addChild(self.item)
self.group.setExpanded(True)
self.widget.ui.treeWidget.setCurrentItem(self.item)
def undo(self):
self.group.takeChild(self.group.childCount()-1)
if self.group.childCount() == 0:
parentIndex = self.widget.ui.treeWidget.indexOfTopLevelItem(self.group)
self.widget.ui.treeWidget.takeTopLevelItem(parentIndex)
def fill_item(item, value, level):
item.setExpanded(True)
if type(value) is dict:
for key, val in sorted(value.items()):
child = QTreeWidgetItem()
child.setText(level, str(key))
item.addChild(child)
fill_item(child, val, level+1)
elif type(value) is list:
for val in value:
child = QTreeWidgetItem()
item.addChild(child)
if type(val) is dict:
child.setText(level, '[dict]')
fill_item(child, val, level+1)
elif type(val) is list:
child.setText(level, '[list]')
fill_item(child, val, level+1)
else:
child.setText(level, str(val))
child.setExpanded(True)
else:
child = QTreeWidgetItem()
child.setText(level, str(value))
item.addChild(child)
def update(self):
items = []
playerx, playery = 0, 0
for objid, obj in self.worldviewer.world_objects.items():
if "Object.ScriptedObject.Character" in obj['_types']:
playerx = obj['loc']['x']
playery = obj['loc']['y']
break
for objid, obj in self.worldviewer.world_objects.items():
name = obj['name']
try:
locx = obj['loc']['x']
except KeyError:
continue
locy = obj['loc']['y']
locz = obj['loc']['z']
resource = obj['resource']
last_modified = datetime.datetime.fromtimestamp(int(str(obj['last_modified']['$date'])[:-3]))
row = self.objects_tree.findItems(objid, Qt.MatchExactly, column=0)
if row:
# Update it if it exists already
item = row[0]
if not row:
# If Item does not exist in the tree widget already, make a new one.
item = QTreeWidgetItem(self.objects_tree)
items.append(item)
for i, param in enumerate((objid, name, (locx, locy, locz), resource, last_modified, "%04d" % euclidian(locx, locy, playerx, playery))):
item.setText(i, str(param))
if items:
self.objects_tree.insertTopLevelItems(0, items)
def addItemForExpense(self, topLevelItem, ex):
ex_str = "%-5d %s\n(%s -> %s)" % (ex.value, ex.desc, self.__envMgr.envNameForId(ex.fromId),
self.__envMgr.envNameForId(ex.toId))
ex_item = QTreeWidgetItem([ex_str])
ex_item.setText(0, ex_str)
ex_item.setData(0, Qt.UserRole, ex)
topLevelItem.insertChild(0, ex_item)
def fill_item(self,item, value):
item.setExpanded(True)
if type(value) is dict:
for key, val in sorted(value.iteritems()):
child = QTreeWidgetItem()
x = "{0:.3f}".format(key)
# x = key
child.setText(0, unicode(x))
child.setFlags(Qt.ItemIsEnabled)
item.addChild(child)
self.fill_item(child, val)
elif type(value) is list:
for val in value:
child = QTreeWidgetItem()
item.addChild(child)
if type(val) is dict:
child.setText(0, '[dict]')
self.fill_item(child, val)
elif type(val) is list:
child.setText(0, '[list]')
self.fill_item(child, val)
else:
child.setText(0, str(value.index(val)))
child.setExpanded(True)
else:
print 'hi'
child = QTreeWidgetItem()
child.setText(0, unicode(value))
item.addChild(child)
def add_children(self, node, item):
for child in node.children:
childItem = QTreeWidgetItem()
childItem.setText(0, child.label)
childItem.setData(1,Qt.ItemDataRole.EditRole, child)
item.addChild(childItem)
self.add_children(child, childItem)
def set_favorites(self, favoritesRoot):
self.tree.clear()
item = QTreeWidgetItem()
item.setText(0, favoritesRoot.label)
item.setData(1,Qt.ItemDataRole.EditRole, favoritesRoot)
self.tree.addTopLevelItem(item)
self.add_children(favoritesRoot, item)
def add_child(self):
item = self.tree.currentItem()
print item.data(1, Qt.ItemDataRole.EditRole).getFullPath()
newItem = add_child(item.data(1, Qt.ItemDataRole.EditRole))
newChildNode = QTreeWidgetItem()
newChildNode.setText(0, newItem.label)
newChildNode.setData(1, Qt.ItemDataRole.EditRole, newItem)
item.addChild(newChildNode)
def cmd_loadList(self):
self.treeWidget.clear()
sels = pymel.core.ls(sl=1, type='transform')
data = []
for sel in sels:
widgetItem = QTreeWidgetItem(self.treeWidget)
widgetItem.setText(0, sel.name())
widgetItem.setText(1, sel.nodeName().split('_')[-1])
widgetItem.setFlags(widgetItem.flags() | QtCore.Qt.ItemIsEditable)
data.append([widgetItem.text(0), widgetItem.text(1)])
def fill_item(self, item, value): #recursively fills the tree
item.setExpanded(True)
for key, val in sorted(value.iteritems()): #tilts
child = QTreeWidgetItem()
child.setText(0, unicode(key))
child.setFlags(Qt.ItemIsEnabled)
item.addChild(child)
for keykey in sorted(val.keys()): #imgIDs
childchild = QTreeWidgetItem()
child.addChild(childchild)
childchild.setText(0, str(keykey))
child.setExpanded(True)
childchild.setExpanded(True)
def _refresh_value_tree(self, directory_info):
info = sorted(directory_info, key=lambda x: x.total_size, reverse=True)
# Clear
for _ in range(self.value_tree.topLevelItemCount()):
self.value_tree.takeTopLevelItem(0)
# Add
for item in info:
tree_widget = QTreeWidgetItem()
tree_widget.setText(0, item.part_path)
tree_widget.setText(1, self._get_size(item.total_size))
self.value_tree.addTopLevelItem(tree_widget)
def updateTree(self, name):
''' adds DataItem to tree view '''
dataItem = QTreeWidgetItem(self.ui.dataView)
dataItem.setText(0, name)
dataItem.setFlags(Qt.ItemIsEnabled|Qt.ItemIsEditable)
for i in range(len(self.datas[-1].data)/4):
x = DataItem(dataItem)
x.setText(0, self.datas[-1].name[i*4])
x.setFlags(Qt.ItemIsEnabled|Qt.ItemIsSelectable)
x.setNumData(self.datas[-1].data[i*4])
if hasattr(self.datas[-1], 'triggers'):
x.triggers = self.datas[-1].triggers
if hasattr(self.datas[-1], 'frames'):
x.depth = self.datas[-1].seekFrame
def add_to_tree(self):
if self.mysql.do:
self.nDataBase = self.mysql.getDataBase()
for i in self.nDataBase:
item_m = QTreeWidgetItem(self)
item_m.setStatusTip(0, 'main')
item_m.setText(0, "%s" % i)
if i in self.li:
item_m.setExpanded(True)
self.table = self.mysql.getTables(i)
for j in self.table:
item_c = QTreeWidgetItem(item_m)
item_c.setStatusTip(0, i)
item_c.setText(0, "%s" % j)
def _refresh_key_tree(self, directory_info, ignore_list=None):
info = LabelInfo(make_dictionary_by_classification(directory_info, ignore_list))
# Clear
for _ in range(self.key_tree.topLevelItemCount()):
self.key_tree.takeTopLevelItem(0)
# Add
for k, v in info.sort_dictionary:
tree_widget = QTreeWidgetItem()
tree_widget.setText(0, k)
total_size = 0
for child in v['children']:
total_size += child.total_size
tree_widget.setText(1, self._get_size(v[constant.sort_size_name]))
self.key_tree.addTopLevelItem(tree_widget)
self._last_info = info
def readData(self, *args):
data = super(Widget_objectList,
self).readData(Widget_objectList.path_uiInfo)
if not type(data) == dict: return
self.treeWidget.clear()
keys = data.keys()
keys.sort()
for key in keys:
try:
nodeName, attrName = data[key]
except:
return
widgetItem = QTreeWidgetItem(self.treeWidget)
widgetItem.setText(0, nodeName)
widgetItem.setText(1, attrName)
widgetItem.setFlags(widgetItem.flags() | QtCore.Qt.ItemIsEditable)
def getTopLevelItemForDate(self, tw, date):
"""
@type tw: QListWidget
"""
for i in range(tw.topLevelItemCount()):
item = tw.topLevelItem(i)
if item is None:
continue
item_date = item.data(0, Qt.UserRole)
if date == item_date:
return item
item = QTreeWidgetItem([str(date)])
item.setData(0, Qt.UserRole, date)
item.setText(0, date.strftime("%A, ") + str(date))
# FIXME: do we always need to insert at zero idx?
tw.insertTopLevelItem(0, item)
return item
def loadControllers(self):
self.treeWidget.clear()
sels = pymel.core.ls( sl=1 )
currentParent = self.treeWidget
self.items = []
for sel in sels:
widgetItem = QTreeWidgetItem( currentParent )
widgetItem.realObject = sel
widgetItem.setText( 0, sel.name() )
if isinstance( currentParent, QTreeWidgetItem ):
currentParent.setExpanded( True )
currentParent = widgetItem
self.items.append( sel.name() )
self.saveInfo()
def addStatus(self, text, err):
subTreeItem = QTreeWidgetItem(self.status)
subTreeItem.setText(0, text)
self.activateWindow()
if err == 1:
font = QFont('Serif', 10, QFont.Bold)
subTreeItem.setFont(0, font)
subTreeItem.setForeground(0, QBrush(Qt.white))
subTreeItem.setBackground(0, QBrush(QColor(150,0,0)))
elif err == 0:
font = QFont('Serif', 10, QFont.Bold)
subTreeItem.setFont(0, font)
subTreeItem.setForeground(0, QBrush(Qt.black))
subTreeItem.setBackground(0, QBrush(Qt.white))
else:
font = QFont('Serif', 10, QFont.Bold)
subTreeItem.setFont(0, font)
subTreeItem.setForeground(0, QBrush(Qt.white))
subTreeItem.setBackground(0, QBrush(QColor(0,150,0)))
self.status.scrollToItem(subTreeItem, QAbstractItemView.PositionAtCenter)
def _addMachineToDeployedList(self, ip_address, comment, host):
'''Adds the given machine to the list of the user deployed ones'''
itm = QTreeWidgetItem()
itm.setText(0, ip_address)
itm.setText(1, comment)
itm.setText(2, host)
self._mywindow.tw_deployed.addTopLevelItem(itm)
def _showDwordCompares(self):
"""
Inspects the *whole* binary looking for comparisons between
global dwords and immediate values. These usually contain error
codes or alike and appear constantly through the code.
"""
self._console_output("Looking for Dword compares...")
self.tree_label.setText("Dword immediate compares")
dw_dict = self.ba.get_dword_compares()
# Fill the tree with items
self.tree.setHeaderLabels(("Dword", "Values", "Address"))
for dw, values in dw_dict.iteritems():
dw_item = QTreeWidgetItem(self.tree)
dw_item.setText(0, dw)
for value, addr in values:
value_item = QTreeWidgetItem(dw_item)
value_item.setText(1, value)
value_item.setText(2, "0x%x" % addr)
# Display all items expanded initially
self.tree.expandAll()
def _showBannedFunctions(self):
"""
Points to functions banned by Microsoft being used.
"""
self._console_output("Looking for banned functions...")
deep_search_f = self.config.deep_dangerous_functions
if deep_search_f:
self._console_output("Performing a deep search \
(based on function name)")
banned_refs_dict = self.vd.find_banned_functions(deep_search_f)
if not banned_refs_dict:
self._console_output("[!] No banned functions found", err = True)
return
self.tree_label.setText("Functions banned by Microsoft")
self.tree.clear()
self.tree.setHeaderLabels(("Banned function", "References", "Name"))
for f_name, refs in banned_refs_dict.iteritems():
bf_item = QTreeWidgetItem(self.tree)
bf_item.setText(0, f_name)
for ref_addr in refs:
ref_item = QTreeWidgetItem(bf_item)
ref_item.setText(1, "%x" % ref_addr)
ref_name = misc.get_function_name(ref_addr)
ref_item.setText(2, ref_name)
# Display all items expanded initially
self.tree.expandAll()
def _showDwordCompares(self):
"""
Inspects the *whole* binary looking for comparisons between
global dwords and immediate values. These usually contain error
codes or alike and appear constantly through the code.
"""
self._console_output("Looking for Dword compares...")
self.tree_label.setText("Dword immediate compares")
dw_dict = self.ba.get_dword_compares()
# Fill the tree with items
self.tree.setHeaderLabels(("Dword", "Values", "Address"))
for dw, values in dw_dict.iteritems():
dw_item = QTreeWidgetItem(self.tree)
dw_item.setText(0, dw)
for value, addr in values:
value_item = QTreeWidgetItem(dw_item)
value_item.setText(1, value)
value_item.setText(2, "%x" %addr)
# Display all items expanded initially
self.tree.expandAll()
def _showBannedFunctions(self):
"""
Points to functions banned by Microsoft being used.
"""
self._console_output("Looking for banned functions...")
deep_search_f = self.config.deep_dangerous_functions
if deep_search_f:
self._console_output("Performing a deep search (based on function name)")
banned_refs_dict = self.vd.find_banned_functions(deep_search_f)
if not banned_refs_dict:
self._console_output("[!] No banned functions found", err = True)
return
self.tree_label.setText("Functions banned by Microsoft")
self.tree.clear()
self.tree.setHeaderLabels(("Banned function", "References", "Name"))
for f_name, refs in banned_refs_dict.iteritems():
bf_item = QTreeWidgetItem(self.tree)
bf_item.setText(0, f_name)
for ref_addr in refs:
ref_item = QTreeWidgetItem(bf_item)
ref_item.setText(1, "%x" %ref_addr)
ref_name = misc.get_function_name(ref_addr)
ref_item.setText(2, ref_name)
# Display all items expanded initially
self.tree.expandAll()
def _addMachineToDeployedList(self, ip_address, comment, host):
'''Adds the given machine to the list of the user deployed ones'''
itm = QTreeWidgetItem()
itm.setText(0, ip_address)
itm.setText(1, comment)
itm.setText(2, host)
self._mywindow.tw_deployed.addTopLevelItem(itm)
def import_from_text_file(self):
arquivo_Caminho = QFileDialog.getOpenFileName(
None, "Select txt file", '/', "(*.txt);; All Files (*.*)", None)[0]
filename = arquivo_Caminho
self.f = open(filename)
reader = csv.reader(self.f, delimiter='\t')
linhas = [linha for linha in reader]
for i in linhas:
if len(i) == 0:
continue
else:
print i
a = QTreeWidgetItem(self.ui.treeWidget)
a.setText(0, str(i[0]))
a.setText(1, str(i[1]))
a.setText(2, str(i[2]))
a.setText(3, str(i[3]))
def loadInfo(self):
data = BaseCommands.readData( self.uiInfoPath )
if not data.has_key( 'controllers' ): return None
controllerList = data[ 'controllers' ]
controllers = []
for controller in controllerList:
if not pymel.core.ls( controller ): continue
controllers.append( pymel.core.ls( controller )[0] )
self.treeWidget.clear()
currentParent = self.treeWidget
self.items = []
for sel in controllers:
widgetItem = QTreeWidgetItem( currentParent )
widgetItem.realObject = sel
widgetItem.setText( 0, sel.name() )
if isinstance( currentParent, QTreeWidgetItem ):
currentParent.setExpanded( True )
currentParent = widgetItem
self.items.append( sel.name() )
def update(self):
items = []
playerx, playery = 0, 0
for objid, obj in self.worldviewer.world_objects.items():
if "Object.ScriptedObject.Character" in obj['_types']:
playerx = obj['loc']['x']
playery = obj['loc']['y']
break
for objid, obj in self.worldviewer.world_objects.items():
name = obj['name']
try:
locx = obj['loc']['x']
except KeyError:
continue
locy = obj['loc']['y']
locz = obj['loc']['z']
resource = obj['resource']
last_modified = datetime.datetime.fromtimestamp(
int(str(obj['last_modified']['$date'])[:-3]))
row = self.objects_tree.findItems(objid, Qt.MatchExactly, column=0)
if row:
# Update it if it exists already
item = row[0]
if not row:
# If Item does not exist in the tree widget already, make a new one.
item = QTreeWidgetItem(self.objects_tree)
items.append(item)
for i, param in enumerate(
(objid, name, (locx, locy, locz), resource, last_modified,
"%04d" % euclidian(locx, locy, playerx, playery))):
item.setText(i, str(param))
if items:
self.objects_tree.insertTopLevelItems(0, items)
def _populateTree(self):
self.pushupsListWidget.clear()
self.pushupsListWidget.setColumnCount(4)
self.pushupsListWidget.setHeaderLabels([
"Date", "TotalPushups", "Series", "Repetitions",
"Average Heart Rate"
])
self.pushupsListWidget.setSortingEnabled(True)
self.pushupsListWidget.setColumnWidth(0, 180)
self.pushupsListWidget.setColumnWidth(4, 150)
pushupDict = self._getPushupDictionary()
for it, dayOfExercise in enumerate(sorted(pushupDict.keys())):
dateItem = QTreeWidgetItem()
dayLabel = dayOfExercise.strftime("%Y/%m/%d")
dateItem.setText(0, "\n" + dayLabel + "\nDay : " + str(it))
self.pushupsListWidget.addTopLevelItem(dateItem)
totalPushups = 0
for pushup in pushupDict[dayOfExercise]:
pushupItem = QTreeWidgetItem()
pushupItem.setText(2, "#" + str(pushup._series))
pushupItem.setText(3, str(pushup._repetitions))
pushupItem.setText(4, str(pushup._averageHeartRate))
pushupItem.setData(0, Qt.UserRole, pushup)
totalPushups = totalPushups + pushup._repetitions
dateItem.addChild(pushupItem)
dateItem.setText(1, str(totalPushups))
def _populateTree(self):
self.pushupsListWidget.clear()
self.pushupsListWidget.setColumnCount(4)
self.pushupsListWidget.setHeaderLabels(["Date", "TotalPushups",
"Series", "Repetitions",
"Average Heart Rate"])
self.pushupsListWidget.setSortingEnabled(True)
self.pushupsListWidget.setColumnWidth(0, 180)
self.pushupsListWidget.setColumnWidth(4, 150)
pushupDict = self._getPushupDictionary()
for it, dayOfExercise in enumerate(sorted(pushupDict.keys())):
dateItem = QTreeWidgetItem()
dayLabel = dayOfExercise.strftime("%Y/%m/%d")
dateItem.setText(0, "\n" + dayLabel + "\nDay : " + str(it))
self.pushupsListWidget.addTopLevelItem(dateItem)
totalPushups = 0
for pushup in pushupDict[dayOfExercise]:
pushupItem = QTreeWidgetItem()
pushupItem.setText(2, "#" + str(pushup._series))
pushupItem.setText(3, str(pushup._repetitions))
pushupItem.setText(4, str(pushup._averageHeartRate))
pushupItem.setData(0, Qt.UserRole, pushup)
totalPushups = totalPushups + pushup._repetitions
dateItem.addChild(pushupItem)
dateItem.setText(1, str(totalPushups))
def _addRunningVmToList(self, lst):
'''adds a vm to the running vm list from a list of strings'''
#FIXME: use a dict
itm = QTreeWidgetItem()
itm.setText(0, lst[0])
itm.setText(1, lst[1])
itm.setText(2, lst[2])
itm.setText(3, lst[3])
itm.setText(4, lst[4])
itm.setText(5, lst[5])
self._mywindow.tw_running_vms.addTopLevelItem(itm)
def _addRunningVmToList(self, lst):
'''adds a vm to the running vm list from a list of strings'''
#FIXME: use a dict
itm = QTreeWidgetItem()
itm.setText(0, lst[0])
itm.setText(1, lst[1])
itm.setText(2, lst[2])
itm.setText(3, lst[3])
itm.setText(4, lst[4])
itm.setText(5, lst[5])
self._mywindow.tw_running_vms.addTopLevelItem(itm)
def update(self):
"""
Updates listed publishers, newspapers and subscribers
"""
self.view.publishers.clear()
self.view.subscribers.clear()
for publisher in self.publishers.values():
p_widget = QTreeWidgetItem()
p_widget.setText(0, publisher.name)
for newspaper in publisher.newspapers:
n_widget = QTreeWidgetItem(p_widget)
n_widget.setText(0, newspaper)
self.view.publishers.addTopLevelItem(p_widget)
for subscriber in self.subscribers:
s_widget = QTreeWidgetItem()
s_widget.setText(0, subscriber)
self.view.subscribers.addTopLevelItem(s_widget)
def __init__(self, mainwindow, config):
super(SettingsDialog, self).__init__()
self.setWindowTitle(self.str_title)
# Reference kept to set settings in MainWindow
self.mainwindow = mainwindow
"""A reference to the top window of the app."""
self.config = config
"""The settings of our app."""
# Setting log handlers
logHandlers = QGroupBox(self.str_logHandlers)
logHandlersLayout = QVBoxLayout()
logHandlers.setLayout(logHandlersLayout)
logToGui = QCheckBox(self.str_logToGui)
logToGui.setChecked(self.config.getboolean('LogHandlers', 'gui'))
logToGui.stateChanged.connect(
lambda: self.chooseHandler(logToGui, 'gui'))
logHandlersLayout.addWidget(logToGui)
logtoStdout = QCheckBox(self.str_logToStdout)
logtoStdout.setChecked(self.config.getboolean('LogHandlers', 'stdout'))
logtoStdout.stateChanged.connect(
lambda: self.chooseHandler(logtoStdout, 'stdout'))
logHandlersLayout.addWidget(logtoStdout)
logToFile = QCheckBox(self.str_logToFile)
logToFile.setChecked(self.config.getboolean('LogHandlers', 'file'))
logToFile.stateChanged.connect(
lambda: self.chooseHandler(logToFile, 'file'))
logHandlersLayout.addWidget(logToFile)
# Setting log verbosity
logVerbosity = QGroupBox(self.str_logVerbosity)
logVerbosityLayout = QHBoxLayout()
logVerbosity.setLayout(logVerbosityLayout)
self.verbosityOptions = QTreeWidget()
self.verbosityOptions.header().setVisible(False)
for k, v in self.str_treeItems.items():
node = QTreeWidgetItem(self.verbosityOptions, [k])
if isinstance(v, str):
node.setText(1, v)
node.setCheckState(
0, boolToCheckState(
self.config.getboolean('LogVerbosity', v)))
else:
count = 0
for key, val in v.items():
item = QTreeWidgetItem(node, [key, val])
checked = self.config.getboolean('LogVerbosity', val)
item.setCheckState(0, boolToCheckState(checked))
if checked:
count += 1
if count == node.childCount():
node.setCheckState(0, Qt.Checked)
elif count == 0:
node.setCheckState(0, Qt.Unchecked)
else:
node.setCheckState(0, Qt.PartiallyChecked)
self.verbosityOptions.itemChanged.connect(self.chooseVerbosity)
logVerbosityLayout.addWidget(self.verbosityOptions)
# Setting clock speed
clock = QGroupBox(self.str_clock)
clockLayout = QHBoxLayout()
clock.setLayout(clockLayout)
clockLayout.addWidget(QLabel(self.str_clockSpeed))
spin = QDoubleSpinBox()
spin.setValue(self.config.getfloat('Clock', 'speed'))
clockLayout.addWidget(spin)
# Setting appearance
appearance = QGroupBox(self.str_appearance)
appearanceLayout = QHBoxLayout()
appearance.setLayout(appearanceLayout)
appearanceLayout.addWidget(QLabel(self.str_circBgColor))
circBgBtn = QPushButton(self.str_choose)
circBgBtn.setPalette(QPalette(
QColor(self.config.get('Appearance', 'circ_bg_color'))))
circBgBtn.clicked.connect(
lambda: self.chooseColor(circBgBtn, 'circ_bg_color'))
appearanceLayout.addWidget(circBgBtn)
appearanceLayout.addWidget(QLabel(self.str_logBgColor))
logBgBtn = QPushButton(self.str_choose)
logBgBtn.setPalette(QPalette(
QColor(self.config.get('Appearance', 'log_bg_color'))))
logBgBtn.clicked.connect(
lambda: self.chooseColor(logBgBtn, 'log_bg_color'))
appearanceLayout.addWidget(logBgBtn)
# Saving settings to file and effectively setting them
close = QPushButton(self.str_close)
close.clicked.connect(self.closeAndApply)
layout = QGridLayout(self)
layout.addWidget(logHandlers, 0, 0, 1, 1)
layout.addWidget(logVerbosity, 0, 1, 1, 1)
layout.addWidget(clock, 1, 0, 1, 2)
layout.addWidget(appearance, 2, 0, 1, 2)
layout.addWidget(close, 3, 1, 1, 1)
self.setLayout(layout)
def loadList(self):
brush_notExists = QBrush(QColor(255, 150, 120))
brush_unUsed = QBrush(QColor(120, 180, 255))
brush_unUsed_and_notExists = QBrush(QColor(225, 120, 225))
brush_notExists_file = QBrush(QColor(255, 100, 100))
brush_unUsed_file = QBrush(QColor(100, 150, 255))
extensionList = [
dict1['extension'] for dict1 in self.dict_extensionList
]
extensionList_with_dot = ['.' + str1 for str1 in extensionList]
def cmdByExtension(first, second):
firstSplit = os.path.splitext(first)
secondSplit = os.path.splitext(second)
if len(firstSplit) < 2 or len(secondSplit) < 2:
return cmp(first, second)
if not firstSplit[-1] or not secondSplit[-1]:
return cmp(first, second)
if firstSplit[-1][0] != '.' or secondSplit[-1][0] != '.':
return cmp(first, second)
if not firstSplit[-1].lower() in extensionList_with_dot:
return cmp(first, second)
if not secondSplit[-1].lower() in extensionList_with_dot:
return cmp(first, second)
if firstSplit[-1].lower() > secondSplit[-1].lower():
return 1
elif firstSplit[-1].lower() < secondSplit[-1].lower():
return -1
return cmp(first, second)
from maya import cmds
basePath = os.path.dirname(cmds.file(q=1, sceneName=1))
self.lineEdit.setText(basePath)
self.w_tree.clear()
dict_attrs = {}
for w_typeAttr in self.w_typeAttrList.w_typeAttrs:
if not w_typeAttr.checkBox.isChecked(): continue
targetAttrs = pymel.core.ls('*.%s' % w_typeAttr.attr_name)
for targetAttr in targetAttrs:
dirName = os.path.dirname(
os.path.normpath(targetAttr.get().strip().lower()))
if not dict_attrs.has_key(dirName):
dict_attrs[dirName] = [targetAttr]
else:
dict_attrs[dirName].append(targetAttr)
showUnusedDir = self.checkBox.isChecked()
for dirName in dict_attrs:
filesInDir = []
for root, dirs, names in os.walk(dirName):
for name in names:
targetPath = os.path.normpath(root + '/' +
name).strip().lower()
try:
ext = os.path.splitext(targetPath)[-1]
except:
continue
if not ext[1:].lower() in extensionList: continue
filesInDir.append(targetPath)
break
attrList = dict_attrs[dirName]
itemBase = QTreeWidgetItem(self.w_tree)
itemBase.setText(0, os.path.normpath(dirName).strip().lower())
notExistsList = []
unusedList = []
attrs_from_paths = {}
for attr in attrList:
path = os.path.normpath(attr.get().strip().lower())
if attrs_from_paths.has_key(path):
attrs_from_paths[path].append(attr)
else:
attrs_from_paths[path] = [attr]
keys_attrs_from_paths = attrs_from_paths.keys()
keys_attrs_from_paths.sort(cmdByExtension)
for path in keys_attrs_from_paths:
item = QTreeWidgetItem(itemBase)
item.setText(0, path)
attrs = attrs_from_paths[path]
attrName = attrs[0].name()
if len(attrs) > 1: attrName += '...'
item.setText(1, attrName)
item.attrs = attrs
if not os.path.exists(path):
item.setForeground(0, brush_notExists_file)
notExistsList.append(path)
if path in filesInDir:
filesInDir.remove(path)
if showUnusedDir:
for fileInDir in filesInDir:
item = QTreeWidgetItem(itemBase)
path = os.path.normpath(fileInDir).strip().lower()
item.setText(0, path)
item.setForeground(0, brush_unUsed_file)
item.attrs = None
unusedList.append(path)
if unusedList and notExistsList:
itemBase.setForeground(0, brush_unUsed_and_notExists)
elif unusedList:
itemBase.setForeground(0, brush_unUsed)
elif notExistsList:
itemBase.setForeground(0, brush_notExists)
self.w_tree.resizeColumnToContents(0)
self.w_tree.setColumnWidth(0, self.w_tree.columnWidth(0) + 10)
