def __init__(self):
super(MessageDataModel, self).__init__()
self._messages = MessageList()
self._message_limit = 20000
self._info_icon = QIcon.fromTheme('dialog-information')
self._warning_icon = QIcon.fromTheme('dialog-warning')
self._error_icon = QIcon.fromTheme('dialog-error')
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, url=None):
"""
Class to load a webpage in a widget.
:param url: If url is empty then a navigation bar is shown otherwise the url is loaded and the navigation bar is hidden, ''str''
"""
super(WebWidget, self).__init__()
rp = rospkg.RosPack()
ui_file = os.path.join(rp.get_path('rqt_web'), 'resource', 'web_widget.ui')
loadUi(ui_file, self)
self.setObjectName('WebWidget')
self._loading = False
self._stop_icon = QIcon.fromTheme('process-stop')
self._reload_icon = QIcon.fromTheme('view-refresh')
self._working_icon = QIcon.fromTheme('process-working')
self._completer_word_list = ['']
self._view = QWebView()
self.verticalLayout.addWidget(self._view)
if url is None:
self.set_url("http://ros.org", True)
else:
self.set_url(url, False)
self.url_lineedit.returnPressed.connect(self._handle_url_change)
self._view.loadFinished[bool].connect(self._handle_load_finished)
self.reload_button.clicked.connect(self._handle_reload_clicked)
self._view.linkClicked.connect(self._handle_link_clicked)
self._view.urlChanged[QUrl].connect(self._handle_url_changed)
def __init__(self, initial_topics=None, start_paused=False):
super(PlotWidget, self).__init__()
self.setObjectName('PlotWidget')
self._initial_topics = initial_topics
rp = rospkg.RosPack()
ui_file = os.path.join(rp.get_path('rqt_histogram'), 'resource',
'plot.ui')
loadUi(ui_file, self)
self.subscribe_topic_button.setIcon(QIcon.fromTheme('list-add'))
self.remove_topic_button.setIcon(QIcon.fromTheme('list-remove'))
self.pause_button.setIcon(QIcon.fromTheme('media-playback-pause'))
self.clear_button.setIcon(QIcon.fromTheme('edit-clear'))
self.data_plot = None
self.subscribe_topic_button.setEnabled(False)
if start_paused:
self.pause_button.setChecked(True)
self._topic_completer = TopicCompleter(self.topic_edit)
self._topic_completer.update_topics()
self.topic_edit.setCompleter(self._topic_completer)
self._start_time = rospy.get_time()
self._rosdata = {}
# init and start update timer for plot
self._update_plot_timer = QTimer(self)
self._update_plot_timer.timeout.connect(self.update_plot)
def __init__(self):
super(ServiceCallerWidget, self).__init__()
self.setObjectName('ServiceCallerWidget')
# create context for the expression eval statement
self._eval_locals = {}
for module in (math, random, time):
self._eval_locals.update(module.__dict__)
self._eval_locals['genpy'] = genpy
del self._eval_locals['__name__']
del self._eval_locals['__doc__']
rp = rospkg.RosPack()
ui_file = os.path.join(rp.get_path('rqt_service_caller'), 'resource', 'ServiceCaller.ui')
loadUi(ui_file, self, {'ExtendedComboBox': ExtendedComboBox})
self.refresh_services_button.setIcon(QIcon.fromTheme('view-refresh'))
self.call_service_button.setIcon(QIcon.fromTheme('call-start'))
self._column_index = {}
for column_name in self.column_names:
self._column_index[column_name] = len(self._column_index)
self._service_info = None
self.on_refresh_services_button_clicked()
self.request_tree_widget.itemChanged.connect(self.request_tree_widget_itemChanged)
def __init__(self, timeline, parent, topic):
MessageView.__init__(self, timeline, topic)
self._parent = parent
self._stamp = None
self._name = parent.objectName()
self.toolbar = QToolBar()
self._first_action = QAction(QIcon.fromTheme('go-first'), '',
self.toolbar)
self._first_action.triggered.connect(self.navigate_first)
self.toolbar.addAction(self._first_action)
self._prev_action = QAction(QIcon.fromTheme('go-previous'), '',
self.toolbar)
self._prev_action.triggered.connect(self.navigate_previous)
self.toolbar.addAction(self._prev_action)
self._next_action = QAction(QIcon.fromTheme('go-next'), '',
self.toolbar)
self._next_action.triggered.connect(self.navigate_next)
self.toolbar.addAction(self._next_action)
self._last_action = QAction(QIcon.fromTheme('go-last'), '',
self.toolbar)
self._last_action.triggered.connect(self.navigate_last)
self.toolbar.addAction(self._last_action)
parent.layout().addWidget(self.toolbar)
def __init__(self, reconf, node_name):
"""
:type reconf: dynamic_reconfigure.client
:type node_name: str
"""
group_desc = reconf.get_group_descriptions()
rospy.logdebug('DynreconfClientWidget.group_desc=%s', group_desc)
super(DynreconfClientWidget, self).__init__(ParamUpdater(reconf),
group_desc, node_name)
# Save and load buttons
self.button_widget = QWidget(self)
self.button_header = QHBoxLayout(self.button_widget)
self.button_header.setContentsMargins(QMargins(0, 0, 0, 0))
self.load_button = QPushButton()
self.save_button = QPushButton()
self.load_button.setIcon(QIcon.fromTheme('document-open'))
self.save_button.setIcon(QIcon.fromTheme('document-save'))
self.load_button.clicked[bool].connect(self._handle_load_clicked)
self.save_button.clicked[bool].connect(self._handle_save_clicked)
self.button_header.addWidget(self.save_button)
self.button_header.addWidget(self.load_button)
self.setMinimumWidth(150)
self.reconf = reconf
self.updater.start()
self.reconf.config_callback = self.config_callback
self._node_grn = node_name
def on_topics_tree_widget_customContextMenuRequested(self, pos):
item = self.topics_tree_widget.itemAt(pos)
if item is None:
return
# show context menu
menu = QMenu(self)
action_moggle_monitoring = menu.addAction(QIcon.fromTheme('search'),
'Toggle Monitoring')
action_item_expand = menu.addAction(QIcon.fromTheme('zoom-in'),
'Expand All Children')
action_item_collapse = menu.addAction(QIcon.fromTheme('zoom-out'),
'Collapse All Children')
action = menu.exec_(self.topics_tree_widget.mapToGlobal(pos))
# evaluate user action
if action is action_moggle_monitoring:
root_item = item
while root_item.parent() is not None:
root_item = root_item.parent()
root_topic_name = root_item.data(0, Qt.UserRole)
self._topics[root_topic_name]['info'].toggle_monitoring()
elif action in (action_item_expand, action_item_collapse):
expanded = (action is action_item_expand)
def recursive_set_expanded(item):
item.setExpanded(expanded)
for index in range(item.childCount()):
recursive_set_expanded(item.child(index))
recursive_set_expanded(item)
def __init__(self, node, initial_topics=None, start_paused=False):
super(PlotWidget, self).__init__()
self.setObjectName('PlotWidget')
self._node = node
self._initial_topics = initial_topics
_, package_path = get_resource('packages', 'rqt_plot')
ui_file = os.path.join(package_path, 'share', 'rqt_plot', 'resource',
'plot.ui')
loadUi(ui_file, self)
self.subscribe_topic_button.setIcon(QIcon.fromTheme('list-add'))
self.remove_topic_button.setIcon(QIcon.fromTheme('list-remove'))
self.pause_button.setIcon(QIcon.fromTheme('media-playback-pause'))
self.clear_button.setIcon(QIcon.fromTheme('edit-clear'))
self.data_plot = None
self.subscribe_topic_button.setEnabled(False)
if start_paused:
self.pause_button.setChecked(True)
self._topic_completer = TopicCompleter(self.topic_edit)
self._topic_completer.update_topics(node)
self.topic_edit.setCompleter(self._topic_completer)
self._start_time = time.time()
self._rosdata = {}
self._remove_topic_menu = QMenu()
# init and start update timer for plot
self._update_plot_timer = QTimer(self)
self._update_plot_timer.timeout.connect(self.update_plot)
def __init__(self):
super(MessageDataModel, self).__init__()
self._messages = MessageList()
self._message_limit = 20000
self._info_icon = QIcon.fromTheme('dialog-information')
self._warning_icon = QIcon.fromTheme('dialog-warning')
self._error_icon = QIcon.fromTheme('dialog-error')
def __init__(self):
super(MainWidget, self).__init__()
self.setObjectName('MainWidget')
rospack = rospkg.RosPack()
ui_file = rospack.get_path('rqt_joint_trajectory_plot')+'/resource/JointTrajectoryPlot.ui'
loadUi(ui_file, self)
self.refresh_button.setIcon(QIcon.fromTheme('reload'))
self.pause_button.setIcon(QIcon.fromTheme('media-playback-pause'))
self.handler = None
self.joint_names = []
self.timer = QTimer(self)
self.timer.timeout.connect(self.update)
self.plot_widget = PlotWidget(self)
self.plot_layout.addWidget(self.plot_widget)
self.draw_curves.connect(self.plot_widget.draw_curves)
self.time = None
(self.dis, self.vel, self.acc, self.eff) = ({}, {}, {}, {})
# refresh topics list in the combobox
self.refresh_topics()
self.change_topic()
self.refresh_button.clicked.connect(self.refresh_topics)
self.topic_combox.currentIndexChanged.connect(self.change_topic)
self.select_tree.itemChanged.connect(self.update_checkbox)
def set_menu(self, menu):
self._menu_manager = MenuManager(menu)
self._perspective_mapper = QSignalMapper(menu)
self._perspective_mapper.mapped[str].connect(self.switch_perspective)
# generate menu
create_action = QAction('&Create perspective...',
self._menu_manager.menu)
create_action.setIcon(QIcon.fromTheme('list-add'))
create_action.triggered.connect(self._on_create_perspective)
self._menu_manager.add_suffix(create_action)
self._remove_action = QAction('&Remove perspective...',
self._menu_manager.menu)
self._remove_action.setEnabled(False)
self._remove_action.setIcon(QIcon.fromTheme('list-remove'))
self._remove_action.triggered.connect(self._on_remove_perspective)
self._menu_manager.add_suffix(self._remove_action)
self._menu_manager.add_suffix(None)
import_action = QAction('&Import...', self._menu_manager.menu)
import_action.setIcon(QIcon.fromTheme('document-open'))
import_action.triggered.connect(self._on_import_perspective)
self._menu_manager.add_suffix(import_action)
export_action = QAction('&Export...', self._menu_manager.menu)
export_action.setIcon(QIcon.fromTheme('document-save-as'))
export_action.triggered.connect(self._on_export_perspective)
self._menu_manager.add_suffix(export_action)
# add perspectives to menu
for name in self.perspectives:
if not name.startswith(self.HIDDEN_PREFIX):
self._add_perspective_action(name)
def __init__(self, topics):
super(HistogramPlotWidget, self).__init__()
self.setObjectName('HistogramPlotWidget')
rp = rospkg.RosPack()
ui_file = os.path.join(rp.get_path('jsk_rqt_plugins'),
'resource', 'plot_histogram.ui')
loadUi(ui_file, self)
self.cv_bridge = CvBridge()
self.subscribe_topic_button.setIcon(QIcon.fromTheme('add'))
self.pause_button.setIcon(QIcon.fromTheme('media-playback-pause'))
self.clear_button.setIcon(QIcon.fromTheme('edit-clear'))
self.data_plot = MatHistogramPlot(self)
self.data_plot_layout.addWidget(self.data_plot)
self._topic_completer = TopicCompleter(self.topic_edit)
self._topic_completer.update_topics()
self.topic_edit.setCompleter(self._topic_completer)
self.data_plot.dropEvent = self.dropEvent
self.data_plot.dragEnterEvent = self.dragEnterEvent
self._start_time = rospy.get_time()
self._rosdata = None
if len(topics) != 0:
self.subscribe_topic(topics)
self._update_plot_timer = QTimer(self)
self._update_plot_timer.timeout.connect(self.update_plot)
self._update_plot_timer.start(self._redraw_interval)
def __init__(self, ros_package):
super(GraphWidget, self).__init__()
self._current_graph = None
self._lock = Lock()
self._load_ui(ros_package)
self._scene = QGraphicsScene()
self._scene.setBackgroundBrush(Qt.white)
factory = DmgItemFactory()
factory.set_color(QColor(50, 50, 50))
factory.set_highlighted_color(QColor(0, 150, 0))
self._dot_to_qt = DotToQtGenerator(factory)
self.initialized = False
self.setObjectName('GraphWidget')
self.graphics_view.setScene(self._scene)
self.open_button.setIcon(QIcon.fromTheme('document-open'))
self.open_button.pressed.connect(self._import)
self.export_button.setIcon(QIcon.fromTheme('document-export'))
self.export_button.pressed.connect(self._export)
self.fit_to_view_button.setIcon(QIcon.fromTheme('zoom-fit-best'))
self.fit_to_view_button.pressed.connect(self._fit_to_view)
self.decision_graphs_combo_box.setSizeAdjustPolicy(QComboBox.AdjustToMinimumContentsLength)
self.decision_graphs_combo_box.currentIndexChanged['QString'].connect(self._graph_item_changed)
self._dot_processor = DotProcessor(self._dot_to_qt)
self.decision_graphs = dict()
self.states = dict()
def __init__(self, url=None):
"""
Class to load a webpage in a widget.
:param url: If url is empty then a navigation bar is shown otherwise the url is loaded and the navigation bar is hidden, ''str''
"""
super(WebWidget, self).__init__()
ui_file = os.path.join(os.path.dirname(os.path.realpath(__file__)),
'web_widget.ui')
loadUi(ui_file, self)
self.setObjectName('WebWidget')
self._loading = False
self._stop_icon = QIcon.fromTheme('process-stop')
self._reload_icon = QIcon.fromTheme('view-refresh')
self._working_icon = QIcon.fromTheme('process-working')
self._completer_word_list = ['']
self._view = QWebView()
self.verticalLayout.addWidget(self._view)
if url is None:
self.set_url("http://ros.org", True)
else:
self.set_url(url, False)
self.url_lineedit.returnPressed.connect(self._handle_url_change)
self._view.loadFinished[bool].connect(self._handle_load_finished)
self.reload_button.clicked.connect(self._handle_reload_clicked)
self._view.linkClicked.connect(self._handle_link_clicked)
self._view.urlChanged[QUrl].connect(self._handle_url_changed)
def __init__(self, initial_topics=None, start_paused=False):
super(PlotWidget, self).__init__()
self.setObjectName('PlotWidget')
self._initial_topics = initial_topics
rp = rospkg.RosPack()
ui_file = os.path.join(rp.get_path('rqt_plot'), 'resource', 'plot.ui')
loadUi(ui_file, self)
self.subscribe_topic_button.setIcon(QIcon.fromTheme('list-add'))
self.remove_topic_button.setIcon(QIcon.fromTheme('list-remove'))
self.pause_button.setIcon(QIcon.fromTheme('media-playback-pause'))
self.clear_button.setIcon(QIcon.fromTheme('edit-clear'))
self.data_plot = None
self.subscribe_topic_button.setEnabled(False)
if start_paused:
self.pause_button.setChecked(True)
self._topic_completer = TopicCompleter(self.topic_edit)
self._topic_completer.update_topics()
self.topic_edit.setCompleter(self._topic_completer)
self._start_time = rospy.get_time()
self._rosdata = {}
self._remove_topic_menu = QMenu()
# init and start update timer for plot
self._update_plot_timer = QTimer(self)
self._update_plot_timer.timeout.connect(self.update_plot)
def __init__(self, initial_topics=None, start_paused=False):
super(PlotWidget, self).__init__()
self.setObjectName('PlotWidget')
self._initial_topics = initial_topics
rp = rospkg.RosPack()
ui_file = os.path.join(rp.get_path('monitoring_rqt_plot'), 'resource',
'plot.ui')
loadUi(ui_file, self)
self.subscribe_topic_button.setIcon(QIcon.fromTheme('list-add'))
self.remove_topic_button.setIcon(QIcon.fromTheme('list-remove'))
self.pause_button.setIcon(QIcon.fromTheme('media-playback-pause'))
self.clear_button.setIcon(QIcon.fromTheme('edit-clear'))
self.data_plot = None
self.subscribe_topic_button.setEnabled(True)
if start_paused:
self.pause_button.setChecked(True)
self._start_time = rospy.get_time()
self._rosdata = {}
self._remove_topic_menu = QMenu()
# init and start update timer for plot
self._update_plot_timer = QTimer(self)
self._update_plot_timer.timeout.connect(self.update_plot)
rospy.Subscriber("/monitoring/gui", Gui,
self.monitoring_topic_overview_list_manager)
def __init__(self, node, parent=None):
super(PublisherWidget, self).__init__(parent)
self._node = node
self._topic_dict = {}
self._update_thread = WorkerThread(self._update_thread_run,
self._update_finished)
package_path = get_package_path('rqt_publisher')
ui_file = os.path.join(package_path, 'share', 'rqt_publisher',
'resource', 'Publisher.ui')
loadUi(
ui_file, self, {
'ExtendedComboBox': ExtendedComboBox,
'PublisherTreeWidget': PublisherTreeWidget
})
self.refresh_button.setIcon(QIcon.fromTheme('view-refresh'))
self.refresh_button.clicked.connect(self.refresh_combo_boxes)
self.add_publisher_button.setIcon(QIcon.fromTheme('list-add'))
self.remove_publisher_button.setIcon(QIcon.fromTheme('list-remove'))
self.clear_button.setIcon(QIcon.fromTheme('edit-clear'))
self.refresh_combo_boxes()
self.publisher_tree_widget.model().item_value_changed.connect(
self.change_publisher)
self.publisher_tree_widget.remove_publisher.connect(
self.remove_publisher)
self.publisher_tree_widget.publish_once.connect(self.publish_once)
self.remove_publisher_button.clicked.connect(
self.publisher_tree_widget.remove_selected_publishers)
self.clear_button.clicked.connect(self.clean_up_publishers)
def __init__(self, parent=None, logger=Logger()):
QTreeWidget.__init__(self, parent)
self.set_logger(logger)
# init tree
self.setHeaderLabels(["Name", "Type", "Value"])
self.sortItems(0, Qt.AscendingOrder)
#self.setSelectionMode(QAbstractItemView.NoSelection)
self.setContextMenuPolicy(Qt.CustomContextMenu)
self.itemActivated.connect(self.edit_item)
self.currentItemChanged.connect(self.current_item_changed)
# context menu
self.customContextMenuRequested.connect(self.context_menu_request)
self._action_item_expand = QAction(QIcon.fromTheme('zoom-in'),
'Expand Selected', self)
self._action_item_expand.triggered.connect(
self._handle_action_item_expand)
self._action_item_collapse = QAction(QIcon.fromTheme('zoom-out'),
'Collapse Selected', self)
self._action_item_collapse.triggered.connect(
self._handle_action_item_collapse)
self._action_item_add = QAction(QIcon.fromTheme('list-add'), 'Add',
self)
self._action_item_add.setEnabled(False) # TODO
self._action_item_remove = QAction(QIcon.fromTheme('list-remove'),
'Remove', self)
self._action_item_remove.setEnabled(False) # TODO
def __init__(self, topics):
super(Plot2DWidget, self).__init__()
self.setObjectName('Plot2DWidget')
rp = rospkg.RosPack()
ui_file = os.path.join(rp.get_path('jsk_rqt_plugins'), 'resource',
'plot_histogram.ui')
loadUi(ui_file, self)
self.cv_bridge = CvBridge()
self.subscribe_topic_button.setIcon(QIcon.fromTheme('add'))
self.pause_button.setIcon(QIcon.fromTheme('media-playback-pause'))
self.clear_button.setIcon(QIcon.fromTheme('edit-clear'))
self.data_plot = MatPlot2D(self)
self.data_plot_layout.addWidget(self.data_plot)
self._topic_completer = TopicCompleter(self.topic_edit)
self._topic_completer.update_topics()
self.topic_edit.setCompleter(self._topic_completer)
self.data_plot.dropEvent = self.dropEvent
self.data_plot.dragEnterEvent = self.dragEnterEvent
self._start_time = rospy.get_time()
self._rosdata = None
if len(topics) != 0:
self.subscribe_topic(topics)
self._update_plot_timer = QTimer(self)
self._update_plot_timer.timeout.connect(self.update_plot)
self._update_plot_timer.start(self._redraw_interval)
def __init__(self, initial_topics=None, start_paused=False):
super(PlotWidget, self).__init__()
self.setObjectName('PlotWidget')
self._initial_topics = initial_topics
rp = rospkg.RosPack()
ui_file = '/home/mohammad/Documents/CMU/RED/catkin_ws/src/rqt_safeguard/resource/plot.ui'
loadUi(ui_file, self)
self.subscribe_topic_button.setIcon(QIcon.fromTheme('list-add'))
self.remove_topic_button.setIcon(QIcon.fromTheme('list-remove'))
self.pause_button.setIcon(QIcon.fromTheme('media-playback-pause'))
# self.clear_button.setIcon(QIcon.fromTheme('edit-clear'))
# self.data_plot = None
self.subscribe_topic_button.setEnabled(False)
if start_paused:
self.pause_button.setChecked(True)
self._topic_completer = TopicCompleter(self.topic_edit)
self._topic_completer.update_topics()
self.topic_edit.setCompleter(self._topic_completer)
self._start_time = rospy.get_time()
self._rosdata = {}
self._remove_topic_menu = QMenu()
self.color_box.setStyleSheet("background-color: red;")
# init and start update timer for plot
self._update_timer = QTimer(self)
self._update_timer.timeout.connect(self.update)
def on_pushButton_calibrate_clicked(self):
self._widget.pushButton_calibrate.setEnabled(False)
status_icon = QIcon.fromTheme('stock_no')
# Fill request information
request = self._selected_service['service_class']._request_class()
request.target_hue.data = self._widget.spinBox_hue.value()
request.mult_diffs.data = self._widget.spinBox_diff.value()
request.mult_sat.data = self._widget.spinBox_sat.value()
try:
# Call service
response = self._selected_service['service_proxy'](request)
except rospy.ServiceException as e:
qWarning('on_pushButton_calibrate_clicked(): error calling service "%s":\n%s' % (self._selected_service['service_name'], e))
else:
# Get debug image and show
img = response.image_debug
qImage = QImage(img.data, img.width, img.height, img.step, QImage.Format_RGB888)
qPixmap = QPixmap()
qPixmap.convertFromImage(qImage)
pixmapItem = QGraphicsPixmapItem(qPixmap)
self._qGraphicsScene.clear()
self._qGraphicsScene.addItem(pixmapItem)
self._widget.graphicsView.fitInView(QRectF(qPixmap.rect()), Qt.KeepAspectRatio)
if response.success.data == True:
status_icon = QIcon.fromTheme('stock_yes')
self._widget.label_status.setPixmap(status_icon.pixmap(status_icon.actualSize(QSize(24, 24))))
self._widget.pushButton_calibrate.setEnabled(True)
def __init__(self, reconf, node_name):
"""
:type reconf: dynamic_reconfigure.client
:type node_name: str
"""
group_desc = reconf.get_group_descriptions()
logging.debug('ParamClientWidget.group_desc=%s', group_desc)
super(ParamClientWidget, self).__init__(ParamUpdater(reconf),
group_desc, node_name)
# Save and load buttons
self.button_widget = QWidget(self)
self.button_header = QHBoxLayout(self.button_widget)
self.button_header.setContentsMargins(QMargins(0, 0, 0, 0))
self.load_button = QPushButton()
self.save_button = QPushButton()
self.load_button.setIcon(QIcon.fromTheme('document-open'))
self.save_button.setIcon(QIcon.fromTheme('document-save'))
self.load_button.clicked[bool].connect(self._handle_load_clicked)
self.save_button.clicked[bool].connect(self._handle_save_clicked)
self.button_header.addWidget(self.save_button)
self.button_header.addWidget(self.load_button)
self.setMinimumWidth(150)
self.reconf = reconf
self.updater.start()
self.reconf.config_callback = self.config_callback
self._node_grn = node_name
def __init__(self, initial_topics=None, start_paused=False):
super(PlotWidget, self).__init__()
self.setObjectName('PlotWidget')
# Available ros topics for plotting
# keys are i=InitSub, s=StateSub, r=RCSub, p=PathSub, w=WaypointSub,
# o=ObstacleSub, g=GPSDataSub, ci=ConInSub, cc=ConComSub
self.message_dict = {
'Course angle vs. Commanded': [('cc', 'chi_c'), ('s', 'chi')],
'Roll angle vs. Commanded': [('ci', 'phi_c'), ('s', 'phi')],
'Pitch angle vs. Commanded': [('s', 'theta'), ('ci', 'theta_c')],
'Airspeed vs. Commanded': [('s', 'Va'), ('cc', 'Va_c')]
}
# # Available ros topics for plotting
# self.message_dict = {
# 'Course angle (rad)':'/state/chi',
# 'Course angle commanded (rad)':'/controller_commands/chi_c',
# 'Airspeed (m/s)':'/state/Va',
# 'Angle of attack (rad)':'/state/alpha',
# 'Slide slip angle (rad)':'/state/beta',
# 'Roll angle (rad)':'/state/phi',
# 'Pitch angle (rad)':'/state/theta',
# 'Yaw angle (rad)':'/state/psi',
# 'Body frame rollrate (rad/s)':'/state/p',
# 'Body frame pitchrate (rad/s)':'/state/q',
# 'Body frame yawrate (rad/s)':'/state/r',
# 'Groundspeed (m/s)':'/state/Vg'
# }
#self._initial_topics = initial_topics
rp = rospkg.RosPack()
ui_file = os.path.join(PWD, 'resources', 'plot.ui')
loadUi(ui_file, self)
self.pause_button.setIcon(QIcon.fromTheme('media-playback-pause'))
self.clear_button.setIcon(QIcon.fromTheme('edit-clear'))
self.data_plot = None
if start_paused:
self.pause_button.setChecked(True)
self._start_time = rospy.get_time()
self._rosdata = {}
self._current_key = ''
self._current_topics = []
self._remove_topic_menu = QMenu()
self._msgs.clear()
self._msgs.addItems(self.message_dict.keys())
self._msgs.currentIndexChanged[str].connect(
self._draw_graph) # <<<<<<< start here (also modify the dict)
# init and start update timer for plot
self._update_plot_timer = QTimer(self)
self._update_plot_timer.timeout.connect(self.update_plot)
def set_menu(self, menu):
self._menu_manager = MenuManager(menu)
self._perspective_mapper = QSignalMapper(menu)
self._perspective_mapper.mapped[str].connect(self.switch_perspective)
# generate menu
create_action = QAction('&Create perspective...', self._menu_manager.menu)
create_action.setIcon(QIcon.fromTheme('list-add'))
create_action.triggered.connect(self._on_create_perspective)
self._menu_manager.add_suffix(create_action)
self._remove_action = QAction('&Remove perspective...', self._menu_manager.menu)
self._remove_action.setEnabled(False)
self._remove_action.setIcon(QIcon.fromTheme('list-remove'))
self._remove_action.triggered.connect(self._on_remove_perspective)
self._menu_manager.add_suffix(self._remove_action)
self._menu_manager.add_suffix(None)
import_action = QAction('&Import...', self._menu_manager.menu)
import_action.setIcon(QIcon.fromTheme('document-open'))
import_action.triggered.connect(self._on_import_perspective)
self._menu_manager.add_suffix(import_action)
export_action = QAction('&Export...', self._menu_manager.menu)
export_action.setIcon(QIcon.fromTheme('document-save-as'))
export_action.triggered.connect(self._on_export_perspective)
self._menu_manager.add_suffix(export_action)
# add perspectives to menu
for name in self.perspectives:
if not name.startswith(self.HIDDEN_PREFIX):
self._add_perspective_action(name)
def __init__(self, ros_package):
super(GraphWidget, self).__init__()
self._current_graph = None
self._lock = Lock()
self._load_ui(ros_package)
self._scene = QGraphicsScene()
self._scene.setBackgroundBrush(Qt.white)
factory = DmgItemFactory()
factory.set_color(QColor(50, 50, 50))
factory.set_highlighted_color(QColor(0, 150, 0))
self._dot_to_qt = DotToQtGenerator(factory)
self.initialized = False
self.setObjectName('GraphWidget')
self.graphics_view.setScene(self._scene)
self.open_button.setIcon(QIcon.fromTheme('document-open'))
self.open_button.pressed.connect(self._import)
self.export_button.setIcon(QIcon.fromTheme('document-export'))
self.export_button.pressed.connect(self._export)
self.fit_to_view_button.setIcon(QIcon.fromTheme('zoom-fit-best'))
self.fit_to_view_button.pressed.connect(self._fit_to_view)
self.decision_graphs_combo_box.setSizeAdjustPolicy(QComboBox.AdjustToMinimumContentsLength)
self.decision_graphs_combo_box.currentIndexChanged['QString'].connect(self._graph_item_changed)
self._dot_processor = DotProcessor(self._dot_to_qt)
self.decision_graphs = dict()
self.states = dict()
def __init__(self, parent=None):
super(LaunchWidget, self).__init__(parent)
self._topic_dict = {}
self._update_thread = WorkerThread(self._update_thread_run,
self._update_finished)
self._rospack = rospkg.RosPack()
ui_file = os.path.join(self._rospack.get_path('roslaunch_monitor'),
'resource', 'rqt_monitor_plugin.ui')
loadUi(
ui_file, self, {
'ExtendedComboBox': ExtendedComboBox,
'LaunchTreeWidget': LaunchTreeWidget
})
self.refresh_button.setIcon(QIcon.fromTheme('view-refresh'))
self.refresh_button.clicked.connect(self.refresh_combo_boxes)
self.add_launch_button.setIcon(QIcon.fromTheme('add'))
self.remove_launch_button.setIcon(QIcon.fromTheme('remove'))
self.clear_button.setIcon(QIcon.fromTheme('edit-clear'))
self.refresh_combo_boxes()
self.launch_tree_widget.model().item_value_changed.connect(
self.change_launch)
self.launch_tree_widget.remove_publisher.connect(self.remove_launch)
#self.publisher_tree_widget.publish_once.connect(self.publish_once)
self.remove_launch_button.clicked.connect(
self.launch_tree_widget.remove_selected_publishers)
self.clear_button.clicked.connect(self.clean_up_launches)
def on_ctrl_list_tree_widget_customContextMenuRequested(self, pos):
ctrlman_ns = self.cm_namespace_combo.currentText()
item = self.ctrl_list_tree_widget.itemAt(pos)
if item is None:
return
ctrl_name = item.data(0, Qt.UserRole)
ctrl_state = self._ctrlers[ctrl_name]['state']
# show context menu
menu = QMenu(self)
if ctrl_state == 'running':
action_stop = menu.addAction(
QIcon.fromTheme('media-playback-stop'), 'Stop Controller')
action_kill = menu.addAction(QIcon.fromTheme('list-remove'),
'Stop and Unload Controller')
elif ctrl_state == 'stopped':
action_start = menu.addAction(
QIcon.fromTheme('media-playback-start'), 'Start Controller')
action_unload = menu.addAction(QIcon.fromTheme('list-remove'),
'Unload Controller')
action = menu.exec_(self.ctrl_list_tree_widget.mapToGlobal(pos))
# evaluate user action
if ctrl_state == 'running':
if action is action_stop:
self.start_stop_controller(ctrlman_ns, ctrl_name, False)
elif action is action_kill:
self.start_stop_controller(ctrlman_ns, ctrl_name, False)
self.unload_controller(ctrlman_ns, ctrl_name)
elif ctrl_state == 'stopped':
if action is action_start:
self.start_stop_controller(ctrlman_ns, ctrl_name, True)
elif action is action_unload:
self.unload_controller(ctrlman_ns, ctrl_name)
def __init__(self, arguments=None, initial_topics=None):
super(PlotWidget, self).__init__()
self.setObjectName('PlotWidget')
ui_file = os.path.join(os.path.dirname(os.path.realpath(__file__)),
'plot.ui')
loadUi(ui_file, self)
self.subscribe_topic_button.setIcon(QIcon.fromTheme('add'))
self.remove_topic_button.setIcon(QIcon.fromTheme('remove'))
self.pause_button.setIcon(QIcon.fromTheme('media-playback-pause'))
self.clear_button.setIcon(QIcon.fromTheme('edit-clear'))
self.data_plot = None
self.subscribe_topic_button.setEnabled(False)
self._topic_completer = TopicCompleter(self.topic_edit)
self._topic_completer.update_topics()
self.topic_edit.setCompleter(self._topic_completer)
self._start_time = rospy.get_time()
self._rosdata = {}
self._ordered_topics = []
self._remove_topic_menu = QMenu()
# init and start update timer for plot
self._update_plot_timer = QTimer(self)
self._update_plot_timer.timeout.connect(self.update_plot)
# save command line arguments
self._arguments = arguments
self._initial_topics = initial_topics
def __init__(self):
QWidget.__init__(self)
rp = rospkg.RosPack()
ui_file = os.path.join(rp.get_path('rqt_bag_annotation'), 'resource', 'export_widget.ui')
loadUi(ui_file, self)
self.add_topic_button.setIcon(QIcon.fromTheme('list-add'))
self.remove_topic_button.setIcon(QIcon.fromTheme('list-remove'))
self.refresh_button.setIcon(QIcon.fromTheme('view-refresh'))
self.add_topic_button.clicked[bool].connect(self._handle_add_topic_clicked)
self.remove_topic_button.clicked[bool].connect(self._handle_remove_topic_clicked)
self.refresh_button.clicked[bool].connect(self._handle_refresh_clicked)
self.export_button.clicked[bool].connect(self._handle_export_clicked)
self.export_location_edit.setPlainText("./export_file.txt")
self.rospack = rospkg.RosPack()
self._exported_topics = list()
self._exported_publisher_info = list()
self._annotations = list()
self._active_topics = list()
self._dt = 0.1
self._current_topic_paths = dict()
self._current_msg_paths = dict()
self._id_counter = 0
self.current_output = ""
def __init__(self):
super(ServiceCallerWidget, self).__init__()
self.setObjectName('ServiceCallerWidget')
# create context for the expression eval statement
self._eval_locals = {}
for module in (math, random, time):
self._eval_locals.update(module.__dict__)
self._eval_locals['genpy'] = genpy
del self._eval_locals['__name__']
del self._eval_locals['__doc__']
rp = rospkg.RosPack()
ui_file = os.path.join(rp.get_path('rqt_service_caller'), 'resource',
'ServiceCaller.ui')
loadUi(ui_file, self, {'ExtendedComboBox': ExtendedComboBox})
self.refresh_services_button.setIcon(QIcon.fromTheme('view-refresh'))
self.call_service_button.setIcon(QIcon.fromTheme('call-start'))
self._column_index = {}
for column_name in self.column_names:
self._column_index[column_name] = len(self._column_index)
self._service_info = None
self.on_refresh_services_button_clicked()
self.request_tree_widget.itemChanged.connect(
self.request_tree_widget_itemChanged)
def on_ctrl_list_tree_widget_customContextMenuRequested(self, pos):
ctrlman_ns = self.cm_namespace_combo.currentText()
item = self.ctrl_list_tree_widget.itemAt(pos)
if item is None:
return
ctrl_name = item.data(0, Qt.UserRole)
ctrl_state = self._ctrlers[ctrl_name]['state']
# show context menu
menu = QMenu(self)
if ctrl_state == 'running':
action_stop = menu.addAction(
QIcon.fromTheme('media-playback-stop'), 'Stop Controller')
action_kill = menu.addAction(
QIcon.fromTheme('list-remove'), 'Stop and Unload Controller')
elif ctrl_state == 'stopped':
action_start = menu.addAction(
QIcon.fromTheme('media-playback-start'), 'Start Controller')
action_unload = menu.addAction(
QIcon.fromTheme('list-remove'), 'Unload Controller')
action = menu.exec_(self.ctrl_list_tree_widget.mapToGlobal(pos))
# evaluate user action
if ctrl_state == 'running':
if action is action_stop:
self.start_stop_controller(ctrlman_ns, ctrl_name, False)
elif action is action_kill:
self.start_stop_controller(ctrlman_ns, ctrl_name, False)
self.unload_controller(ctrlman_ns, ctrl_name)
elif ctrl_state == 'stopped':
if action is action_start:
self.start_stop_controller(ctrlman_ns, ctrl_name, True)
elif action is action_unload:
self.unload_controller(ctrlman_ns, ctrl_name)
def __init__(self):
super(MainWidget, self).__init__()
self.setObjectName('MainWidget')
rospack = rospkg.RosPack()
ui_file = rospack.get_path(
'rqt_joint_trajectory_plot') + '/resource/JointTrajectoryPlot.ui'
loadUi(ui_file, self)
self.refresh_button.setIcon(QIcon.fromTheme('reload'))
self.pause_button.setIcon(QIcon.fromTheme('media-playback-pause'))
self.handler = None
self.joint_names = []
self.timer = QTimer(self)
self.timer.timeout.connect(self.update)
self.plot_widget = PlotWidget(self)
self.plot_layout.addWidget(self.plot_widget)
self.draw_curves.connect(self.plot_widget.draw_curves)
self.time = None
(self.dis, self.vel, self.acc, self.eff) = ({}, {}, {}, {})
# refresh topics list in the combobox
self.refresh_topics()
self.change_topic()
self.refresh_button.clicked.connect(self.refresh_topics)
self.topic_combox.currentIndexChanged.connect(self.change_topic)
self.select_tree.itemChanged.connect(self.update_checkbox)
def toggle_paused(self, BagWidget):
self._paused = not self._paused
if self._paused:
BagWidget.record_button.setIcon(QIcon.fromTheme('media-record'))
BagWidget.record_button.setToolTip("Keep Record")
else:
BagWidget.record_button.setToolTip("Pause")
BagWidget.record_button.setIcon(QIcon.fromTheme('media-playback-pause'))
def __init__(self, parent=None):
super(PublisherTreeWidget, self).__init__(parent)
self.setModel(PublisherTreeModel(self))
self._action_remove_publisher = QAction(QIcon.fromTheme('list-remove'), 'Remove Selected', self)
self._action_remove_publisher.triggered[bool].connect(self._handle_action_remove_publisher)
self._action_publish_once = QAction(QIcon.fromTheme('media-playback-start'), 'Publish Selected Once', self)
self._action_publish_once.triggered[bool].connect(self._handle_action_publish_once)
self.setItemDelegateForColumn(self.model()._column_index['rate'], SpinBoxDelegate(min_value=0, max_value=1000000, decimals=2))
def __init__(self, parent=None):
super(PublisherTreeWidget, self).__init__(parent)
self.setModel(PublisherTreeModel(self))
self._action_remove_publisher = QAction(QIcon.fromTheme('list-remove'), 'Remove Selected', self)
self._action_remove_publisher.triggered[bool].connect(self._handle_action_remove_publisher)
self._action_publish_once = QAction(QIcon.fromTheme('media-playback-start'), 'Publish Selected Once', self)
self._action_publish_once.triggered[bool].connect(self._handle_action_publish_once)
def __init__(self, parent=None):
super(PublisherTreeWidget, self).__init__(parent)
self.setModel(PublisherTreeModel(self))
self._action_remove_publisher = QAction(QIcon.fromTheme('remove'), 'Remove Selected', self)
self._action_remove_publisher.triggered[bool].connect(self._handle_action_remove_publisher)
self._action_publish_once = QAction(QIcon.fromTheme('media-playback-start'), 'Publish Selected Once', self)
self._action_publish_once.triggered[bool].connect(self._handle_action_publish_once)
self.setItemDelegateForColumn(self.model()._column_index['rate'], SpinBoxDelegate(min_value=0, max_value=1000000, decimals=2))
def _bt_enabled_cb(self, msg):
self._bt_enabled = msg.data
if self._bt_enabled:
self.run_push_button.setIcon(
QIcon.fromTheme('media-playback-pause'))
else:
self.run_push_button.setIcon(
QIcon.fromTheme('media-playback-start'))
def _pause_resume_plots(self):
if self.pause is 0:
self.pause = 1
self._widget.pause_resume_plot_button.setIcon(QIcon.fromTheme('media-playback-start'))
self._widget.pause_resume_plot_button.setText("Resume")
else:
self.pause = 0
self._widget.pause_resume_plot_button.setIcon(QIcon.fromTheme('media-playback-pause'))
self._widget.pause_resume_plot_button.setText("Pause")
def __init__(self, context):
super(KinestheticTeachingWidget, self).__init__()
ui_file = os.path.join(rospkg.RosPack().get_path('rqt_kinesthetic_teaching'), 'resource', 'KinestheticTeaching.ui')
loadUi(ui_file, self)
self.setObjectName('KTeachingUi')
self.setWindowTitle(self.windowTitle() + (' (%d)' % context.serial_number()))
# Add widget to the user interface
context.add_widget(self)
# Set icons for buttons because they don't persist frm Qt creator for some reason
self.demoLocationSaveButton.setIcon(QIcon.fromTheme("document-save-as"))
self.demoLocationButton.setIcon(QIcon.fromTheme("document-open"))
self.demoFolderLocationButton.setIcon(QIcon.fromTheme("folder"))
self.playDemoButton.setIcon(QIcon.fromTheme("media-playback-start"))
# Attach event handlers
self.demoLocationButton.clicked[bool].connect(self.browseForLocation)
self.demoFolderLocationButton.clicked[bool].connect(self.browseForFolder)
self.demoLocationSaveButton.clicked[bool].connect(self.newLocation)
self.demoLocation.returnPressed.connect(self.loadLocation)
self.startTrajectoryButton.clicked[bool].connect(self.startTrajectory)
self.startButton.clicked[bool].connect(self.startKeyframe)
self.addButton.clicked[bool].connect(self.addKeyframe)
self.openHandButton.clicked[bool].connect(self.openHand)
self.closeHandButton.clicked[bool].connect(self.closeHand)
self.endButton.clicked[bool].connect(self.endKeyframe)
self.playDemoButton.clicked[bool].connect(self.playDemo)
self.enableKIBox.stateChanged.connect(self.enableKI)
self.locateObjectsBox.stateChanged.connect(self.locateObjectsChanged)
# Set sizing options for tree widget headers
self.playbackTree.header().setStretchLastSection(False)
self.playbackTree.header().setResizeMode(0, QHeaderView.Stretch)
self.playbackTree.header().setResizeMode(1, QHeaderView.ResizeToContents)
self.zeroMarker.setInsertPolicy(QComboBox.InsertAlphabetically)
# Initialize the demonstration recorder
self.kinesthetic_interaction = None
try:
self.kinesthetic_interaction = RQTKinestheticInteraction()
print "Waiting for RQT kinesthetic interaction service"
rospy.wait_for_service("kinesthetic_interaction")
self.enable_kinesthetic_service = rospy.ServiceProxy("kinesthetic_interaction", KinestheticInteract)
self.enable_kinesthetic_service(True)
# Register callbacks
self.kinesthetic_interaction.start_trajectory_cb = self.startTrajectoryCallback
self.kinesthetic_interaction.start_keyframe_cb = self.startKeyframeCallback
self.kinesthetic_interaction.add_keyframe_cb = self.addKeyframeCallback
self.kinesthetic_interaction.end_keyframe_cb = self.endKeyframeCallback
except TimeoutException as err:
self._showWarning("Record keyframe demo server unreachable", str(err))
self.keyframeBagInterface = None
def __init__(self, dock_widget, qtgui_path):
super(DockWidgetTitleBar, self).__init__(dock_widget)
self._dock_widget = dock_widget
self.hide_title_bar = False
ui_file = os.path.join(qtgui_path, 'resource',
'dock_widget_title_bar.ui')
loadUi(ui_file, self)
self._extra_buttons = {
'configuration': self.configuration_button,
'reload': self.reload_button,
'help': self.help_button,
'close': self.close_button,
}
icon = QIcon.fromTheme('emblem-system')
if not icon.isNull():
self.configuration_button.setIcon(icon)
self.configuration_button.setText("")
icon = QIcon.fromTheme('view-refresh')
if not icon.isNull():
self.reload_button.setIcon(icon)
self.reload_button.setText("")
icon = QIcon.fromTheme('help-browser')
if not icon.isNull():
self.help_button.setIcon(icon)
self.help_button.setText("")
icon = QIcon.fromTheme('window-close')
if not icon.isNull():
self.close_button.setIcon(icon)
self.close_button.setText("")
self.close_button.clicked.connect(self._close_clicked)
self.float_button.clicked.connect(self._toggle_floating)
self.dockable_button.clicked[bool].connect(self._toggle_dockable)
self.minimize_button.clicked.connect(self._minimize_dock_widget)
self._dock_widget.featuresChanged.connect(self._features_changed)
self._features_changed()
self._update_icon()
self._update_title()
self._close_callbacks = []
self._event_callbacks = {
QEvent.WindowIconChange: self._update_icon,
QEvent.WindowTitleChange: self._update_title,
}
self._dock_widget.installEventFilter(self)
self.title_label.installEventFilter(self)
self.title_edit.hide()
self.title_edit.editingFinished.connect(self._finished_editing)
self.title_edit.returnPressed.connect(self._update_title_label)
def __init__(self, menu_button):
QMenu.__init__(self)
self.button = menu_button
try:
rqt_icon_path = roslib.packages.find_resource('rqt_gui', 'rqt.png').pop()
menu_button.setText('')
menu_button.setIcon(QIcon(rqt_icon_path))
# creates a default config menu
self.action_rqt_console = QAction(QIcon.fromTheme('mail-message-new'),
"&Console", self,
statusTip='"<p>Starts a python GUI plugin for displaying and filtering '
'ROS log messages that is connected to the selected master.</p>"',
triggered=self.on_show_console_clicked)
self.addAction(self.action_rqt_console)
self.action_rqt_logger_level = QAction(QIcon.fromTheme('format-indent-more'),
"&Logger Level", self,
statusTip='"<p>Starts a python GUI plugin for configuring the level of '
'ROS loggers that is connected to the selected master.</p>"',
triggered=self.on_show_logger_level_clicked)
self.addAction(self.action_rqt_logger_level)
self.action_rqt_tf_tree = QAction(QIcon.fromTheme('preferences-system-network'),
"&TF Tree", self,
statusTip='"<p>Starts a python GUI plugin for visualizing the TF tree'
'that is connected to the selected master.</p>"',
triggered=self.on_show_tf_tree_clicked)
self.addAction(self.action_rqt_tf_tree)
self.action_rqt_ros_graph = QAction(QIcon(":/icons/button_graph.png"),
"Ros &Graph", self,
statusTip='"<p>Starts a python GUI plugin for visualizing the ROS computation graph'
'that is connected to the selected master</p>"',
triggered=self.on_show_ros_graph_clicked)
self.addAction(self.action_rqt_ros_graph)
self.action_rosbag_record = QAction(QIcon.fromTheme('media-record'),
"rosbag record", self,
statusTip='"<p>Starts the rosbag record with selected topics</p>"',
triggered=self.on_start_rosbag_clicked)
self.addAction(self.action_rosbag_record)
self.action_rqt_rviz = QAction(QIcon.fromTheme('image-x-generic'),
"R&Viz", self,
statusTip='"<p>Starts RViz</p>"',
triggered=self.on_show_rviz_clicked)
self.addAction(self.action_rqt_rviz)
self.addSeparator()
self.action_rqt = QAction(QIcon(rqt_icon_path),
"&Rqt GUI", self,
statusTip='"<p>Start the rqt GUI'
'that is connected to the selected master</p>"',
triggered=self.on_start_rqt_clicked)
self.addAction(self.action_rqt)
menu_button.setMenu(self)
except Exception as e:
print '%s' % e
menu_button.setEnabled(False)
menu_button.setToolTip('rqt_gui not found! Please install rqt to use its plugins!')
def __init__(self, dock_widget, qtgui_path):
super(DockWidgetTitleBar, self).__init__(dock_widget)
self._dock_widget = dock_widget
self.hide_title_bar = False
ui_file = os.path.join(qtgui_path, 'resource', 'dock_widget_title_bar.ui')
loadUi(ui_file, self)
self._extra_buttons = {
'configuration': self.configuration_button,
'reload': self.reload_button,
'help': self.help_button,
'close': self.close_button,
}
icon = QIcon.fromTheme('emblem-system')
if not icon.isNull():
self.configuration_button.setIcon(icon)
self.configuration_button.setText("")
icon = QIcon.fromTheme('view-refresh')
if not icon.isNull():
self.reload_button.setIcon(icon)
self.reload_button.setText("")
icon = QIcon.fromTheme('help-browser')
if not icon.isNull():
self.help_button.setIcon(icon)
self.help_button.setText("")
icon = QIcon.fromTheme('window-close')
if not icon.isNull():
self.close_button.setIcon(icon)
self.close_button.setText("")
self.close_button.clicked.connect(self._close_clicked)
self.float_button.clicked.connect(self._toggle_floating)
self.dockable_button.clicked[bool].connect(self._toggle_dockable)
self.minimize_button.clicked.connect(self._minimize_dock_widget)
self._dock_widget.featuresChanged.connect(self._features_changed)
self._features_changed()
self._update_icon()
self._update_title()
self._close_callbacks = []
self._event_callbacks = {
QEvent.WindowIconChange: self._update_icon,
QEvent.WindowTitleChange: self._update_title,
}
self._dock_widget.installEventFilter(self)
self.title_label.installEventFilter(self)
self.title_edit.hide()
self.title_edit.editingFinished.connect(self._finished_editing)
self.title_edit.returnPressed.connect(self._update_title_label)
def __init__(self):
super(MessageDataModel, self).__init__()
self._messages = MessageList()
self._time_format = 'hh:mm:ss.zzz (yyyy-MM-dd)'
self._insert_message_queue = []
self._paused = False
self._message_limit = 20000
self._error_icon = QIcon.fromTheme('dialog-error')
self._warning_icon = QIcon.fromTheme('dialog-warning')
self._info_icon = QIcon.fromTheme('dialog-information')
def _pause_resume_plots(self):
if self.pause is 0:
self.pause = 1
self._widget.pause_resume_plot_button.setIcon(
QIcon.fromTheme('media-playback-start'))
self._widget.pause_resume_plot_button.setText("Resume")
else:
self.pause = 0
self._widget.pause_resume_plot_button.setIcon(
QIcon.fromTheme('media-playback-pause'))
self._widget.pause_resume_plot_button.setText("Pause")
def __check_icon_theme_compliance(self):
from python_qt_binding.QtGui import QIcon
# TODO find a better way to verify Theme standard compliance
if QIcon.themeName() == '' or \
QIcon.fromTheme('document-save').isNull() or \
QIcon.fromTheme('document-open').isNull() or \
QIcon.fromTheme('edit-cut').isNull() or \
QIcon.fromTheme('object-flip-horizontal').isNull():
original_theme = QIcon.themeName()
QIcon.setThemeName('Tango')
if QIcon.fromTheme('document-save').isNull():
QIcon.setThemeName(original_theme)
def __init__(self, topic="diagnostics"):
super(RuntimeMonitorWidget, self).__init__()
rp = rospkg.RosPack()
ui_file = os.path.join(rp.get_path('rqt_runtime_monitor'), 'resource',
'runtime_monitor_widget.ui')
loadUi(ui_file, self)
self.setObjectName('RuntimeMonitorWidget')
self._mutex = threading.Lock()
self._error_icon = QIcon.fromTheme('dialog-error')
self._warning_icon = QIcon.fromTheme('dialog-warning')
self._ok_icon = QIcon.fromTheme('dialog-information')
self._stale_node = QTreeWidgetItem(
self.tree_widget.invisibleRootItem(), ['Stale (0)'])
self._stale_node.setIcon(0, self._error_icon)
self.tree_widget.addTopLevelItem(self._stale_node)
self._error_node = QTreeWidgetItem(
self.tree_widget.invisibleRootItem(), ['Errors (0)'])
self._error_node.setIcon(0, self._error_icon)
self.tree_widget.addTopLevelItem(self._error_node)
self._warning_node = QTreeWidgetItem(
self.tree_widget.invisibleRootItem(), ['Warnings (0)'])
self._warning_node.setIcon(0, self._warning_icon)
self.tree_widget.addTopLevelItem(self._warning_node)
self._ok_node = QTreeWidgetItem(self.tree_widget.invisibleRootItem(),
['Ok (0)'])
self._ok_node.setIcon(0, self._ok_icon)
self.tree_widget.addTopLevelItem(self._ok_node)
self.tree_widget.itemSelectionChanged.connect(self._refresh_selection)
self.keyPressEvent = self._on_key_press
self._name_to_item = {}
self._new_errors_callback = None
self._subscriber = rospy.Subscriber(topic, DiagnosticArray,
self._diagnostics_callback)
self._previous_ros_time = rospy.Time.now()
self._timer = QTimer()
self._timer.timeout.connect(self._on_timer)
self._timer.start(1000)
self._msg_timer = QTimer()
self._msg_timer.timeout.connect(self._update_messages)
self._msg_timer.start(100)
self._messages = []
self._used_items = 0
def __init__(self, context):
"""
:param context: plugin context hook to enable adding widgets as a ROS_GUI pane, ''PluginContext''
"""
super(MapTopoWidget, self).__init__()
self.edit_mode = False
rp = rospkg.RosPack()
ui_file = os.path.join(rp.get_path('rqt_map_topo'), 'resource',
'map_widget.ui')
loadUi(ui_file, self, {'MapTopoGraphicsView': MapTopoGraphicsView})
self.setObjectName('MapTopoWidget')
self._scene = MapTopoScene()
self.graphics_view.setScene(self._scene)
self.places_dict = {} # places to be stored in a yaml file
self.map = None
self._clicked_pos = None
self._grid_pos = None
self._sceneItems = {
} # map that will store all the scene items for each place
self._mag = 10 # magnitude in pixels of the line drawn
self.load_button.setIcon(QIcon.fromTheme('document-open'))
self.save_button.setIcon(QIcon.fromTheme('document-save'))
self.theta_spin.setRange(-359.99, +359.99)
self.add_button.clicked[bool].connect(self._handle_add_clicked)
self.load_button.clicked[bool].connect(self._handle_load_clicked)
self.save_button.clicked[bool].connect(self._handle_save_clicked)
self.map_button.clicked[bool].connect(self._handle_read_map)
self.get_button.clicked[bool].connect(self._handle_get_clicked)
self.remove_button.clicked[bool].connect(self._handle_remove_clicked)
self.theta_spin.valueChanged.connect(self._theta_changed)
self.x_spin.valueChanged.connect(self._x_changed)
self.y_spin.valueChanged.connect(self._y_changed)
self.graphics_view.mousePressEvent = self.on_mouse_down
self.graphics_view.wheelEvent = self.on_wheel_event
self.add_button.setEnabled(False)
self.load_button.setEnabled(False)
self.save_button.setEnabled(False)
self.name_edit.setEnabled(False)
self.x_spin.setEnabled(False)
self.y_spin.setEnabled(False)
self.theta_spin.setEnabled(False)
self.get_button.setEnabled(False)
self.remove_button.setEnabled(False)
self.graphics_view.setEnabled(False)
self.map_read.connect(self._update_map)
def __init__(self, parent=None):
super(MessageTreeWidget, self).__init__(parent)
self.setDragEnabled(True)
self.sortByColumn(0, Qt.AscendingOrder)
self.header().setResizeMode(QHeaderView.ResizeToContents)
self.header().setContextMenuPolicy(Qt.CustomContextMenu)
self.header().customContextMenuRequested.connect(self.handle_header_view_customContextMenuRequested)
self._action_item_expand = QAction(QIcon.fromTheme('zoom-in'), 'Expand Selected', self)
self._action_item_expand.triggered.connect(self._handle_action_item_expand)
self._action_item_collapse = QAction(QIcon.fromTheme('zoom-out'), 'Collapse Selected', self)
self._action_item_collapse.triggered.connect(self._handle_action_item_collapse)
self.customContextMenuRequested.connect(self.handle_customContextMenuRequested)
def _check_icon_theme_compliance(self):
from python_qt_binding.QtGui import QIcon
# TODO find a better way to verify Theme standard compliance
if QIcon.themeName() == '' or \
QIcon.fromTheme('document-save').isNull() or \
QIcon.fromTheme('document-open').isNull() or \
QIcon.fromTheme('edit-cut').isNull() or \
QIcon.fromTheme('object-flip-horizontal').isNull():
if 'darwin' in platform.platform().lower() and '/usr/local/share/icons' not in QIcon.themeSearchPaths():
QIcon.setThemeSearchPaths(QIcon.themeSearchPaths() + ['/usr/local/share/icons'])
original_theme = QIcon.themeName()
QIcon.setThemeName('Tango')
if QIcon.fromTheme('document-save').isNull():
QIcon.setThemeName(original_theme)
def __init__(self, mode=rosmsg.MODE_MSG,
pkg_name='rqt_msg',
ui_filename='messages.ui'):
"""
:param ui_filename: This Qt-based .ui file must have elements that are
referred from this class. Otherwise unexpected
errors are likely to happen. Best way to avoid that
situation when you want to give your own .ui file
is to implement all Qt components in
rqt_msg/resource/message.ui file.
"""
super(MessagesWidget, self).__init__()
self._rospack = rospkg.RosPack()
ui_file = os.path.join(self._rospack.get_path(pkg_name), 'resource', ui_filename)
loadUi(ui_file, self, {'MessagesTreeView': MessagesTreeView})
self.setObjectName(ui_filename)
self._mode = mode
self._add_button.setIcon(QIcon.fromTheme('list-add'))
self._add_button.clicked.connect(self._add_message)
self._refresh_packages(mode)
self._refresh_msgs(self._package_combo.itemText(0))
self._package_combo.currentIndexChanged[str].connect(self._refresh_msgs)
self._messages_tree.mousePressEvent = self._handle_mouse_press
self._browsers = []
def __init__(self, context):
super(CapabilityGraph, self).__init__(context)
self.setObjectName('CapabilityGraph')
self.__current_dotcode = None
self.__widget = QWidget()
self.__dot_to_qt = DotToQtGenerator()
rp = rospkg.RosPack()
ui_file = os.path.join(rp.get_path('rqt_capabilities'), 'resources', 'CapabilityGraph.ui')
loadUi(ui_file, self.__widget, {'InteractiveGraphicsView': InteractiveGraphicsView})
self.__widget.setObjectName('CapabilityGraphUI')
if context.serial_number() > 1:
self.__widget.setWindowTitle(self.__widget.windowTitle() + (' (%d)' % context.serial_number()))
self.__scene = QGraphicsScene()
self.__scene.setBackgroundBrush(Qt.white)
self.__widget.graphics_view.setScene(self.__scene)
self.__widget.refresh_graph_push_button.setIcon(QIcon.fromTheme('view-refresh'))
self.__widget.refresh_graph_push_button.pressed.connect(self.__update_capabilities_graph)
self.__update_capabilities_graph()
self.__deferred_fit_in_view.connect(self.__fit_in_view, Qt.QueuedConnection)
self.__deferred_fit_in_view.emit()
context.add_widget(self.__widget)
def __init__(self, parent = None, logger = Logger()):
QWidgetWithLogger.__init__(self, parent, logger)
# start widget
hbox = QHBoxLayout()
hbox.setMargin(0)
hbox.setContentsMargins(0, 0, 0, 0)
# get system icon
icon = QIcon.fromTheme("view-refresh")
size = icon.actualSize(QSize(32, 32))
# add combo box
self.parameter_set_names_combo_box = QComboBox()
self.parameter_set_names_combo_box.currentIndexChanged[str].connect(self.param_changed)
hbox.addWidget(self.parameter_set_names_combo_box)
# add refresh button
self.get_all_parameter_set_names_button = QPushButton()
self.get_all_parameter_set_names_button.clicked.connect(self._get_all_parameter_set_names)
self.get_all_parameter_set_names_button.setIcon(icon)
self.get_all_parameter_set_names_button.setFixedSize(size.width()+2, size.height()+2)
hbox.addWidget(self.get_all_parameter_set_names_button)
# end widget
self.setLayout(hbox)
# init widget
self.reset_parameter_set_selection()
def __init__(self, topic="diagnostics"):
super(RuntimeMonitorWidget, self).__init__()
rp = rospkg.RosPack()
ui_file = os.path.join(rp.get_path('rqt_runtime_monitor'), 'resource', 'runtime_monitor_widget.ui')
loadUi(ui_file, self)
self.setObjectName('RuntimeMonitorWidget')
self._mutex = threading.Lock()
self._error_icon = QIcon.fromTheme('dialog-error')
self._warning_icon = QIcon.fromTheme('dialog-warning')
self._ok_icon = QIcon.fromTheme('dialog-information')
self._stale_node = QTreeWidgetItem(self.tree_widget.invisibleRootItem(), ['Stale (0)'])
self._stale_node.setIcon(0, self._error_icon)
self.tree_widget.addTopLevelItem(self._stale_node)
self._error_node = QTreeWidgetItem(self.tree_widget.invisibleRootItem(), ['Errors (0)'])
self._error_node.setIcon(0, self._error_icon)
self.tree_widget.addTopLevelItem(self._error_node)
self._warning_node = QTreeWidgetItem(self.tree_widget.invisibleRootItem(), ['Warnings (0)'])
self._warning_node.setIcon(0, self._warning_icon)
self.tree_widget.addTopLevelItem(self._warning_node)
self._ok_node = QTreeWidgetItem(self.tree_widget.invisibleRootItem(), ['Ok (0)'])
self._ok_node.setIcon(0, self._ok_icon)
self.tree_widget.addTopLevelItem(self._ok_node)
self.tree_widget.itemSelectionChanged.connect(self._refresh_selection)
self.keyPressEvent = self._on_key_press
self._name_to_item = {}
self._new_errors_callback = None
self._subscriber = rospy.Subscriber(topic, DiagnosticArray, self._diagnostics_callback)
self._previous_ros_time = rospy.Time.now()
self._timer = QTimer()
self._timer.timeout.connect(self._on_timer)
self._timer.start(1000)
self._msg_timer = QTimer()
self._msg_timer.timeout.connect(self._update_messages)
self._msg_timer.start(100)
self._messages = []
self._used_items = 0
def __init__(self, container_manager, serial_number):
super(DockWidgetContainer, self).__init__(container_manager)
self._serial_number = serial_number
self._settings = None
self.main_window = DockableMainWindow()
self.setWidget(self.main_window)
self.setWindowIcon(QIcon.fromTheme('folder'))
def _show_context_menu(self, item, global_pos):
if item is None:
return
# show context menu
menu = QMenu(self)
action_item_expand = menu.addAction(QIcon.fromTheme('zoom-in'), "Expand All Children")
action_item_collapse = menu.addAction(QIcon.fromTheme('zoom-out'), "Collapse All Children")
action = menu.exec_(global_pos)
# evaluate user action
if action in (action_item_expand, action_item_collapse):
expanded = (action is action_item_expand)
def recursive_set_expanded(item):
item.setExpanded(expanded)
for index in range(item.childCount()):
recursive_set_expanded(item.child(index))
recursive_set_expanded(item)
def on_topics_tree_widget_customContextMenuRequested(self, pos):
item = self.topics_tree_widget.itemAt(pos)
if item is None:
return
# show context menu
menu = QMenu(self)
action_item_expand = menu.addAction(QIcon.fromTheme('zoom-in'), 'Expand All Children')
action_item_collapse = menu.addAction(QIcon.fromTheme('zoom-out'), 'Collapse All Children')
action = menu.exec_(self.topics_tree_widget.mapToGlobal(pos))
# evaluate user action
if action in (action_item_expand, action_item_collapse):
expanded = (action is action_item_expand)
def recursive_set_expanded(item):
item.setExpanded(expanded)
for index in range(item.childCount()):
recursive_set_expanded(item.child(index))
recursive_set_expanded(item)
def __init__(self, initial_topics=None, start_paused=False,
buffer_length=100, use_poly=True, no_legend=False):
super(Plot3DWidget, self).__init__()
self.setObjectName('Plot3DWidget')
self._buffer_length = buffer_length
self._initial_topics = initial_topics
rp = rospkg.RosPack()
ui_file = os.path.join(rp.get_path('jsk_rqt_plugins'),
'resource', 'plot3d.ui')
loadUi(ui_file, self)
self.subscribe_topic_button.setIcon(QIcon.fromTheme('add'))
self.remove_topic_button.setIcon(QIcon.fromTheme('remove'))
self.pause_button.setIcon(QIcon.fromTheme('media-playback-pause'))
self.clear_button.setIcon(QIcon.fromTheme('edit-clear'))
self.data_plot = MatDataPlot3D(self, self._buffer_length,
use_poly, no_legend)
self.data_plot_layout.addWidget(self.data_plot)
self.data_plot.autoscroll(self.autoscroll_checkbox.isChecked())
self.data_plot.dropEvent = self.dropEvent
self.data_plot.dragEnterEvent = self.dragEnterEvent
self.subscribe_topic_button.setEnabled(False)
if start_paused:
self.pause_button.setChecked(True)
self._topic_completer = TopicCompleter(self.topic_edit)
self._topic_completer.update_topics()
self.topic_edit.setCompleter(self._topic_completer)
self._start_time = rospy.get_time()
self._rosdata = {}
self._remove_topic_menu = QMenu()
# init and start update timer for plot
self._update_plot_timer = QTimer(self)
self._update_plot_timer.timeout.connect(self.update_plot)
if self._initial_topics:
for topic_name in self._initial_topics:
self.add_topic(topic_name)
self._initial_topics = None
def __init__(self, context):
super(CopterPlugin, self).__init__(context)
self.setObjectName('CopterPlugin')
self._widget = QWidget()
rp = rospkg.RosPack()
ui_file = os.path.join(rp.get_path('rqt_copter'), 'resource', 'CopterPlugin.ui')
loadUi(ui_file, self._widget)
self._widget.setObjectName('CopterPluginUi')
if context.serial_number() > 1:
self._widget.setWindowTitle(self._widget.windowTitle() + (' (%d)' % context.serial_number()))
context.add_widget(self._widget)
# Add icons to the buttons
self._widget.pause_resume_plot_button.setIcon(QIcon.fromTheme('media-playback-pause'))
self._widget.start_reset_plot_button.setIcon(QIcon.fromTheme('view-refresh'))
self._widget.srv_refresh_button.setIcon(QIcon.fromTheme('view-refresh'))
self._widget.battery_alert.setIcon(QIcon.fromTheme('dialog-warning'))
self._widget.battery_alert.setVisible(0)
# Initialize the timer
self._start_time = rospy.get_time()
self._timer = QTimer(self)
self._timer.timeout.connect(self._timer_update)
self._timer.start(50)
# Initialize all plots and subscribers
self._state_subscriber = None
self._status_subscriber = None
self._client = None
self._create_plots()
self._get_init_services()
# Add event functions
self._widget.start_reset_plot_button.clicked.connect(self._reset_plots)
self._widget.pause_resume_plot_button.clicked.connect(self._pause_resume_plots)
self._widget.copter_namespace_textbox.returnPressed.connect(self._reset_subscriber)
self._widget.copter_namespace_button.clicked.connect(self._reset_subscriber)
self._widget.srv_refresh_button.clicked.connect(self._refresh_init_services)
self._widget.copter_namespace_textbox.setFocus()
