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()