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 restore_settings(self, settings):
serial_number = settings.value('parent', None)
#print 'DockWidget.restore_settings()', 'parent', serial_number, 'settings group', settings._group
if serial_number is not None:
serial_number = int(serial_number)
if self._parent_container_serial_number() != serial_number and self._container_manager is not None:
floating = self.isFloating()
pos = self.pos()
new_container = self._container_manager.get_container(serial_number)
if new_container is not None:
new_parent = new_container.main_window
else:
new_parent = self._container_manager.get_root_main_window()
area = self.parent().dockWidgetArea(self)
new_parent.addDockWidget(area, self)
if floating:
self.setFloating(floating)
self.move(pos)
title_bar = self.titleBarWidget()
title_bar.restore_settings(settings)
if title_bar.hide_title_bar and not self.features() & DockWidget.DockWidgetFloatable and \
not self.features() & DockWidget.DockWidgetMovable:
self._title_bar_backup = title_bar
title_widget = QWidget(self)
layout = QHBoxLayout(title_widget)
layout.setContentsMargins(0, 0, 0, 0)
title_widget.setLayout(layout)
self.setTitleBarWidget(title_widget)
class PropStatus(Plugin):
def __init__(self, context):
super(PropStatus, self).__init__(context)
self.setObjectName('Status')
self._widget = QWidget()
loadUi(os.path.join(uipath, 'propagatorstatus.ui'), self._widget)
context.add_widget(self._widget)
rospy.Subscriber('/thrusters/info',ThrusterInfo,motordriver_callback)
rospy.Subscriber('/skytraq_serial',SerialPacket,gps_callback)
rospy.Subscriber('/imu/data_raw',Imu,imu_callback)
rospy.Subscriber('/scan',LaserScan,lidar_callback)
rospy.Subscriber('/mv_bluefox_camera_node/image_raw',Image,camera_callback)
rospy.Timer(rospy.Duration(2),kill)
self._update_timer = QTimer(self._widget)
self._update_timer.timeout.connect(self._on_update)
self._update_timer.start(100)
def _on_update(self):
self._widget.findChild(QListWidget, 'list').clear()
for i in ['FR','FL','BR','BL','GPS','IMU','LIDAR','CAMERA']:
pItem = QListWidgetItem(i);
if i in active:
pItem.setBackground(Qt.green);
else:
pItem.setBackground(Qt.red);
self._widget.findChild(QListWidget, 'list').addItem(pItem)
def __init__(self, parent=None):
QWidget.__init__(self, parent)
self.setObjectName("MainBox")
self.__on_intern_change = False
boxLayout = QFormLayout()
boxLayout.setVerticalSpacing(0)
self.setLayout(boxLayout)
class MyPlugin(Plugin):
def __init__(self, context):
super(MyPlugin, self).__init__(context)
# Give QObjects reasonable names
self.setObjectName('MyPlugin')
# 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
# Create QWidget
self._widget = QWidget()
# Get path to UI file which should be in the "resource" folder of this package
ui_file = os.path.join(rospkg.RosPack().get_path('rqt_mypkg'), 'resource', 'MyPlugin.ui')
# Extend the widget with all atrributes and children from UI File
loadUi(ui_file, self._widget)
# Give QObjects reasonable names
self._widget.setObjectName('MyPluginUi')
# Show _widget.windowTitle on left-top of each plugin(when it's set in _widget).
# This is useful when you open multiple plugins aat once. Also if you open multiple
# instances of your plugin at once, these lines add number to make it easy to
# tell from pane to pane.
if context.serial_number() > 1:
self._widget.setWindowTitle(self._widget.windowTitle() + (' %d' % context.serial_number()))
# Add widget to the user interface
context.add_widget(self._widget)
self._widget.cancelButton.clicked[bool].connect(self._handle_cancel_clicked)
self._widget.okButton.clicked[bool].connect(self._handle_ok_clicked)
def shutdown_plugin(self):
# TODO unregister all publishers here
pass
def save_settings(self, plugin_settings, instance_settings):
# TODO save intrinsic configuration, usually using:
# instance_settings.get_value(k, v)
pass
def restore_settings(self, pluign_settings, instance_settings):
# TODO restore intrinsic configuration, usually using:
# v = instance_settings.value(k)
pass
def _handle_cancel_clicked(self):
print "cancelButton is clicked"
def _handle_ok_clicked(self):
print "okButton is clicked"
class ExampleGuiPub(Plugin):
def __init__(self, context=None):
super(ExampleGuiPub, self).__init__(context)
# Give QObjects reasonable names
self.setObjectName('ExampleGuiPub')
# Create QWidget
self._widget = QWidget()
# Get path to UI file which is a sibling of this file
pkg_dir = roslib.packages.get_pkg_dir('example_gui_pub')
ui_file_path = os.path.join(pkg_dir, 'ui/example_gui_pub.ui')
# Extend the widget with all attributes and children from UI file
loadUi(ui_file_path, self._widget)
# Give QObjects reasonable names
self._widget.setObjectName('ExampleGuiPubUi')
# Show _widget.windowTitle on left-top of each plugin (when
# it's set in _widget). This is useful when you open multiple
# plugins at once. Also if you open multiple instances of your
# plugin at once, these lines add number to make it easy to
# tell from pane to pane.
if context.serial_number() > 1:
self._widget.setWindowTitle(self._widget.windowTitle() + (' (%d)' % context.serial_number()))
# Add widget to the user interface
context.add_widget(self._widget)
# Now Set up our own interface:
# ==> Connect the buttons to the functions
self._widget.btn_ok.clicked.connect(self.btn_ok_clicked)
def shutdown_plugin(self):
"""Kill all subscribers and publishers."""
pass
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
def btn_ok_clicked(self):
#printing the word in the ui label box
spin_speed = 3.0
self._widget.StatusReturn.setText('set LIDAR speed to ' + str(spin_speed))
#publisher the data to multisense_sl
self.pub = rospy.Publisher('multisense_sl/set_spindle_speed', Float64, queue_size=10)
self.pub.publish(spin_speed)
class BalanceModeWidget(Plugin):
def __init__(self, context):
super(BalanceModeWidget, self).__init__(context)
# Give QObjects reasonable names
self.setObjectName('BalanceMode')
# 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
# Create QWidget
self._widget = QWidget()
# Get path to UI file which should be in the "resource" folder of this package
ui_file = os.path.join(rospkg.RosPack().get_path('rsv_balance_rqt'), 'resource', 'BalanceModeWidget.ui')
# Extend the widget with all attributes and children from UI file
loadUi(ui_file, self._widget)
# Give QObjects reasonable names
self._widget.setObjectName('BalanceModeWidgetUI')
# Numerated windowTitle
if context.serial_number() > 1:
self._widget.setWindowTitle(self._widget.windowTitle() + (' (%d)' % context.serial_number()))
# Add widget to the user interface
context.add_widget(self._widget)
self._widget.set_park.clicked[bool].connect(self.on_set_park_button)
self._widget.set_tractor.clicked[bool].connect(self.on_set_tractor_button)
self._widget.set_balance.clicked[bool].connect(self.on_set_balance_button)
self._widget.topic_line_edit.textChanged.connect(self.on_topic_changed)
# Set mode client
self.set_mode_srv = None
self.on_topic_changed()
def shutdown_plugin(self):
pass
def save_settings(self, plugin_settings, instance_settings):
instance_settings.set_value('topic', self._widget.topic_line_edit.text())
def restore_settings(self, plugin_settings, instance_settings):
value = instance_settings.value('topic', "/set_mode")
self._widget.topic_line_edit.setText(value)
def on_set_park_button(self):
try:
self.set_mode_srv(rsv_balance_msgs.srv.SetModeRequest.PARK)
except rospy.ServiceException, e:
rospy.logwarn("Service call failed: %s" % e)
class skeletonPlugin(Plugin):
def __init__(self, context):
super(skeletonPlugin, self).__init__(context)
# Give QObjects reasonable names
self.setObjectName('skeletonPlugin')
# 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
# Create QWidget
self._widget = QWidget()
# Get path to UI file which is a sibling of this file
# in this example the .ui and .py file are in the same folder
ui_file = os.path.join(os.path.dirname(os.path.realpath(__file__)), 'skeleton.ui')
# Extend the widget with all attributes and children from UI file
loadUi(ui_file, self._widget)
# Give QObjects reasonable names
self._widget.setObjectName('skeletonUi')
# Show _widget.windowTitle on left-top of each plugin (when
# it's set in _widget). This is useful when you open multiple
# plugins at once. Also if you open multiple instances of your
# plugin at once, these lines add number to make it easy to
# tell from pane to pane.
if context.serial_number() > 1:
self._widget.setWindowTitle(self._widget.windowTitle() + (' (%d)' % context.serial_number()))
# Add widget to the user interface
context.add_widget(self._widget)
def shutdown_plugin(self):
# TODO unregister all publishers here
pass
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
class CalibrationControl(Plugin):
def __init__(self, context):
super(CalibrationControl, self).__init__(context)
self.setObjectName('CalibrationControl')
# Argument parsing
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
# Create QWidget
self._widget = QWidget()
# Get path to UI file which is a sibling of this file
rp = rospkg.RosPack()
ui_file = os.path.join(rp.get_path('industrial_calibration_gui'), 'resource', 'calibration_control.ui')
loadUi(ui_file, self._widget)
# Give QObjects reasonable names
self._widget.setObjectName('calibration_control_Ui')
# Custom code begins here
self._widget.cal_button.clicked[bool].connect(self.__handle_cal_clicked)
self.cal_service = rospy.ServiceProxy('calibration_service', Empty)
# Add widget to the user interface
context.add_widget(self._widget)
def shutdown_plugin(self):
# TODO unregister all publishers here
pass
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
def __handle_cal_clicked(self, checked):
self.cal_service()
def _add_thruster_widget(self, id):
self._widget.findChild(QLabel, 'noThrustersLabel').setVisible(False)
thruster_widget = QWidget()
thruster_frame = self._widget.findChild(QFrame, 'thrusterFrame')
pos = sum(1 for existing_id in self._thruster_widgets if id > existing_id)
thruster_frame.layout().insertWidget(pos, thruster_widget)
loadUi(os.path.join(uipath, 'thruster.ui'), thruster_widget)
thruster_widget.findChild(QLabel, 'thrusterLabel').setText(id)
thruster_widget.findChild(QPushButton, 'offButton').clicked.connect(lambda: self._on_stop_clicked(id))
self._thruster_widgets[id] = thruster_widget
return thruster_widget
class RunStopPlugin(Plugin):
def __init__(self, context):
super(RunStopPlugin, self).__init__(context)
# Give QObjects reasonable names
self.setObjectName('RunStopPlugin')
# 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
# Create QWidget
self._widget = QWidget()
# Get path to UI file
ui_file = os.path.join(rospkg.RosPack().get_path('rqt_runstop'), 'src', 'rqt_runstop', 'runstop.ui')
# Extend the widget with all attributes and children from UI file
loadUi(ui_file, self._widget)
# Give QObjects reasonable names
self._widget.setObjectName('RunStopPluginUi')
# Show _widget.windowTitle on left-top of each plugin (when
# it's set in _widget). This is useful when you open multiple
# plugins at once. Also if you open multiple instances of your
# plugin at once, these lines add number to make it easy to
# tell from pane to pane.
if context.serial_number() > 1:
self._widget.setWindowTitle(self._widget.windowTitle() + (' (%d)' % context.serial_number()))
# Add widget to the user interface
context.add_widget(self._widget)
# initialize publisher to publish cancel messages
self._publisher = rospy.Publisher('move_base/cancel', GoalID, queue_size=10)
self._widget.runstopButton.clicked.connect(self.runstopButton_clicked) # button handler
# cancel all goals by sending empty goal to /move_base/cancel
def runstopButton_clicked(self):
emptyGoal = GoalID()
self._publisher.publish(emptyGoal)
return
class GhostRobotControlPlugin(Plugin):
updateStateSignal = Signal(object)
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 ghost_joint_states_cb(self, data):
self.ghost_joint_states = data
def real_joint_states_cb(self, data):
self.real_joint_states = data
def handle_set_real_to_ghost(self):
self.joint_states_to_ghost_pub.publish(self.real_joint_states)
@Slot(bool)
def handle_send_motion_plan_to_real_robot_check_box(self, checked):
self.move_real_robot = checked
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
def __init__(self, context,namespace = None):
# it is either "" or the input given at creation of plugin
self.namespace = self._parse_args(context.argv())
super(tabbedGUIPlugin, self).__init__(context)
# Give QObjects reasonable names
self.setObjectName('tabbedGUIPlugin')
# 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
# Create QWidget
self._widget = QWidget()
# Get path to UI file which is a sibling of this file
# in this example the .ui and .py file are in the same folder
ui_file = os.path.join(os.path.dirname(os.path.realpath(__file__)), 'tabbedGUI.ui')
# Extend the widget with all attributes and children from UI file
loadUi(ui_file, self._widget)
# Give QObjects reasonable names
self._widget.setObjectName('tabbedGUIUi')
# Show _widget.windowTitle on left-top of each plugin (when
# it's set in _widget). This is useful when you open multiple
# plugins at once. Also if you open multiple instances of your
# plugin at once, these lines add number to make it easy to
# tell from pane to pane.
if context.serial_number() > 1:
self._widget.setWindowTitle(self._widget.windowTitle() + (' (%d)' % context.serial_number()))
# Add widget to the user interface
context.add_widget(self._widget)
# # Adding all the tabs
self.saver_mavros = saver_mavrosPlugin(context,self.namespace)
# self.saver = saverPlugin(context,self.namespace)
self.positionPlot = positionPlotPlugin(context,self.namespace)
self.TrajectorySelection = TrajectorySelectionPlugin(context,self.namespace)
self.ChooseController = ChooseControllerPlugin(context,self.namespace)
self.ChooseSimulator = ChooseSimulatorPlugin(context,self.namespace)
self._widget.tabWidget.addTab(self.saver_mavros._widget,'Data recorder')
# self._widget.tabWidget.addTab(self.saver._widget,'Data recorder')
self._widget.tabWidget.addTab(self.positionPlot._widget,'Check Data')
self._widget.tabWidget.addTab(self.TrajectorySelection._widget,'Select Trajectory')
self._widget.tabWidget.addTab(self.ChooseController._widget,'Select Controller')
self._widget.tabWidget.addTab(self.ChooseSimulator._widget,'Select Simulator')
self._widget.tabWidget.show()
def __init__(self, context=None):
super(ExampleBtnGUI, self).__init__(context) # Initializes child and base
# Give QObjects reasonable names
self.setObjectName('ExampleBtnGUI')
# Create QWidget
self._widget = QWidget()
# Get path to UI file which is a sibling of this file
pkg_dir = roslib.packages.get_pkg_dir('example_button_gui')
ui_file_path = os.path.join(pkg_dir, 'ui/example_button_gui.ui')
# Extend the widget with all attributes and children from UI file
loadUi(ui_file_path, self._widget)
# Give QObjects reasonable names
self._widget.setObjectName('ExampleBtnGUIUi')
# Show _widget.windowTitle on left-top of each plugin (when
# it's set in _widget). This is useful when you open multiple
# plugins at once. Also if you open multiple instances of your
# plugin at once, these lines add number to make it easy to
# tell from pane to pane.
if context.serial_number() > 1:
self._widget.setWindowTitle(self._widget.windowTitle() + (' (%d)' % context.serial_number()))
# Add widget to the user interface
context.add_widget(self._widget)
# Now Set up our own interface:
# ==> Connect the buttons to the functions. simpleBtnDemo is defined in ui/example_button_gui.ui
self._widget.simpleBtnDemo.clicked.connect(self.btn_clicked_CB)
def __init__(self, context):
super(MultiRobotPasserGUIPlugin, self).__init__(context)
# Give QObjects reasonable names
self.setObjectName('MultiRobotPasserGUIPlugin')
# Create QWidget
self.widget = QWidget()
self.master_layout = QVBoxLayout(self.widget)
self.buttons = {}
self.button_layout = QHBoxLayout()
self.master_layout.addLayout(self.button_layout)
for button_text in ["Enable", "Disable"]:
button = QPushButton(button_text, self.widget)
button.clicked[bool].connect(self.handle_button)
button.setCheckable(True)
self.button_layout.addWidget(button)
self.buttons[button_text] = button
self.widget.setObjectName('MultiRobotPasserGUIPluginUI')
if context.serial_number() > 1:
self.widget.setWindowTitle(self._widget.windowTitle() + (' (%d)' % context.serial_number()))
context.add_widget(self.widget)
self.status_subscriber = rospy.Subscriber("status", Bool, self.status_callback)
self.enable = rospy.ServiceProxy("enable", Empty)
self.disable = rospy.ServiceProxy("disable", Empty)
self.enabled = False
self.connect(self.widget, SIGNAL("update"), self.update)
def __init__(self, context):
super(MyPlugin, self).__init__(context)
# Give QObjects reasonable names
self.setObjectName('MyPlugin')
# 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
# Create QWidget
self._widget = QWidget()
# Get path to UI file which should be in the "resource" folder of this package
ui_file = os.path.join(rospkg.RosPack().get_path('my_rqt_pkg'), 'resource', 'MyPlugin.ui')
# Extend the widget with all attributes and children from UI file
loadUi(ui_file, self._widget)
# Give QObjects reasonable names
self._widget.setObjectName('MyPluginUi')
# Show _widget.windowTitle on left-top of each plugin (when
# it's set in _widget). This is useful when you open multiple
# plugins at once. Also if you open multiple instances of your
# plugin at once, these lines add number to make it easy to
# tell from pane to pane.
if context.serial_number() > 1:
self._widget.setWindowTitle(self._widget.windowTitle() + (' (%d)' % context.serial_number()))
# Add widget to the user interface
context.add_widget(self._widget)
def __init__(self, context):
super(WoZPlugin, self).__init__(context)
self._widget = QWidget()
self._widget.setFixedSize(600, 600)
QtGui.QToolTip.setFont(QtGui.QFont('SansSerif', 10))
large_box = QtGui.QVBoxLayout()
#Button for outreaching to recieve book from Human
button_box = QtGui.QVBoxLayout()
box_1 = QtGui.QHBoxLayout()
box_2 = QtGui.QHBoxLayout()
box_3 = QtGui.QHBoxLayout()
box_4 = QtGui.QHBoxLayout()
box_5 = QtGui.QHBoxLayout()
box_6 = QtGui.QHBoxLayout()
box_7 = QtGui.QHBoxLayout()
box_8 = QtGui.QHBoxLayout()
box_9 = QtGui.QHBoxLayout()
box_10 = QtGui.QHBoxLayout()
box_1.addWidget(self.create_button('print nice', self.printCallback))
self._widget.setObjectName('TrashbotGUI')
self._widget.setLayout(large_box)
context.add_widget(self._widget)
def __init__(self, context):
super(utilityPlugin, self).__init__(context)
# Give QObjects reasonable names
self.setObjectName("utilityPlugin")
# 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
# Create QWidget
self._widget = QWidget()
# Get path to UI file which is a sibling of this file
# in this example the .ui and .py file are in the same folder
ui_file = os.path.join(os.path.dirname(os.path.realpath(__file__)), "utility.ui")
# Extend the widget with all attributes and children from UI file
loadUi(ui_file, self._widget)
# Give QObjects reasonable names
self._widget.setObjectName("utilityUi")
# Show _widget.windowTitle on left-top of each plugin (when
# it's set in _widget). This is useful when you open multiple
# plugins at once. Also if you open multiple instances of your
# plugin at once, these lines add number to make it easy to
# tell from pane to pane.
if context.serial_number() > 1:
self._widget.setWindowTitle(self._widget.windowTitle() + (" (%d)" % context.serial_number()))
# Add widget to the user interface
context.add_widget(self._widget)
self.ID = 0
self.State = QuadPositionDerived()
self.Target = QuadPositionDerived()
self.sub = ""
self.name = ""
self.pwd = os.environ["PWD"]
self._widget.IrisInputBox.insertItems(0, ["iris1", "iris2", "iris3", "iris4", "iris5"])
self._widget.bStart.clicked.connect(self.Start)
self._widget.GravityCancelButton.clicked.connect(self.adjust_gravity_cancel)
self._widget.XBox.setMinimum(-10.0)
self._widget.XBox.setMaximum(10.0)
self._widget.XBox.setSingleStep(0.1)
self._widget.YBox.setMinimum(-10.0)
self._widget.YBox.setMaximum(10.0)
self._widget.YBox.setSingleStep(0.1)
self._widget.ZBox.setMinimum(-10.0)
self._widget.ZBox.setMaximum(10.0)
self._widget.ZBox.setSingleStep(0.1)
self._widget.GravitySpinBox.setMaximum(1800)
self._widget.GravitySpinBox.setMinimum(1200)
self._widget.GravitySpinBox.setSingleStep(10)
self._widget.GravitySpinBox.setValue(1500)
def __init__(self, context):
super(Builder, self).__init__(context)
self.setObjectName('BeetreeBuilder')
# Create QWidget
self._widget = QWidget()
# Get path to UI file which is a sibling of this file
rospack = rospkg.RosPack()
ui_path = rospack.get_path('beetree_builder') + '/ui/main.ui'
# Load the ui attributes into the main widget
loadUi(ui_path, self._widget)
self._widget.setObjectName('BeetreeBuilderPluginUi')
# Show _widget.windowTitle on left-top of each plugin (when
# it's set in _widget). This is useful when you open multiple
# plugins at once. Also if you open multiple instances of your
# plugin at once, these lines add number to make it easy to
# tell from pane to pane.
if context.serial_number() > 1:
self._widget.setWindowTitle(self._widget.windowTitle() + (' (%d)' % context.serial_number()))
# Add widget to the user interface
context.add_widget(self._widget)
palette = QPalette ()
palette.setColor(QPalette.Background, Qt.white)
self._widget.setPalette(palette)
# Add custom options
self._widget.node_type_list.addItems(['test1','test2'])
def __init__(self):
super(TopicSelection, self).__init__()
master = rosgraph.Master('rqt_bag_recorder')
self.setWindowTitle("Select the topics you want to record")
self.resize(500, 700)
self.topic_list = []
self.selected_topics = []
self.items_list = []
self.area = QScrollArea(self)
self.main_widget = QWidget(self.area)
self.ok_button = QPushButton("Record", 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.item_all = QCheckBox("All", self)
self.item_all.stateChanged.connect(self.updateList)
self.selection_vlayout.addWidget(self.item_all)
topic_data_list = master.getPublishedTopics('')
topic_data_list.sort()
for topic, datatype in topic_data_list:
self.addCheckBox(topic)
self.main_widget.setLayout(self.selection_vlayout)
self.area.setWidget(self.main_widget)
self.show()
def __init__(self, context, service_name):
self._service_name = service_name
self._service = rosservice.get_service_class_by_name(self._service_name)
self._service_proxy = rospy.ServiceProxy(self._service_name, self._service)
self._widget = QWidget()
rp = rospkg.RosPack()
ui_file = os.path.join(rp.get_path('rqt_copter'), 'resource', 'SrvWidget.ui')
loadUi(ui_file, self._widget)
context.addWidget(self._widget)
self._widget.service_label.setText("Service " + self._service_name)
self._request = self._service._request_class()
self._inputs = []
for slot_name, type_name in zip(self._request.__slots__, self._request._slot_types):
if type_name in ["float32", "float64"]:
self._inputs.append(FloatInputWidget(self._widget.input_container, slot_name))
elif type_name in ["int8", "uint8", "int16", "uint16", "int32", "uint32", "int64", "uint64"]:
self._inputs.append(IntInputWidget(self._widget.input_container, slot_name))
elif type_name in ["string"]:
self._inputs.append(StringInputWidget(self._widget.input_container, slot_name))
else:
print "Service input type", type_name, "needs to be implemented!"
print "Service", self._service_name, "is not available."
self._widget.close()
self._widget.apply_button.clicked.connect(self._init_msf)
def __init__(self, context,namespace = None):
# it is either "" or the input given at creation of plugin
self.namespace = self._parse_args(context.argv())
super(saverPlugin, self).__init__(context)
# Give QObjects reasonable names
self.setObjectName('saverPlugin')
# 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
# Create QWidget
self._widget = QWidget()
# Get path to UI file which is a sibling of this file
# in this example the .ui and .py file are in the same folder
ui_file = os.path.join(os.path.dirname(os.path.realpath(__file__)), 'saver.ui')
# Extend the widget with all attributes and children from UI file
loadUi(ui_file, self._widget)
# Give QObjects reasonable names
self._widget.setObjectName('saverUi')
# Show _widget.windowTitle on left-top of each plugin (when
# it's set in _widget). This is useful when you open multiple
# plugins at once. Also if you open multiple instances of your
# plugin at once, these lines add number to make it easy to
# tell from pane to pane.
if context.serial_number() > 1:
self._widget.setWindowTitle(self._widget.windowTitle() + (' (%d)' % context.serial_number()))
# Add widget to the user interface
context.add_widget(self._widget)
# ---------------------------------------------- #
# ---------------------------------------------- #
# BUTTON TO START EXPERIMENT
self._widget.ButtonSTART_SIM.stateChanged.connect(self.StartSimulatorService)
# Button to Reset Simulator
self._widget.ResetSimulator.clicked.connect(self.ResetSimulator)
# BUTTON TO CONNECT TO QUALISYS
self._widget.Qualisys.stateChanged.connect(self.QualisysConnect)
# BUTTON TO CHANGE ID
self._widget.changeID.clicked.connect(self.changeID)
# Default Value for Id of Quad (as in QUALISYS computer)
self._widget.ID.setValue(13)
def __init__(self, context):
super(RQTNavigation, self).__init__(context)
# Give QObjects reasonable names
self.setObjectName('Navigation')
# Create QWidget
self._widget = QWidget()
ui_file = os.path.join(os.path.dirname(os.path.realpath(__file__)), 'rqt_navigation.ui')
loadUi(ui_file, self._widget)
self._widget.setObjectName('rqt_navigation')
# Show _widget.windowTitle on left-top of each plugin (when
# it's set in _widget). This is useful when you open multiple
# plugins at once. Also if you open multiple instances of your
# plugin at once, these lines add number to make it easy to
# tell from pane to pane.
if context.serial_number() > 1:
self._widget.setWindowTitle(self._widget.windowTitle() + (' (%d)' % context.serial_number()))
# Add widget to the user interface
context.add_widget(self._widget)
self.loadComboBoxItems()
# ROS stuff
self.veh = rospy.get_param('/veh')
self.topic_name = '/' + self.veh + '/actions_dispatcher_node/plan_request'
self.pub = rospy.Publisher(self.topic_name,SourceTargetNodes, queue_size = 1, latch=True)
self._widget.buttonFindPlan.clicked.connect(self.requestPlan)
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, 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 __init__(self, timeline_frame):
QWidget.__init__(self)
self.timeline_frame = timeline_frame
rp = rospkg.RosPack()
ui_file = os.path.join(rp.get_path('rqt_bag_annotation'), 'resource', 'annotation_widget.ui')
loadUi(ui_file, self)
self.setObjectName('AnnotationWidget')
rd_file = os.path.join(rp.get_path('turtlebot_description'), 'robots', 'kobuki_hexagons_kinect.urdf.xacro')
a = xacro.parse(rd_file)
xacro.process_includes(a, rd_file)
xacro.eval_self_contained(a)
rospy.set_param('robot_description', a.toxml())
self._cur_annotation = None
self.save_button.clicked[bool].connect(self.save)
def __init__(self, context):
super(LevelSelectorPlugin, self).__init__(context)
# Give QObjects reasonable names
self.setObjectName('LevelSelectorPlugin')
# Create QWidget
self._widget = QWidget()
# self._widget.setFont(QFont("Times", 15, QFont.Bold))
self._button_layout = QVBoxLayout(self._widget)
self.buttons = []
self.text_label = QLabel("Waiting for MultiLevelMapData...", self._widget)
self._button_layout.addWidget(self.text_label)
self._widget.setObjectName('LevelSelectorPluginUI')
if context.serial_number() > 1:
self._widget.setWindowTitle(self._widget.windowTitle() + (' (%d)' % context.serial_number()))
context.add_widget(self._widget)
self.connect(self._widget, SIGNAL("update_buttons"), self.update_buttons)
self.connect(self._widget, SIGNAL("update_button_status"), self.update_button_status)
# Subcribe to the multi level map data to get information about all the maps.
self.multimap_subscriber = rospy.Subscriber("map_metadata", MultiLevelMapData, self.process_multimap)
self.levels = []
self.current_level = None
# Subscribe to the current level we are on.
self.status_subscriber = None
# Create a service proxy to change the current level.
self.level_selector_proxy = rospy.ServiceProxy("level_mux/change_current_level", ChangeCurrentLevel)
self.level_selector_proxy.wait_for_service()
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 __init__(self, context):
super(ActuatorPlugin, self).__init__(context)
self.setObjectName("ActuatorPlugin")
self._widget = QWidget()
loadUi(os.path.join(uipath, "actuatorplugin.ui"), self._widget)
context.add_widget(self._widget)
self._setvalve = rospy.ServiceProxy("actuator_driver/set_valve", SetValve)
self._pulsevalve = rospy.ServiceProxy("actuator_driver/pulse_valve", PulseValve)
self._switches_sub = rospy.Subscriber(
"actuator_driver/switches", Switches, lambda msg: self.switches_changed.emit(msg)
)
self.switches_changed.connect(self._on_switches_changed)
self._widget.findChild(QPushButton, "shootLeftButton").clicked.connect(
lambda: self._pulsevalve(VALVE_SHOOTER_LEFT, rospy.Duration(0.3))
)
self._widget.findChild(QPushButton, "shootRightButton").clicked.connect(
lambda: self._pulsevalve(VALVE_SHOOTER_RIGHT, rospy.Duration(0.3))
)
self._widget.findChild(QPushButton, "extendButton").clicked.connect(
lambda: self._setvalve(VALVE_GAS_POWERED_STICK, True)
)
self._widget.findChild(QPushButton, "retractButton").clicked.connect(
lambda: self._setvalve(VALVE_GAS_POWERED_STICK, False)
)
self._widget.findChild(QPushButton, "openButton").clicked.connect(self._open_grabber)
self._widget.findChild(QPushButton, "closeButton").clicked.connect(self._close_grabber)
self._widget.findChild(QPushButton, "dropButton").clicked.connect(
lambda: self._pulsevalve(VALVE_DROPPER, rospy.Duration(0.5))
)
self._widget.findChild(QPushButton, "shutAllValvesButton").clicked.connect(self._shut_valves)
class MyPlugin(Plugin):
def __init__(self, context):
super(MyPlugin, self).__init__(context)
self.setObjectName('MyPlugin')
from argparse import ArgumentParser
parser = ArgumentParser()
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
# Create QWidget
self._widget = QWidget()
# Get path to UI file which should be in the "resource" folder of this package
ui_file = os.path.join(rospkg.RosPack().get_path('rqt_pkg'), 'resource', 'MyPlugin.ui')
# Extend the widget with all attributes and children from UI file
loadUi(ui_file, self._widget)
# Give QObjects reasonable names
self._widget.setObjectName('MyPluginUi')
# Show _widget.windowTitle on left-top of each plugin (when
# it's set in _widget). This is useful when you open multiple
# plugins at once. Also if you open multiple instances of your
# plugin at once, these lines add number to make it easy to
# tell from pane to pane.
if context.serial_number() > 1:
self._widget.setWindowTitle(self._widget.windowTitle() + (' (%d)' % context.serial_number()))
# Add widget to the user interface
context.add_widget(self._widget)
def shutdown_plugin(self):
# TODO unregister all publishers here
pass
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
def __init__(self, context=None):
super(ExampleGui2, self).__init__(context)
# Give QObjects reasonable names
self.setObjectName('ExampleGui2')
# 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
# Create QWidget
self._widget = QWidget()
# Get path to UI file which is a sibling of this file
pkg_dir = roslib.packages.get_pkg_dir('example_gui2')
ui_file_path = os.path.join(pkg_dir, 'ui/example_gui2.ui')
# Extend the widget with all attributes and children from UI file
loadUi(ui_file_path, self._widget)
# Give QObjects reasonable names
self._widget.setObjectName('ExampleGuiUi')
# Show _widget.windowTitle on left-top of each plugin (when
# it's set in _widget). This is useful when you open multiple
# plugins at once. Also if you open multiple instances of your
# plugin at once, these lines add number to make it easy to
# tell from pane to pane.
if context.serial_number() > 1:
self._widget.setWindowTitle(self._widget.windowTitle() +
(' (%d)' % context.serial_number()))
# Add widget to the user interface
context.add_widget(self._widget)
# Now Set up our own interface:
# ==> Connect the buttons to the functions
self._widget.btn_ok.clicked.connect(self.btn_ok_clicked)
def __init__(self, context):
super(VelocityControl, self).__init__(context)
# Give QObjects reasonable names
self.setObjectName('VelocityControl')
# 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())
# Create QWidget
self._widget = QWidget()
# Get path to UI file which is a sibling of this file
# in this example the .ui and .py file are in the same folder
#ui_file = os.path.join(os.path.dirname(os.path.realpath(__file__)), 'MyPlugin.ui')
# Extend the widget with all attributes and children from UI file
#loadUi(ui_file, self._widget)
# Give QObjects reasonable names
self._widget.setObjectName('VelocityControlUi')
vLayout = QVBoxLayout(self._widget)
vLayout.setContentsMargins(0, 0, 0, 0)
vLayout.setSpacing(0)
self._widget.setLayout(vLayout)
self._widget.layout().setSpacing(0)
self._widget.setWindowTitle("VelocityControl");
# Show _widget.windowTitle on left-top of each plugin (when
# it's set in _widget). This is useful when you open multiple
# plugins at once. Also if you open multiple instances of your
# plugin at once, these lines add number to make it easy to
# tell from pane to pane.
if context.serial_number() > 1:
self._widget.setWindowTitle(self._widget.windowTitle() + (' (%d)' % context.serial_number()))
# Add widget to the user interface
context.add_widget(self._widget)
self.context = context
self._topic_list = ''
self._topic_commands = {}
self._jointgroups = {}
self.signal_topic.connect( self.signal_callback_list )
rospy.on_shutdown(self.on_ros_shutdown) #handle the ROS shutdown commands
class MasterInfo(Plugin):
def __init__(self, context):
super(MasterInfo, self).__init__(context)
self.initialised = False
self.setObjectName('MasterInfo')
self._current_dotcode = None
self._master_info = rocon_master_info.get_master_info(0.5) # at worst a small timeout here, but perhaps should be run in a thread.
self._widget = QWidget()
self._widget.setObjectName('RoconMasterInfoUi')
rospack = rospkg.RosPack()
ui_file = os.path.join(rospack.get_path('rocon_qt_master_info'), 'ui', 'master_info.ui')
loadUi(ui_file, self._widget)
if context.serial_number() > 1:
self._widget.setWindowTitle(self._widget.windowTitle() + (' (%d)' % context.serial_number()))
pixmap = QPixmap()
pixmap.loadFromData(self._master_info.icon.data, format=self._master_info.icon.format)
self._widget.icon_label.setPixmap(pixmap)
self._widget.icon_label.resize(pixmap.width(), pixmap.height())
self._widget.info_label.resize(200, pixmap.height())
self._widget.info_label.setText("<b>Name:</b> %s<br/><b>Rocon Version:</b> %s<br/><b>Description:</b> %s" % (self._master_info.name, self._master_info.version, self._master_info.description))
self._widget.adjustSize()
context.add_widget(self._widget)
def shutdown_plugin(self):
pass
def _create_buttons(self):
# create the buttons line
self.buttons = QWidget(self)
self.horizontalLayout = QHBoxLayout(self.buttons)
self.horizontalLayout.setContentsMargins(4, 0, 4, 0)
self.horizontalLayout.setObjectName("horizontalLayout")
# add the search button
self.searchButton = QPushButton(self)
self.searchButton.setObjectName("searchButton")
# self.searchButton.clicked.connect(self.on_shortcut_find)
self.searchButton.toggled.connect(self.on_toggled_find)
self.searchButton.setText(self._translate("&Find"))
self.searchButton.setToolTip('Open a search dialog (Ctrl+F)')
self.searchButton.setFlat(True)
self.searchButton.setCheckable(True)
self.horizontalLayout.addWidget(self.searchButton)
# add the replace button
self.replaceButton = QPushButton(self)
self.replaceButton.setObjectName("replaceButton")
# self.replaceButton.clicked.connect(self.on_shortcut_replace)
self.replaceButton.toggled.connect(self.on_toggled_replace)
self.replaceButton.setText(self._translate("&Replace"))
self.replaceButton.setToolTip('Open a search&replace dialog (Ctrl+R)')
self.replaceButton.setFlat(True)
self.replaceButton.setCheckable(True)
self.horizontalLayout.addWidget(self.replaceButton)
# add the goto button
self.gotoButton = QPushButton(self)
self.gotoButton.setObjectName("gotoButton")
self.gotoButton.clicked.connect(self.on_shortcut_goto)
self.gotoButton.setText(self._translate("&Goto line"))
self.gotoButton.setShortcut("Ctrl+G")
self.gotoButton.setToolTip('Open a goto dialog (Ctrl+G)')
self.gotoButton.setFlat(True)
self.horizontalLayout.addWidget(self.gotoButton)
# add a tag button
self.tagButton = self._create_tag_button(self)
self.horizontalLayout.addWidget(self.tagButton)
# add spacer
spacerItem = QSpacerItem(515, 20, QSizePolicy.Expanding, QSizePolicy.Minimum)
self.horizontalLayout.addItem(spacerItem)
# add line number label
self.pos_label = QLabel()
self.horizontalLayout.addWidget(self.pos_label)
# add spacer
spacerItem = QSpacerItem(515, 20, QSizePolicy.Expanding, QSizePolicy.Minimum)
self.horizontalLayout.addItem(spacerItem)
# add save button
self.saveButton = QPushButton(self)
self.saveButton.setObjectName("saveButton")
self.saveButton.clicked.connect(self.on_saveButton_clicked)
self.saveButton.setText(self._translate("&Save"))
self.saveButton.setShortcut("Ctrl+S")
self.saveButton.setToolTip('Save the changes to the file (Ctrl+S)')
self.saveButton.setFlat(True)
self.horizontalLayout.addWidget(self.saveButton)
return self.buttons
def paintEvent(self, event):
contents_y = self.edit.verticalScrollBar().value()
page_bottom = contents_y + self.edit.viewport().height()
font_metrics = self.fontMetrics()
current_block = self.edit.document().findBlock(
self.edit.textCursor().position())
painter = QPainter(self)
painter.setPen(Qt.darkGray)
line_count = 0
# Iterate over all text blocks in the document.
block = self.edit.document().begin()
while block.isValid():
line_count += 1
# the top left position of the block in the document
position = self.edit.document().documentLayout(
).blockBoundingRect(block).topLeft()
# check if the position of the block is out side of visible area
if position.y() > page_bottom:
break
# we want the line number for the selected line to be bold.
bold = False
if block == current_block:
bold = True
font = painter.font()
font.setBold(True)
painter.setFont(font)
painter.setPen(Qt.black)
# Draw the line number right justified at the y position of the
# line. 3 is the magic padding number. drawText(x, y, text)
painter.drawText(
self.width() - font_metrics.width(str(line_count)) - 3,
round(position.y()) - contents_y + font_metrics.ascent() +
self.edit.document().documentMargin(), str(line_count))
if bold:
font = painter.font()
font.setBold(False)
painter.setFont(font)
painter.setPen(Qt.darkGray)
block = block.next()
self.highest_line = line_count
painter.end()
QWidget.paintEvent(self, event)
def __init__(self, parent=None, subscribe=False):
QWidget.__init__(self, parent)
# start widget
vbox = QVBoxLayout()
vbox.setMargin(0)
vbox.setContentsMargins(0, 0, 0, 0)
# add error status text edit
self.error_status_text_box = QErrorStatusTextBox()
self.error_status_text_box_layout = QHBoxLayout()
self.error_status_text_box_layout.addWidget(self.error_status_text_box)
vbox.addLayout(self.error_status_text_box_layout)
# add panel
hbox = QHBoxLayout()
# clear push button
self.execute_command = QPushButton("Clear")
self.execute_command.clicked.connect(self.error_status_text_box.clear)
hbox.addWidget(self.execute_command)
hbox.addStretch()
# hide window checkbox
hide_window_check_box = QCheckBox("Hide")
hide_window_check_box.stateChanged.connect(self.state_changed)
hbox.addWidget(hide_window_check_box)
# end panel
vbox.addLayout(hbox)
# end widget
self.setLayout(vbox)
#self.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Minimum)
# subscriber
if subscribe:
self.error_status_sub = rospy.Subscriber("error_status", ErrorStatus, self.error_status_callback)
self.subscribed = subscribe
# connect signal slot internally to prevent crash by subscriber
self.error_status_signal.connect(self.append_error_status)
def __init__(self, context):
super(PyConsole, self).__init__(context)
self.setObjectName('PyConsole')
self._context = context
self._use_spyderlib = _has_spyderlib
self._console_widget = None
self._widget = QWidget()
self._widget.setLayout(QVBoxLayout())
self._widget.layout().setContentsMargins(0, 0, 0, 0)
if context.serial_number() > 1:
self._widget.setWindowTitle(self._widget.windowTitle() +
' (%d)' % context.serial_number())
self._context.add_widget(self._widget)
self.dg_actif = "The dynamic graph is running."
self.dg_inactif = "The dynamic graph is NOT running."
self.dg_button = DynamicGraphButton(self._widget)
self._widget.layout().addWidget(self.dg_button)
def __init__(self, context):
self._context = context
super(AdminApp, self).__init__(context)
self.initialised = False
self.setObjectName('Admin App')
self.is_setting_dlg_live = False
self._widget = QWidget()
rospack = rospkg.RosPack()
ui_file = os.path.join(rospack.get_path('rocon_admin_app'), 'ui',
'admin_app.ui')
self._widget.setObjectName('AdminApphUi')
loadUi(ui_file, self._widget, {})
if context.serial_number() > 1:
self._widget.setWindowTitle(self._widget.windowTitle() +
(' (%d)' % context.serial_number()))
self._widget.enable_btn.pressed.connect(self._enable_service)
self._widget.disable_btn.pressed.connect(self._disable_service)
self._widget.setting_btn.pressed.connect(self._setting_service)
self._widget.refresh_btn.pressed.connect(self._refresh_service)
self._widget.clear_btn.pressed.connect(self._clear_service_list)
self._widget.service_tree_widget.itemClicked.connect(
self._select_service_tree_item) #concert item click event
self._refresh_service_list_signal.connect(self._update_service_list)
#Not implementation
self._widget.clear_btn.setDisabled(True)
self._widget.setting_btn.setDisabled(True)
self._widget.setting_btn.setToolTip("Not yet")
self._widget.clear_btn.setToolTip("Not yet")
context.add_widget(self._widget)
#init
self.admin_app_info = AdminAppInfo()
self.admin_app_info._reg_event_callback(self._refresh_service)
self.current_service = ""
self._widget.client_tab_widget.clear()
self._update_service_list()
def __init__(self, context):
super(RoomDialogPlugin, self).__init__(context)
# Give QObjects reasonable names
self.setObjectName('RoomDialogPlugin')
font_size = rospy.get_param("~font_size", 30)
# Create QWidget
self._widget = QWidget()
self._widget.setFont(QFont("Times", font_size, QFont.Bold))
self._layout = QVBoxLayout(self._widget)
self._text_browser = QTextBrowser(self._widget)
self._layout.addWidget(self._text_browser)
self._button_layout = QGridLayout()
self._layout.addLayout(self._button_layout)
# rospy.loginfo("Hello world")
# Add combobox
self._cb_layout = QHBoxLayout()
self._cb = QComboBox()
self._layout.addLayout(self._cb_layout)
#layout = QVBoxLayout(self._widget)
#layout.addWidget(self._button)
self._widget.setObjectName('RoomDialogPluginUI')
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('room_dialog', RoomDialog,
self.service_callback)
self.response_ready = False
self.response = None
self.buttons = []
self.text_label = None
self.text_input = None
# Add combo options
self.connect(self._widget, SIGNAL("update"), self.update)
self.connect(self._widget, SIGNAL("timeout"), self.timeout)
def __init__(self, context):
super(MyGUI, self).__init__(context)
# Give QObjects reasonable names
self.setObjectName('MyGUI')
# 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
# Create QWidget
self._widget = QWidget()
# Get path to UI file which is a sibling of this file
# in this example the .ui and .py file are in the same folder
ui_file = os.path.join(os.path.dirname(os.path.realpath(__file__)), 'BARC_experiment.ui')
# Extend the widget with all attributes and children from UI file
loadUi(ui_file, self._widget)
# Give QObjects reasonable names
self._widget.setObjectName('MyGUIUi')
# Show _widget.windowTitle on left-top of each plugin (when
# it's set in _widget). This is useful when you open multiple
# plugins at once. Also if you open multiple instances of your
# plugin at once, these lines add number to make it easy to
# tell from pane to pane.
if context.serial_number() > 1:
self._widget.setWindowTitle(self._widget.windowTitle() + (' (%d)' % context.serial_number()))
# Add widget to the user interface
context.add_widget(self._widget)
self._widget.pushbutton_record.clicked[bool].connect(self._handle_record)
self.record_started = False
self.setup_topics_list()
self.p = None
self.initialize()
def __init__(self, context):
super(SMInterfaceGUI, self).__init__(context)
# Give QObjects reasonable names
self.setObjectName('SMInterfaceGUI')
# 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
# Create QWidget
self._widget = QWidget()
# Get path to UI file which is a sibling of this file
# in this example the .ui and .py file are in the same folder
ui_file = os.path.join(os.path.dirname(os.path.realpath(__file__)), 'sm_interface.ui')
# Extend the widget with all attributes and children from UI file
loadUi(ui_file, self._widget)
# Give QObjects reasonable names
self._widget.setObjectName('SMInterfaceUi')
# Show _widget.windowTitle on left-top of each plugin (when
# it's set in _widget). This is useful when you open multiple
# plugins at once. Also if you open multiple instances of your
# plugin at once, these lines add number to make it easy to
# tell from pane to pane.
if context.serial_number() > 1:
self._widget.setWindowTitle(self._widget.windowTitle() + (' (%d)' % context.serial_number()))
# Add widget to the user interface
context.add_widget(self._widget)
# Custom code begins here
self._widget.start_button.clicked[bool].connect(self.__handle_start_clicked)
self._widget.stop_button.clicked[bool].connect(self.__handle_stop_clicked)
self._widget.reset_button.clicked[bool].connect(self.__handle_reset_clicked)
self.cmd_service = rospy.ServiceProxy('external_command', StateMachineCmd)
self.sm_status_sub = rospy.Subscriber('state_machine_status', StateMachineStatus, self.__sm_status_callback)
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
def __init__(self, context):
super(MyPlugin, self).__init__(context)
# Give QObjects reasonable names
self.setObjectName('MyPlugin')
# 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
# Create QWidget
self._widget = QWidget()
# Get path to UI file which should be in the "resource" folder of this package
ui_file = os.path.join(os.path.dirname(os.path.realpath(__file__)),
'MyPlugin.ui')
# Extend the widget with all attributes and children from UI file
loadUi(ui_file, self._widget)
# Give QObjects reasonable names
self._widget.setObjectName('MyPluginUi')
# Show _widget.windowTitle on left-top of each plugin (when
# it's set in _widget). This is useful when you open multiple
# plugins at once. Also if you open multiple instances of your
# plugin at once, these lines add number to make it easy to
# tell from pane to pane.
self._widget.pushButton.clicked.connect(self.callbackFunction)
if context.serial_number() > 1:
self._widget.setWindowTitle(self._widget.windowTitle() +
(' (%d)' % context.serial_number()))
# Add widget to the user interface
context.add_widget(self._widget)
def __init__(self, context, parameter_name):
self._parameter_name = parameter_name
self._widget = QWidget()
rp = rospkg.RosPack()
ui_file = os.path.join(rp.get_path('rqt_copter'), 'resource',
'StringInputWidget.ui')
loadUi(ui_file, self._widget)
context.addWidget(self._widget)
self._widget.input_label.setText("Change " + self._parameter_name)
def __init__(self, context):
super(Packml, self).__init__(context)
self.setObjectName('Packml')
from argparse import ArgumentParser
parser = ArgumentParser()
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
# Create QWidget
self._widget = QWidget()
ui_file = os.path.join(rospkg.RosPack().get_path('packml_gui'), 'resource', 'packml.ui')
loadUi(ui_file, self._widget)
self._widget.setObjectName('Packml')
if context.serial_number() > 1:
self._widget.setWindowTitle(self._widget.windowTitle() + (' (%d)' % context.serial_number()))
context.add_widget(self._widget)
# Custom code begins here
self._widget.reset_button.clicked[bool].connect(self.__handle_reset_clicked)
self._widget.start_button.clicked[bool].connect(self.__handle_start_clicked)
self._widget.stop_button.clicked[bool].connect(self.__handle_stop_clicked)
self._widget.clear_button.clicked[bool].connect(self.__handle_clear_clicked)
self._widget.hold_button.clicked[bool].connect(self.__handle_hold_clicked)
self._widget.unhold_button.clicked[bool].connect(self.__handle_unhold_clicked)
self._widget.suspend_button.clicked[bool].connect(self.__handle_suspend_clicked)
self._widget.unsuspend_button.clicked[bool].connect(self.__handle_unsuspend_clicked)
self._widget.abort_button.clicked[bool].connect(self.__handle_abort_clicked)
self._service_thread = Thread(target=self.wait_for_services, args=())
self._service_thread.start()
self._status_sub = rospy.Subscriber('packml/status', Status, self.status_callback)
def __init__(self, context):
super(ImageSnapShotGUI, self).__init__(context)
# Give QObjects reasonable names
self.setObjectName('ImageSnapShotGUI')
# 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('ImageSnapShot'))
# 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 ....
self._go_button = QPushButton('Head')
self._go_button.clicked.connect(self._head)
self._layout.addWidget(self._go_button)
self._clear_button = QPushButton('L arm')
self._clear_button.clicked.connect(self._larm)
self._layout.addWidget(self._clear_button)
self._clear_button = QPushButton('R arm')
self._clear_button.clicked.connect(self._rarm)
self._layout.addWidget(self._clear_button)
# self._step_run_button.setStyleSheet('QPushButton {color: black}')
context.add_widget(self._container)
self._head_pub = rospy.Publisher('/head_snap/snapshot', std_msgs.msg.Empty)
self._lhand_pub = rospy.Publisher('/lhand_snap/snapshot', std_msgs.msg.Empty)
self._rhand_pub = rospy.Publisher('/rhand_snap/snapshot', std_msgs.msg.Empty)
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 __init__(self, parent=None):
QDialog.__init__(self, parent)
self.setWindowTitle('Select Binary')
self.verticalLayout = QVBoxLayout(self)
self.verticalLayout.setObjectName("verticalLayout")
self.content = QWidget()
self.contentLayout = QFormLayout(self.content)
self.contentLayout.setVerticalSpacing(0)
self.verticalLayout.addWidget(self.content)
self.packages = None
package_label = QLabel("Package:", self.content)
self.package_field = QComboBox(self.content)
self.package_field.setInsertPolicy(QComboBox.InsertAlphabetically)
self.package_field.setSizePolicy(QSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed))
self.package_field.setEditable(True)
self.contentLayout.addRow(package_label, self.package_field)
binary_label = QLabel("Binary:", self.content)
self.binary_field = QComboBox(self.content)
# self.binary_field.setSizeAdjustPolicy(QComboBox.AdjustToContents)
self.binary_field.setSizePolicy(QSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed))
self.binary_field.setEditable(True)
self.contentLayout.addRow(binary_label, self.binary_field)
self.buttonBox = QDialogButtonBox(self)
self.buttonBox.setStandardButtons(QDialogButtonBox.Ok | QDialogButtonBox.Cancel)
self.buttonBox.setOrientation(Qt.Horizontal)
self.buttonBox.setObjectName("buttonBox")
self.verticalLayout.addWidget(self.buttonBox)
self.package_field.setFocus(Qt.TabFocusReason)
self.package = ''
self.binary = ''
if self.packages is None:
self.package_field.addItems(['packages searching...'])
self.package_field.setCurrentIndex(0)
self._fill_packages_thread = PackagesThread()
self._fill_packages_thread.packages.connect(self._fill_packages)
self._fill_packages_thread.start()
self.buttonBox.accepted.connect(self.accept)
self.buttonBox.rejected.connect(self.reject)
QMetaObject.connectSlotsByName(self)
self.package_field.activated[str].connect(self.on_package_selected)
if hasattr(self.package_field, "textChanged"): # qt compatibility
self.package_field.textChanged.connect(self.on_package_selected)
self.binary_field.textChanged.connect(self.on_binary_selected)
else:
self.package_field.editTextChanged.connect(self.on_package_selected)
self.binary_field.editTextChanged.connect(self.on_binary_selected)
def __init__(self, interactive_client_interface=None, with_rqt=False):
self.interactive_client_interface = interactive_client_interface
self.with_rqt = with_rqt
self.binded_function = {}
self.role_list = []
self.cur_selected_role = ''
self.roles_widget = QWidget()
# load ui
rospack = rospkg.RosPack()
path = os.path.join(rospack.get_path('rocon_remocon'), 'ui', 'role_list.ui')
loadUi(path, self.roles_widget)
# connect ui event role list widget
self.roles_widget.role_list_widget.setIconSize(QSize(50, 50))
self.roles_widget.role_list_widget.itemDoubleClicked.connect(self._select_role)
self.roles_widget.refresh_btn.pressed.connect(self.refresh_role_list)
self.roles_widget.back_btn.pressed.connect(self._back)
self.roles_widget.stop_all_interactions_button.pressed.connect(self._stop_all_interactions)
self.roles_widget.closeEvent = self._close_event
self._init()
def __init__(self, filenames, search_text='', parent=None):
'''
@param filenames: a list with filenames. The last one will be activated.
@type filenames: C{[str, ...]}
@param search_text: if not empty, searches in new document for first occurrence of the given text
@type search_text: C{str} (Default: C{Empty String})
'''
QMainWindow.__init__(self, parent)
self.setObjectName(' - '.join(['Editor', str(filenames)]))
self.setAttribute(Qt.WA_DeleteOnClose, True)
self.setWindowFlags(Qt.Window)
self.mIcon = QIcon(":/icons/crystal_clear_edit_launch.png")
self._error_icon = QIcon(":/icons/crystal_clear_warning.png")
self._empty_icon = QIcon()
self.setWindowIcon(self.mIcon)
window_title = "ROSLaunch Editor"
if filenames:
window_title = self.__getTabName(filenames[0])
self.setWindowTitle(window_title)
self.init_filenames = list(filenames)
self._search_thread = None
# list with all open files
self.files = []
# create tabs for files
self.main_widget = QWidget(self)
self.verticalLayout = QVBoxLayout(self.main_widget)
self.verticalLayout.setContentsMargins(0, 0, 0, 0)
self.verticalLayout.setSpacing(1)
self.verticalLayout.setObjectName("verticalLayout")
self.tabWidget = EditorTabWidget(self)
self.tabWidget.setTabPosition(QTabWidget.North)
self.tabWidget.setDocumentMode(True)
self.tabWidget.setTabsClosable(True)
self.tabWidget.setMovable(False)
self.tabWidget.setObjectName("tabWidget")
self.tabWidget.tabCloseRequested.connect(self.on_close_tab)
self.verticalLayout.addWidget(self.tabWidget)
self.buttons = self._create_buttons()
self.verticalLayout.addWidget(self.buttons)
self.setCentralWidget(self.main_widget)
self.find_dialog = TextSearchFrame(self.tabWidget, self)
self.find_dialog.search_result_signal.connect(self.on_search_result)
self.find_dialog.replace_signal.connect(self.on_replace)
self.addDockWidget(Qt.RightDockWidgetArea, self.find_dialog)
# open the files
for f in filenames:
if f:
self.on_load_request(os.path.normpath(f), search_text)
self.readSettings()
self.find_dialog.setVisible(False)
def __init__(self, context):
super(MyPlugin, self).__init__(context)
# Give QObjects reasonable names
self.setObjectName('MyPlugin')
rp = rospkg.RosPack()
# 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
# Create QWidget
self._widget = QWidget()
# Get path to UI file which is a sibling of this file
# in this example the .ui and .py file are in the same folder
ui_file = os.path.join(rp.get_path('rqt_mypkg'), 'resource',
'MyPlugin.ui')
# Extend the widget with all attributes and children from UI file
loadUi(ui_file, self._widget)
# Give QObjects reasonable names
self._widget.setObjectName('MyPluginUi')
# Show _widget.windowTitle on left-top of each plugin (when
# it's set in _widget). This is useful when you open multiple
# plugins at once. Also if you open multiple instances of your
# plugin at once, these lines add number to make it easy to
# tell from pane to pane.
if context.serial_number() > 1:
self._widget.setWindowTitle(self._widget.windowTitle() +
(' (%d)' % context.serial_number()))
# Add widget to the user interface
context.add_widget(self._widget)
def __init__(self, context):
super(cob_teacher_plugin, self).__init__(context)
# Give QObjects reasonable names
self.setObjectName('cob_teacher_plugin')
self._widget = QWidget()
self._widget.setObjectName('cob_teacher_plugin')
self.group_layout = QtGui.QVBoxLayout()
if context.serial_number() > 1:
self._widget.setWindowTitle(self._widget.windowTitle() +
(' (%d)' % context.serial_number()))
context.add_widget(self._widget)
args = self._parse_args(context.argv())
for config_file in args.config_file:
print config_file
self.ym = YamlManager(config_file)
for field in self.ym.getFields():
self.group_layout.addWidget(self.getFieldWidget(field))
placeholder = QtGui.QWidget()
self.group_layout.addWidget(placeholder, 1)
self.save_header = QtGui.QWidget()
self.save_layout = QtGui.QHBoxLayout()
self.save_header.setLayout(self.save_layout)
self.save_button = QtGui.QPushButton("Save")
self.save_button.connect(self.save_button, QtCore.SIGNAL('clicked()'),
self.saveValues)
self.close_button = QtGui.QPushButton("Close")
self.connect(self.close_button, QtCore.SIGNAL('clicked()'), QtGui.qApp,
QtCore.SLOT('quit()'))
self.save_layout.addWidget(self.save_button)
self.save_layout.addWidget(self.close_button)
self.group_layout.addWidget(self.save_header)
self._widget.setLayout(self.group_layout)
def __init__(self, parent=None, topic_type=str(), is_action_topic=False):
QWidget.__init__(self, parent)
if is_action_topic:
self.topic_type = topic_type + "Goal"
else:
self.topic_type = topic_type
self.is_action_topic = is_action_topic
# start widget
hbox = QHBoxLayout()
hbox.setMargin(0)
hbox.setContentsMargins(0, 0, 0, 0)
# topic combo box
self.topic_combo_box = QComboBox()
self.topic_combo_box.setEnabled(False)
self.topic_combo_box.blockSignals(True)
self.topic_combo_box.setValidator(
QRegExpValidator(QRegExp('((\d|\w|/)(?!//))*'), self))
self.topic_combo_box.currentIndexChanged[str].connect(
self.topic_changed)
hbox.addWidget(self.topic_combo_box)
# get system icon
icon = QIcon.fromTheme("view-refresh")
size = icon.actualSize(QSize(32, 32))
# add refresh button
refresh_topics_button = QPushButton()
refresh_topics_button.clicked.connect(self.update_topic_list)
refresh_topics_button.setIcon(icon)
refresh_topics_button.setFixedSize(size.width() + 2, size.height() + 2)
hbox.addWidget(refresh_topics_button)
# end widget
self.setLayout(hbox)
# init widget
self.update_topic_list()
def __init__(self, context):
super(LevelSelectorPlugin, self).__init__(context)
# Give QObjects reasonable names
self.setObjectName('LevelSelectorPlugin')
# Create QWidget
self._widget = QWidget()
# self._widget.setFont(QFont("Times", 15, QFont.Bold))
self._button_layout = QVBoxLayout(self._widget)
self.buttons = []
self.text_label = QLabel("Waiting for MultiLevelMapData...",
self._widget)
self._button_layout.addWidget(self.text_label)
self._widget.setObjectName('LevelSelectorPluginUI')
if context.serial_number() > 1:
self._widget.setWindowTitle(self._widget.windowTitle() +
(' (%d)' % context.serial_number()))
context.add_widget(self._widget)
self.connect(self._widget, SIGNAL("update_buttons"),
self.update_buttons)
self.connect(self._widget, SIGNAL("update_button_status"),
self.update_button_status)
# Subcribe to the multi level map data to get information about all the maps.
self.multimap_subscriber = rospy.Subscriber("map_metadata",
MultiLevelMapData,
self.process_multimap)
self.levels = []
self.current_level = None
# Subscribe to the current level we are on.
self.status_subscriber = None
# Create a service proxy to change the current level.
self.level_selector_proxy = rospy.ServiceProxy(
"level_mux/change_current_level", ChangeCurrentLevel)
self.level_selector_proxy.wait_for_service()
def __init__(self, context, parameter_name):
self._parameter_name = parameter_name
self._widget = QWidget()
rp = rospkg.RosPack()
ui_file = os.path.join(rp.get_path('rqt_copter'), 'resource',
'IntInputWidget.ui')
loadUi(ui_file, self._widget)
context.addWidget(self._widget)
self._widget.input_label.setText("Change " + self._parameter_name)
self._widget.input_slider.valueChanged.connect(self._slider_change)
self._widget.input_spin_box.valueChanged.connect(self._box_change)
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 __init__(self, context, service_name):
self._service_name = service_name
self._service = rosservice.get_service_class_by_name(
self._service_name)
self._service_proxy = rospy.ServiceProxy(self._service_name,
self._service)
self._widget = QWidget()
rp = rospkg.RosPack()
ui_file = os.path.join(rp.get_path('rqt_copter'), 'resource',
'SrvWidget.ui')
loadUi(ui_file, self._widget)
context.addWidget(self._widget)
self._widget.service_label.setText("Service " + self._service_name)
self._request = self._service._request_class()
self._inputs = []
for slot_name, type_name in zip(self._request.__slots__,
self._request._slot_types):
if type_name in ["float32", "float64"]:
self._inputs.append(
FloatInputWidget(self._widget.input_container, slot_name))
elif type_name in [
"int8", "uint8", "int16", "uint16", "int32", "uint32",
"int64", "uint64"
]:
self._inputs.append(
IntInputWidget(self._widget.input_container, slot_name))
elif type_name in ["string"]:
self._inputs.append(
StringInputWidget(self._widget.input_container, slot_name))
else:
print "Service input type", type_name, "needs to be implemented!"
print "Service", self._service_name, "is not available."
self._widget.close()
self._widget.apply_button.clicked.connect(self._init_msf)
def __init__(self, context):
QObject.__init__(self, context)
self.setObjectName('CO2Detection')
# setup main widget
self._widget = QWidget()
ui_file = os.path.join(rospkg.RosPack().get_path('hector_co2_detection_plugin'), 'lib', 'CO2Detection.ui')
loadUi(ui_file, self._widget)
self._widget.setObjectName('CO2Detection')
# Show _widget.windowTitle on left-top of each plugin (when
# it's set in _widget). This is useful when you open multiple
# plugins at once. Also if you open multiple instances of your
# plugin at once, these lines add number to make it easy to
# tell from pane to pane.
if context.serial_number() > 1:
self._widget.setWindowTitle(self._widget.windowTitle() + (' (%d)' % context.serial_number()))
# Add widget to the user interface
context.add_widget(self._widget)
# setup subscribers
self._CO2Subscriber = rospy.Subscriber("/co2detected", Bool, self._on_co2_detected)
# style settings
self._co2_detected_color = QColor(0, 0, 0, 255)
self._status_no_co2_style = "background-color: rgb(50, 255, 50);"
self._status_co2_style = "background-color: rgb(255, 50, 50);"
self._co2_font = QFont()
self._co2_font.setBold(True)
# Qt Signals
#self.connect(self, QtCore.SIGNAL('setCO2Style(PyQt_PyObject)'), self._set_co2_style)
self._update_co2_color.connect(self._set_co2_style)
self._update_no_co2_color.connect(self._set_no_co2_style)
self._widget.co2detectbutton.setText("Clear Air")
self._update_no_co2_color.emit()
def __init__(self):
super(TopicSelection, self).__init__()
master = rosgraph.Master('rqt_bag_recorder')
self.setWindowTitle("Select the topics you want to record")
self.resize(500, 700)
self.topic_list = []
self.selected_topics = []
self.items_list = []
self.area = QScrollArea(self)
self.main_widget = QWidget(self.area)
self.ok_button = QPushButton("Record", self)
self.ok_button.clicked.connect(self.onButtonClicked)
self.ok_button.setEnabled(False)
self.from_nodes_button = QPushButton("From Nodes", self)
self.from_nodes_button.clicked.connect(self.onFromNodesButtonClicked)
self.main_vlayout = QVBoxLayout(self)
self.main_vlayout.addWidget(self.area)
self.main_vlayout.addWidget(self.ok_button)
self.main_vlayout.addWidget(self.from_nodes_button)
self.setLayout(self.main_vlayout)
self.selection_vlayout = QVBoxLayout(self)
self.item_all = QCheckBox("All", self)
self.item_all.stateChanged.connect(self.updateList)
self.selection_vlayout.addWidget(self.item_all)
topic_data_list = master.getPublishedTopics('')
topic_data_list.sort()
for topic, datatype in topic_data_list:
self.addCheckBox(topic)
self.main_widget.setLayout(self.selection_vlayout)
self.area.setWidget(self.main_widget)
self.show()
