def __init__(self, parent=None, logger=Logger()): QWidgetWithLogger.__init__(self, parent, logger) # start widget vbox = QVBoxLayout() vbox.setMargin(0) vbox.setContentsMargins(0, 0, 0, 0) # parameter action server topic selection topic_widget = QTopicWidget( self, 'vigir_generic_params/GetParameterSetNamesAction', True) vbox.addWidget(topic_widget) # parameter set selection self.parameter_set_selection_widget = QParameterSetSelectionWidget( self, logger) self.parameter_set_selection_widget.param_cleared_signal.connect( self.param_cleared) self.parameter_set_selection_widget.param_changed_signal.connect( self.param_changed) topic_widget.topic_changed_signal.connect(self.topic_changed) topic_widget.topic_changed_signal.connect( self.parameter_set_selection_widget.set_topic_name) vbox.addWidget(self.parameter_set_selection_widget) # end widget self.setLayout(vbox) # init widget topic_widget.emit_topic_name()
def __init__(self, status): super(InspectorWidget, self).__init__() self.status = status self.setWindowTitle(status.name) self.paused = False layout = QVBoxLayout() self.disp = QTextEdit() self.snapshot = QPushButton("Snapshot") self.time = TimelineWidget(self) layout.addWidget(self.disp, 1) layout.addWidget(self.time, 0) layout.addWidget(self.snapshot) self.snaps = [] self.snapshot.clicked.connect(self.take_snapshot) self.write.connect(self.write_kv) self.newline.connect(lambda: self.disp.insertPlainText('\n')) self.clear.connect(lambda: self.disp.clear()) self.setLayout(layout) self.setGeometry(0,0,300,400) self.show() self.update(status)
def __init__(self, tabwidget, parent=None): QDockWidget.__init__(self, "Find", parent) self.setObjectName('SearchFrame') self.setFeatures(QDockWidget.DockWidgetMovable | QDockWidget.DockWidgetFloatable) self._dockwidget = QFrame(self) self.vbox_layout = QVBoxLayout(self._dockwidget) self.layout().setContentsMargins(0, 0, 0, 0) self.layout().setSpacing(1) # frame with two rows for find and replace find_replace_frame = QFrame(self) find_replace_vbox_layout = QVBoxLayout(find_replace_frame) find_replace_vbox_layout.setContentsMargins(0, 0, 0, 0) find_replace_vbox_layout.setSpacing(1) # find_replace_vbox_layout.addSpacerItem(QSpacerItem(1, 1, QSizePolicy.Expanding, QSizePolicy.Expanding)) # create frame with find row find_frame = self._create_find_frame() find_replace_vbox_layout.addWidget(find_frame) rplc_frame = self._create_replace_frame() find_replace_vbox_layout.addWidget(rplc_frame) # frame for find&replace and search results self.vbox_layout.addWidget(find_replace_frame) self.vbox_layout.addWidget(self._create_found_frame()) # self.vbox_layout.addStretch(2024) self.setWidget(self._dockwidget) # intern search parameters self._tabwidget = tabwidget self.current_search_text = '' self.search_results = [] self.search_results_fileset = set() self._search_result_index = -1 self._search_recursive = False self._search_thread = None
def _update_client_list(self, service_name): service_list = self.admin_app_info.service_list client_list = service_list[service_name]["client_list"] self._widget.client_tab_widget.clear() for k in client_list.values(): client_name = k["name"] k["index"] = self._widget.client_tab_widget.count() main_widget = QWidget() ver_layout = QVBoxLayout(main_widget) ver_layout.setContentsMargins(9, 9, 9, 9) ver_layout.setSizeConstraint(ver_layout.SetDefaultConstraint) sub_widget = QWidget() sub_widget.setAccessibleName('sub_widget') ver_layout.addWidget(sub_widget) client_context_widget = QPlainTextEdit() client_context_widget.setObjectName(client_name + '_' + 'app_context_widget') client_context_widget.setAccessibleName('app_context_widget') client_context_widget.appendPlainText("client name is " + client_name) #ap><b>uuidp_context_widget.appendHtml(k["app_context"]) ver_layout.addWidget(client_context_widget) #add tab self._widget.client_tab_widget.addTab(main_widget, client_name) pass
def __init__(self, context): super(SpectrogramPlugin, self).__init__(context) self.setObjectName('Spectrogram') self._widget = QWidget() layout = QVBoxLayout() self._widget.setLayout(layout) layout_ = QHBoxLayout() self.line_edit = QLineEdit() layout_.addWidget(self.line_edit) self.apply_btn = QPushButton("Apply") self.apply_btn.clicked.connect(self.apply_clicked) layout_.addWidget(self.apply_btn) layout.addLayout(layout_) self.fig = Figure((5, 4), dpi=100) self.canvas = FigureCanvas(self.fig) self.axes = self.fig.add_subplot(111) self.fig.tight_layout() layout.addWidget(self.canvas) context.add_widget(self._widget) self.update_signal.connect(self.update_spectrogram) self.subscriber_signal.connect(self.update_subscriber) self.subscriber_signal.emit('spec')
def __init__(self, context): super(GhostRobotControlPlugin, self).__init__(context) self.setObjectName('GhostRobotControlPlugin') self.joint_states_to_ghost_pub = rospy.Publisher('/joint_states_to_ghost', JointState, queue_size=10) self.ghost_joint_states_sub = rospy.Subscriber('/ghost/joint_states', JointState, self.ghost_joint_states_cb) self.real_joint_states_sub = rospy.Subscriber('/atlas/joint_states', JointState, self.real_joint_states_cb) self.ghost_joint_states = JointState() self.real_joint_states = JointState() self.move_real_robot = False self.widget = QWidget() vbox = QVBoxLayout() self.real_to_ghost_push_button = QPushButton('Set Ghost from real robot') self.real_to_ghost_push_button.clicked.connect(self.handle_set_real_to_ghost) vbox.addWidget(self.real_to_ghost_push_button) self.send_motion_plan_to_real_robot_check_box = QCheckBox('Motion GUI moves real robot') self.send_motion_plan_to_real_robot_check_box.stateChanged.connect(self.handle_send_motion_plan_to_real_robot_check_box) vbox.addWidget(self.send_motion_plan_to_real_robot_check_box) self.widget.setLayout(vbox) context.add_widget(self.widget)
def add_widget(self, widget): if widget in self._embed_widgets: qWarning( 'PluginHandlerXEmbedClient.add_widget() widget "%s" already added' % widget.objectName()) return embed_widget = QX11EmbedWidget() layout = QVBoxLayout() layout.setContentsMargins(0, 0, 0, 0) layout.addWidget(widget) embed_widget.setLayout(layout) # close embed widget when container is closed # TODO necessary? #embed_widget.containerClosed.connect(embed_widget.close) embed_container_window_id = self._remote_container.embed_widget( os.getpid(), widget.objectName()) embed_widget.embedInto(embed_container_window_id) signaler = WindowChangedSignaler(widget, widget) signaler.window_icon_changed_signal.connect( self._on_embed_widget_icon_changed) signaler.window_title_changed_signal.connect( self._on_embed_widget_title_changed) self._embed_widgets[widget] = embed_widget, signaler # trigger to update initial window icon and title signaler.window_icon_changed_signal.emit(widget) signaler.window_title_changed_signal.emit(widget) embed_widget.show()
def __init__(self, context): super(RescueControlDialog, self).__init__(context) self.setObjectName('RescueControlDialog') self.joint_states_pub={} self._widget = QWidget() vbox = QVBoxLayout() #Add a Pushbutton for resetting the system state resetPushButton = QPushButton("Reset State") resetPushButton.pressed.connect(self.handleReset) self._syscommand_pub = rospy.Publisher('syscommand', String) vbox.addWidget(resetPushButton) #Add a Pushbutton for adding a victim in front of the robot and projecting it against the wall addVictimInFrontOfRobotPushButton = QPushButton("Add victim in front of robot") addVictimInFrontOfRobotPushButton.pressed.connect(self.on_add_victim_in_front_of_robot_pressed) vbox.addWidget(addVictimInFrontOfRobotPushButton) #add stretch at end so all GUI elements are at top of dialog vbox.addStretch(1) self._widget.setLayout(vbox) context.add_widget(self._widget)
def add_toolbar(self, toolbar): if toolbar in self._embed_widgets: qWarning( 'PluginHandlerXEmbedClient.add_toolbar() toolbar "%s" already added' % toolbar.objectName()) return embed_widget = QX11EmbedWidget() layout = QVBoxLayout() layout.setContentsMargins(0, 0, 0, 0) layout.addWidget(toolbar) embed_widget.setLayout(layout) # close embed widget when container is closed # TODO necessary? #embed_widget.containerClosed.connect(embed_widget.close) def foo(): print('embed_widget.containerClosed') embed_widget.containerClosed.connect(foo) embed_container_window_id = self._remote_container.embed_toolbar( os.getpid(), toolbar.objectName()) embed_widget.embedInto(embed_container_window_id) self._embed_widgets[toolbar] = embed_widget, None embed_widget.show()
def __init__(self, parent=None, current_values=None): super(BlacklistDialog, self).__init__(parent) self.setWindowTitle("Blacklist") vbox = QVBoxLayout() self.setLayout(vbox) self._blacklist = Blacklist() if isinstance(current_values, list): for val in current_values: self._blacklist.append(val) vbox.addWidget(self._blacklist) controls_layout = QHBoxLayout() add_button = QPushButton(icon=QIcon.fromTheme('list-add')) rem_button = QPushButton(icon=QIcon.fromTheme('list-remove')) ok_button = QPushButton("Ok") cancel_button = QPushButton("Cancel") add_button.clicked.connect(self._add_item) rem_button.clicked.connect(self._remove_item) ok_button.clicked.connect(self.accept) cancel_button.clicked.connect(self.reject) controls_layout.addWidget(add_button) controls_layout.addWidget(rem_button) controls_layout.addStretch(0) controls_layout.addWidget(ok_button) controls_layout.addWidget(cancel_button) vbox.addLayout(controls_layout)
def __init__(self, parent = None, logger = Logger()): QWidgetWithLogger.__init__(self, parent, logger) # start widget vbox = QVBoxLayout() vbox.setMargin(0) vbox.setContentsMargins(0, 0, 0, 0) # parameter action server topic selection topic_widget = QTopicWidget(self, 'vigir_footstep_planning_msgs/GetParameterSetNamesAction', True) vbox.addWidget(topic_widget) # parameter set selection self.parameter_set_selection_widget = QParameterSetSelectionWidget(self, logger) self.parameter_set_selection_widget.param_cleared_signal.connect(self.param_cleared) self.parameter_set_selection_widget.param_changed_signal.connect(self.param_changed) topic_widget.topic_changed_signal.connect(self.topic_changed) topic_widget.topic_changed_signal.connect(self.parameter_set_selection_widget.set_topic_name) vbox.addWidget(self.parameter_set_selection_widget) # end widget self.setLayout(vbox) # init widget topic_widget.emit_topic_name()
def add_widget(self, widget): if widget in self._embed_widgets: qWarning('PluginHandlerXEmbedClient.add_widget() widget "%s" already added' % widget.objectName()) return embed_widget = QX11EmbedWidget() layout = QVBoxLayout() layout.setContentsMargins(0, 0, 0, 0) layout.addWidget(widget) embed_widget.setLayout(layout) # close embed widget when container is closed # TODO necessary? #embed_widget.containerClosed.connect(embed_widget.close) embed_container_window_id = self._remote_container.embed_widget(os.getpid(), widget.objectName()) embed_widget.embedInto(embed_container_window_id) signaler = WindowChangedSignaler(widget, widget) signaler.window_icon_changed_signal.connect(self._on_embed_widget_icon_changed) signaler.window_title_changed_signal.connect(self._on_embed_widget_title_changed) self._embed_widgets[widget] = embed_widget, signaler # trigger to update initial window icon and title signaler.window_icon_changed_signal.emit(widget) signaler.window_title_changed_signal.emit(widget) embed_widget.show()
def __init__(self, parent=None): super(MatPlot2D, self).__init__(parent) self._canvas = MatPlot2D.Canvas() self._toolbar = NavigationToolbar(self._canvas, self._canvas) vbox = QVBoxLayout() vbox.addWidget(self._toolbar) vbox.addWidget(self._canvas) self.setLayout(vbox)
def __init__(self): super(Tester, self).__init__(); vlayout = QVBoxLayout(); self.testButton = QPushButton("Exactly one row of buttons"); vlayout.addWidget(self.testButton); self.testButton.clicked.connect(self.exactlyOneRow); self.setLayout(vlayout); self.show();
def __init__(self, content_widget, parent=None): QDialog.__init__(self, parent) self.tab_widget = DetachableTabWidget(self) layout = QVBoxLayout(self) layout.setContentsMargins(3, 3, 3, 3) layout.addWidget(self.tab_widget) self.setWindowFlags(Qt.Window) tab_index = self.tab_widget.addTab(content_widget, content_widget.name()) self.tab_widget.setCurrentIndex(tab_index) self.tab_widget.empty_tabbar_signal.connect(self._close_if_empty)
def __init__(self, parent=None): super(PlotWidget, self).__init__(parent) # create widgets self.canvas = PlotCanvas() self.toolbar = NavigationToolbar(self.canvas, self.canvas) self.toolbar.setSizePolicy(QSizePolicy.Preferred, QSizePolicy.Preferred) vbox = QVBoxLayout() vbox.addWidget(self.toolbar) vbox.addWidget(self.canvas) self.setLayout(vbox)
def __init__(self, parent=None): super(PyQtGraphDataPlot, self).__init__(parent) self._plot_widget = PlotWidget() self._plot_widget.setBackground((255, 255, 255)) self._plot_widget.setXRange(0, 10, padding=0) vbox = QVBoxLayout() vbox.addWidget(self._plot_widget) self.setLayout(vbox) self._color_index = 0 self._curves = {}
def __init__(self, parent=None): super(MatDataPlot, self).__init__(parent) self._canvas = MatDataPlot.Canvas() self._toolbar = NavigationToolbar(self._canvas, self._canvas) vbox = QVBoxLayout() vbox.addWidget(self._toolbar) vbox.addWidget(self._canvas) self.setLayout(vbox) self._color_index = 0 self._curves = {}
def __init__(self, parent = None, logger = Logger(), step_plan_topic = str()): QWidgetWithLogger.__init__(self, parent, logger) # start widget vbox = QVBoxLayout() vbox.setMargin(0) vbox.setContentsMargins(0, 0, 0, 0) # step plan input topic selection if len(step_plan_topic) == 0: step_plan_topic_widget = QTopicWidget(topic_type = 'vigir_footstep_planning_msgs/StepPlan') step_plan_topic_widget.topic_changed_signal.connect(self._init_step_plan_subscriber) vbox.addWidget(step_plan_topic_widget) else: self._init_step_plan_subscriber(step_plan_topic) # execute action server topic selection execute_topic_widget = QTopicWidget(topic_type = 'vigir_footstep_planning_msgs/ExecuteStepPlanAction', is_action_topic = True) execute_topic_widget.topic_changed_signal.connect(self._init_execute_action_client) vbox.addWidget(execute_topic_widget) # start button part buttons_hbox = QHBoxLayout() buttons_hbox.setMargin(0) # execute self.execute_command = QPushButton("Execute (Steps: 0)") self.execute_command.clicked.connect(self.execute_command_callback) self.execute_command.setEnabled(False) buttons_hbox.addWidget(self.execute_command) # repeat self.repeat_command = QPushButton("Repeat") self.repeat_command.clicked.connect(self.execute_command_callback) self.repeat_command.setEnabled(False) buttons_hbox.addWidget(self.repeat_command) # stop self.stop_command = QPushButton("Stop") self.stop_command.clicked.connect(self.stop_command_callback) self.stop_command.setEnabled(False) buttons_hbox.addWidget(self.stop_command) # end button part vbox.addLayout(buttons_hbox) # end widget self.setLayout(vbox) # init widget if len(step_plan_topic) == 0: step_plan_topic_widget.emit_topic_name() execute_topic_widget.emit_topic_name()
def __init__(self, parent=None): super(MatDataPlot, self).__init__(parent) self._canvas = MatDataPlot.Canvas() self._toolbar = NavigationToolbar(self._canvas, self._canvas) vbox = QVBoxLayout() vbox.addWidget(self._toolbar) vbox.addWidget(self._canvas) self.setLayout(vbox) self._curves = {} self._current_vline = None self._canvas.mpl_connect('button_release_event', self._limits_changed)
class NavViewWidget(QWidget): def __init__(self, map_topic = '/map', paths = ['/move_base/SBPLLatticePlanner/plan', '/move_base/TrajectoryPlannerROS/local_plan'], polygons= ['/move_base/local_costmap/robot_footprint']): super(NavViewWidget, self).__init__() self._layout = QVBoxLayout() self.setWindowTitle('Navigation Viewer') self._nav_view = NavView(map_topic, paths, polygons) self._layout.addWidget(self._nav_view) self.setLayout(self._layout)
class PingGUI(Plugin): def __init__(self, context): super(PingGUI, self).__init__(context) # Give QObjects reasonable names self.setObjectName('PingGUI') self.msg = None # Create a container widget and give it a layout self._container = QWidget() self._layout = QVBoxLayout() self._container.setLayout(self._layout) self._label = QLabel("xx ms latency") p = self._label.palette() p.setColor(self._label.backgroundRole(), Qt.red) self._label.setPalette(p) self._layout.addWidget(self._label) self.set_bg_color(100, 100, 100) rospy.Subscriber("/ping/delay", Float64, self.ping_cb) context.add_widget(self._container) self._update_plot_timer = QTimer(self) self._update_plot_timer.timeout.connect(self.update_gui) self._update_plot_timer.start(1) def update_gui(self): if not self.msg: return msg = self.msg # msec # 100 -> green, 1000 -> red # normalize within 1000 ~ 100 orig_latency = msg.data msg_data = orig_latency if msg.data > 1000: msg_data = 1000 elif msg.data < 100: msg_data = 100 ratio = (msg_data - 100) / (1000 - 100) color_r = ratio * 255.0 color_g = (1 - ratio) * 255.0 # devnull = open(os.devnull, "w") # with RedirectStdStreams(stdout=devnull, stderr=devnull): self.set_bg_color(color_r, color_g, 0) self._label.setText("%d ms latency" % (orig_latency)) def set_bg_color(self, r, g, b): self._label.setStyleSheet("QLabel { display: block; background-color: rgba(%d, %d, %d, 255); text-align: center; font-size: 30px;}" % (r, g, b)) def ping_cb(self, msg): self.msg = msg def shutdown_plugin(self): pass def save_settings(self, plugin_settings, instance_settings): pass def restore_settings(self, plugin_settings, instance_settings): pass
def __init__(self, parent=None): super(PyQtGraphDataPlot, self).__init__(parent) self._plot_widget = PlotWidget() self._plot_widget.getPlotItem().addLegend() self._plot_widget.setBackground((255, 255, 255)) self._plot_widget.setXRange(0, 10, padding=0) vbox = QVBoxLayout() vbox.addWidget(self._plot_widget) self.setLayout(vbox) self._plot_widget.getPlotItem().sigRangeChanged.connect(self.limits_changed) self._curves = {} self._current_vline = None
def setup_group_frame(self, group): layout = QVBoxLayout() # grid for buttons for named targets grid = QGridLayout() grid.setSpacing(1) self.button_group = QButtonGroup(self) row = 0 column = 0 named_targets = self.get_named_targets(group) for target in named_targets: button = QPushButton(target) self.button_group.addButton(button) grid.addWidget(button, row, column) column += 1 if column >= self.MAX_COLUMNS: row += 1 column = 0 self.button_group.buttonClicked.connect(self._handle_button_clicked) # grid for show joint value and move arm buttons/text field joint_values_grid = QGridLayout() joint_values_grid.setSpacing(1) button_show_joint_values = QPushButton('Current Joint Values') button_show_joint_values.clicked[bool].connect( self._handle_show_joint_values_clicked) line_edit = QLineEdit() self.text_joint_values.append(line_edit) button_move_to = QPushButton('Move to') button_move_to.clicked[bool].connect(self._handle_move_to_clicked) joint_values_grid.addWidget(button_show_joint_values, 0, 1) joint_values_grid.addWidget(line_edit, 0, 2) joint_values_grid.addWidget(button_move_to, 0, 3) layout.addLayout(grid) line = QFrame() line.setFrameShape(QFrame.HLine) line.setFrameShadow(QFrame.Sunken) layout.addWidget(line) layout.addLayout(joint_values_grid) frame = QFrame() frame.setLayout(layout) return frame
def __init__(self, ): super(LocalNavGUI, self).__init__() self.setObjectName("LocalNavGUI") self._widget = QWidget() ui_file = os.path.join(os.path.dirname(os.path.realpath(__file__)), 'localnav_gui.ui') loadUi(ui_file, self._widget) l = QVBoxLayout(self) l.addWidget(self._widget) # set ROS subscriber #rospy.Subscriber("/SLAM/current_pose", Pose2D, self.currentPoseCallback) rospy.Subscriber("/localnav/sensor_data", PointCloud, self.sensorDataCallback) rospy.Subscriber("/localnav/objects", Object, self.objectCallback) # set UI stuff self._widget.map.setScene(QtGui.QGraphicsScene(self)) self.viewRect = self._widget.map.rect() self.mapHeight = self.viewRect.height() self.mapWidth = self.viewRect.width() self._widget.map.setSceneRect(QtCore.QRectF(self.viewRect)) self.scene = self._widget.map.scene() # link buttons to functions self._widget.buttonClear.clicked.connect(self.buttonClear) self._widget.checkGrid.stateChanged.connect(self.filterGrid) self._widget.checkAxis.stateChanged.connect(self.filterAxis) self._widget.checkRobot.stateChanged.connect(self.filterRobot) self._widget.checkOrientation.stateChanged.connect( self.filterOrientation) self._widget.checkPath.stateChanged.connect(self.filterPath) self._widget.checkSensorData.stateChanged.connect( self.filterSensorData) self._widget.checkObjects.stateChanged.connect(self.filterObjects) self._widget.checkObstacles.stateChanged.connect(self.filterObstacles) # subscribe to signals self.sigRedraw.connect(self.sigRedrawHandler) # launch thread that redraws the map at a set rate t_redraw = threading.Thread(target=self.threadRedraw) t_redraw.daemon = True t_redraw.start()
def __init__(self, parent=None, buffer_length=100, use_poly=True, no_legend=False): super(MatDataPlot3D, self).__init__(parent) self._canvas = MatDataPlot3D.Canvas() self._use_poly = use_poly self._buffer_length = buffer_length self._toolbar = NavigationToolbar(self._canvas, self._canvas) vbox = QVBoxLayout() vbox.addWidget(self._toolbar) vbox.addWidget(self._canvas) self.setLayout(vbox) self._curves_verts = {} self._color_index = 0 self._curves = {} self._no_legend = no_legend self._autoscroll = False
def __init__(self,): super(LocalNavGUI, self).__init__() self.setObjectName("LocalNavGUI") self._widget = QWidget() ui_file = os.path.join(os.path.dirname(os.path.realpath(__file__)), 'localnav_gui.ui') loadUi(ui_file, self._widget) l = QVBoxLayout(self) l.addWidget(self._widget) # set ROS subscriber #rospy.Subscriber("/SLAM/current_pose", Pose2D, self.currentPoseCallback) rospy.Subscriber("/localnav/sensor_data", PointCloud, self.sensorDataCallback) rospy.Subscriber("/localnav/objects", Object, self.objectCallback) # set UI stuff self._widget.map.setScene(QtGui.QGraphicsScene(self)) self.viewRect = self._widget.map.rect() self.mapHeight = self.viewRect.height() self.mapWidth = self.viewRect.width() self._widget.map.setSceneRect(QtCore.QRectF(self.viewRect)) self.scene = self._widget.map.scene() # link buttons to functions self._widget.buttonClear.clicked.connect(self.buttonClear) self._widget.checkGrid.stateChanged.connect(self.filterGrid) self._widget.checkAxis.stateChanged.connect(self.filterAxis) self._widget.checkRobot.stateChanged.connect(self.filterRobot) self._widget.checkOrientation.stateChanged.connect(self.filterOrientation) self._widget.checkPath.stateChanged.connect(self.filterPath) self._widget.checkSensorData.stateChanged.connect(self.filterSensorData) self._widget.checkObjects.stateChanged.connect(self.filterObjects) self._widget.checkObstacles.stateChanged.connect(self.filterObstacles) # subscribe to signals self.sigRedraw.connect(self.sigRedrawHandler) # launch thread that redraws the map at a set rate t_redraw = threading.Thread(target=self.threadRedraw) t_redraw.daemon = True t_redraw.start()
def __init__(self, context): super(BiasCalibrationDialog, self).__init__(context) self.setObjectName('BiasCalibrationDialog') self._widget = QWidget() vbox = QVBoxLayout() controller_widget = QWidget() hbox = QHBoxLayout() # Left to right layout self.joint_control = JointBias(self, roslib.packages.get_pkg_dir('vigir_rqt_bias_calibration') + '/launch/joints.txt',hbox) controller_widget.setLayout(hbox) self.marker = Marker() self.marker.header.frame_id = "/world" self.marker.type = self.marker.CUBE self.marker.action = self.marker.ADD self.marker.scale.x = 14.0 self.marker.scale.y = 14.0 self.marker.scale.z = 0.02 self.marker.color.a = 0.25 self.marker.color.r = 1.0 self.marker.color.g = 1.0 self.marker.color.b = 0.0 #self.marker.points = [[0.0, 0.0, 0.0], [7.0, -4.0, 0.0], [7.0, 4.0, 0.0]] self.marker.pose.orientation.w = 1.0 self.marker.pose.position.x = 0.0 self.marker.pose.position.y = 0.0 self.marker.pose.position.z = 0.0 self.bias_pub = rospy.Publisher('/flor/controller/atlas_biases', JointState, queue_size=10) self.flor_marker_pub = rospy.Publisher('/flor_plane_marker', Marker, queue_size=10) self.feet_state_sub = rospy.Subscriber('/atlas/atlas_sim_interface_state', AtlasSimInterfaceState, self.stateCallbackFnc) vbox.addWidget(controller_widget) self.save_button = QPushButton("Save Biases") self.save_button.pressed.connect(self.on_savePressed) vbox.addWidget(self.save_button) self._widget.setLayout(vbox) context.add_widget(self._widget)
def __init__(self, masteruri, cfg, ns, nodes, parent=None): QFrame.__init__(self, parent) self._masteruri = masteruri self._nodes = {cfg: {ns: nodes}} frame_layout = QVBoxLayout(self) frame_layout.setContentsMargins(0, 0, 0, 0) # create frame for warning label self.warning_frame = warning_frame = QFrame(self) warning_layout = QHBoxLayout(warning_frame) warning_layout.setContentsMargins(0, 0, 0, 0) warning_layout.addItem( QSpacerItem(0, 0, QSizePolicy.Expanding, QSizePolicy.Expanding)) self.warning_label = QLabel() icon = nm.settings().icon('crystal_clear_warning.png') self.warning_label.setPixmap(icon.pixmap(QSize(40, 40))) self.warning_label.setToolTip( 'Multiple configuration for same node found!\nA first one will be selected for the start a node!' ) warning_layout.addWidget(self.warning_label) warning_layout.addItem( QSpacerItem(0, 0, QSizePolicy.Expanding, QSizePolicy.Expanding)) frame_layout.addItem( QSpacerItem(0, 0, QSizePolicy.Expanding, QSizePolicy.Expanding)) frame_layout.addWidget(warning_frame) # create frame for start/stop buttons buttons_frame = QFrame() buttons_layout = QHBoxLayout(buttons_frame) buttons_layout.setContentsMargins(0, 0, 0, 0) buttons_layout.addItem(QSpacerItem(20, 20)) self.on_button = QPushButton() self.on_button.setFlat(False) self.on_button.setText("On") self.on_button.clicked.connect(self.on_on_clicked) buttons_layout.addWidget(self.on_button) self.off_button = QPushButton() self.off_button.setFlat(True) self.off_button.setText("Off") self.off_button.clicked.connect(self.on_off_clicked) buttons_layout.addWidget(self.off_button) buttons_layout.addItem(QSpacerItem(20, 20)) frame_layout.addWidget(buttons_frame) frame_layout.addItem( QSpacerItem(0, 0, QSizePolicy.Expanding, QSizePolicy.Expanding)) self.warning_frame.setVisible(False)
def __init__(self, context): super(StableStepDialog, self).__init__(context) self.setObjectName('StableStepDialog') self.bdi_state_msg = AtlasSimInterfaceState() self.footstep_plan = rospy.Publisher('/flor/controller/footstep_plan',AtlasFootstepPlan, None, False, True, None, queue_size=10) self.bdi_state_sub = rospy.Subscriber("/atlas/atlas_sim_interface_state", AtlasSimInterfaceState, self.simStateCallback) self._widget = QWidget() vbox = QVBoxLayout() apply_command = QPushButton("Re-Center Steps") apply_command.clicked.connect(self.apply_command_callback) vbox.addWidget(apply_command) vbox.addStretch(1) self._widget.setLayout(vbox) context.add_widget(self._widget)
class CameraViewWidget(QWidget): def __init__(self, camera_topic='/image_raw', name='camera'): super(CameraViewWidget,self).__init__() self._layout = QVBoxLayout() self.name = name self._colors = [(238, 34, 116), (68, 134, 252), (236, 228, 46), (102, 224, 18), (242, 156, 6), (240, 64, 10), (196, 30, 250)] self.setWindowTitle('Camera \''+name+'\' Viewer') self._cam_view = CameraView(camera_topic) self._layout.addWidget(self._cam_view) self.setLayout(self._layout) def close(self): if self._cam_view: self._cam_view.close()
def __init__(self, parent=None, logger=Logger()): QWidgetWithLogger.__init__(self, parent, logger) # start widget vbox = QVBoxLayout() vbox.setMargin(0) vbox.setContentsMargins(0, 0, 0, 0) # add layout which is dynamically filled self.parameter_tree_widget = QParameterTreeWidget(logger=self.logger) vbox.addWidget(self.parameter_tree_widget) # button panel vbox_commands = QVBoxLayout() hbox = QHBoxLayout() # upload topic send_parameter_topic_widget = QTopicWidget(self, 'vigir_footstep_planning_msgs/SetParameterSetAction', True) send_parameter_topic_widget.topic_changed_signal.connect(self._init_upload_paramater_set_client) hbox.addWidget(send_parameter_topic_widget) # upload command self.upload_command = QPushButton("Upload") self.upload_command.clicked.connect(self.upload_parameters) hbox.addWidget(self.upload_command) vbox_commands.addLayout(hbox) # reload command self.reload_command = QPushButton("Reload") self.reload_command.clicked.connect(self.reload_parameters) vbox_commands.addWidget(self.reload_command) # add button panel vbox.addLayout(vbox_commands) # end widget self.setLayout(vbox) # init self.clear() send_parameter_topic_widget.emit_topic_name()
class CameraViewWidget(QWidget): def __init__(self, camera_topic='/image_raw', name='camera'): super(CameraViewWidget, self).__init__() self._layout = QVBoxLayout() self.name = name self._colors = [(238, 34, 116), (68, 134, 252), (236, 228, 46), (102, 224, 18), (242, 156, 6), (240, 64, 10), (196, 30, 250)] self.setWindowTitle('Camera \'' + name + '\' Viewer') self._cam_view = CameraView(camera_topic) self._layout.addWidget(self._cam_view) self.setLayout(self._layout) def close(self): if self._cam_view: self._cam_view.close()
def __init__(self, topic): super(RobotMonitor, self).__init__() self.setObjectName('Robot Monitor') self.top_items = [] layout = QVBoxLayout() self.err = QTreeWidget() self.err.setHeaderLabel("Errors") self.warn = QTreeWidget() self.warn.setHeaderLabel("Warnings") self.sig_clear.connect(self.clear) self.sig_err.connect(self.disp_err) self.sig_warn.connect(self.disp_warn) self.comp = QTreeWidget() self.comp.setHeaderLabel("All") self.comp.itemDoubleClicked.connect(self.tree_clicked) self.time = TimelineWidget(self) layout.addWidget(self.err) layout.addWidget(self.warn) layout.addWidget(self.comp, 1) layout.addWidget(self.time, 0) self.setLayout(layout) self.paused = False self.topic = topic self.sub = rospy.Subscriber(self.topic, DiagnosticArray, self.cb) self.setWindowTitle('Robot Monitor')
def __init__(self, context): super(MotionEditorPlugin, self).__init__(context) self.setObjectName('MotionEditorPlugin') config_loader = RobotConfigLoader() try: robot_config_name = rospy.get_param('/motion_editor/robot_config') except KeyError: rospy.logwarn('Could not find robot config param in /motion_editor/robot_config. Using default config for ' 'Thor Mang.') robot_config_name = 'thor' config_loader.load_xml_by_name(robot_config_name + '_config.xml') motion_publishers = {} for target in config_loader.targets: motion_publishers[target.name] = MotionPublisher(config_loader.robot_config, target.joint_state_topic, target.publisher_prefix) input_output_selector = InputOutputSelectorWidget(motion_publishers) self._motion_editor = MotionEditorWidget(input_output_selector, config_loader.robot_config) position_editor = PositionEditorWidget(input_output_selector, config_loader.robot_config) position_editor.position_list_updated.connect(self._motion_editor.update_positions_lists) position_editor.position_list_updated.emit(position_editor._position_data) self._motion_editor.position_renamed.connect(position_editor.on_position_renamed) layout = QVBoxLayout() layout.addWidget(input_output_selector) layout.addWidget(position_editor) layout.addWidget(self._motion_editor) self._widget = QWidget() self._widget.setLayout(layout) context.add_widget(self._widget)
def _update_client_tab(self): print('[conductor graph]: _update_client_tab') self.pre_selected_client_name = self.cur_selected_client_name self._widget.tabWidget.clear() for k in self._graph.concert_clients.values(): # Only pull in information from connected or connectable clients if k.state not in [ concert_msgs.ConcertClientState.AVAILABLE, concert_msgs.ConcertClientState.MISSING, concert_msgs.ConcertClientState.UNINVITED ]: continue main_widget = QWidget() ver_layout = QVBoxLayout(main_widget) ver_layout.setContentsMargins(9, 9, 9, 9) ver_layout.setSizeConstraint(ver_layout.SetDefaultConstraint) #button layout sub_widget = QWidget() sub_widget.setAccessibleName('sub_widget') ver_layout.addWidget(sub_widget) #client information layout context_label = QLabel() context_label.setText("Client information") ver_layout.addWidget(context_label) app_context_widget = QPlainTextEdit() app_context_widget.setObjectName(k.concert_alias + '_' + 'app_context_widget') app_context_widget.setAccessibleName('app_context_widget') app_context_widget.appendHtml(k.get_rapp_context()) app_context_widget.setReadOnly(True) cursor = app_context_widget.textCursor() cursor.movePosition(QTextCursor.Start, QTextCursor.MoveAnchor, 0) app_context_widget.setTextCursor(cursor) ver_layout.addWidget(app_context_widget) # new icon path = "" if k.is_new: # This only changes when the concert client changes topic publishes anew path = os.path.join(os.path.dirname(os.path.abspath(__file__)), "../../resources/images/new.gif") #add tab self._widget.tabWidget.addTab(main_widget, QIcon(path), k.concert_alias) #set previous selected tab for k in range(self._widget.tabWidget.count()): tab_text = self._widget.tabWidget.tabText(k) if tab_text == self.pre_selected_client_name: self._widget.tabWidget.setCurrentIndex(k)
def __init__(self, masteruri, cfg, ns, nodes, parent=None): QFrame.__init__(self, parent) self._masteruri = masteruri self._nodes = {cfg: {ns: nodes}} frame_layout = QVBoxLayout(self) frame_layout.setContentsMargins(0, 0, 0, 0) # create frame for warning label self.warning_frame = warning_frame = QFrame(self) warning_layout = QHBoxLayout(warning_frame) warning_layout.setContentsMargins(0, 0, 0, 0) warning_layout.addItem(QSpacerItem(0, 0, QSizePolicy.Expanding, QSizePolicy.Expanding)) self.warning_label = QLabel() icon = QIcon(':/icons/crystal_clear_warning.png') self.warning_label.setPixmap(icon.pixmap(QSize(40, 40))) self.warning_label.setToolTip('Multiple configuration for same node found!\nA first one will be selected for the start a node!') warning_layout.addWidget(self.warning_label) warning_layout.addItem(QSpacerItem(0, 0, QSizePolicy.Expanding, QSizePolicy.Expanding)) frame_layout.addItem(QSpacerItem(0, 0, QSizePolicy.Expanding, QSizePolicy.Expanding)) frame_layout.addWidget(warning_frame) # create frame for start/stop buttons buttons_frame = QFrame() buttons_layout = QHBoxLayout(buttons_frame) buttons_layout.setContentsMargins(0, 0, 0, 0) buttons_layout.addItem(QSpacerItem(20, 20)) self.on_button = QPushButton() self.on_button.setFlat(False) self.on_button.setText("On") self.on_button.clicked.connect(self.on_on_clicked) buttons_layout.addWidget(self.on_button) self.off_button = QPushButton() self.off_button.setFlat(True) self.off_button.setText("Off") self.off_button.clicked.connect(self.on_off_clicked) buttons_layout.addWidget(self.off_button) buttons_layout.addItem(QSpacerItem(20, 20)) frame_layout.addWidget(buttons_frame) frame_layout.addItem(QSpacerItem(0, 0, QSizePolicy.Expanding, QSizePolicy.Expanding)) self.warning_frame.setVisible(False)
def __init__(self, context): super(MoveitCommanderWidget, self).__init__() self.setObjectName('MoveitCommanderWidget') self.groups = self.get_groups() self.commanders = [ moveit_commander.MoveGroupCommander(group) for group in self.groups ] # list of QLineEdit fields used to display joint values self.text_joint_values = [] self.MAX_COLUMNS = 4 self.tab_widget = QTabWidget() for g in self.groups: frame = self.setup_group_frame(g) self.tab_widget.addTab(frame, g) widget_layout = QVBoxLayout() widget_layout.addWidget(self.tab_widget) self.setLayout(widget_layout)
def add_toolbar(self, toolbar): if toolbar in self._embed_widgets: qWarning('PluginHandlerXEmbedClient.add_toolbar() toolbar "%s" already added' % toolbar.objectName()) return embed_widget = QX11EmbedWidget() layout = QVBoxLayout() layout.setContentsMargins(0, 0, 0, 0) layout.addWidget(toolbar) embed_widget.setLayout(layout) # close embed widget when container is closed # TODO necessary? #embed_widget.containerClosed.connect(embed_widget.close) def foo(): print('embed_widget.containerClosed') embed_widget.containerClosed.connect(foo) embed_container_window_id = self._remote_container.embed_toolbar(os.getpid(), toolbar.objectName()) embed_widget.embedInto(embed_container_window_id) self._embed_widgets[toolbar] = embed_widget, None embed_widget.show()
def __init__(self, context): super(ParameterEditorWidget, self).__init__() # start widget widget = context vbox = QVBoxLayout() error_status_widget = QErrorStatusWidget() self.logger = Logger(error_status_widget) # parameter set selection self.parameter_set_widget = QParameterSetWidget(logger=self.logger) add_widget_with_frame(vbox, self.parameter_set_widget, "Parameter Set:") # start horizontal splitter vsplitter = QSplitter() vsplitter.setOrientation(Qt.Vertical) vsplitter.setChildrenCollapsible(False) # parameter set editor parameter_editor_widget = QParameterEditorWidget(logger=self.logger) add_widget_with_frame(vsplitter, parameter_editor_widget, "Editor:") # add error status widget add_widget_with_frame(vsplitter, error_status_widget, "Status:") # end horizontal splitter vbox.addWidget(vsplitter) # end widget widget.setLayout(vbox) #context.add_widget(widget) # init parameter editor self.parameter_set_widget.topic_changed_signal.connect(parameter_editor_widget.set_get_parameter_set_topic_name) self.parameter_set_widget.param_changed_signal.connect(parameter_editor_widget.load_parameters) self.parameter_set_widget.param_cleared_signal.connect(parameter_editor_widget.clear)
class DataDialog(QWidget): TOPIC_NAME = 'chatter' MSG_CLASS = Float32 def __init__(self): super(DataDialog, self).__init__() rp = rospkg.RosPack() uiFile = os.path.join(rp.get_path('my_topic_viewer'), 'resource', 'TopicViewer.ui') loadUi(uiFile, self) self._displayedData = None self._displayedName = None self._groupBox = QGroupBox() self._layout = QFormLayout() self._mainLayout = QVBoxLayout(); self._mainLayout.addWidget(self._groupBox) # self.setLayout(self._mainLayout); def setDisplayedData(self, data, name): if isinstance(data, dict): self.displayData(data) else: dictData = {} if name is None: dictData['unknown'] = data elif isinstance(data, list): dictData = dict(zip(name, data)) else: dictData[name] = data self.displayData(dictData) def displayData(self, dictData): for key in dictData.keys(): self._layout.addRow(QLabel(key+': '), QLineEdit(str(dictData[key])))
def __init__(self, main, fileName, main_hbox): self.main = main self.chain = [] self.poses = [] self.chain_name = "" frame = QFrame() frame.setFrameShape(QFrame.StyledPanel); frame.setFrameShadow(QFrame.Raised); vbox = QVBoxLayout() label = QLabel() vbox.addWidget(label); self.load_file(fileName, vbox) self.trajectoryPublisher = rospy.Publisher('/trajectory_controllers/'+self.chain_name+'_traj_controller/trajectory' ,JointTrajectory, queue_size=10) self.positionPublisher = rospy.Publisher('/trajectory_controllers/'+self.chain_name+'_traj_controller/joint_states',JointState, queue_size=10) self.ghostPublisher = rospy.Publisher('/flor/ghost/set_joint_states',JointState, queue_size=10) label.setText(self.chain_name) vbox.addStretch(1) frame.setLayout(vbox) main_hbox.addWidget(frame)
def __init__(self, caller, jointstate, parent=None, stored_topic=None): super(JointStateGroup, self).__init__(parent) ti = TopicInfo() # create a new group ui_file = os.path.join(os.path.dirname(os.path.realpath(__file__)), 'iop_rqt_velocity_joint_group.ui') loadUi(ui_file, self) group_layout = QVBoxLayout(self.frame) group_layout.setContentsMargins(0, 0, 0, 0) group_layout.setSpacing(0) self._cmd_type = Float64MultiArray if len(jointstate.name) == 1: self._cmd_type = Float64 ti.fill_subscribed_topics(self.comboBox_cmdTopic, self._cmd_type._type, stored_topic) for joint_name in jointstate.name: joint_frame = QFrame() ui_file = os.path.join(os.path.dirname(os.path.realpath(__file__)), 'iop_rqt_velocity_joint.ui') loadUi(ui_file, joint_frame) joint_frame.setObjectName(joint_name) joint_frame.labelJointName.setText(joint_name) joint_frame.lineEditCurrentValue.setText('0.0') joint_frame.doubleSpinBoxNewValue.setValue(0.0) joint_frame.layout().setContentsMargins(0, 0, 0, 0) joint_frame.layout().setSpacing(0) group_layout.addWidget(joint_frame) # self._widget.layout().insertWidget(self._widget.layout().count() - 1, group_frame) # self._jointgroups[caller] = group_frame self.setObjectName(caller) self._caller = caller self._jointstate = jointstate self._topic_command = self.comboBox_cmdTopic.currentText() self.pushButtonSend.clicked.connect(self.on_clicked_send) self.pushButtonSendZero.clicked.connect(self.on_clicked_send_zero) self.comboBox_cmdTopic.activated.connect(self.on_activated_topic) self._cmd_publisher = None if self._cmd_type and self._topic_command: self._cmd_publisher = rospy.Publisher(self._topic_command, self._cmd_type, queue_size=1)
def __init__(self, parent=None): super(VisualizerWidget, self).__init__(parent) self.setWindowTitle('Graph Profiler Visualizer') vbox = QVBoxLayout() self.setLayout(vbox) toolbar_layout = QHBoxLayout() refresh_button = QPushButton() refresh_button.setIcon(QIcon.fromTheme('view-refresh')) auto_refresh_checkbox = QCheckBox("Auto Refresh") hide_disconnected_topics = QCheckBox("Hide Disconnected Topics") topic_blacklist_button = QPushButton("Topic Blacklist") node_blacklist_button = QPushButton("Node Blacklist") refresh_button.clicked.connect(self._refresh) topic_blacklist_button.clicked.connect(self._edit_topic_blacklist) node_blacklist_button.clicked.connect(self._edit_node_blacklist) auto_refresh_checkbox.setCheckState(2) auto_refresh_checkbox.stateChanged.connect(self._autorefresh_changed) hide_disconnected_topics.setCheckState(2) hide_disconnected_topics.stateChanged.connect(self._hidedisconnectedtopics_changed) toolbar_layout.addWidget(refresh_button) toolbar_layout.addWidget(auto_refresh_checkbox) toolbar_layout.addStretch(0) toolbar_layout.addWidget(hide_disconnected_topics) toolbar_layout.addWidget(topic_blacklist_button) toolbar_layout.addWidget(node_blacklist_button) vbox.addLayout(toolbar_layout) # Initialize the Visualizer self._view = qt_view.QtView() self._adapter = rosprofiler_adapter.ROSProfileAdapter(self._view) self._adapter.set_topic_quiet_list(TOPIC_BLACKLIST) self._adapter.set_node_quiet_list(NODE_BLACKLIST) vbox.addWidget(self._view)
def __init__(self, parent, fileName, top_widget_layout): self.controllers = [] self.parent = parent self.loadFile(fileName) print "Initialize controllers..." for controller in self.controllers: frame = QFrame() frame.setFrameShape(QFrame.StyledPanel); frame.setFrameShadow(QFrame.Raised); vbox = QVBoxLayout() label = QLabel() label.setText(controller.label) vbox.addWidget(label); print controller.name for joint in controller.joints: label = QLabel() label.setText(joint.name) vbox.addWidget(label); #Add input for setting the biases widget = QWidget() hbox = QHBoxLayout() hbox.addWidget(joint.sensor_bias_spinbox) hbox.addWidget(joint.control_bias_spinbox) hbox.addWidget(joint.gearing_bias_spinbox) widget.setLayout(hbox) vbox.addWidget(widget) label = QLabel() label.setText(" Sensor Control Gearing") vbox.addWidget(label); vbox.addStretch() frame.setLayout(vbox) top_widget_layout.addWidget(frame) print "Done loading controllers"
class NodeSelection(QWidget): def __init__(self, parent): super(NodeSelection, self).__init__() self.parent_widget = parent self.selected_nodes = [] self.setWindowTitle("Select the nodes you want to record") self.resize(500, 700) self.area = QScrollArea(self) self.main_widget = QWidget(self.area) self.ok_button = QPushButton("Done", self) self.ok_button.clicked.connect(self.onButtonClicked) self.ok_button.setEnabled(False) self.main_vlayout = QVBoxLayout(self) self.main_vlayout.addWidget(self.area) self.main_vlayout.addWidget(self.ok_button) self.setLayout(self.main_vlayout) self.selection_vlayout = QVBoxLayout(self) self.node_list = rosnode.get_node_names() self.node_list.sort() for node in self.node_list: self.addCheckBox(node) self.main_widget.setLayout(self.selection_vlayout) self.show() def addCheckBox(self, node): item = QCheckBox(node, self) item.stateChanged.connect(lambda x: self.updateNode(x, node)) self.selection_vlayout.addWidget(item) def updateNode(self, state, node): if state == Qt.Checked: self.selected_nodes.append(node) else: self.selected_nodes.remove(node) if len(self.selected_nodes) > 0: self.ok_button.setEnabled(True) else: self.ok_button.setEnabled(False) def onButtonClicked(self): master = rosgraph.Master('rqt_bag_recorder') state = master.getSystemState() subs = [ t for t, l in state[1] if len([ node_name for node_name in self.selected_nodes if node_name in l ]) > 0 ] for topic in subs: self.parent_widget.changeTopicCheckState(topic, Qt.Checked) self.parent_widget.updateList(Qt.Checked, topic) self.close()
class TriangleGUI(Plugin): def __init__(self, context): super(TriangleGUI, self).__init__(context) # Give QObjects reasonable names self.setObjectName('TriangleGUI') # Process standalone plugin command-line arguments from argparse import ArgumentParser parser = ArgumentParser() # Add argument(s) to the parser. parser.add_argument("-q", "--quiet", action="store_true", dest="quiet", help="Put plugin in silent mode") args, unknowns = parser.parse_known_args(context.argv()) self._toolbar = QToolBar() self._toolbar.addWidget(QLabel('Triangle')) # Create a container widget and give it a layout self._container = QWidget() self._layout = QVBoxLayout() self._container.setLayout(self._layout) self._layout.addWidget(self._toolbar) # Add a button for killing nodes self._go_button = QPushButton('Go') self._go_button.clicked.connect(self._go) self._layout.addWidget(self._go_button) self._clear_button = QPushButton('Clear') self._clear_button.clicked.connect(self._clear) self._layout.addWidget(self._clear_button) # self._step_run_button.setStyleSheet('QPushButton {color: black}') context.add_widget(self._container) def _go(self): go = rospy.ServiceProxy('/triangle_screenpoint/go', Empty) go() def _clear(self): clear = rospy.ServiceProxy('/triangle_screenpoint/cancel', Empty) clear() def shutdown_plugin(self): pass def save_settings(self, plugin_settings, instance_settings): pass def restore_settings(self, plugin_settings, instance_settings): pass
class EusGUI(Plugin): def __init__(self, context): super(EusGUI, self).__init__(context) # Give QObjects reasonable names self.setObjectName('EusGUI') self.msg = None # Create a container widget and give it a layout self._toolbar = QToolBar() self._toolbar.addWidget(QLabel('EusGUI')) self._container = QWidget() self._layout = QVBoxLayout() self._container.setLayout(self._layout) self._layout.addWidget(self._toolbar) self._prev_button = QPushButton('PREV') self._prev_button.clicked.connect(self._prev_cb) self._layout.addWidget(self._prev_button) self._refresh_button = QPushButton('DO IT AGAIN') self._refresh_button.clicked.connect(self._refresh_cb) self._layout.addWidget(self._refresh_button) self._next_button = QPushButton('NEXT') self._next_button.clicked.connect(self._next_cb) self._layout.addWidget(self._next_button) context.add_widget(self._container) def _prev_cb(self): func = rospy.ServiceProxy('prev', Empty) func() def _next_cb(self): func = rospy.ServiceProxy('next', Empty) func() def _refresh_cb(self): func = rospy.ServiceProxy('refresh', Empty) func() def shutdown_plugin(self): pass def save_settings(self, plugin_settings, instance_settings): pass def restore_settings(self, plugin_settings, instance_settings): pass
class Top(Plugin): NODE_FIELDS = [ 'pid', 'get_cpu_percent', 'get_memory_percent', 'get_num_threads'] OUT_FIELDS = ['node_name', 'pid', 'cpu_percent', 'memory_percent', 'num_threads' ] FORMAT_STRS = ['%s', '%s', '%0.2f', '%0.2f', '%s' ] NODE_LABELS = ['Node', 'PID', 'CPU %', 'Mem %', 'Num Threads' ] SORT_TYPE = [str, str, float, float, float ] TOOLTIPS = { 0: ('cmdline', lambda x: '\n'.join(textwrap.wrap(' '.join(x)))), 3: ('memory_info', lambda x: ('Resident: %0.2f MiB, Virtual: %0.2f MiB' % (x[0]/2**20, x[1]/2**20))) } _node_info = NodeInfo() name_filter = re.compile('') def __init__(self, context): super(Top, self).__init__(context) # Give QObjects reasonable names self.setObjectName('Top') # Process standalone plugin command-line arguments from argparse import ArgumentParser parser = ArgumentParser() # Add argument(s) to the parser. parser.add_argument("-q", "--quiet", action="store_true", dest="quiet", help="Put plugin in silent mode") args, unknowns = parser.parse_known_args(context.argv()) # if not args.quiet: # print 'arguments: ', args # print 'unknowns: ', unknowns self._selected_node = '' self._selected_node_lock = RLock() # Setup the toolbar self._toolbar = QToolBar() self._filter_box = QLineEdit() self._regex_box = QCheckBox() self._regex_box.setText('regex') self._toolbar.addWidget(QLabel('Filter')) self._toolbar.addWidget(self._filter_box) self._toolbar.addWidget(self._regex_box) self._filter_box.returnPressed.connect(self.update_filter) self._regex_box.stateChanged.connect(self.update_filter) # Create a container widget and give it a layout self._container = QWidget() self._container.setWindowTitle('Process Monitor') self._layout = QVBoxLayout() self._container.setLayout(self._layout) self._layout.addWidget(self._toolbar) # Create the table widget self._table_widget = QTreeWidget() self._table_widget.setObjectName('TopTable') self._table_widget.setColumnCount(len(self.NODE_LABELS)) self._table_widget.setHeaderLabels(self.NODE_LABELS) self._table_widget.itemClicked.connect(self._tableItemClicked) self._table_widget.setSortingEnabled(True) self._table_widget.setAlternatingRowColors(True) self._layout.addWidget(self._table_widget) context.add_widget(self._container) # Add a button for killing nodes self._kill_button = QPushButton('Kill Node') self._layout.addWidget(self._kill_button) self._kill_button.clicked.connect(self._kill_node) # Update twice since the first cpu% lookup will always return 0 self.update_table() self.update_table() self._table_widget.resizeColumnToContents(0) # Start a timer to trigger updates self._update_timer = QTimer() self._update_timer.setInterval(1000) self._update_timer.timeout.connect(self.update_table) self._update_timer.start() def _tableItemClicked(self, item, column): with self._selected_node_lock: self._selected_node = item.text(0) def update_filter(self, *args): if self._regex_box.isChecked(): expr = self._filter_box.text() else: expr = re.escape(self._filter_box.text()) self.name_filter = re.compile(expr) self.update_table() def _kill_node(self): self._node_info.kill_node(self._selected_node) def update_one_item(self, row, info): twi = TopWidgetItem() for col, field in enumerate(self.OUT_FIELDS): val = info[field] twi.setText(col, self.FORMAT_STRS[col] % val) self._table_widget.insertTopLevelItem(row, twi) for col, (key, func) in self.TOOLTIPS.iteritems(): twi.setToolTip(col, func(info[key])) with self._selected_node_lock: if twi.text(0) == self._selected_node: twi.setSelected(True) self._table_widget.setItemHidden(twi, len(self.name_filter.findall(info['node_name'])) == 0) def update_table(self): self._table_widget.clear() infos = self._node_info.get_all_node_fields(self.NODE_FIELDS) for nx, info in enumerate(infos): self.update_one_item(nx, info) def shutdown_plugin(self): self._update_timer.stop() def save_settings(self, plugin_settings, instance_settings): instance_settings.set_value('filter_text', self._filter_box.text()) instance_settings.set_value('is_regex', int(self._regex_box.checkState())) def restore_settings(self, plugin_settings, instance_settings): self._filter_box.setText(instance_settings.value('filter_text')) is_regex_int = instance_settings.value('is_regex') if is_regex_int: self._regex_box.setCheckState(Qt.CheckState(is_regex_int)) else: self._regex_box.setCheckState(Qt.CheckState(0)) self.update_filter()
class QuestionDialogPlugin(Plugin): def __init__(self, context): super(QuestionDialogPlugin, self).__init__(context) # Give QObjects reasonable names self.setObjectName('QuestionDialogPlugin') # Create QWidget self._widget = QWidget() self._widget.setFont(QFont("Times", 14, QFont.Bold)) self._layout = QVBoxLayout(self._widget) self._text_browser = QTextBrowser(self._widget) self._layout.addWidget(self._text_browser) self._button_layout = QHBoxLayout() self._layout.addLayout(self._button_layout) # layout = QVBoxLayout(self._widget) # layout.addWidget(self.button) self._widget.setObjectName('QuestionDialogPluginUI') if context.serial_number() > 1: self._widget.setWindowTitle(self._widget.windowTitle() + (' (%d)' % context.serial_number())) context.add_widget(self._widget) # Setup service provider self.service = rospy.Service('question_dialog', QuestionDialog, self.service_callback) self.response_ready = False self.response = None self.buttons = [] self.text_label = None self.text_input = None self.connect(self._widget, SIGNAL("update"), self.update) self.connect(self._widget, SIGNAL("timeout"), self.timeout) def shutdown_plugin(self): self.service.shutdown() def service_callback(self, req): self.response_ready = False self.request = req self._widget.emit(SIGNAL("update")) # Start timer against wall clock here instead of the ros clock. start_time = time.time() while not self.response_ready: if req.timeout != QuestionDialogRequest.NO_TIMEOUT: current_time = time.time() if current_time - start_time > req.timeout: self._widget.emit(SIGNAL("timeout")) return QuestionDialogResponse( QuestionDialogRequest.TIMED_OUT, "") time.sleep(0.2) return self.response def update(self): self.clean() req = self.request self._text_browser.setText(req.message) if req.type == QuestionDialogRequest.DISPLAY: # All done, nothing more too see here. self.response = QuestionDialogResponse( QuestionDialogRequest.NO_RESPONSE, "") self.response_ready = True elif req.type == QuestionDialogRequest.CHOICE_QUESTION: for index, options in enumerate(req.options): button = QPushButton(options, self._widget) button.clicked.connect(partial(self.handle_button, index)) self._button_layout.addWidget(button) self.buttons.append(button) elif req.type == QuestionDialogRequest.TEXT_QUESTION: self.text_label = QLabel("Enter here: ", self._widget) self._button_layout.addWidget(self.text_label) self.text_input = QLineEdit(self._widget) self.text_input.editingFinished.connect(self.handle_text) self._button_layout.addWidget(self.text_input) def timeout(self): self._text_browser.setText("Oh no! The request timed out.") self.clean() def clean(self): while self._button_layout.count(): item = self._button_layout.takeAt(0) item.widget().deleteLater() self.buttons = [] self.text_input = None self.text_label = None def handle_button(self, index): self.response = QuestionDialogResponse(index, "") self.clean() self.response_ready = True def handle_text(self): self.response = QuestionDialogResponse( QuestionDialogRequest.TEXT_RESPONSE, self.text_input.text()) self.clean() self.response_ready = True def save_settings(self, plugin_settings, instance_settings): # TODO save intrinsic configuration, usually using: # instance_settings.set_value(k, v) pass def restore_settings(self, plugin_settings, instance_settings): # TODO restore intrinsic configuration, usually using: # v = instance_settings.value(k) pass