def _update_output_nodes(self, is_node_running, node_name):
"""
Slot for signals that tell nodes existence.
@type is_node_running: bool
@type node_name: str
"""
#TODO: What this method does is exactly the same with
# monitor_parameters. Unify them.
rospy.logdebug('is_node_running={} par_name={}'.format(
is_node_running, node_name))
node_name = str(node_name)
node_qitem = None
if not node_name in self._node_qitems:
node_qitem = QStandardItem(node_name)
self._node_qitems[node_name] = node_qitem
self._node_datamodel.appendRow(node_qitem)
else: # qsitem with the node name already exists.
node_qitem = self._node_qitems[str(node_name)]
qindex = self._node_datamodel.indexFromItem(node_qitem)
_str_node_running = 'Not running'
if is_node_running:
_str_node_running = 'Running'
qitem_node_status = QStandardItem(_str_node_running)
self._node_datamodel.setItem(qindex.row(), 1, qitem_node_status)
def _update_output_parameters(self, has_param, param_name):
"""
Slot
@type has_param: bool
@type param_name: str
"""
rospy.logdebug('has_param={} par_name={}'.format(
has_param, param_name))
param_name = str(param_name)
param_qitem = None
if not param_name in self._param_qitems:
param_qitem = QStandardItem(param_name)
self._param_qitems[param_name] = param_qitem
self._param_datamodel.appendRow(param_qitem)
else: # qsitem with the param name already exists.
param_qitem = self._param_qitems[str(param_name)]
qindex = self._param_datamodel.indexFromItem(param_qitem)
_str_param_found = 'No'
if has_param:
_str_param_found = 'Yes'
qitem_param_status = QStandardItem(_str_param_found)
self._param_datamodel.setItem(qindex.row(), 1, qitem_param_status)
self._view_params.resizeColumnsToContents()
def __append_element_to_item(self, parent_item, debug_data):
"""
Append an elements debug_data to a QStandardItem.
:type parent_item: python_qt_binding.QtGui.QStandardItem
:type debug_data: dict or list or int or float or str or bool
:rtype: python_qt_binding.QtGui.QStandardItem
"""
if type(debug_data) is list:
for i, data in enumerate(debug_data):
child_item = QStandardItem()
child_item.setText(str(i) + ": ")
child_item.setEditable(False)
self.__append_element_to_item(child_item, data)
parent_item.appendRow(child_item)
elif type(debug_data) is dict:
for label, data in debug_data.items():
child_item = QStandardItem()
child_item.setText(str(label) + ": ")
child_item.setEditable(False)
self.__append_element_to_item(child_item, data)
parent_item.appendRow(child_item)
elif type(debug_data) is str or type(debug_data) is int \
or type(debug_data) is float or type(debug_data) is bool\
or type(debug_data) is unicode:
parent_item.setText(parent_item.text() + str(debug_data))
def _append_items(self, item, deep, items=[]):
sub_items = []
inc_item = None
for inc_file in items:
if inc_file.rec_depth == deep:
if inc_item is not None:
if sub_items:
self._append_items(inc_item, deep + 1, sub_items)
sub_items = []
item.appendRow(inc_item)
inc_item = None
if inc_item is None:
pkg, _ = package_name(os.path.dirname(inc_file.inc_path))
size_color = 'gray'
if inc_file.size == 0 or inc_file.size > 1000000:
size_color = 'orange'
itemstr = '%s <span style="color:%s;"><em>%s</em></span> [%s]' % (os.path.basename(inc_file.inc_path), size_color, sizeof_fmt(inc_file.size), pkg)
inc_item = QStandardItem('%d: %s' % (inc_file.line_number, itemstr))
inc_item.setData(self.ITEM_TYPE_INC_FILE, self.ITEM_TYPE)
inc_item.setData(inc_file.path_or_str, self.DATA_FILE)
inc_item.setData(inc_file.line_number, self.DATA_LINE)
inc_item.setData(inc_file.inc_path, self.DATA_INC_FILE)
inc_item.setData(inc_file.rec_depth + 1, self.DATA_LEVEL)
inc_item.setData(inc_file.size, self.DATA_SIZE)
inc_item.setData(inc_file.raw_inc_path, self.DATA_RAW)
inc_item.setData(inc_file.args, self.DATA_ARGS)
inc_item.setData(inc_file.unset_default_args, self.DATA_DEF_ARGS_NOT_SET)
# add included arguments
if inc_file.unset_default_args or inc_file.args:
arg_item = QStandardItem('arguments')
arg_item.setData(self.ITEM_TYPE_INC_GROUP_ARG, self.ITEM_TYPE)
if inc_file.unset_default_args:
self.has_warnings = True
arg_item.setIcon(self._info_icon)
for da_name, da_value in inc_file.unset_default_args.items():
da_item = QStandardItem('<arg_not_set>%s: %s' % (da_name, da_value))
da_item.setData(self.ITEM_TYPE_INC_ARG, self.ITEM_TYPE)
da_item.setData(inc_file.path_or_str, self.DATA_FILE)
da_item.setData(inc_file.inc_path, self.DATA_INC_FILE)
da_item.setData(da_name, self.DATA_ARG_NAME)
da_item.setToolTip("This argument is definded as default, but no set while include.")
arg_item.appendRow(da_item)
if inc_file.args:
for da_name, da_value in inc_file.args.items():
da_item = QStandardItem('<arg>%s: %s' % (da_name, da_value))
da_item.setData(self.ITEM_TYPE_INC_ARG, self.ITEM_TYPE)
da_item.setData(inc_file.path_or_str, self.DATA_FILE)
da_item.setData(inc_file.inc_path, self.DATA_INC_FILE)
da_item.setData(da_name, self.DATA_ARG_NAME)
arg_item.appendRow(da_item)
inc_item.appendRow(arg_item)
elif inc_file.rec_depth > deep:
sub_items.append(inc_file)
if inc_item is not None:
if sub_items:
self._append_items(inc_item, deep + 1, sub_items)
sub_items = []
item.appendRow(inc_item)
inc_item = None
def _get_data_items_for_path(self, slot_name, slot_type, slot_path,
**kwargs):
expression_item = QStandardItem('')
expression_item.setToolTip(
'enter valid Python expression here, using "i" as counter and functions from math, random and time modules'
)
return (ReadonlyItem(slot_name),
ReadonlyItem(QStandardItem(slot_type)), expression_item)
def _refill_tree(self, tree, create_tree=True):
deep = 0
file_dsrc = self._root_path
try:
file_dsrc = os.path.basename(self._root_path)
except Exception:
pass
self.setWindowTitle("Include Graph - %s" % file_dsrc)
if not self._created_tree and create_tree:
has_none_packages = False
self.graphTreeView.model().clear()
pkg, _ = package_name(os.path.dirname(self._root_path))
if pkg is None:
has_none_packages = True
itemstr = '%s [%s]' % (os.path.basename(self._root_path), pkg)
inc_item = QStandardItem('%s' % itemstr)
inc_item.setData(self.ITEM_TYPE_INC_FILE, self.ITEM_TYPE)
inc_item.setData(self._root_path, self.DATA_FILE)
inc_item.setData(-1, self.DATA_LINE)
inc_item.setData(self._root_path, self.DATA_INC_FILE)
inc_item.setData(deep, self.DATA_LEVEL)
# add included arguments for root file
launch_args = nm.nmd().launch.launch_args(self._root_path)
if launch_args:
arg_item = QStandardItem('arguments')
arg_item.setData(self.ITEM_TYPE_INC_GROUP_ARG, self.ITEM_TYPE)
for da_name, da_value in launch_args.items():
da_item = QStandardItem('<arg>%s: %s' % (da_name, da_value))
da_item.setData(self.ITEM_TYPE_INC_ARG, self.ITEM_TYPE)
da_item.setData(self._root_path, self.DATA_FILE)
da_item.setData(da_name, self.DATA_ARG_NAME)
arg_item.appendRow(da_item)
inc_item.appendRow(arg_item)
self._append_items(inc_item, deep, tree)
self.graphTreeView.model().appendRow(inc_item)
# self.graphTreeView.expand(self.graphTreeView.model().indexFromItem(inc_item))
self._created_tree = True
self.has_none_packages = has_none_packages
items = self.graphTreeView.model().match(self.graphTreeView.model().index(0, 0), self.DATA_INC_FILE, self._current_path, 10, Qt.MatchRecursive)
first = True
self.graphTreeView.selectionModel().clear()
for item in items:
if first:
self._current_deep = item.data(self.DATA_LEVEL)
first = False
self.graphTreeView.selectionModel().select(item, QItemSelectionModel.Select)
self.graphTreeView.expandAll()
# collapse argument nodes
proxy = self.graphTreeView.model()
for row in range(proxy.rowCount()):
index = proxy.index(row, 0)
item = proxy.itemFromIndex(index)
self._collapse_args(item)
self.finished_signal.emit()
def _get_data_items_for_path(self, slot_name, slot_type_name, slot_path,
**kwargs):
if slot_name.startswith('/'):
return (CheckableItem(slot_name), ReadonlyItem(slot_type_name),
QStandardItem(''), ReadonlyItem(''))
expression_item = QStandardItem('')
expression_item.setToolTip(
'enter valid Python expression here, using "i" as counter and functions from math, '
'random and time modules')
return (ReadonlyItem(slot_name), QStandardItem(slot_type_name),
ReadonlyItem(''), expression_item)
def take_snapshot(self):
# >>> Take the snapshot
self.textedit.append('Taking snapshot ...')
# Get the transform from `tool0` to `base_link`
T = self.get_tf_transform(self.base_frame.text(),
self.endeffector_frame.text())
bTe = np.zeros((4, 4))
q = [
T.transform.rotation.w, T.transform.rotation.x,
T.transform.rotation.y, T.transform.rotation.z
]
bTe = br.quaternion.to_transform(q)
bTe[:3, 3] = np.array([
T.transform.translation.x, T.transform.translation.y,
T.transform.translation.z
])
self.textedit.append('Lookup transform: from `{}` to `{}`.'.format(
self.base_frame.text(), self.endeffector_frame.text()))
self.node.get_logger().info(bcolors.OKGREEN + 'bTe:' + bcolors.ENDC +
'\n{}'.format(bTe))
# Get the transform from `calib_board` to `camera_link`
T = self.get_tf_transform(self.camera_frame.text(),
self.object_frame.text())
cTo = np.zeros((4, 4))
q = [
T.transform.rotation.w, T.transform.rotation.x,
T.transform.rotation.y, T.transform.rotation.z
]
cTo = br.quaternion.to_transform(q)
cTo[:3, 3] = np.array([
T.transform.translation.x, T.transform.translation.y,
T.transform.translation.z
])
self.textedit.append('Lookup transform: from `{}` to `{}`.'.format(
self.camera_frame.text(), self.object_frame.text()))
self.node.get_logger().info(bcolors.OKGREEN + 'cTo:' + bcolors.ENDC +
'\n{}'.format(cTo))
parent = QStandardItem('Snapshot {}'.format(len(self.Tsamples)))
child_1 = QStandardItem('bTe:\n{}\n{}\n{}\n{}'.format(
bTe[0, :], bTe[1, :], bTe[2, :], bTe[3, :]))
child_2 = QStandardItem('cTo:\n{}\n{}\n{}\n{}'.format(
cTo[0, :], cTo[1, :], cTo[2, :], cTo[3, :]))
parent.appendRow(child_1)
parent.appendRow(child_2)
self.model.appendRow(parent)
self.Tsamples.append((bTe, cTo))
self.le5.setText(str(len(self.Tsamples)))
def _on_load_error(self, msg):
self.setWindowTitle("Include Graph - %s" % os.path.basename(self._root_path))
if not self._created_tree:
inc_item = QStandardItem('%s' % msg)
self.graphTreeView.model().appendRow(inc_item)
self.finished_signal.emit()
self.info_signal.emit("build tree failed: %s" % msg, True)
def update_connect_to_list(self, infer_name):
self.connect_from_listmodel.clear()
self.connect_to_listmodel.clear()
for node in self.dotgraph.get_node_list():
pipeline_item = QStandardItem()
pipeline_item.setText(node.get_name())
pipeline_item.setCheckable(True)
pipeline_item.setCheckState(False)
if node.get_name() == infer_name.encode('utf-8'):
continue
if node.get('nodetype') == 'input':
self.connect_from_listmodel.appendRow(pipeline_item)
# self.connect_from_listview.addItem(node.get_name())
elif node.get('nodetype') == 'output':
self.connect_to_listmodel.appendRow(pipeline_item)
# self.connect_to_listview.addItem(node.get_name())
elif node.get('nodetype') == 'infer':
if infer_name in self.get_infer_desc(infer_name)['connect_from']:
self.connect_from_listmodel.appendRow(pipeline_item)
elif infer_name in self.get_infer_desc(infer_name)['connect_to']:
self.connect_to_listmodel.appendRow(pipeline_item)
self.connect_from_listview.setModel(self.connect_from_listmodel)
self.connect_to_listview.setModel(self.connect_to_listmodel)
def create_item_list(self, name, parent, is_group):
'''
Creates the list of the items for this group. This list is used for the
visualization of group data as a table row.
:param str name: the group name
:return: the list for the representation as a row
:rtype: C{[L{TopicGroupItem} or U{QStandardItem<https://srinikom.github.io/pyside-docs/PySide/QtGui/QStandardItem.html>}, ...]}
'''
items = []
item = TopicGroupItem(name, parent, is_group)
items.append(item)
pubItem = QStandardItem()
items.append(pubItem)
subItem = QStandardItem()
items.append(subItem)
typeItem = QStandardItem()
items.append(typeItem)
return items
def to_QItemModel(self):
"""
Represent the DSDs debug data as QITemModel
"""
# Return cached result if available
if self.__cached_item_model is not None:
return self.__cached_item_model
# Return empty model when no dsd data was received yet
if self.__cached_msg is None:
return self.__empty_item_model()
# Construct a new item-model
model = QStandardItemModel()
for i in range(len(self.stack)):
elem, _ = self.stack[i]
elem_item = QStandardItem()
elem_item.setEditable(False)
if isinstance(elem, SequenceTreeElement):
elem_item.setText('Sequence: ' + ', '.join(
str(e) for e in elem.action_elements))
sequence = True
else:
elem_item.setText(str(elem))
sequence = False
self.__append_element_to_item(elem_item, elem.debug_data)
model.invisibleRootItem().appendRow(elem_item)
# Add a spacer if this is not the last item
if elem != self.stack[-1][0]:
spacer = QStandardItem()
spacer.setEditable(False)
model.invisibleRootItem().appendRow(spacer)
if sequence:
break
self.__cached_item_model = model
return self.__cached_item_model
def _add_log(self, data):
timestamp = QStandardItem(
QDateTime.currentDateTime().toString('d.M.yyyy hh:mm:ss.zzz'))
timestamp.setTextAlignment(Qt.AlignRight)
timestamp.setEditable(False)
message = QStandardItem(data)
message.setEditable(False)
row = []
row.append(timestamp)
row.append(message)
self._message_count = self._message_count + 1
self.model.insertRow(0, row)
if self._message_count > self._message_limit:
self.model.removeRow(self.model.rowCount() - 1)
self._message_count = self._message_count - 1
def _create_widgets_for_launchfile(self, config):
self._config = config
# Delete old nodes' GUIs.
self._node_controllers = []
# These lines seem to remove indexWidgets previously set on treeview.
# Per suggestion in API doc, we are not using reset(). Instead,
# using 2 methods below without any operation in between, which
# I suspect might be inproper.
# http://qt-project.org/doc/qt-4.8/qabstractitemmodel.html#reset
self._datamodel.beginResetModel()
self._datamodel.endResetModel()
# Need to store the num of nodes outside of the loop -- this will
# be used for removing excessive previous node rows.
order_xmlelement = 0
# Loop per xml element
for order_xmlelement, node in enumerate(self._config.nodes):
proxy = NodeProxy(self._run_id, self._config.master.uri, node)
# TODO: consider using QIcon.fromTheme()
status_label = StatusIndicator()
qindex_nodewidget = self._datamodel.index(order_xmlelement,
0, QModelIndex())
node_widget = self._delegate.create_node_widget(qindex_nodewidget,
proxy.config,
status_label)
#TODO: Ideally find a way so that we don't need this block.
#BEGIN If these lines are missing, widget won't be shown either.
std_item = QStandardItem(
#node_widget.get_node_name()
)
self._datamodel.setItem(order_xmlelement, 0, std_item)
#END If these lines are missing, widget won't be shown either.
self._treeview.setIndexWidget(qindex_nodewidget, node_widget)
node_controller = NodeController(proxy, node_widget)
self._node_controllers.append(node_controller)
node_widget.connect_start_stop_button( \
node_controller.start_stop_slot)
rospy.logdebug('loop #%d proxy.config.namespace=%s ' +
'proxy.config.name=%s',
order_xmlelement, proxy.config.namespace,
proxy.config.name)
self._num_nodes_previous = order_xmlelement
self._parent.set_node_controllers(self._node_controllers)
def _on_ctrl_info(self, index):
popup = self._popup_widget
ctrl = self._controllers[index.row()]
popup.ctrl_name.setText(ctrl.name)
popup.ctrl_type.setText(ctrl.type)
res_model = QStandardItemModel()
model_root = QStandardItem('Claimed Resources')
res_model.appendRow(model_root)
for hw_res in ctrl.claimed_resources:
hw_iface_item = QStandardItem(hw_res.hardware_interface)
model_root.appendRow(hw_iface_item)
for res in hw_res.resources:
res_item = QStandardItem(res)
hw_iface_item.appendRow(res_item)
popup.resource_tree.setModel(res_model)
popup.resource_tree.setItemDelegate(FontDelegate(popup.resource_tree))
popup.resource_tree.expandAll()
popup.move(QCursor.pos())
popup.show()
def setUp(self):
unittest.TestCase.setUp(self)
self._model = QStandardItemModel()
node1 = QStandardItem('node1')
self._node1_1 = QStandardItem('node1_1')
self._node1_1_1 = QStandardItem('node1_1_1')
node1_1_2 = QStandardItem('node1_1_2')
node1_2 = QStandardItem('node1_2')
node1.appendRow(self._node1_1)
self._node1_1.appendRow(self._node1_1_1)
self._node1_1.appendRow(node1_1_2)
node1.appendRow(node1_2)
self._model.appendRow(node1)
# node_list = [node1, node1_1, self._node1_1_1, node1_1_2, node1_2]
# self._model.appendRow(node_list)
self._grn_node1_1_1 = '/node1/node1_1/node1_1_1'
self._len_lower_grn_node1_1 = 2
def create_item_list(self, topic, root):
'''
Creates the list of the items from topic. This list is used for the
visualization of topic data as a table row.
:param str topic: the topic name
:param root: The parent QStandardItem
:type root: U{QStandardItem<https://srinikom.github.io/pyside-docs/PySide/QtGui/QStandardItem.html>}
:return: the list for the representation as a row
:rtype: C{[L{TopicItem} or U{QStandardItem<https://srinikom.github.io/pyside-docs/PySide/QtGui/QStandardItem.html>}, ...]}
'''
items = []
item = TopicItem(topic.name, topic, parent=root)
items.append(item)
pubItem = QStandardItem()
# TopicItem.updatePublisherView(topic, pubItem)
items.append(pubItem)
subItem = QStandardItem()
# TopicItem.updateSubscriberView(topic, subItem)
items.append(subItem)
typeItem = QStandardItem()
# TopicItem.updateTypeView(topic, typeItem)
items.append(typeItem)
return items
def create_item_list(self, name, parent, is_group):
'''
Creates the list of the items for this group. This list is used for the
visualization of group data as a table row.
:param str name: the group name
:return: the list for the representation as a row
:rtype: [:class:`ServiceGroupItem` or :class:`QtGui.QStandardItem` <https://srinikom.github.io/pyside-docs/PySide/QtGui/QStandardItem.html>}]
'''
items = []
item = ServiceGroupItem(name, parent, is_group)
items.append(item)
typeItem = QStandardItem()
items.append(typeItem)
return items
def _append_items(self, item, deep):
path = item.data(self.DATA_INC_FILE)
if not path:
path = item.data(self.DATA_FILE)
if path in GRAPH_CACHE:
for inc_lnr, inc_path in GRAPH_CACHE[path]:
pkg, _ = package_name(os.path.dirname(inc_path))
itemstr = '%s [%s]' % (os.path.basename(inc_path), pkg)
inc_item = QStandardItem('%d: %s' % (inc_lnr + 1, itemstr))
inc_item.setData(path, self.DATA_FILE)
inc_item.setData(inc_lnr + 1, self.DATA_LINE)
inc_item.setData(inc_path, self.DATA_INC_FILE)
inc_item.setData(deep, self.DATA_LEVEL)
self._append_items(inc_item, deep + 1)
item.appendRow(inc_item)
def _append_element_to_item(self, parent_item, debug_data):
"""
Append an elements debug_data to a QStandardItem.
:type parent_item: python_qt_binding.QtGui.QStandardItem
:type debug_data: dict or list or int or float or str or bool
:rtype: python_qt_binding.QtGui.QStandardItem
"""
if isinstance(debug_data, list):
for i, data in enumerate(debug_data):
child_item = QStandardItem()
child_item.setText(str(i) + ": ")
child_item.setEditable(False)
self._append_element_to_item(child_item, data)
parent_item.appendRow(child_item)
elif isinstance(debug_data, dict):
for label, data in debug_data.items():
child_item = QStandardItem()
child_item.setText(str(label) + ": ")
child_item.setEditable(False)
self._append_element_to_item(child_item, data)
parent_item.appendRow(child_item)
elif isinstance(debug_data, (bool, float, int, str, bytes)):
parent_item.setText(parent_item.text() + str(debug_data))
def _get_result_cb(self, status, res):
rospy.loginfo("got result!")
self._blocks_model.setRowCount(0)
self._blocks_model.setRowCount(len(res.blocks))
for (i, block) in zip(range(len(res.blocks)), res.blocks):
# Store in dict
self.blocks[block.name] = block
cb = QStandardItem(True)
cb.setCheckable(True)
cb.setCheckState(Qt.Checked if block.state.value == conman_msgs.
msg.TaskState.RUNNING else Qt.Unchecked)
cb.setTextAlignment(Qt.AlignHCenter)
cb.setTristate(True)
action = QStandardItem(True)
action.setText("")
state = QStandardItem(True)
state.setText(state_map[block.state.value])
name = QStandardItem(True)
name.setText(str(block.name))
self._blocks_model.setItem(i, 0, cb)
self._blocks_model.setItem(i, 1, action)
self._blocks_model.setItem(i, 2, state)
self._blocks_model.setItem(i, 3, name)
for (i, group) in zip(range(len(res.groups)), res.groups):
self.groups[group.name] = group
cb = QStandardItem(True)
cb.setCheckable(True)
cb.setCheckState(Qt.Checked)
cb.setTextAlignment(Qt.AlignHCenter)
cb.setEnabled(False)
name = QStandardItem(True)
name.setText(str(group.name))
self._groups_model.setItem(i, 0, cb)
self._groups_model.setItem(i, 3, name)
self._update_groups()
self._update_blocks()
self._widget.blocks_table.resizeColumnsToContents()
self._widget.blocks_table.horizontalHeader().setStretchLastSection(
True)
self._widget.groups_table.resizeColumnsToContents()
self._widget.groups_table.horizontalHeader().setStretchLastSection(
True)
def getItemList(self, topic, root):
'''
Creates the list of the items from topic. This list is used for the
visualization of topic data as a table row.
@param name: the topic name
@type name: C{str}
@param root: The parent QStandardItem
@type root: L{PySide.QStandardItem}
@return: the list for the representation as a row
@rtype: C{[L{TopicItem} or L{PySide.QStandardItem}, ...]}
'''
items = []
item = TopicItem(topic.name, topic, parent=root)
items.append(item)
pubItem = QStandardItem()
# TopicItem.updatePublisherView(topic, pubItem)
items.append(pubItem)
subItem = QStandardItem()
# TopicItem.updateSubscriberView(topic, subItem)
items.append(subItem)
typeItem = QStandardItem()
# TopicItem.updateTypeView(topic, typeItem)
items.append(typeItem)
return items
def getItemList(self, service):
'''
Creates the list of the items from service. This list is used for the
visualization of service data as a table row.
@param service: the service data
@type service: U{master_discovery_fkie.ServiceInfo<http://docs.ros.org/kinetic/api/master_discovery_fkie/html/modules.html#master_discovery_fkie.master_info.ServiceInfo>}
@return: the list for the representation as a row
@rtype: C{[L{ServiceItem} or U{QtGui.QStandardItem<https://srinikom.github.io/pyside-docs/PySide/QtGui/QStandardItem.html>}, ...]}
'''
items = []
item = ServiceItem(service)
# removed tooltip for clarity !!!
# item.setToolTip(''.join(['<div><h4>', str(service.name), '</h4><dl><dt>', str(service.uri),'</dt></dl></div>']))
items.append(item)
typeItem = QStandardItem()
ServiceItem.updateTypeView(service, typeItem)
items.append(typeItem)
return items
def getItemList(self, service):
'''
Creates the list of the items from service. This list is used for the
visualization of service data as a table row.
@param service: the service data
@type service: L{master_discovery_fkie.ServiceInfo}
@return: the list for the representation as a row
@rtype: C{[L{ServiceItem} or L{PySide.QtGui.QStandardItem}, ...]}
'''
items = []
item = ServiceItem(service)
# removed tooltip for clarity !!!
# item.setToolTip(''.join(['<div><h4>', str(service.name), '</h4><dl><dt>', str(service.uri),'</dt></dl></div>']))
items.append(item)
typeItem = QStandardItem()
ServiceItem.updateTypeView(service, typeItem)
items.append(typeItem)
return items
def create_item_list(self, service, root):
'''
Creates the list of the items from service. This list is used for the
visualization of service data as a table row.
:param service: the service data
:type service: U{fkie_master_discovery.ServiceInfo<http://docs.ros.org/kinetic/api/fkie_master_discovery/html/modules.html#fkie_master_discovery.master_info.ServiceInfo>}
:return: the list for the representation as a row
:rtype: [:class:`ServiceItem` or :class:`QtGui.QStandardItem` <https://srinikom.github.io/pyside-docs/PySide/QtGui/QStandardItem.html>]
'''
items = []
item = ServiceItem(service, parent=root)
# removed tooltip for clarity !!!
# item.setToolTip(''.join(['<div><h4>', utf8(service.name), '</h4><dl><dt>', utf8(service.uri),'</dt></dl></div>']))
items.append(item)
typeItem = QStandardItem()
ServiceItem.updateTypeView(service, typeItem)
items.append(typeItem)
return items
def _load_pipeline(self):
self._dotgraphs.clear()
self._listmodel.clear()
file_path, _ = QFileDialog.getOpenFileName(
self._widget, "QFileDialog.getOpenFileName()", "", "*.yaml")
self._dotgraphs = generate_dotcode_from_yaml_file(
self.dotcode_factory, self.param_manager, str(file_path))
for pipeline_name, pipeline_dotgraph in self._dotgraphs.items():
pipeline_item = QStandardItem()
pipeline_item.setText(pipeline_name)
self._listmodel.appendRow(pipeline_item)
self._current_pipeline_name = self._dotgraphs.iterkeys().next()
self._refresh_rosgraph()
def _create_pipeline(self):
pipeline_name, okPressed = QInputDialog.getText(
self._widget, "Create a new pipeline", "new pipeline name:",
QLineEdit.Normal, "")
if okPressed != True or pipeline_name == '':
#Empty name
return
pipeline_item = QStandardItem()
pipeline_item.setText(pipeline_name)
self._listmodel.appendRow(pipeline_item)
new_dotgraph = dotparser.generate_dotcode_from_empty(
self.dotcode_factory, pipeline_name)
self._dotgraphs.update(new_dotgraph)
self._current_pipeline_name = pipeline_name
self._refresh_rosgraph()
def update_connect_to_list(self, output_name):
self.connect_from_listmodel.clear()
for node in self.dotgraph.get_node_list():
if node.get('nodetype') == 'input':
pass
elif node.get('nodetype') == 'output':
pass
elif node.get('nodetype') == 'infer':
if output_name in self.get_infer_desc(
node.get_name())['connect_to']:
pipeline_item = QStandardItem()
pipeline_item.setText(node.get_name())
pipeline_item.setCheckable(True)
pipeline_item.setCheckState(False)
self.connect_from_listmodel.appendRow(pipeline_item)
self.connect_from_listview.setModel(self.connect_from_listmodel)
def _refill_tree(self, tree, create_tree=True):
deep = 0
file_dsrc = self._root_path
try:
file_dsrc = os.path.basename(self._root_path)
except Exception:
pass
self.setWindowTitle("Include Graph - %s" % file_dsrc)
if not self._created_tree and create_tree:
has_none_packages = False
self.graphTreeView.model().clear()
pkg, _ = package_name(os.path.dirname(self._root_path))
if pkg is None:
has_none_packages = True
itemstr = '%s [%s]' % (os.path.basename(self._root_path), pkg)
inc_item = QStandardItem('%s' % itemstr)
inc_item.setData(self._root_path, self.DATA_FILE)
inc_item.setData(-1, self.DATA_LINE)
inc_item.setData(self._root_path, self.DATA_INC_FILE)
inc_item.setData(deep, self.DATA_LEVEL)
self._append_items(inc_item, deep, tree)
self.graphTreeView.model().appendRow(inc_item)
# self.graphTreeView.expand(self.graphTreeView.model().indexFromItem(inc_item))
self._created_tree = True
self.has_none_packages = has_none_packages
items = self.graphTreeView.model().match(
self.graphTreeView.model().index(0, 0), self.DATA_INC_FILE,
self._current_path, 10, Qt.MatchRecursive)
first = True
self.graphTreeView.selectionModel().clear()
for item in items:
if first:
self._current_deep = item.data(self.DATA_LEVEL)
first = False
self.graphTreeView.selectionModel().select(
item, QItemSelectionModel.Select)
self.graphTreeView.expandAll()
self.finished_signal.emit()
def _refill_tree(self, included_from, includes, create_tree=True):
deep = 0
file_dsrc = self._root_path
try:
file_dsrc = os.path.basename(self._root_path)
except Exception:
pass
self.setWindowTitle("Include Graph - %s" % file_dsrc)
if not self._created_tree and create_tree:
with CHACHE_MUTEX:
if self._root_path in GRAPH_CACHE:
pkg, _ = package_name(os.path.dirname(self._root_path))
itemstr = '%s [%s]' % (os.path.basename(
self._root_path), pkg)
inc_item = QStandardItem('%s' % itemstr)
inc_item.setData(self._root_path, self.DATA_FILE)
inc_item.setData(-1, self.DATA_LINE)
inc_item.setData(self._root_path, self.DATA_INC_FILE)
inc_item.setData(deep, self.DATA_LEVEL)
self._append_items(inc_item, deep + 1)
self.graphTreeView.model().appendRow(inc_item)
# self.graphTreeView.expand(self.graphTreeView.model().indexFromItem(inc_item))
self._created_tree = True
items = self.graphTreeView.model().match(
self.graphTreeView.model().index(0, 0), self.DATA_INC_FILE,
self._current_path, 10, Qt.MatchRecursive)
first = True
self.graphTreeView.selectionModel().clearSelection()
for item in items:
if first:
self._current_deep = item.data(self.DATA_LEVEL)
self.graphTreeView.selectionModel().select(
item, QItemSelectionModel.SelectCurrent)
first = False
else:
self.graphTreeView.selectionModel().select(
item, QItemSelectionModel.Select)
self.graphTreeView.expandAll()
