def __init__(self):
super(mywindow, self).__init__()
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
self.initUI()
zsparent = QTreeWidgetItem(self.ui.treeWidget)
zsparent.setText(0, "股票指数")
zsnames = [
"上证指数-sh", "深圳成指-sz", "沪深300指数-hs300", "上证50-sz50", "中小板-zxb",
"创业板-cyb"
]
#股票列表
for k in zsnames:
child = QTreeWidgetItem(zsparent)
child.setText(0, k)
zsparent2 = QTreeWidgetItem(self.ui.treeWidget)
zsparent2.setText(0, "上海")
shanghai = ma.list_input('sh')
list_name = list(shanghai.values)
for code in list_name:
child = QTreeWidgetItem(zsparent2)
child.setText(0, '%s %s' % (code[0], code[1]))
#print(shanghai)
self.ui.treeWidget.setContextMenuPolicy(Qt.CustomContextMenu)
self.ui.treeWidget.customContextMenuRequested.connect(self.openMenu)
def add_items(self, defaults=None):
"""
-i- defaults : dict, current selection of modules
"""
if defaults is None:
self.extmodules = copy.deepcopy(EXTMODULES_DEFAULTS_DICT)
else:
self.extmodules = defaults
itemNameOld = None
for option in sorted(self.extmodules.keys()):
itemName, subitemName = option.split('/')
checkState = self.extmodules[option]
if itemName != itemNameOld:
item = QTreeWidgetItem(self.treeWidget)
item.setText(0, _(itemName))
item.setFlags(item.flags() | Qt.ItemIsTristate
| Qt.ItemIsUserCheckable)
itemNameOld = itemName
subitem = QTreeWidgetItem(item)
subitem.setText(0, subitemName)
subitem.setFlags(item.flags() | Qt.ItemIsUserCheckable)
if checkState == 'True':
subitem.setCheckState(0, Qt.Checked)
else:
subitem.setCheckState(0, Qt.Unchecked)
def __init__(self, parent):
super(ProjectWidget, self).__init__("Projects manager", parent)
main_tree_widget = QTreeWidget(self)
# main_layout = QVBoxLayout()
# main_tree_widget.setLayout(main_layout)
self.setObjectName("projects_dock")
self.setAllowedAreas(Qt.AllDockWidgetAreas)
main_tree_widget.setHeaderLabels(["Untitled project"])
# main_tree_widget.setHeaderLabels(["ProjectName"])
# item = QTreeWidgetItem()
for i in range(3):
parent = QTreeWidgetItem(main_tree_widget)
parent.setText(0, "Parent {}".format(i))
parent.setFlags(parent.flags() | Qt.ItemIsTristate | Qt.ItemIsUserCheckable)
for x in range(5):
child = QTreeWidgetItem(parent)
child.setFlags(child.flags() | Qt.ItemIsUserCheckable)
child.setText(0, "Child {}".format(x))
child.setCheckState(0, Qt.Unchecked)
main_tree_widget.currentItemChanged.connect(self.changed_item)
self.setWidget(main_tree_widget)
self.setVisible(False)
print(self.objectName())
def append_result(self, results, num_matches):
"""Real-time update of search results"""
self.num_files += 1
search_text = self.search_text
title = "'%s' - " % search_text
nb_files = self.num_files
if nb_files == 0:
text = _('String not found')
else:
text_matches = _('matches in')
text_files = _('file')
if nb_files > 1:
text_files += 's'
text = "%d %s %d %s" % (num_matches, text_matches,
nb_files, text_files)
self.set_title(title + text)
for filename in sorted(results.keys()):
file_item = QTreeWidgetItem(self, [osp.basename(filename) +
u" - " + osp.dirname(filename)],
QTreeWidgetItem.Type)
file_item.setToolTip(0, filename)
file_item.setIcon(0, get_filetype_icon(filename))
for lineno, colno, line in results[filename]:
item = QTreeWidgetItem(file_item,
[u"{0} ({1}): {2}".format(lineno,
colno,
line.rstrip()
)],
QTreeWidgetItem.Type)
item.setIcon(0, ima.icon('arrow'))
self.data[id(item)] = (filename, lineno, colno)
def _add_tree_items(self, item_list, algorithm_data):
"""
Recursively adds QTreeWidgetItems to item_list. Data for the items
are taken from algorithm_data
:param item_list: A list of QTreeWidgetItem
:param algorithm_data: A dict of algorithm descriptors as returned from
Model.get_algorithm_data()
:return: None
"""
for key, sub_tree in sorted(algorithm_data.items()):
if key == self.algorithm_key:
for name, versions in sub_tree.items():
versions = sorted(versions)
default_version_item = QTreeWidgetItem(
['{0} v.{1}'.format(name, versions[-1])])
item_list.append(default_version_item)
if len(versions) > 1:
for v in versions[:-1]:
default_version_item.addChild(
QTreeWidgetItem(['{0} v.{1}'.format(name, v)]))
else:
cat_item = QTreeWidgetItem([key])
item_list.append(cat_item)
cat_item_list = []
self._add_tree_items(cat_item_list, sub_tree)
cat_item.addChildren(cat_item_list)
def update_dependencies(self, dependencies):
self.clear()
headers = (_("Module"), _(" Required "), _(" Installed "),
_("Provided features"))
self.setHeaderLabels(headers)
mandatory_item = QTreeWidgetItem(["Mandatory"])
font = mandatory_item.font(0)
font.setBold(True)
mandatory_item.setFont(0, font)
optional_item = QTreeWidgetItem(["Optional"])
optional_item.setFont(0, font)
self.addTopLevelItems([mandatory_item, optional_item])
for dependency in dependencies:
item = QTreeWidgetItem([
dependency.modname, dependency.required_version,
dependency.installed_version, dependency.features
])
if dependency.check():
item.setIcon(0, ima.icon('dependency_ok'))
elif dependency.optional:
item.setIcon(0, ima.icon('dependency_warning'))
item.setForeground(2, QColor('#ff6a00'))
else:
item.setIcon(0, ima.icon('dependency_error'))
item.setForeground(2, QColor(Qt.darkRed))
if dependency.optional:
optional_item.addChild(item)
else:
mandatory_item.addChild(item)
self.expandAll()
def set_data_view(self, data_dic: Dict[str, object],
root: 'QTreeWidgetItem'):
"""
递归方式显示json。
显示的时候要注意层级。
:param data_dic:
:param root:
:return:
"""
for k in data_dic.keys():
print(k)
if type(data_dic[k]) == dict:
child = QTreeWidgetItem(root)
child.setText(0, repr(k))
self.set_data_view(data_dic[k], child)
elif not isinstance(data_dic[k], str):
print(k)
d = {
attr_name: str(getattr(data_dic[k], attr_name))
for attr_name in dir(data_dic[k])
}
child = QTreeWidgetItem(root)
child.setText(0, repr(k))
self.set_data_view(d, child)
else:
child = QTreeWidgetItem(root)
child.setText(0, repr(k))
child.setText(1, str(self.get_size(data_dic[k])))
child.setText(2, data_dic[k])
def load_dq_flags(self, layer_item=None, layer=None):
self.tree_widget_dq.clear()
if layer_item is None and layer is None:
return
layer = layer_item.data(0, Qt.UserRole)
if layer is not None:
if layer.meta.get('mask_def') is not None:
for row in layer.meta['mask_def'].filled():
new_item = QTreeWidgetItem()
new_item.setFlags(new_item.flags()
| Qt.ItemIsUserCheckable)
new_item.setCheckState(0, Qt.Checked)
new_item.setText(0, str(row['BIT']))
new_item.setData(0, Qt.UserRole, row['BIT'])
new_item.setText(1, row['NAME'])
new_item.setText(2, row['DESCRIPTION'])
self.tree_widget_dq.addTopLevelItem(new_item)
else:
new_item = QTreeWidgetItem()
new_item.setFlags(new_item.flags() | Qt.ItemIsUserCheckable)
new_item.setCheckState(0, Qt.Checked)
new_item.setText(0, str(0))
new_item.setData(0, Qt.UserRole, 0)
new_item.setText(1, 'BAD_PIXEL')
new_item.setText(2, 'A bad pixel')
self.tree_widget_dq.addTopLevelItem(new_item)
def refresh(self):
title = _('Results for ') + self.filename
self.set_title(title)
self.clear()
self.data = {}
if 'C:' in self.results:
results = self.results
result_vals = (_('coala'), ima.icon('convention'), results)
title, icon, messages = result_vals
title += ' (%d message%s)' % (len(messages),
's' if len(messages) > 1 else '')
title_item = QTreeWidgetItem(self, [title], QTreeWidgetItem.Type)
if not messages:
title_item.setDisabled(True)
parent = title_item
for lineno, charno, bearval, msg in messages['C:']:
if lineno:
text = "(%d %d) %s: %s" % (int(lineno), int(charno),
bearval, msg)
else:
text = "%d : %s" % (int(lineno), msg)
msg_item = QTreeWidgetItem(parent, [text],
QTreeWidgetItem.Type)
msg_item.setIcon(0, ima.icon('arrow'))
self.data[id(msg_item)] = lineno
def reading_tree_item(reading, mapping: dict = None):
"""
Get data from archiver and transform into a node with branches according to the bit value defined by the mapping.
:param reading: A data item from the archiver request
:param mapping: Mapping for each bit on the integer where the key is an integer from
representing the bit position starting from zero and the key is a string with it's meaning
:return: A QTreeWidgetItem
"""
# Timestamp
if mapping is None:
mapping = {0: 'Zero', 1: 'One', 2: 'Two'}
timestamp = str(
datetime.datetime.fromtimestamp(reading['secs']).astimezone(SP_TZ))
severity = Severity.nameOf(reading['severity'])
alarm_status = Alarm.nameOf(reading['status'])
value = reading['val']
node = QTreeWidgetItem(
['{} {} {} {}'.format(timestamp, value, severity, alarm_status)])
# A meaning per bit defined at the "mapping"
for k, v in mapping.items():
if value & 1 << k:
node_child = QTreeWidgetItem(['{}: {}'.format(k, v)])
node.addChild(node_child)
return node
def explore_tree(self, up_widget, node_plan, deep=True):
"""
:type up_widget: QTreeWidgetItem
:type node_plan: CalculationTree
:type deep: bool
:param up_widget: List widget item
:param node_plan: node from calculation plan
:return:
"""
widget = QTreeWidgetItem(up_widget)
widget.setText(0, CalculationPlan.get_el_name(node_plan.operation))
self.setCurrentItem(widget)
if isinstance(node_plan.operation, (MeasurementCalculate, ROIExtractionProfile, MaskCreate)):
desc = QTreeWidgetItem(widget)
desc.setText(0, "Description")
if isinstance(node_plan.operation, ROIExtractionProfile):
txt = node_plan.operation.pretty_print(analysis_algorithm_dict)
else:
txt = str(node_plan.operation)
for line in txt.split("\n")[1:]:
QTreeWidgetItem(desc, [line])
if deep:
for el in node_plan.children:
self.explore_tree(widget, el)
up_widget.setExpanded(True)
def add_model_item(self, layer, unique=True):
"""
Adds an `astropy.modeling.Model` to the loaded model tree widget.
Parameters
----------
"""
if hasattr(layer.model, '_submodels'):
models = layer.model._submodels
else:
models = [layer.model]
for model in models:
if model is None:
continue
if unique:
if self.get_model_item(model) is not None:
continue
name = model.name
if not name:
count = 1
root = self.contents.tree_widget_current_models.invisibleRootItem(
)
for i in range(root.childCount()):
child = root.child(i)
if isinstance(model, child.data(0, Qt.UserRole).__class__):
count += 1
name = model.__class__.__name__.replace('1D', '') + str(count)
model._name = name
new_item = QTreeWidgetItem()
new_item.setFlags(new_item.flags() | Qt.ItemIsEditable)
new_item.setText(0, name)
new_item.setData(0, Qt.UserRole, model)
for i, para in enumerate(model.param_names):
new_para_item = QTreeWidgetItem(new_item)
new_para_item.setText(0, para)
new_para_item.setData(1, Qt.UserRole, model.parameters[i])
new_para_item.setText(1, "{:4.4g}".format(model.parameters[i]))
new_para_item.setFlags(new_para_item.flags()
| Qt.ItemIsEditable
| Qt.ItemIsUserCheckable)
new_para_item.setCheckState(
0, Qt.Checked if model.fixed.get(para) else Qt.Unchecked)
self.contents.tree_widget_current_models.addTopLevelItem(new_item)
self.contents.tree_widget_current_models.expandItem(new_item)
self._update_arithmetic_text(layer)
def update_view(self):
# this part of the code is a hack - re-create tree every time
# self.ui.treeWidget_stations.clear()
# for group in self.file_handler.get_groups():
# node = QtGui.QTreeWidgetItem(self.ui.treeWidget_stations)
# node.setText(0, group)
# for ref in self.file_handler.get_group_members(group):
# mt_obj = self.file_handler.get_MT_obj(ref)
# child_node = QtGui.QTreeWidgetItem(node)
# child_node.setText(0, mt_obj.station)
# child_node.setText(1, ref)
root = self.ui.treeWidget_stations.invisibleRootItem()
groups = set()
to_delete = []
existing_groups = set(self.file_handler.get_groups())
for i in range(root.childCount()):
group_item = root.child(i)
group_id = str(group_item.text(0))
if group_id in existing_groups:
groups.add(group_id)
refs = set()
# check station items
for j in range(group_item.childCount()):
station_item = group_item.child(j)
station_ref = str(station_item.text(1))
mt_obj = self.file_handler.get_MT_obj(station_ref)
if mt_obj:
refs.add(station_ref)
else:
to_delete.append(station_item)
# add new children
for ref in self.file_handler.get_group_members(group_id):
if ref not in refs:
child_node = QTreeWidgetItem(group_item)
child_node.setText(
0,
self.file_handler.get_MT_obj(ref).station)
child_node.setText(1, ref)
else:
to_delete.append(group_item)
# delete all non existed items
for item in to_delete:
(item.parent() or root).removeChild(item)
# add now groups
for group_id in existing_groups:
if group_id not in groups:
# create new node
node = QTreeWidgetItem(self.ui.treeWidget_stations)
node.setText(0, group_id)
for ref in self.file_handler.get_group_members(group_id):
child_node = QTreeWidgetItem(node)
child_node.setText(
0,
self.file_handler.get_MT_obj(ref).station)
child_node.setText(1, ref)
# self.ui.treeWidget_stations.updateGeometry()
self.selection_changed.emit()
def refresh(self):
title = _('Results for ')+self.filename
self.set_title(title)
self.clear()
self.data = {}
# Populating tree
results = ((_('Convention'),
ima.icon('convention'), self.results['C:']),
(_('Refactor'),
ima.icon('refactor'), self.results['R:']),
(_('Warning'),
ima.icon('warning'), self.results['W:']),
(_('Error'),
ima.icon('error'), self.results['E:']))
for title, icon, messages in results:
title += ' (%d message%s)' % (len(messages),
's' if len(messages) > 1 else '')
title_item = QTreeWidgetItem(self, [title], QTreeWidgetItem.Type)
title_item.setIcon(0, icon)
if not messages:
title_item.setDisabled(True)
modules = {}
for module, lineno, message, msg_id in messages:
basename = osp.splitext(osp.basename(self.filename))[0]
if not module.startswith(basename):
# Pylint bug
i_base = module.find(basename)
module = module[i_base:]
dirname = osp.dirname(self.filename)
if module.startswith('.') or module == basename:
modname = osp.join(dirname, module)
else:
modname = osp.join(dirname, *module.split('.'))
if osp.isdir(modname):
modname = osp.join(modname, '__init__')
for ext in ('.py', '.pyw'):
if osp.isfile(modname+ext):
modname = modname + ext
break
if osp.isdir(self.filename):
parent = modules.get(modname)
if parent is None:
item = QTreeWidgetItem(title_item, [module],
QTreeWidgetItem.Type)
item.setIcon(0, ima.icon('python'))
modules[modname] = item
parent = item
else:
parent = title_item
if len(msg_id) > 1:
text = "[%s] %d : %s" % (msg_id, lineno, message)
else:
text = "%d : %s" % (lineno, message)
msg_item = QTreeWidgetItem(parent, [text],
QTreeWidgetItem.Type)
msg_item.setIcon(0, ima.icon('arrow'))
self.data[id(msg_item)] = (modname, lineno)
def code_sort_tree(self, companies):
self.ui.treeWidget.clear()
sorted_comps = companies.sort_values(["code"])
code_list = sorted_comps["code"].tolist()
name_list = sorted_comps["name"].tolist()
shares_parent = QTreeWidgetItem(self.ui.treeWidget)
shares_parent.setText(0, "个股行情")
for idx, val in enumerate(code_list):
child = QTreeWidgetItem(shares_parent)
child.setText(0, name_list[idx] + "-" + str(val))
self.ui.treeWidget.expandToDepth(0)
def showEvent(self, event):
super().showEvent(event)
ok_icon = QIcon(os.path.join(icons_dir, "task-accepted.png"))
bad_icon = QIcon(os.path.join(icons_dir, "task-reject.png"))
warn_icon = QIcon(os.path.join(icons_dir, "task-attempt.png"))
all_prefix = os.path.commonprefix(self.file_list)
if not os.path.exists(all_prefix):
all_prefix = os.path.dirname(all_prefix)
for file_num, file_path in enumerate(self.file_list):
widget = QTreeWidgetItem(self.file_list_widget)
widget.setText(0, os.path.relpath(file_path, all_prefix))
if not os.path.exists(file_path):
widget.setIcon(0, bad_icon)
widget.setToolTip(0, "File do not exists")
sub_widget = QTreeWidgetItem(widget)
sub_widget.setText(0, "File do not exists")
continue
for mask_num, mask_mapper in enumerate(self.mask_mapper_list):
if mask_mapper.is_ready():
mask_path = mask_mapper.get_mask_path(file_path)
exist = os.path.exists(mask_path)
if exist:
sub_widget = QTreeWidgetItem(widget)
sub_widget.setText(
0, "Mask {} ok".format(mask_mapper.name))
sub_widget.setIcon(0, ok_icon)
self.state_list[file_num, mask_num] = 0
else:
sub_widget = QTreeWidgetItem(widget)
sub_widget.setText(
0,
"Mask {} do not exists (path: {})".format(
mask_mapper.name,
os.path.relpath(mask_path, all_prefix)),
)
sub_widget.setIcon(0, bad_icon)
self.state_list[file_num, mask_num] = 2
else:
sub_widget = QTreeWidgetItem(widget)
sub_widget.setText(
0, "Mask {} unknown".format(mask_mapper.name))
sub_widget.setIcon(0, warn_icon)
self.state_list[file_num, mask_num] = 1
if self.state_list.shape[1] == 0:
state = 0
else:
state = self.state_list[file_num].max()
if state == 0:
widget.setIcon(0, ok_icon)
elif state == 1:
widget.setIcon(0, warn_icon)
else:
widget.setIcon(0, bad_icon)
def init_treeWidget(self, list1, series):
self.ui.treeWidget.clear()
for j in list1:
parent = QTreeWidgetItem(
self.ui.treeWidget) #populate treewidget with names
parent.setText(0, j)
var = series.loc[series["c_name"] == j]
list2 = var["code"].tolist()
name = var["name"].tolist()
#var = showcollection(i) #Display database items
for idx, val in enumerate(list2):
child = QTreeWidgetItem(parent)
child.setText(0, name[idx] + "-" + str(val))
def search_comp(self, companies):
self.ui.treeWidget.clear()
text = self.ui.search_lineEdit.text()
filtered_codes = companies[companies['code'].str.contains(text)]
filtered_names = companies[companies['name'].str.contains(text)]
filtered_comps = filtered_codes.append(filtered_names)
code_list = filtered_comps["code"].tolist()
name_list = filtered_comps["name"].tolist()
parent = QTreeWidgetItem(self.ui.treeWidget)
parent.setText(0, "搜索结果")
for idx, val in enumerate(code_list):
child = QTreeWidgetItem(parent)
child.setText(0, name_list[idx] + "-" + str(val))
self.ui.treeWidget.expandToDepth(0)
def update_result(assortment: Dict[Assortment, List[Assortment]]) -> None:
"""Update results."""
self.assortment.update(assortment)
for la, cla_list in assortment.items():
la_item = QTreeWidgetItem([", ".join(
f"NL{i + 2} = {a}" for i, a in enumerate(la)
), "N/A"])
for cla in cla_list:
la_item.addChild(QTreeWidgetItem([", ".join(
f"NC{i + 1} = {a}" for i, a in enumerate(cla)
), "N/A"]))
self.link_assortment_list.addTopLevelItem(la_item)
first_item = self.link_assortment_list.topLevelItem(0)
self.link_assortment_list.setCurrentItem(first_item)
dlg.deleteLater()
def search_weibo(self):
self.ui.stocks_tree.clear()
weibo_id = self.ui.search_edit_text.text()
start_date = self.ui.start_date_edit.date()
start_date = start_date.toPyDate()
start_date = start_date.strftime("%Y/%m/%d")
start_date = time.mktime(time.strptime(start_date, "%Y/%m/%d"))
end_date = self.ui.end_date_edit.date()
end_date = end_date.toPyDate()
end_date = end_date.strftime("%Y/%m/%d")
end_date = time.mktime(time.strptime(end_date, "%Y/%m/%d"))
if weibo_id:
dispatcher = Dispatcher(uid=weibo_id,
start_date=start_date,
end_date=end_date,
filter_flag=True,
update_cookies=False)
dispatcher.execute()
else:
print('please input weibo uid here.')
self.ui.stocks_tree.setContextMenuPolicy(Qt.CustomContextMenu)
self.ui.stocks_tree.customContextMenuRequested.connect(
self.openWidgetMenu)
stock_id_list = list()
stock_comments_list = list()
try:
with self.connection.cursor() as cursor:
cursor.execute(STOCK_SEARCH_BY_WEIBOID, [weibo_id])
search_results = cursor.fetchall()
if len(search_results) > 0:
for row in search_results:
print(row[3], row[4], row[5])
stock_id = row[3]
stock_comments = row[4] + "" + row[5]
stock_id_list.append(stock_id)
stock_comments_list.append(stock_comments)
finally:
self.connection.close()
parent = QTreeWidgetItem(self.ui.stocks_tree)
parent.setText(0, "搜索结果")
for i in range(len(stock_id_list)):
child = QTreeWidgetItem(parent)
child.setText(0, stock_id_list[i] + "-" + stock_comments_list[i])
self.ui.stocks_tree.expandToDepth(0)
def update_dependencies(self, dependencies):
self.clear()
headers = (_("Module"), _("Package name"), _(" Required "),
_(" Installed "), _("Provided features"))
self.setHeaderLabels(headers)
# Mandatory items
mandatory_item = QTreeWidgetItem([_("Mandatory")])
font = mandatory_item.font(0)
font.setBold(True)
mandatory_item.setFont(0, font)
# Optional items
optional_item = QTreeWidgetItem([_("Optional")])
optional_item.setFont(0, font)
# Spyder plugins
spyder_plugins = QTreeWidgetItem([_("Spyder plugins")])
spyder_plugins.setFont(0, font)
self.addTopLevelItems([mandatory_item, optional_item, spyder_plugins])
for dependency in sorted(dependencies,
key=lambda x: x.modname.lower()):
item = QTreeWidgetItem([
dependency.modname, dependency.package_name,
dependency.required_version, dependency.installed_version,
dependency.features
])
# Format content
if dependency.check():
item.setIcon(0, ima.icon('dependency_ok'))
elif dependency.kind == OPTIONAL:
item.setIcon(0, ima.icon('dependency_warning'))
item.setForeground(2, QColor('#ff6a00'))
else:
item.setIcon(0, ima.icon('dependency_error'))
item.setForeground(2, QColor(Qt.darkRed))
# Add to tree
if dependency.kind == OPTIONAL:
optional_item.addChild(item)
elif dependency.kind == PLUGIN:
spyder_plugins.addChild(item)
else:
mandatory_item.addChild(item)
self.expandAll()
def populate_tree(parent, node):
item = QTreeWidgetItem(parent)
item.setText(0, node.tag.strip())
if node.text is not None and node.text.strip():
item.setText(1, node.text.strip())
for element in node:
populate_tree(item, element)
def set_data_dic(self, data_dic: Dict[str, object]) -> None:
"""
显示数据
:param data_dic:所有数据的字典{变量名：变量对象}
:return:
"""
self.expanding_stat = {}
self.memorize_expanding_stat()
self.clear()
self.nodes = {}
for data_name in data_dic:
data = data_dic[data_name]
text = str(data_name)
size = self.get_size(data)
"""
如果变量不在变量列表中，就新建一个节点，并通过递归方式创建变量的各个属性。
"""
child = QTreeWidgetItem(self)
child.item_id = text
self.nodes[child.item_id] = child
child.setText(0, text)
self.try_expand_item(child)
if isinstance(data, dict):
self.set_data_view(data, child)
def update_alarm_tree(self, alarm_tree, response: requests.Response):
"""
Build the alarm tree
:param alarm_tree: QTreeWidget to append the alarms
:param responses: typing.List[requests.Response]
"""
# For each PV
# for response in responses:
if response.status_code != 200:
logger.warning(
"Invalid status code for request. Response {}".format(
response))
logger.debug(response.text)
return
try:
if len(response.json()) < 0:
logger.info("empty response")
return
json_data = response.json()[0]
pv_node = QTreeWidgetItem(["{}".format(json_data["meta"]["name"])])
alarm_tree.addTopLevelItem(pv_node)
for data in response.json()[0]["data"]:
if data["val"] == 0:
# Will not display alarms, only actual value changes
continue
pv_node_child = self.reading_tree_item(data)
pv_node.addChild(pv_node_child)
except Exception:
logger.exception("Failed to add node")
def setup_ui(self):
self.translator = create_translator(
path=os.path.join(os.path.dirname(__file__), 'translations',
'qt_{0}.qm'.format(QLocale.system().name()))) # translator
self.nodes: Dict[str, 'QTreeWidgetItem'] = {}
self.setColumnCount(2)
header_item = QTreeWidgetItem()
header_item.setText(0, self.tr('Name'))
self.setColumnWidth(0, 200)
header_item.setText(1, self.tr('Value'))
header_item.setTextAlignment(0, Qt.AlignCenter)
header_item.setTextAlignment(1, Qt.AlignCenter)
self.setHeaderItem(header_item)
self.auto_expand = False
self.itemClicked.connect(self.on_item_clicked)
self.itemDoubleClicked.connect(self.on_item_double_clicked)
self.customContextMenuRequested.connect(self.on_right_clicked)
self.setContextMenuPolicy(Qt.CustomContextMenu)
self.context_menu = QMenu()
show_action = self.context_menu.addAction(self.tr('View'))
save_action = self.context_menu.addAction(self.tr('Save as '))
cancel_action = self.context_menu.addAction(self.tr('Undo'))
redo_action = self.context_menu.addAction(self.tr('Redo'))
delete_action = self.context_menu.addAction(self.tr('Delete'))
show_action.triggered.connect(self.on_show_data_by_context_menu)
def setup_ui(self):
self.nodes: Dict[str, 'QTreeWidgetItem'] = {}
self.setColumnCount(3)
header_item = QTreeWidgetItem()
header_item.setText(0, self.tr('Name'))
self.setColumnWidth(0, 10 * 10)
header_item.setText(1, self.tr('Size'))
self.setColumnWidth(1, 10 * 10)
header_item.setText(2, self.tr('Value'))
header_item.setTextAlignment(0, Qt.AlignCenter)
header_item.setTextAlignment(1, Qt.AlignCenter)
header_item.setTextAlignment(2, Qt.AlignCenter)
self.setHeaderItem(header_item)
self.auto_expand = False
self.itemClicked.connect(self.on_item_clicked)
self.itemDoubleClicked.connect(self.on_item_double_clicked)
self.customContextMenuRequested.connect(self.on_right_clicked)
self.setContextMenuPolicy(Qt.CustomContextMenu)
self.context_menu = QMenu()
show_action = self.context_menu.addAction(self.tr('View'))
save_action = self.context_menu.addAction(self.tr('Save as '))
cancel_action = self.context_menu.addAction(self.tr('Undo'))
redo_action = self.context_menu.addAction(self.tr('Redo'))
delete_action = self.context_menu.addAction(self.tr('Delete'))
show_action.triggered.connect(self.on_show_data_by_context_menu)
def addItem(self, dictNote):
item = QTreeWidgetItem(self)
item.setText(0, dictNote['Title'])
item.setText(1, dictNote['Keyword'])
item.setFont(0, self.font)
item.setFont(1, self.font)
self.lod.append(dictNote)
def __init__(self, presenter, parent=None):
super(SampleMaterialDialogView, self).__init__(parent=parent)
self.ui = load_ui(__file__,
'samplematerialdialog.ui',
baseinstance=self)
self.setWindowIcon(QIcon(':/images/MantidIcon.ico'))
self.setModal(True)
self.presenter = presenter
self.setAttribute(Qt.WA_DeleteOnClose, True)
# Top level items in the tree.
self.formula_item = QTreeWidgetItem(self.material_properties_tree,
["Formula", ""])
self.number_density_item = QTreeWidgetItem(
self.material_properties_tree, ["Number Density", ""])
self.temperature_item = QTreeWidgetItem(self.material_properties_tree,
["Temperature", ""])
self.pressure_item = QTreeWidgetItem(self.material_properties_tree,
["Pressure", ""])
self.cross_sections_item = QTreeWidgetItem(
self.material_properties_tree, ["Cross Sections", ""])
# Items under "Cross Section".
self.absorption_item = QTreeWidgetItem(self.cross_sections_item,
["Absorption", ""])
self.scattering_item = QTreeWidgetItem(self.cross_sections_item,
["Scattering", ""])
# Items under "Scattering".
self.total_item = QTreeWidgetItem(self.scattering_item, ["Total", ""])
self.coherent_item = QTreeWidgetItem(self.scattering_item,
["Coherent", ""])
self.incoherent_item = QTreeWidgetItem(self.scattering_item,
["Incoherent", ""])
# Expand all items with child items.
self.cross_sections_item.setExpanded(True)
self.scattering_item.setExpanded(True)
# Connect button signals.
self.close_button.clicked.connect(self.close_request)
self.copy_material_button.clicked.connect(self.copy_material_request)
self.set_material_button.clicked.connect(self.set_material_request)
def save_state_action(self, state: ProjectInfoBase, custom_name):
# TODO left elipsis
# state: ProjectInfoBase = self.get_state()
if not isinstance(state,
ProjectInfoBase): # workaround for PointsInfo load
return
normed_file_path = os.path.normpath(state.file_path)
sub_dict = self.state_dict[normed_file_path]
name = f"state {self.state_dict_count[normed_file_path]+1}"
if custom_name:
name, ok = QInputDialog.getText(self,
"Save name",
"Save name:",
text=name)
if not ok:
return
while name in sub_dict or name in ["raw image", "image with mask"]:
name, ok = QInputDialog.getText(self,
"Save name",
"Save name (previous in use):",
text=name)
if not ok:
return
try:
index = self.file_list.index(os.path.normpath(normed_file_path))
item = self.file_view.topLevelItem(index)
except ValueError:
metric = QFontMetrics(self.file_view.font())
width = self.file_view.width() - 45
clipped_text = metric.elidedText(normed_file_path, Qt.ElideLeft,
width)
item = QTreeWidgetItem(self.file_view, [clipped_text])
item.setToolTip(0, normed_file_path)
self.file_list.append(normed_file_path)
QTreeWidgetItem(item, ["raw image"])
sub_dict["raw image"] = state.get_raw_copy()
if state.is_masked():
QTreeWidgetItem(item, ["image with mask"])
sub_dict["image with mask"] = state.get_raw_mask_copy()
item.setExpanded(True)
if state.is_raw():
return
it = QTreeWidgetItem(item, [name])
self.file_view.setCurrentItem(it)
sub_dict[name] = state
self.state_dict_count[state.file_path] += 1
def __init__(self, opts):
super(VCPChooser, self).__init__()
uic.loadUi(os.path.join(CHOOSER_DIR, 'vcp_chooser.ui'), self)
self.setAttribute(Qt.WA_DeleteOnClose, True)
self.opts = opts
self._vcp_data = {}
self.selection = self.vcpTreeView.selectionModel()
# example VCP section
category = QTreeWidgetItem(self.vcpTreeView)
category.setText(0, 'Example VCPs')
category.setFlags(Qt.ItemIsEnabled)
# add example VCPs to the treeview
for entry_point in iter_entry_points(group='qtpyvcp.example_vcp'):
child = QTreeWidgetItem(category)
child.setText(0, self.get_vcp_data(entry_point))
# test VCP section
category = QTreeWidgetItem(self.vcpTreeView)
category.setText(0, 'Video Test VCPs')
category.setFlags(Qt.ItemIsEnabled)
# add example VCPs to the treeview
for entry_point in iter_entry_points(group='qtpyvcp.test_vcp'):
child = QTreeWidgetItem(category)
child.setText(0, self.get_vcp_data(entry_point))
# installed VCP section
category = QTreeWidgetItem(self.vcpTreeView)
category.setText(0, 'Installed VCPs')
category.setFlags(Qt.ItemIsEnabled)
category.setHidden(True)
# add installed VCPs to the treeview
for entry_point in iter_entry_points(group='qtpyvcp.vcp'):
child = QTreeWidgetItem(category)
child.setText(0, self.get_vcp_data(entry_point))
category.setHidden(False)
if os.path.exists(CUSTOM_VCP_DIR):
category = QTreeWidgetItem(self.vcpTreeView)
category.setText(0, 'Custom VCPs')
category.setFlags(Qt.ItemIsEnabled)
for dir_name in os.listdir(CUSTOM_VCP_DIR):
if not os.path.isdir(os.path.join(CUSTOM_VCP_DIR, dir_name)):
continue
child = QTreeWidgetItem(category)
child.setText(0, dir_name)
self.vcpTreeView.expandAll()
self.vcpTreeView.activated.connect(self.on_launchVCPButton_clicked)
self.selection.selectionChanged.connect(self.on_selection_changed)
