def setupUi(self, MainWindow): self.lock = Lock() self.talker = Talker('taskview') rospy.Subscriber('BbSync', bbsynch, self.taskview) MainWindow.setObjectName("MainWindow") MainWindow.resize(800, 600) self.centralwidget = QtWidgets.QWidget(MainWindow) self.centralwidget.setObjectName("centralwidget") self.listView = QtWidgets.QListWidget(self.centralwidget) self.listView.setGeometry(QtCore.QRect(10, 40, 771, 521)) self.listView.setVerticalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOn) self.listView.setHorizontalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOn) self.listView.setObjectName("listView") self.label = QtWidgets.QLabel(self.centralwidget) self.label.setGeometry(QtCore.QRect(10, 10, 67, 17)) self.label.setObjectName("label") MainWindow.setCentralWidget(self.centralwidget) self.statusbar = QtWidgets.QStatusBar(MainWindow) self.statusbar.setObjectName("statusbar") MainWindow.setStatusBar(self.statusbar) self.retranslateUi(MainWindow) QtCore.QMetaObject.connectSlotsByName(MainWindow) self.tasklist = [] self.markers = rviz_tools.RvizMarkers('/map', 'markers')
class UploadWorker(QtCore.QObject): ret = QtCore.pyqtSignal(object) finished = QtCore.pyqtSignal() program_progress = QtCore.pyqtSignal(int, int) verify_progress = QtCore.pyqtSignal(int, int) def __init__(self, fun=None, path=None): super(UploadWorker, self).__init__() self.upload = fun self.path = path def set_fun(self, fun): self.upload = fun def set_path(self, path): self.path = path def on_program_progress(self, progress, total): self.program_progress.emit(progress, total) def on_verify_progress(self, progress, total): self.verify_progress.emit(progress, total) def run(self): ret = None try: ret = self.upload(self.path) except Exception as e: logger.error("Error during firmware upload: %s", e) self.ret.emit(ret) self.finished.emit()
class ReadWriteParamsWorker(QtCore.QObject): ret = QtCore.pyqtSignal(object) finished = QtCore.pyqtSignal() progress = QtCore.pyqtSignal(int, int) def __init__(self, fun, param_names=None, param_values=None): super(ReadWriteParamsWorker, self).__init__() self.names = param_names self.values = param_values self.fun = fun def set_params(self, names, values=None): self.names = names self.values = values def run(self): ret_values = dict() if self.names is not None: self.progress.emit(0, len(self.names)) for i, param in enumerate(self.names): if self.values is None: ret_values[param] = self.fun(param) else: ret_values[param] = self.fun(param, self.values[i]) self.progress.emit(i + 1, len(self.names)) self.ret.emit(ret_values) self.finished.emit()
class ServiceThread(QtCore.QObject, threading.Thread): ''' A thread to to retrieve the list of nodes from the default configuration service and publish it by sending a QT signal. ''' update_signal = QtCore.Signal(str, str, list) err_signal = QtCore.Signal(str, str, str) def __init__(self, service_uri, service, delay_exec=0.0, parent=None): QtCore.QObject.__init__(self) threading.Thread.__init__(self) self._service_uri = service_uri self._service = service self._delay_exec = delay_exec self.setDaemon(True) def run(self): ''' ''' if self._service and self._service_uri: try: if self._delay_exec > 0: time.sleep(self._delay_exec) _, resp = nm.starter().callService(self._service_uri, self._service, ListNodes) self.update_signal.emit(self._service_uri, self._service, resp.nodes) except: import traceback lines = traceback.format_exc().splitlines() rospy.logwarn( "Error while retrieve the node list from %s[%s]: %s", str(self._service), str(self._service_uri), str(lines[-1])) self.err_signal.emit(self._service_uri, self._service, lines[-1])
class Worker(QObject): progress = QtCore.Signal(int) finished = QtCore.Signal() error = QtCore.Signal(str) def __init__(self, run): super(Worker, self).__init__() self.run_function = run def process(self): self.progress.emit(0) try: if isinstance(self.run_function, types.GeneratorType): p = 0 self.progress.emit(p) while p < 100: p = self.run_function() self.progress.emit(p) else: self.run_function() self.progress.emit(100) self.finished.emit() except Exception as e: self.error.emit(str(e)) raise
def handleMessage(self): socket = self._server.nextPendingConnection() if socket.waitForReadyRead(self._timeout): self.messageAvailable.emit(socket.readAll().data().decode('utf-8')) socket.disconnectFromServer() else: QtCore.qDebug(socket.errorString())
def minimumSize(self): size = QtCore.QSize() for item in self._items: size = size.expandedTo(item.minimumSize()) size += QtCore.QSize(2 * self.margin(), 2 * self.margin()) return size
def __init__(self, parent=None): QtGui.QSyntaxHighlighter.__init__(self, parent) self.rules = [] self.commentStart = QtCore.QRegExp("#") self.commentEnd = QtCore.QRegExp("\n") self.commentFormat = QtGui.QTextCharFormat() self.commentFormat.setFontItalic(True) self.commentFormat.setForeground(QtCore.Qt.darkGray) f = QtGui.QTextCharFormat() r = QtCore.QRegExp() r.setMinimal(True) f.setFontWeight(QtGui.QFont.Normal) f.setForeground(QtCore.Qt.darkBlue) tagList = [ "\\bignore_hosts\\b", "\\bsync_hosts\\b", "\\bignore_nodes\\b", "\\bsync_nodes\\b", "\\bignore_topics\\b", "\\bsync_topics\\b", "\\bignore_services\\b", "\\bsync_services\\b", "\\bsync_topics_on_demand\\b", "\\bsync_remote_nodes\\b" ] for tag in tagList: r.setPattern(tag) self.rules.append((QtCore.QRegExp(r), QtGui.QTextCharFormat(f))) f.setForeground(QtCore.Qt.darkGreen) f.setFontWeight(QtGui.QFont.Bold) attrList = ["\\b\\*|\\*\\B|\\/\\*"] for attr in attrList: r.setPattern(attr) self.rules.append((QtCore.QRegExp(r), QtGui.QTextCharFormat(f)))
def paintSection(self, painter, rect, logicalIndex): ''' The method paint the robot or capability images in the backgroud of the cell. @see: L{QtGui.QHeaderView.paintSection()} ''' painter.save() QtGui.QHeaderView.paintSection(self, painter, rect, logicalIndex) painter.restore() if logicalIndex in range(len( self._data)) and self._data[logicalIndex]['images']: if len(self._data[logicalIndex]['images']) == 1: pix = self._data[logicalIndex]['images'][0] pix = pix.scaled(rect.width(), rect.height() - 20, QtCore.Qt.KeepAspectRatio, QtCore.Qt.SmoothTransformation) self.style().drawItemPixmap(painter, rect, 5, pix) elif len(self._data[logicalIndex]['images']) > 1: new_rect = QtCore.QRect(rect.left(), rect.top(), rect.width(), (rect.height() - 20) / 2.) pix = self._data[logicalIndex]['images'][0] pix = pix.scaled(new_rect.width(), new_rect.height(), QtCore.Qt.KeepAspectRatio, QtCore.Qt.SmoothTransformation) self.style().drawItemPixmap(painter, new_rect, 5, pix) new_rect = QtCore.QRect(rect.left(), rect.top() + new_rect.height(), rect.width(), new_rect.height()) pix = self._data[logicalIndex]['images'][1] pix = pix.scaled(new_rect.width(), new_rect.height(), QtCore.Qt.KeepAspectRatio, QtCore.Qt.SmoothTransformation) self.style().drawItemPixmap(painter, new_rect, 5, pix)
class MasterListService(QtCore.QObject): ''' A class to retrieve the ROS master list from a ROS service. The service will be determine using L{master_discovery_fkie.interface_finder.get_listmaster_service()} ''' masterlist_signal = QtCore.Signal(str, str, list) '''@ivar: a signal with a list of the masters retrieved from the master_discovery service 'list_masters'. ParameterB{:} C{masteruri}, C{service name}, C{[L{master_discovery_fkie.ROSMaster}, ...]}''' masterlist_err_signal = QtCore.Signal(str, str) '''@ivar: this signal is emitted if an error while calling #list_masters' service of master_discovery is failed. ParameterB{:} C{masteruri}, C{error}''' def __init__(self): QtCore.QObject.__init__(self) self.__serviceThreads = {} self._lock = threading.RLock() def stop(self): print " Shutdown discovery listener..." for _, thread in self.__serviceThreads.iteritems(): thread.join(3) print " Discovery listener is off!" def retrieveMasterList(self, masteruri, wait=False): ''' This method use the service 'list_masters' of the master_discovery to get the list of discovered ROS master. The retrieved list will be emitted as masterlist_signal. @param masteruri: the ROS master URI @type masteruri: C{str} @param wait: wait for the service @type wait: C{boolean} ''' with self._lock: if not (self.__serviceThreads.has_key(masteruri)): upthread = MasterListThread(masteruri, wait) upthread.master_list_signal.connect(self._on_master_list) upthread.err_signal.connect(self._on_err) self.__serviceThreads[masteruri] = upthread upthread.start() def _on_master_list(self, masteruri, service_name, items): with self._lock: try: thread = self.__serviceThreads.pop(masteruri) del thread except KeyError: pass self.masterlist_signal.emit(masteruri, service_name, items) def _on_err(self, masteruri, msg): with self._lock: try: thread = self.__serviceThreads.pop(masteruri) del thread except KeyError: pass self.masterlist_err_signal.emit(masteruri, msg)
def handleMessage(self): socket = self._server.nextPendingConnection() if socket.waitForReadyRead(self._timeout): self.messageAvailable.emit( socket.readAll().data().decode('utf-8')) socket.disconnectFromServer() else: QtCore.qDebug(socket.errorString())
class UpdateThread(QtCore.QObject, threading.Thread): ''' A thread to retrieve the state about ROS master from remote discovery node and publish it be sending a QT signal. ''' update_signal = QtCore.Signal(MasterInfo) ''' @ivar: update_signal is a signal, which is emitted, if a new L{aster_discovery_fkie.MasterInfo} is retrieved. ''' error_signal = QtCore.Signal(str, str) ''' @ivar: error_signal is a signal (masteruri, error message), which is emitted, if an error while retrieving a master info was occurred. ''' def __init__(self, monitoruri, masteruri, delayed_exec=0., parent=None): ''' @param masteruri: the URI of the remote ROS master @type masteruri: C{str} @param monitoruri: the URI of the monitor RPC interface of the master_discovery node @type monitoruri: C{str} @param delayed_exec: Delay the execution of the request for given seconds. @type delayed_exec: C{float} ''' QtCore.QObject.__init__(self) threading.Thread.__init__(self) self._monitoruri = monitoruri self._masteruri = masteruri self._delayed_exec = delayed_exec self.setDaemon(True) def run(self): ''' ''' try: delay = self._delayed_exec + 0.5 + random.random() #'print "wait request update", self._monitoruri, delay time.sleep(delay) #'print "request update", self._monitoruri socket.setdefaulttimeout(25) remote_monitor = xmlrpclib.ServerProxy(self._monitoruri) remote_info = remote_monitor.masterInfo() master_info = MasterInfo.from_list(remote_info) master_info.check_ts = time.time() #'print "request success", self._monitoruri self.update_signal.emit(master_info) except: import traceback # print traceback.print_exc() formatted_lines = traceback.format_exc(1).splitlines() rospy.logwarn("Connection to %s failed:\n\t%s", str(self._monitoruri), formatted_lines[-1]) #'print "request failed", self._monitoruri self.error_signal.emit(self._masteruri, formatted_lines[-1]) finally: if not socket is None: socket.setdefaulttimeout(None)
def _subscribe(self): self._depGraph = rospy.Subscriber( "dependency_graph", String, lambda data: self.emit(QtCore.SIGNAL("onDepGraph"), data.data)) self._pnGraph = rospy.Subscriber( "petri_net_graph", String, lambda data: self.emit(QtCore.SIGNAL("onPNGraph"), data.data)) pass
def __init__(self, parent=None): QtGui.QDialog.__init__(self, parent) self.setWindowTitle('Select Binary') self.verticalLayout = QtGui.QVBoxLayout(self) self.verticalLayout.setObjectName("verticalLayout") self.content = QtGui.QWidget() self.contentLayout = QtGui.QFormLayout(self.content) self.contentLayout.setVerticalSpacing(0) self.verticalLayout.addWidget(self.content) self.packages = None package_label = QtGui.QLabel("Package:", self.content) self.package_field = QtGui.QComboBox(self.content) self.package_field.setInsertPolicy( QtGui.QComboBox.InsertAlphabetically) self.package_field.setSizePolicy( QtGui.QSizePolicy(QtGui.QSizePolicy.Expanding, QtGui.QSizePolicy.Fixed)) self.package_field.setEditable(True) self.contentLayout.addRow(package_label, self.package_field) binary_label = QtGui.QLabel("Binary:", self.content) self.binary_field = QtGui.QComboBox(self.content) # self.binary_field.setSizeAdjustPolicy(QtGui.QComboBox.AdjustToContents) self.binary_field.setSizePolicy( QtGui.QSizePolicy(QtGui.QSizePolicy.Expanding, QtGui.QSizePolicy.Fixed)) self.binary_field.setEditable(True) self.contentLayout.addRow(binary_label, self.binary_field) self.buttonBox = QtGui.QDialogButtonBox(self) self.buttonBox.setStandardButtons(QtGui.QDialogButtonBox.Ok | QtGui.QDialogButtonBox.Cancel) self.buttonBox.setOrientation(QtCore.Qt.Horizontal) self.buttonBox.setObjectName("buttonBox") self.verticalLayout.addWidget(self.buttonBox) self.package_field.setFocus(QtCore.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() QtCore.QObject.connect(self.buttonBox, QtCore.SIGNAL("accepted()"), self.accept) QtCore.QObject.connect(self.buttonBox, QtCore.SIGNAL("rejected()"), self.reject) QtCore.QMetaObject.connectSlotsByName(self) self.package_field.activated[str].connect(self.on_package_selected) self.package_field.textChanged.connect(self.on_package_selected)
def readSettings(self): if nm.settings().store_geometry: settings = nm.settings().qsettings(nm.settings().CFG_GUI_FILE) settings.beginGroup("editor") maximized = settings.value("maximized", 'false') == 'true' if maximized: self.showMaximized() else: self.resize(settings.value("size", QtCore.QSize(800,640))) self.move(settings.value("pos", QtCore.QPoint(0, 0))) settings.endGroup()
def __init__(self, guimgr): super(AwRosbagSimulatorWidget, self).__init__() self.rosbag_mode_proc = QtCore.QProcess(self) self.rosbag_info_proc = QtCore.QProcess(self) self.rosbag_play_proc = QtCore.QProcess(self) self.rosbag_file = widgets.AwFileSelect(self) self.rosbag_info = QtWidgets.QPushButton("Info") self.rosbag_text = QtWidgets.QLabel("No information") self.rosbag_enable = QtWidgets.QCheckBox() self.rosbag_label = QtWidgets.QLabel("Simulation Mode") self.rosbag_play = QtWidgets.QPushButton("Play") self.rosbag_stop = QtWidgets.QPushButton("Stop") self.rosbag_pause = QtWidgets.QPushButton("Pause") self.rosbag_state = QtWidgets.QLabel() #self.rosbag_stime = QtWidgets.QLineEdit() #start time #repeat #rate self.rosbag_enable.stateChanged.connect(self.simulation_mode_changed) self.rosbag_info.clicked.connect(self.rosbag_info_requested) self.rosbag_info_proc.finished.connect(self.rosbag_info_completed) self.rosbag_play.clicked.connect(self.rosbag_started) self.rosbag_stop.clicked.connect(self.rosbag_stopped) self.rosbag_play_proc.finished.connect(self.rosbag_finished) self.rosbag_play_proc.readyReadStandardOutput.connect( self.rosbag_output) self.rosbag_pause.setCheckable(True) self.rosbag_pause.toggled.connect(self.rosbag_paused) self.setStyleSheet( "QCheckBox::indicator { width: 28px; height: 28px; }") self.rosbag_label.setSizePolicy(QtWidgets.QSizePolicy.Expanding, QtWidgets.QSizePolicy.Preferred) self.rosbag_text.setSizePolicy(QtWidgets.QSizePolicy.Preferred, QtWidgets.QSizePolicy.Expanding) layout = QtWidgets.QGridLayout() layout.addWidget(self.rosbag_enable, 0, 0) layout.addWidget(self.rosbag_label, 0, 1) layout.addWidget(self.rosbag_play, 0, 2) layout.addWidget(self.rosbag_stop, 0, 3) layout.addWidget(self.rosbag_pause, 0, 4) layout.addWidget(self.rosbag_state, 1, 0, 1, 5) layout.addWidget(self.rosbag_file.path, 2, 0, 1, 3) layout.addWidget(self.rosbag_file.button, 2, 3) layout.addWidget(self.rosbag_info, 2, 4) layout.addWidget(self.rosbag_text, 3, 0, 1, 5) self.setLayout(layout) self.simulation_mode_disabled()
class Worker(QtCore.QObject): ret = QtCore.pyqtSignal(object) finished = QtCore.pyqtSignal() def __init__(self, fun, *args, **kwargs): super(Worker, self).__init__() self.fun = fun self.args = args self.kwargs = kwargs def run(self): self.ret.emit(self.fun(*self.args, **self.kwargs)) self.finished.emit()
def updateCapabilities(self, masteruri, cfg_name, description): ''' Updates the capabilities view. @param masteruri: the ROS master URI of updated ROS master. @type masteruri: C{str} @param cfg_name: The name of the node provided the capabilities description. @type cfg_name: C{str} @param description: The capabilities description object. @type description: L{default_cfg_fkie.Description} ''' # if it is a new masteruri add a new column robot_index = self._robotHeader.index(masteruri) robot_name = description.robot_name if description.robot_name else nm.nameres().mastername(masteruri) if robot_index == -1: # append a new robot robot_index = self._robotHeader.insertSortedItem(masteruri, robot_name) self.insertColumn(robot_index) # robot_index = self.columnCount()-1 # self._robotHeader.insertItem(robot_index) self._robotHeader.setDescription(robot_index, cfg_name, masteruri, robot_name, description.robot_type, description.robot_descr.replace("\\n ", "\n").decode(sys.getfilesystemencoding()), description.robot_images) item = QtGui.QTableWidgetItem() item.setSizeHint(QtCore.QSize(96,96)) self.setHorizontalHeaderItem(robot_index, item) self.horizontalHeaderItem(robot_index).setText(robot_name) else: #update self._robotHeader.setDescription(robot_index, cfg_name, masteruri, robot_name, description.robot_type, description.robot_descr.replace("\\n ", "\n").decode(sys.getfilesystemencoding()), description.robot_images) #set the capabilities for c in description.capabilities: cap_index = self._capabilityHeader.index(c.name.decode(sys.getfilesystemencoding())) if cap_index == -1: # append a new capability cap_index = self._capabilityHeader.insertSortedItem(c.name.decode(sys.getfilesystemencoding()), c.name.decode(sys.getfilesystemencoding())) self.insertRow(cap_index) self.setRowHeight(cap_index, 96) self._capabilityHeader.setDescription(cap_index, cfg_name, c.name.decode(sys.getfilesystemencoding()), c.name.decode(sys.getfilesystemencoding()), c.type, c.description.replace("\\n ", "\n").decode(sys.getfilesystemencoding()), c.images) item = QtGui.QTableWidgetItem() item.setSizeHint(QtCore.QSize(96,96)) self.setVerticalHeaderItem(cap_index, item) self.verticalHeaderItem(cap_index).setText(c.name.decode(sys.getfilesystemencoding())) # add the capability control widget controlWidget = CapabilityControlWidget(masteruri, cfg_name, c.namespace, c.nodes) controlWidget.start_nodes_signal.connect(self._start_nodes) controlWidget.stop_nodes_signal.connect(self._stop_nodes) self.setCellWidget(cap_index, robot_index, controlWidget) self._capabilityHeader.controlWidget.insert(cap_index, controlWidget) else: self._capabilityHeader.updateDescription(cap_index, cfg_name, c.name.decode(sys.getfilesystemencoding()), c.name.decode(sys.getfilesystemencoding()), c.type, c.description.replace("\\n ", "\n").decode(sys.getfilesystemencoding()), c.images) self._capabilityHeader.controlWidget[cap_index].updateNodes(cfg_name, c.namespace, c.nodes)
def __init__(self, filename, parent=None): self.parent = parent QtGui.QTextEdit.__init__(self, parent) self.setObjectName(' - '.join(['Editor', filename])) font = QtGui.QFont() font.setFamily("Fixed".decode("utf-8")) font.setPointSize(12) self.setFont(font) self.setLineWrapMode(QtGui.QTextEdit.NoWrap) self.setTabStopWidth(25) self.setAcceptRichText(False) self.setCursorWidth(2) self.setFontFamily("courier new") self.setProperty("backgroundVisible", True) self.regexp_list = [QtCore.QRegExp("\\binclude\\b"), QtCore.QRegExp("\\btextfile\\b"), QtCore.QRegExp("\\bfile\\b"), QtCore.QRegExp("\\bvalue=.*pkg:\/\/\\b"), QtCore.QRegExp("\\bvalue=.*package:\/\/\\b"), QtCore.QRegExp("\\bvalue=.*\$\(find\\b")] self.filename = filename self.file_info = None if self.filename: f = QtCore.QFile(filename); if f.open(QtCore.QIODevice.ReadOnly | QtCore.QIODevice.Text): self.file_info = QtCore.QFileInfo(filename) self.setText(unicode(f.readAll(), "utf-8")) self.path = '.' # enables drop events self.setAcceptDrops(True)
class Channels(QtCore.QObject): vehicle_create = QtCore.pyqtSignal(str, str, dict, list) vehicle_move = QtCore.pyqtSignal(str, dict) vehicle_hide = QtCore.pyqtSignal(str) vehicle_show = QtCore.pyqtSignal(str) rqt_vviz_resize = QtCore.pyqtSignal(list) rqt_vviz_clear = QtCore.pyqtSignal() road_marking_set_size = QtCore.pyqtSignal(list, int) road_marking_edit_first = QtCore.pyqtSignal(str, int) draw_circle = QtCore.pyqtSignal(str, dict, int, str) remove_circle = QtCore.pyqtSignal(str)
class SupervisedPopen(QtCore.QObject, subprocess.Popen): ''' The class overrides the subprocess.Popen and waits in a thread for its finish. If an error is printed out, it will be shown in a message dialog. ''' error = QtCore.Signal(str, str, str) '''@ivar: the signal is emitted if error output was detected (id, decription, message)''' finished = QtCore.Signal(str) '''@ivar: the signal is emitted on exit (id)''' def __init__(self, args, bufsize=0, executable=None, stdin=None, stdout=None, stderr=subprocess.PIPE, preexec_fn=None, close_fds=False, shell=False, cwd=None, env=None, universal_newlines=False, startupinfo=None, creationflags=0, id='', description=''): ''' For arguments see https://docs.python.org/2/library/subprocess.html Additional arguments: :param id: the identification string of this object and title of the error message dialog :type id: str :param description: the description string used as addiotional information in dialog if an error was occured :type description: str ''' try: subprocess.Popen.__init__(self, args, bufsize, executable, stdin, stdout, stderr, preexec_fn, close_fds, shell, cwd, env, universal_newlines, startupinfo, creationflags) QtCore.QObject.__init__(self) self._args = args self._id = id self._description = description self.error.connect(self.on_error) # wait for process to avoid 'defunct' processes thread = threading.Thread(target=self.supervise) thread.setDaemon(True) thread.start() except Exception as e: raise # def __del__(self): # print "Deleted:", self._description def supervise(self): # wait for process to avoid 'defunct' processes self.wait() result_err = self.stderr.read() if result_err: self.error.emit(self._id, self._description, result_err) self.finished.emit(self._id) def on_error(self, id, descr, msg): WarningMessageBox(QtGui.QMessageBox.Warning, id, '%s\n\n%s'%(descr, msg), ' '.join(self._args)).exec_()
def paintEvent(self,event): if not self._initialized: self.placeStickAtCenter() self._initialized = True borderWidth = 1 joyRange = 80 center = QtCore.QPoint(self.height()/2,self.width()/2) qp = QPainter() qp.begin(self) qp.setRenderHint(QPainter.Antialiasing, True) qp.setPen(QPen(QtCore.Qt.lightGray, borderWidth, QtCore.Qt.SolidLine, QtCore.Qt.RoundCap,QtCore.Qt.RoundJoin)) if self._mode == "circle": qp.drawEllipse(center,joyRange,joyRange) if self._mode == "square": x = center.x() - joyRange y = center.y() - joyRange width = joyRange * 2 height = joyRange * 2 qp.drawRect(x,y,width,height) qp.end() super(JoystickView,self).paintEvent(event)
def limitStickMove(self,pos,mode = "square"): # Give joystick position from (0,0) x = 0 y = 0 if mode == "circle": norm = math.sqrt(pos.x() ** 2 + pos.y() ** 2) if norm > self._range: ratio = self._range / norm else: ratio = 1.0 x = pos.x() * ratio y = pos.y() * ratio if mode == "square": if abs(pos.x()) > self._range: sign = pos.x() / abs(pos.x()) x = sign * self._range else: x = pos.x() if abs(pos.y()) > self._range: sign = pos.y() / abs(pos.y()) y = sign * self._range else: y = pos.y() return QtCore.QPoint(x,y)
def setup_gui(self, two_columns=True): if qt_version_below_5: widget_layout = QtGui.QHBoxLayout() else: widget_layout = QtWidgets.QHBoxLayout() widget_layout.addLayout(self._column_1) if two_columns: widget_layout.addLayout(self._column_2) if qt_version_below_5: main_layout = QtGui.QHBoxLayout() else: main_layout = QtWidgets.QHBoxLayout() main_layout = QtWidgets.QVBoxLayout() main_layout.addLayout(widget_layout) self._column_1.setAlignment(QtCore.Qt.AlignTop) if two_columns: self._column_2.setAlignment(QtCore.Qt.AlignTop) widget_layout.setAlignment(QtCore.Qt.AlignTop) main_layout.setAlignment(QtCore.Qt.AlignTop) self.setLayout(main_layout) self._update_info_timer = QtCore.QTimer(self) self._update_info_timer.timeout.connect(self.update_gui) self._update_info_timer.start(100)
def set_timer(self, parent=None): interval = self.publish_interval if not self._timer: self._timer = QtCore.QTimer(parent=parent) self._timer.timeout.connect(self.publish) self._timer.setInterval(interval) self._timer.start()
def __init__(self, parent=None): QtGui.QWidget.__init__(self, parent) path = rospkg.RosPack().get_path('cyplam_data') loadUi(os.path.join(path, 'resources', 'data.ui'), self) rospy.Subscriber('/supervisor/status', MsgStatus, self.cbStatus, queue_size=1) self.btnConnect.clicked.connect(self.btnConnectClicked) self.btnJob.clicked.connect(self.btnJobClicked) self.btnPredict.clicked.connect(self.btnPredictClicked) self.btnRecord.clicked.connect(self.btnRecordClicked) self.btnTransfer.clicked.connect(self.btnTransferClicked) dirdata = os.path.join(HOME, DIRDATA) if not os.path.exists(dirdata): os.mkdir(dirdata) self.job = '' self.name = '' self.status = False self.running = False self.process = QtCore.QProcess(self) if rospy.has_param('/material'): self.setMaterialParameters(rospy.get_param('/material')) self.btnJobClicked()
def __init__(self, parent=None): QtGui.QWidget.__init__(self, parent) loadUi(os.path.join(path, 'resources', 'part.ui'), self) self.pub_marker_array = rospy.Publisher('visualization_marker_array', MarkerArray, queue_size=1) self.btnLoad.clicked.connect(self.btnLoadClicked) self.btnProcessMesh.clicked.connect(self.btnProcessMeshClicked) self.btnProcessLayer.clicked.connect(self.btnProcessLayerClicked) self.btnAcceptPath.clicked.connect(self.btnAcceptPathClicked) self.sbPositionX.valueChanged.connect(self.changePosition) self.sbPositionY.valueChanged.connect(self.changePosition) self.sbPositionZ.valueChanged.connect(self.changePosition) self.sbSizeX.valueChanged.connect(self.changeSize) self.sbSizeY.valueChanged.connect(self.changeSize) self.sbSizeZ.valueChanged.connect(self.changeSize) self.processing = False self.timer = QtCore.QTimer(self) self.timer.timeout.connect(self.updateProcess) self.robpath = RobPath()
def __init__(self, guimgr): super(AwLgsvlSimulatorWidget, self).__init__() self.process = QtCore.QProcess(self) self.console = AwProcessViewer(self.process) self.button = QtWidgets.QPushButton("Launch Simulator") self.button.setCheckable(True) self.button.toggled.connect(self.launch_lgsvm) self.server_addr = QtWidgets.QLineEdit() self.server_port = QtWidgets.QLineEdit() self.client_addr = QtWidgets.QLineEdit() self.client_port = QtWidgets.QLineEdit() self.server_addr.setText("10.100.2.1") self.server_port.setText("5000") for host in QtNetwork.QNetworkInterface.allAddresses(): if not host.isLoopback(): if host.protocol() == QtNetwork.QAbstractSocket.IPv4Protocol: self.client_addr.setText(host.toString()) self.client_port.setText("9090") layout = QtWidgets.QGridLayout() layout.addWidget(QtWidgets.QLabel("Server Address"), 0, 0) layout.addWidget(QtWidgets.QLabel("Server Port"), 1, 0) layout.addWidget(QtWidgets.QLabel("Client Address"), 2, 0) layout.addWidget(QtWidgets.QLabel("Client Port"), 3, 0) layout.addWidget(self.server_addr, 0, 1) layout.addWidget(self.server_port, 1, 1) layout.addWidget(self.client_addr, 2, 1) layout.addWidget(self.client_port, 3, 1) layout.addWidget(self.button, 4, 0, 1, 2) layout.addWidget(self.console, 5, 0, 1, 2) self.setLayout(layout)
class RawDataSelector(QGroupBox): dataSourceChanged = QtCore.Signal(int) def __init__(self, parent=None): super(RawDataSelector, self).__init__() self.parent = parent self.setTitle('Select bag file') # Init the components self.bag1RadioBtn = QRadioButton('ground truth') self.bag2RadioBtn = QRadioButton('camera') # connect the signals to the slots self.bag1RadioBtn.clicked.connect(self.btn1Clicked) self.bag2RadioBtn.clicked.connect(self.btn2Clicked) # layout layout = QVBoxLayout() layout.addWidget(self.bag1RadioBtn) layout.addWidget(self.bag2RadioBtn) self.setLayout(layout) def btn1Clicked(self): ''' "ground truth" is selected ''' self.dataSourceChanged.emit(0) def btn2Clicked(self): ''' "camera" is selected ''' self.dataSourceChanged.emit(1)
def on_topic_control_btn_clicked(self): try: if self.sub is None and self.ssh_output_file is None: if self.__msg_class: self.sub = rospy.Subscriber(self.topic, self.__msg_class, self._msg_handle) else: self._on_display_anchorClicked(QtCore.QUrl( self._masteruri)) self.topic_control_button.setText('stop') self.topic_control_button.setIcon( QtGui.QIcon(':/icons/deleket_deviantart_stop.png')) else: if not self.sub is None: self.sub.unregister() self.sub = None elif not self.ssh_output_file is None: self.ssh_output_file.close() self.ssh_error_file.close() self.ssh_output_file = None self.topic_control_button.setText('play') self.topic_control_button.setIcon( QtGui.QIcon(':/icons/deleket_deviantart_play.png')) self.no_str_checkbox.setEnabled(True) self.no_arr_checkbox.setEnabled(True) except Exception as e: rospy.logwarn('Error while stop/play echo for topic %s: %s' % (self.topic, e))
def paintEvent(self,event): super(JoystickPointView,self).paintEvent(event) try: if self._initialized: pass except: self._origPos = self.pos() self._initialized = True qp = QPainter() qp.begin(self) borderWidth = 2 radius = self.height()/2 center = QtCore.QPoint(self.height()/2,self.width()/2) # Outer Circle qp.setRenderHint(QPainter.Antialiasing, True) qp.setPen(QPen(QtCore.Qt.darkGray, borderWidth, QtCore.Qt.SolidLine, QtCore.Qt.RoundCap,QtCore.Qt.RoundJoin)) qp.setBrush(QBrush(QtCore.Qt.white, QtCore.Qt.SolidPattern)) qp.drawEllipse(center,radius-borderWidth,radius-borderWidth) # Inner Circle qp.setPen(QPen(QtCore.Qt.lightGray, borderWidth, QtCore.Qt.SolidLine, QtCore.Qt.RoundCap,QtCore.Qt.RoundJoin)) qp.setBrush(QBrush(QtCore.Qt.white, QtCore.Qt.SolidPattern)) qp.drawEllipse(center,radius-borderWidth-1,radius-borderWidth-1) qp.end()