def update_setpoints(self, joint): self.table_widget.setRowCount(len(joint.setpoints)) for i, setpoint in enumerate(joint.setpoints): time_item = QTableWidgetItem( str(round(setpoint.time, self.TABLE_DIGITS))) position_item = QTableWidgetItem( str(round(math.degrees(setpoint.position), self.TABLE_DIGITS))) velocity_item = QTableWidgetItem( str(round(math.degrees(setpoint.velocity), self.TABLE_DIGITS))) self.table_widget.setItem(i, 0, time_item) self.table_widget.setItem(i, 1, position_item) self.table_widget.setItem(i, 2, velocity_item) self.table_widget.setItemDelegate( JointSettingSpinBoxDelegate( joint.limits.velocity, joint.limits.lower, joint.limits.upper, joint.duration, )) self.table_widget.resizeColumnsToContents()
def __init__(self, subsystem_name, parent=None): super(StateHistoryDialog, self).__init__(parent) self.parent = parent self.setWindowFlags(Qt.Window) rp = rospkg.RosPack() ui_file = os.path.join(rp.get_path('rqt_agent'), 'resource', 'StateHistory.ui') loadUi(ui_file, self) self.setWindowTitle(subsystem_name + " - state history") self.pushButton_close.clicked.connect(self.closeClick) hdr = self.MyHorizHeader(self.tableWidget) hdr.setMinimumSectionSize(40) hdr.setDefaultSectionSize(40) self.tableWidget.setHorizontalHeader(hdr) self.initialized = False item0 = QTableWidgetItem("behavior") item1 = QTableWidgetItem("reason") item2 = QTableWidgetItem("time") self.tableWidget.setHorizontalHeaderItem (0, item0) self.tableWidget.setHorizontalHeaderItem (1, item1) self.tableWidget.setHorizontalHeaderItem (2, item2) self.tableWidget.setColumnWidth(0, 100) self.tableWidget.setColumnWidth(1, 50) self.tableWidget.setColumnWidth(2, 75)
def _add_parameter(self, param): key = QTableWidgetItem(param.key) key.setFlags(key.flags() & ~Qt.ItemIsEditable) row = self.skill_params_table.rowCount() self.skill_params_table.insertRow(row) #row = row-1 self.skill_params_table.setItem(row, 0, key) if param.dataTypeIs(bool): cbox = QCheckBox() if param.hasSpecifiedDefault(): cbox.setChecked(param.default) self.skill_params_table.setCellWidget(row, 1, cbox) elif param.dataTypeIs(Element): combobox = QComboBox() self.skill_params_table.setCellWidget(row, 1, combobox) matches = self._wmi.resolve_elements(param.default) if param.paramTypeIs(ParamTypes.Optional): combobox.addItem("", None) for e in matches: combobox.addItem(e.printState(), e._id) else: lineedit = QLineEdit() if param.isSpecified(): lineedit.setText(str(param.value)) self.skill_params_table.setCellWidget(row, 1, lineedit)
def set_motor_joint_states(self, data): if self.current_tab == 0: self.motorheaderlist = [] for i in range(0, len(data.name)): self.torquelist[i].append(float(data.effort[i])) if not data.name[i] in self.motorheaderlist: self.motorheaderlist.append(data.name[i]) for j in range(0, len(self.motorheaderlist)): if j < 10: selected = self._widget.tableWidget k = j else: selected = self._widget.tableWidget_2 k = j - 10 for j in self.motorheaderlist: if j == data.name[i]: selected.setItem( 2, k, QTableWidgetItem( str( round( float( math.degrees( data.position[i])), 2)))) selected.setItem( 5, k, QTableWidgetItem( str(round(float(data.effort[i]), 2)))) self._widget.tableWidget.setHorizontalHeaderLabels( self.motorheaderlist) self._widget.tableWidget_2.setHorizontalHeaderLabels( self.motorheaderlist[10:]) self.totrigger.emit()
def wm_tree_widget_currentItemChanged(self, item, prev_item): while self.wm_properties_widget.rowCount() > 0: self.wm_properties_widget.removeRow(0) item = QTableWidgetItem(str(item.text(0))) self.wm_properties_widget.insertRow(0) self.wm_properties_widget.setItem(0, 0, item) while self.wm_relations_widget.rowCount() > 0: self.wm_relations_widget.removeRow(0) item = QTableWidgetItem("") self.wm_relations_widget.insertRow(0) self.wm_relations_widget.setItem(0, 0, item)
def _update_data_table(self): self._data_table.setRowCount(0) for data_key, data_dict in self._data_buffer.items(): current_row = self._data_table.rowCount() self._data_table.insertRow(current_row) self._data_table.setItem(current_row, 0, QTableWidgetItem(data_dict['time'])) self._data_table.setItem(current_row, 1, QTableWidgetItem(data_dict['trig_name'])) self._data_table.setItem(current_row, 2, QTableWidgetItem(data_dict['trig_type'])) self._data_table.setItem(current_row, 3, QTableWidgetItem(data_dict['data']._type)) self._data_table.setItem(current_row, 4, QTableWidgetItem(data_key)) self._data_table.sortItems(0, Qt.DescendingOrder)
def set_current_grid(self): if 'grid' not in self.step.keys(): self.add_grid() self.gridTable.setItem(0, 1, QTableWidgetItem(self.step['grid']['X'])) self.gridTable.setItem(1, 1, QTableWidgetItem(self.step['grid']['Y'])) self.gridTable.setItem(2, 1, QTableWidgetItem(self.step['grid']['x_first'])) self.gridTable.setItem(3, 1, QTableWidgetItem(self.step['grid']['x_step'])) self.gridTable.setItem(4, 1, QTableWidgetItem(self.step['grid']['y_step']))
def _update_progress_table(self, msg): last_msg = self.tableWidget_output.item(self.tableWidget_output.rowCount() - 1, 5).text() if self.tableWidget_output.rowCount() > 0 else "" if msg.progress_message != "Start" and (msg.label.find("task") >= 0 or (msg.progress_message != "End" and msg.progress_message != last_msg)): self.tableWidget_output.insertRow(self.tableWidget_output.rowCount()) self.tableWidget_output.setItem(self.tableWidget_output.rowCount() - 1, 0, QTableWidgetItem("{:0.3f}".format(msg.progress_time))) self.tableWidget_output.setItem(self.tableWidget_output.rowCount() - 1, 1, QTableWidgetItem("{}_{}".format(msg.parent_label, msg.parent_id))) self.tableWidget_output.setItem(self.tableWidget_output.rowCount() - 1, 2, QTableWidgetItem("{}_{}".format(msg.label, msg.id))) self.tableWidget_output.setItem(self.tableWidget_output.rowCount() - 1, 3, QTableWidgetItem(State(msg.state).name)) self.tableWidget_output.setItem(self.tableWidget_output.rowCount() - 1, 4, QTableWidgetItem(str(msg.progress_code))) progress = QTableWidgetItem(str(msg.progress_message)) progress.setToolTip(str(msg.progress_message)) self.tableWidget_output.setItem(self.tableWidget_output.rowCount() - 1, 5, progress) self.tableWidget_output.scrollToBottom()
def updateState(self, mcd): hist = mcd[0] if self.tableWidget.rowCount() != len(hist): self.tableWidget.setRowCount( len(hist) ) row = 0 curr_pred = mcd[1].split(",") curr_pred_v = [] for cp in curr_pred: k_v = cp.split(":") if len(k_v) == 2: curr_pred_v.append(k_v[1]) for ss in hist: for col in range(3): self.tableWidget.setItem(row, col, QTableWidgetItem(ss[col])) pred = ss[3].split(",") if not self.initialized: self.initialized = True predicates = [] for p in pred: k_v = p.split(":") if len(k_v) != 2: continue predicates.append( k_v[0] ) self.tableWidget.setColumnCount(len(predicates)+3) idx = 3 for p in predicates: item = QTableWidgetItem(p) self.tableWidget.setHorizontalHeaderItem(idx, item) idx += 1 idx = 0 for p in pred: k_v = p.split(":") if len(k_v) != 2: continue if row == 0: self.tableWidget.setItem(row, 3+idx, QTableWidgetItem(k_v[1] + " ("+curr_pred_v[idx]+")")) else: self.tableWidget.setItem(row, 3+idx, QTableWidgetItem(k_v[1])) idx += 1 row = row + 1
def _add_entry(self): self._table_widget.blockSignals(True) # insert new row self._table_widget.insertRow(self._table_widget.rowCount() - 1) # move key and value items up self._table_widget.setItem( self._table_widget.rowCount() - 2, 0, self._table_widget.takeItem(self._table_widget.rowCount() - 1, 0)) self._table_widget.setItem( self._table_widget.rowCount() - 2, 1, self._table_widget.takeItem(self._table_widget.rowCount() - 1, 1)) self._table_widget.setItem(self._table_widget.rowCount() - 1, 0, QTableWidgetItem()) self._table_widget.setItem(self._table_widget.rowCount() - 1, 1, QTableWidgetItem()) # add 'remove' button item = QTableWidgetItem() item.setFlags(Qt.NoItemFlags) self._table_widget.setItem(self._table_widget.rowCount() - 2, 2, item) self._table_widget.setCellWidget( self._table_widget.rowCount() - 2, 2, self._create_cell_push_button( '', lambda: self._table_widget.removeRow(item.row()), QIcon.fromTheme('list-remove'))) self._table_widget.blockSignals(False)
def new_pano_state(self, msg): self.tableWidget.clearContents() self.files = {} self.pixmaps = {} j = 0 self.tableWidget.setRowCount( len(msg.in_transfer) + len(msg.transferred)) for i in msg.in_transfer: self.tableWidget.setItem(j, 0, QTableWidgetItem(i)) self.tableWidget.setItem(j, 1, QTableWidgetItem("Transferring")) j += 1 # self.tableWidget.setRowCount(j) for i in msg.transferred: self.tableWidget.setItem(j, 0, QTableWidgetItem(i)) self.tableWidget.setItem(j, 1, QTableWidgetItem("Transferred")) self.files[j] = i print self.files self.pixmaps[j] = QPixmap(i) j += 1
def handle_add_button_clicked(self, checked): '''When the add button is clicked this function moves any selected items to the plan queue table.''' #get selected items selected_plans = self._widget.planList.selectedItems() #create a new row in the queue table for each selection and insert it for i in selected_plans: row_position = self._widget.planQueueTable.rowCount() self._widget.planQueueTable.insertRow(row_position) self._widget.planQueueTable.setItem(row_position-1, 1, QTableWidgetItem(i.text())) self._widget.planList.selectionModel().clear() self._widget.planQueueTable.resizeColumnsToContents() return
def pose_selected(self, index): rospy.loginfo('%s::%s:' % (self._name, self.get_function_name())) if index < 0: self.posesTable.setRowCount(0) pose = self.get_pose(index) if pose == None or len(pose) != 2 or len(pose[0]) != 3 or len( pose[1]) != 3: return axes = [['X', 'Y', 'Z'], ['roll', 'pitch', 'yaw']] self.posesTable.setRowCount(0) for i in range(len(axes)): for j in range(len(axes[i])): row_count = self.posesTable.rowCount() self.posesTable.insertRow(row_count) self.posesTable.setItem(row_count, 0, QTableWidgetItem(axes[i][j])) self.posesTable.setItem(row_count, 1, QTableWidgetItem(str(pose[i][j])))
def update_table(table, joint, duration): table.setRowCount(len(joint.setpoints)) for i in range(0, len(joint.setpoints)): time_item = QTableWidgetItem(str(round(joint.setpoints[i].time, TABLE_DIGITS))) position_item = QTableWidgetItem( str(round(math.degrees(joint.setpoints[i].position), TABLE_DIGITS))) velocity_item = QTableWidgetItem( str(round(math.degrees(joint.setpoints[i].velocity), TABLE_DIGITS))) table.setItem(i, 0, time_item) table.setItem(i, 1, position_item) table.setItem(i, 2, velocity_item) table.setItemDelegate(JointSettingSpinBoxDelegate( joint.limits.velocity, joint.limits.lower, joint.limits.upper, duration)) # table.resizeRowsToContents() table.resizeColumnsToContents() return table
def _init_table_widget(self): self._table_widget.blockSignals(True) self._table_widget.setRowCount(1) self._table_widget.setColumnCount(3) self._table_widget.verticalHeader().setVisible(False) self._table_widget.setHorizontalHeaderLabels(['Key', 'Value', '']) self._table_widget.horizontalHeader().setSectionResizeMode( QHeaderView.Stretch) self._table_widget.horizontalHeader().setSectionResizeMode( 2, QHeaderView.ResizeToContents) self._table_widget.setItem(0, 0, QTableWidgetItem()) self._table_widget.setItem(0, 1, QTableWidgetItem()) self._table_widget.setItem(0, 2, QTableWidgetItem()) self._table_widget.item(0, 2).setFlags(Qt.NoItemFlags) self._table_widget.setCellWidget( 0, 2, self._create_cell_push_button('', lambda: self._add_entry(), QIcon.fromTheme('list-add'))) self._table_widget.blockSignals(False)
def joint_pose_selected(self, index): rospy.loginfo('%s::%s: index: %d' % (self._name, self.get_function_name(), index)) if index < 0: self.jointPosesTable.setRowCount(0) joint_pose = self.get_joint_pose(index) if joint_pose == None or len(joint_pose) != len(self.joint_state.name): return self.jointPosesTable.setRowCount(0) for i in range(len(joint_pose)): row_count = self.jointPosesTable.rowCount() self.jointPosesTable.insertRow(row_count) self.jointPosesTable.setItem( row_count, 0, QTableWidgetItem(self.joint_state.name[i])) self.jointPosesTable.setItem(row_count, 1, QTableWidgetItem(str(joint_pose[i]))) rospy.loginfo('%s::%s: adding : %s, %f' % (self._name, self.get_function_name(), self.joint_state.name[i], joint_pose[i]))
def set_current_arm(self): # this is view... self._widget.groupNameEdit.setText(self.get_current_movegroup_name()) self._widget.actionNSEdit.setText(self.get_current_actionns()) self._widget.baseLinkEdit.setText(self.get_current_base_link()) self._widget.endEffectorEdit.setText(self.get_current_end_effector()) joint_names = self.get_current_joint_names() self._widget.jointsTable.setRowCount(len(joint_names)) for i in range(len(joint_names)): self._widget.jointsTable.setItem(i, 0, QTableWidgetItem(joint_names[i])) inputs = self.get_current_inputs() self._widget.inputsTable.setRowCount(0) for input_key in inputs: # different ways of filling the tabele row_count = self._widget.inputsTable.rowCount() self._widget.inputsTable.insertRow(row_count) self._widget.inputsTable.setItem(row_count, 0, QTableWidgetItem(input_key)) self._widget.inputsTable.setItem( row_count, 1, QTableWidgetItem(str(inputs[input_key]))) outputs = self.get_current_outputs() self._widget.outputsTable.setRowCount(0) for output_key in outputs: # different ways of filling the tabele row_count = self._widget.outputsTable.rowCount() self._widget.outputsTable.insertRow(row_count) self._widget.outputsTable.setItem(row_count, 0, QTableWidgetItem(output_key)) self._widget.outputsTable.setItem( row_count, 1, QTableWidgetItem(str(outputs[output_key]))) self._widget.stepBox.clear() steps = self.get_steps() for s in steps: self._widget.stepBox.addItem(s) self._widget.stepBox.setCurrentIndex(0)
def handle_send_button_clicked(self, checked): '''When send button is clicked any items in the plan queue table are sent (in order) to the sent plans table. It then publishes a string array of these plans so that the ow_plexil_plan_selection node can run them sequentially. If the subscriber is not connected a popup box reminding the user to run the ow_plexil node will show up.''' if self.check_client_set_up() == False: return num_rows = self._widget.planQueueTable.rowCount() plans_sent = [] #creates a new row in the sent table for each item in the queue table and inserts it for i in range(num_rows): plan_name = self._widget.planQueueTable.item(0,0).text() plans_sent.append(str(plan_name + ".plx")) self._widget.planQueueTable.removeRow(0) row_position = self._widget.sentPlansTable.rowCount() self._widget.sentPlansTable.insertRow(row_position) self._widget.sentPlansTable.setItem(row_position, 0, QTableWidgetItem(plan_name)) self._widget.sentPlansTable.setItem(row_position, 1, QTableWidgetItem("Pending...")) self._widget.sentPlansTable.resizeColumnsToContents() # Create msg and send to subscriber for plan execution self.plan_select_client("ADD", plans_sent) return
def __init__(self, context): super(Controls, self).__init__(context) # Give QObjects reasonable names self.setObjectName('Controls') # Create QWidget self._widget = QWidget() # Get path to UI file which should be in the "resource" folder of this package _ui_file = path.join(rospkg.RosPack().get_path('rqt_controls'), 'resource', 'Controls.ui') # Extend the widget with all attributes and children from UI file self._ui = loadUi(_ui_file, self._widget) self._ui.ButtonKillnode.clicked.connect(self.onKillnode) for i in range(0, 3): self._ui.MotorTable.setItem(i, 0, QTableWidgetItem()) self._ui.MotorTable.setItem(i, 1, QTableWidgetItem()) # Give QObjects reasonable names self._widget.setObjectName('ControlsUi') self._widget.setWindowTitle("Robot Controls") # Show _widget.windowTitle on left-top of each plugin (when # it's set in _widget). This is useful when you open multiple # plugins at once. Also if you open multiple instances of your # plugin at once, these lines add number to make it easy to # tell from pane to pane. if context.serial_number() > 1: self._widget.setWindowTitle(self._widget.windowTitle() + (' (%d)' % context.serial_number())) # Add widget to the user interface context.add_widget(self._widget) self._ui.BatteryPanel.display(999.9) self.motor_stats = rospy.Subscriber("skid_steering_node/motor_stats", ChannelFloat32, self.callback)
def _write_conf_to_table(self): self._conf_table.setRowCount(len(self._conf_yaml)) for row, conf_key in enumerate(self._conf_yaml.items()): conf = conf_key[1] self._conf_table.setItem(row, 0, QTableWidgetItem(conf['trig_name'])) self._conf_table.setItem(row, 1, QTableWidgetItem(conf['robot_ns'])) self._conf_table.setItem(row, 2, QTableWidgetItem(conf['trig_topic'])) self._conf_table.setItem(row, 3, QTableWidgetItem(conf['trig_type'])) self._conf_table.setItem(row, 4, QTableWidgetItem(str(conf['trig_value']))) self._conf_table.setItem(row, 5, QTableWidgetItem(conf['trig_callback']))
def addRow(self, label, c_rgba, mean, deviation): rowIdx = self.rowCount() - 1 self.insertRow(rowIdx) # create QColor color = QtGui.QColor.fromRgbF(c_rgba[0], c_rgba[1], c_rgba[2], c_rgba[3]) # create QBrush with color brush = QtGui.QBrush(color) # legend item leg_item = QTableWidgetItem(label) leg_item.setBackground(brush) self.setItem(rowIdx, 0, leg_item) # mean item mean_item = QTableWidgetItem(str(mean)) mean_item.setBackground(brush) self.setItem(rowIdx, 1, mean_item) # deviation item dev_item = QTableWidgetItem(str(deviation)) dev_item.setBackground(brush) self.setItem(rowIdx, 2, dev_item)
def update_display(self): self.clear_display() self.update_flight_plan() for i in xrange(len(self.loaded_movement.waypoints)): self._widget.table_waypoints.insertRow(i) item_x = QTableWidgetItem(str(self.loaded_movement.waypoints[i].x)) item_y = QTableWidgetItem(str(self.loaded_movement.waypoints[i].y)) item_z = QTableWidgetItem(str(self.loaded_movement.waypoints[i].z)) item_yaw = QTableWidgetItem(str(self.loaded_movement.waypoints[i].yaw)) item_x.setTextAlignment(QtCore.Qt.AlignVCenter | QtCore.Qt.AlignRight) item_y.setTextAlignment(QtCore.Qt.AlignVCenter | QtCore.Qt.AlignRight) item_z.setTextAlignment(QtCore.Qt.AlignVCenter | QtCore.Qt.AlignRight) item_yaw.setTextAlignment(QtCore.Qt.AlignVCenter | QtCore.Qt.AlignRight) self._widget.table_waypoints.setItem(i, 0, item_x) self._widget.table_waypoints.setItem(i, 1, item_y) self._widget.table_waypoints.setItem(i, 2, item_z) self._widget.table_waypoints.setItem(i, 3, item_yaw) self.update_plot()
def _add_relations_table_row(self, relation, editable_src=False, editable_dst=False): src = QTableWidgetItem(utils.ontology_type2name(relation['src'])) rel = QTableWidgetItem(utils.ontology_type2name(relation['type'])) dst = QTableWidgetItem(utils.ontology_type2name(relation['dst'])) src.id = relation['src'] rel.id = relation['type'] dst.id = relation['dst'] src.setTextAlignment(Qt.AlignRight) rel.setTextAlignment(Qt.AlignHCenter) dst.setTextAlignment(Qt.AlignLeft) if not editable_src: src.setFlags(src.flags() & ~Qt.ItemIsEditable) rel.setFlags(rel.flags() & ~Qt.ItemIsEditable) if not editable_dst: dst.setFlags(dst.flags() & ~Qt.ItemIsEditable) self.wm_relations_widget.insertRow(self.wm_relations_widget.rowCount()) # self.wm_relations_widget.setSpan(self.wm_relations_widget.rowCount()-1, 0, 1, 3) self.wm_relations_widget.setItem(self.wm_relations_widget.rowCount() - 1, 0, src) self.wm_relations_widget.setItem(self.wm_relations_widget.rowCount() - 1, 1, rel) self.wm_relations_widget.setItem(self.wm_relations_widget.rowCount() - 1, 2, dst)
def set_motor_diagnostics(self, data): """Updates the table in the motor overview tab""" self.timestamp = data.header.stamp.secs #setting timestamp here, because this topic should always exist. self._widget.label_13.setText(str(self.timestamp)) self.motorheaderlist = [] for i in range(len(data.status)): if data.status[i].level == 1: self.templist[int(data.status[i].hardware_id) - 101].append( float(data.status[i].values[3].value)) self.voltagelist[int(data.status[i].hardware_id) - 101].append( float(data.status[i].values[1].value)) if len(self.templist[i]) > 20: self.templist[i].pop(0) if len(self.voltagelist[i]) > 20: self.voltagelist[i].pop(0) if self.current_tab == 0: if data.status[i].level == 1: if not data.status[i].values[ 2].value in self.motorheaderlist: self.motorheaderlist.append( data.status[i].values[2].value) for j in range(0, len(self.motorheaderlist)): if j < 10: selected = self._widget.tableWidget k = j else: selected = self._widget.tableWidget_2 k = j - 10 try: if self.motorheaderlist[j] == data.status[ i].values[2].value: selected.setItem( 0, k, QTableWidgetItem( data.status[i].message)) selected.setItem( 1, k, QTableWidgetItem( str( round( float(data.status[i]. values[3].value), 2)))) selected.setItem( 3, k, QTableWidgetItem( str( round( float(data.status[i]. values[1].value), 2)))) selected.setItem( 4, k, QTableWidgetItem( data.status[i].values[0].value)) except IndexError: rospy.logwarn( "Received a message that misses some information. Faulty message: " + data.status[i]) self._widget.tableWidget.setHorizontalHeaderLabels( self.motorheaderlist) self._widget.tableWidget_2.setHorizontalHeaderLabels( self.motorheaderlist[10:]) self._widget.tableWidget.reset() self._widget.tableWidget_2.reset() self._widget.tableWidget.setEditTriggers( QTableWidget.NoEditTriggers) self.tetrigger.emit() self.votrigger.emit()
def _add_properties_table_row(self, prop, editable_key=False, editable_value=True): key = QTableWidgetItem(utils.ontology_type2name(prop.key)) if not editable_key: key.setFlags(key.flags() & ~Qt.ItemIsEditable) value = prop.values if prop.isList() else prop.value if prop.dataTypeIs(float): val = QTableWidgetItem(format(value, '.4f') if value is not None else '') else: val = QTableWidgetItem(str(value) if value is not None else '') if not editable_value: val.setFlags(val.flags() & ~Qt.ItemIsEditable) if prop.dataTypeIs(bool): val.setText('') val.setFlags(val.flags() & ~Qt.ItemIsEditable) val.setCheckState(Qt.Checked if prop.value else Qt.Unchecked) # if isinstance(prop.dataType(), bool): # val.setCheckState(prop.value) key.id = val.id = prop.key self.wm_properties_widget.insertRow(self.wm_properties_widget.rowCount()) self.wm_properties_widget.setItem(self.wm_properties_widget.rowCount() - 1, 0, key) self.wm_properties_widget.setItem(self.wm_properties_widget.rowCount() - 1, 1, val)