def load(self, argv):
'''
@param argv: the list with argv parameter needed to load the launch file.
The name and value are separated by C{:=}
@type argv: C{[str]}
@return True, if the launch file was loaded
@rtype boolean
@raise LaunchConfigException: on load errors
'''
try:
roscfg = roslaunch.ROSLaunchConfig()
loader = roslaunch.XmlLoader()
self.argv = self.resolveArgs(argv)
loader.load(self.Filename, roscfg, verbose=False, argv=self.argv)
self.__roscfg = roscfg
nm.file_watcher().add_launch(self.__masteruri, self.__launchFile, self.__launch_id, self.getIncludedFiles(self.Filename))
if not nm.is_local(nm.nameres().getHostname(self.__masteruri)):
files = self.getIncludedFiles(self.Filename,
regexp_list=[QRegExp("\\bdefault\\b"),
QRegExp("\\bvalue=.*pkg:\/\/\\b"),
QRegExp("\\bvalue=.*package:\/\/\\b"),
QRegExp("\\bvalue=.*\$\(find\\b")])
nm.file_watcher_param().add_launch(self.__masteruri,
self.__launchFile,
self.__launch_id,
files)
except roslaunch.XmlParseException, e:
test = list(re.finditer(r"environment variable '\w+' is not set", str(e)))
message = str(e)
if test:
message = ''.join([message, '\n', 'environment substitution is not supported, use "arg" instead!'])
raise LaunchConfigException(message)
def __init__(self, parent=None):
QSyntaxHighlighter.__init__(self, parent)
self.rules = []
self.commentStart = QRegExp("#")
self.commentEnd = QRegExp("\n")
self.commentFormat = QTextCharFormat()
self.commentFormat.setFontItalic(True)
self.commentFormat.setForeground(Qt.darkGray)
f = QTextCharFormat()
r = QRegExp()
r.setMinimal(True)
f.setFontWeight(QFont.Normal)
f.setForeground(Qt.darkBlue)
tagList = [
"\\bignore_hosts\\b", "\\bsync_hosts\\b", "\\bignore_nodes\\b",
"\\bsync_nodes\\b", "\\bignore_topics\\b",
"\\bignore_publishers\\b", "\\bignore_topics\\b",
"\\bsync_topics\\b", "\\bignore_subscribers\\b",
"\\bsync_services\\b", "\\bsync_topics_on_demand\\b",
"\\bsync_remote_nodes\\b"
]
for tag in tagList:
r.setPattern(tag)
self.rules.append((QRegExp(r), QTextCharFormat(f)))
f.setForeground(Qt.darkGreen)
f.setFontWeight(QFont.Bold)
attrList = ["\\b\\*|\\*\\B|\\/\\*"]
for attr in attrList:
r.setPattern(attr)
self.rules.append((QRegExp(r), QTextCharFormat(f)))
def __init__(self, parent=None):
QSyntaxHighlighter.__init__(self, parent)
self.rules = []
self.commentStart = QRegExp("#")
self.commentEnd = QRegExp("\n|\r")
self.default_format = QTextCharFormat()
self.default_format.setForeground(QColor(24, 24, 24))
self.commentFormat = QTextCharFormat()
self.commentFormat.setFontItalic(True)
self.commentFormat.setForeground(Qt.darkGray)
tagList = ["\\btrue\\b", "\\bfalse\\b"]
# create patterns for tags
for tag in tagList:
self.rules.append(
(self._create_regexp(tag), self._create_format(Qt.blue)))
# create pattern for digits
self.rules.append((self._create_regexp("\\d+"),
self._create_format(QColor(127, 64, 127))))
# create pattern for params
self.rules.append((self._create_regexp("\s*[_.\w]*\s*:"),
self._create_format(Qt.darkBlue)))
# create pattern for params
self.rules.append(
(self._create_regexp(":\s*:[_\.\w]*$|:\s*\@[_\.\w]*$"),
self._create_format(Qt.darkBlue)))
# create pattern for list signes
self.rules.append((self._create_regexp("^\s*-"),
self._create_format(Qt.darkRed, 'bold')))
# create pattern for ???
self.rules.append(
(self._create_regexp("^---$"), self._create_format(Qt.darkRed)))
# create pattern for braces
self.rules.append((self._create_regexp("[\[\]\{\}\,]"),
self._create_format(Qt.darkGreen)))
# create patterns for strings
self.rules.append((self._create_regexp("\".*\"|\'.*\'"),
self._create_format(Qt.blue)))
# create patterns for substitutions
self.rules.append((self._create_regexp("\\$\\(.*\\)"),
self._create_format(QColor(127, 64, 127))))
# create patterns for DOCTYPE
self.rules.append((self._create_regexp("<!DOCTYPE.*>"),
self._create_format(Qt.lightGray)))
self.rules.append((self._create_regexp("<\\?xml.*\\?>"),
self._create_format(Qt.lightGray)))
def __on_show_erroneous_check_box_state_changed(self, activated):
"""
If this checkBox is set, only erroneous hosts and nodes will be displayed.
:param activated: 2 if checkBox is set, 0 if check is unset
:type activated: Integer
"""
if activated is 2:
self.__filter_proxy.setFilterRegExp(QRegExp("error"))
self.__filter_proxy.setFilterKeyColumn(2)
else:
self.__filter_proxy.setFilterRegExp(QRegExp(""))
def __init__(self, parent=None):
QSyntaxHighlighter.__init__(self, parent)
self.rules = []
self.comment_start = QRegExp("<!--")
self.comment_end = QRegExp("-->")
self.comment_format = self._create_format(Qt.darkGray, 'italic')
# self.mark_background = QBrush(QColor(251, 247, 222))
# create patterns for braces
self.rules.append((self._create_regexp("</?|/?>"),
self._create_format(QColor(24, 24, 24))))
# create patterns for TAG
tag_list = '|'.join(
["\\b%s\\b" % t for t in self.LAUNCH_CHILDS.keys()])
self.rules.append(
(self._create_regexp(tag_list), self._create_format(Qt.darkRed)))
# create patterns for ATTRIBUTES
attr_list = '|'.join(
set([
"\\b%s" % attr for v in self.LAUNCH_ATTR.values()
for attr in v.keys()
]))
self.rules.append((self._create_regexp(attr_list),
self._create_format(QColor(0, 100,
0)))) # darkGreen
# create patterns for substitutions
self.rule_arg = (self._create_regexp("\\$\\(.*\\)"),
self._create_format(QColor(77, 0, 38)))
# create patterns for DOCTYPE
self.rules.append((self._create_regexp("<!DOCTYPE.*>"),
self._create_format(Qt.lightGray)))
self.rules.append((self._create_regexp("<\\?xml.*\\?>"),
self._create_format(Qt.lightGray)))
# create patterns for yaml parameter inside
self.rules.append((self._create_regexp("^\s*[_.\w]*\s*:"),
self._create_format(Qt.darkBlue)))
# create patterns for yaml oneline strings inside
self.rules.append(
(self._create_regexp("'.*'"), self._create_format(Qt.blue)))
# create pattern for list signes
self.rules.append((self._create_regexp("^\s*-"),
self._create_format(Qt.darkRed, 'bold')))
# create pattern for digits
self.rules.append((self._create_regexp("\\d+"),
self._create_format(QColor(127, 64, 127))))
# create patterns for strings
self.string_pattern = QRegExp("\"")
self.string_format = self._create_format(Qt.blue)
# part to select an XML block
self._tag_hl_range = [] # list with puples (start, length)
self._tag_hl_last = set() # set with blocks of last highlighted tags
def discover_frames(self):
# Define a search pattern, it will look for all namespaces that contain the 'received_control_mode' topic
search_pattern = re.compile(r'^(?!.*link).*')
# search_pattern = re.compile(r'^((?!.*link)|(.*base)).*$')
# Get the list of all currently availabel frames in TF1 (this is a temporary solution until a better one is found)
time.sleep(1) # Give tf time to start working
# all_frames = self._tf_listener.getFrameStrings()
yaml_frames = yaml.load(self._tf2_buffer.all_frames_as_yaml())
# Look through all avaiable topics
for entry in yaml_frames:
namespace = search_pattern.findall(entry)
if len(namespace):
self._available_frames.append(namespace[0])
# Sort the namespaces alphabetically
self._available_frames.sort()
# rospy.logdebug out the result of the search
# rospy.loginfo("Found robots with namespace: \n%s", self._available_frames)
# Add robots namespaces to combobox
self._combobox = self._widget.findChildren(QComboBox, QRegExp('frameSelector'))[0]
self._combobox.insertItems(0, self._available_frames)
self._namespace = self._combobox.currentText()
# Quit if no robots are found
if len(self._available_frames) == 0:
rospy.logerr("[%s]: No robots available !!", rospy.get_name())
sys.exit()
def _included_files(self, path):
'''
Returns all included files in the given file.
'''
result = []
with open(path, 'r') as f:
data = f.read()
reg = QRegExp("=[\s\t]*\".*\"")
reg.setMinimal(True)
pos = reg.indexIn(data)
while pos != -1 and self._isrunning:
try:
pp = interpret_path(reg.cap(0).strip('"'))
f = QFile(pp)
ext = os.path.splitext(pp)
if f.exists() and ext[1] in nm.settings().SEARCH_IN_EXT:
result.append(pp)
except Exception as exp:
parsed_text = pp
try:
parsed_text = reg.cap(0).strip('"')
except:
pass
self.warning_signal.emit("Error while parse '%s': %s" %
(parsed_text, exp))
pos += reg.matchedLength()
pos = reg.indexIn(data, pos)
return result
def _create_regexp(self,
pattern='',
cs=Qt.CaseInsensitive,
syntax=QRegExp.Wildcard,
minimal=False):
_regexp = QRegExp(pattern, cs, syntax)
_regexp.setMinimal(minimal)
return _regexp
def __init__(self, filename, parent=None):
self.parent = parent
QTextEdit.__init__(self, parent)
self.setObjectName('Editor - %s' % filename)
self.setContextMenuPolicy(Qt.CustomContextMenu)
self.customContextMenuRequested.connect(self.show_custom_context_menu)
# self.setFrameStyle(QFrame.StyledPanel | QFrame.Sunken)
self.setAcceptRichText(False)
font = QFont()
font.setFamily("Fixed".decode("utf-8"))
font.setPointSize(12)
self.setFont(font)
self.setLineWrapMode(QTextEdit.NoWrap)
self.setTabStopWidth(25)
self.setAcceptRichText(False)
self.setCursorWidth(2)
self.setFontFamily("courier new")
self.setProperty("backgroundVisible", True)
bg_style = "QTextEdit { background-color: #fffffc;}"
self.setStyleSheet("%s" % (bg_style))
self.setTextColor(QColor(0, 0, 0))
self.regexp_list = [QRegExp("\\binclude\\b"), QRegExp("\\btextfile\\b"),
QRegExp("\\bfile\\b"), QRegExp("\\bvalue=.*pkg:\/\/\\b"),
QRegExp("\\bvalue=.*package:\/\/\\b"),
QRegExp("\\bvalue=.*\$\(find\\b"),
QRegExp("\\bargs=.*\$\(find\\b"),
QRegExp("\\bdefault=.*\$\(find\\b")]
self.filename = filename
self.file_mtime = 0
# f = QFile(filename)
# if f.open(QIODevice.ReadOnly | QIODevice.Text):
# self.file_info = QFileInfo(filename)
# self.setText(unicode(f.readAll(), "utf-8"))
self.path = '.'
# enables drop events
self.setAcceptDrops(True)
# variables for threaded search
self._search_thread = None
self._stop = False
self._internal_args = {}
ext = os.path.splitext(filename)
if self.filename:
self.setText("")
_, self.file_mtime, file_content = nm.nmd().file.get_file_content(filename)
if ext[1] in ['.launch', '.xml']:
self._internal_args = get_internal_args(file_content)
self.setText(file_content)
self._is_launchfile = False
if ext[1] in ['.launch', '.xml', '.xacro', '.srdf', '.urdf']:
if ext[1] in ['.launch']:
self._is_launchfile = True
self.hl = XmlHighlighter(self.document(), is_launch=False)
self.cursorPositionChanged.connect(self._document_position_changed)
else:
self.hl = YamlHighlighter(self.document())
def setUp(self):
unittest.TestCase.setUp(self)
syntax_nr = QRegExp.RegExp
syntax = QRegExp.PatternSyntax(syntax_nr)
self._regExp = QRegExp(self._query_text, Qt.CaseInsensitive, syntax)
self._filter = TextFilter(self._regExp)
self._filter.set_text(self._query_text)
def filter_by_item(self, item):
"""
Used to tell the filter by which item should filter. If the AbstractItem is None all log entries should be shown.
:param item: the item by which the filter should filter
:type item: AbstractItem
"""
self.invalidateFilter()
if item is not None:
self.setFilterRegExp(QRegExp(".*" + item.get_seuid() + ".*"))
self.setFilterKeyColumn(2)
def included_files(cls, text_or_path, regexp_list=[QRegExp("\\btextfile\\b"),
QRegExp("\\bfile\\b"),
QRegExp("\\bdefault\\b"),
QRegExp("\\bvalue=.*pkg:\/\/\\b"),
QRegExp("\\bvalue=.*package:\/\/\\b"),
QRegExp("\\bvalue=.*\$\(find\\b"),
QRegExp("\\bargs=.*\$\(find\\b")],
recursive=True, unique=True):
result = []
lines = []
pwd = '.'
f = QFile(text_or_path)
if f.exists():
pwd = os.path.dirname(text_or_path)
with open(text_or_path, 'r') as f:
content = f.read()
# remove the comments
comment_pattern = QRegExp("<!--.*?-->")
pos = comment_pattern.indexIn(content)
while pos != -1:
content = content[:pos] + content[pos + comment_pattern.matchedLength():]
pos = comment_pattern.indexIn(content)
lines = content.splitlines()
else:
lines = [text_or_path]
line_index = 0
for line in lines:
index = cls._index(line, regexp_list)
if index > -1:
startIndex = line.find('"', index)
if startIndex > -1:
endIndex = line.find('"', startIndex + 1)
fileName = line[startIndex + 1:endIndex]
if len(fileName) > 0:
try:
path = cls.interpretPath(fileName, pwd)
if os.path.isfile(path):
if not unique:
result.append((line_index, path))
else:
result.append(path)
ext = os.path.splitext(path)
if recursive and ext[1] in nm.settings().SEARCH_IN_EXT:
result += cls.included_files(path, regexp_list)
except Exception:
import traceback
print traceback.format_exc()
line_index += 1
if unique:
return list(set(result))
return result
def __init__(self, filename, parent=None):
self.parent = parent
QTextEdit.__init__(self, parent)
self.setObjectName('Editor - %s' % filename)
self.setContextMenuPolicy(Qt.CustomContextMenu)
self.customContextMenuRequested.connect(self.show_custom_context_menu)
# self.setFrameStyle(QFrame.StyledPanel | QFrame.Sunken)
self.setAcceptRichText(False)
font = QFont()
font.setFamily('Fixed')
font.setPointSize(12)
self.setFont(font)
self.setLineWrapMode(QTextEdit.NoWrap)
self.setTabStopWidth(25)
self.setAcceptRichText(False)
self.setCursorWidth(2)
self.setFontFamily("courier new")
self.setProperty("backgroundVisible", True)
bg_style = "QTextEdit { background-color: #fffffc;}"
self.setStyleSheet("%s" % (bg_style))
self.setTextColor(QColor(0, 0, 0))
self.regexp_list = [
QRegExp("\\binclude\\b"),
QRegExp("\\btextfile\\b"),
QRegExp("\\bfile\\b"),
QRegExp("\\bvalue=.*pkg:\/\/\\b"),
QRegExp("\\bvalue=.*package:\/\/\\b"),
QRegExp("\\bvalue=.*\$\(find\\b"),
QRegExp("\\bargs=.*\$\(find\\b"),
QRegExp("\\bdefault=.*\$\(find\\b")
]
self.filename = filename
self.file_mtime = 0
# f = QFile(filename)
# if f.open(QIODevice.ReadOnly | QIODevice.Text):
# self.file_info = QFileInfo(filename)
# self.setText(unicode(f.readAll(), "utf-8"))
self.path = '.'
# variables for threaded search
self._search_thread = None
self._stop = False
self._internal_args = {}
self._ext = os.path.splitext(filename)[1]
self.setText("Loading file content ... press F5 to reload!")
self.setReadOnly(True)
self._to_select = []
nm.nmd().file.file_content.connect(self._apply_file_content)
nm.nmd().file.error.connect(self._on_nmd_error)
if self.filename:
nm.nmd().file.get_file_content_threaded(filename)
def set_text(self, text):
"""
Setter for _text
:param text: text to set ''str''
:emits filter_changed_signal: If _enabled is true
"""
super(TextFilter, self).set_text(text)
syntax_nr = QRegExp.RegExp
syntax = QRegExp.PatternSyntax(syntax_nr)
self.regex = QRegExp(text, Qt.CaseInsensitive, syntax)
self.set_regex(self.regex)
def getIncludedFiles(cls,
inc_file,
regexp_list=[
QRegExp("\\binclude\\b"),
QRegExp("\\btextfile\\b"),
QRegExp("\\bfile\\b"),
QRegExp("\\bdefault\\b"),
QRegExp("\\bvalue=.*pkg:\/\/\\b"),
QRegExp("\\bvalue=.*package:\/\/\\b"),
QRegExp("\\bvalue=.*\$\(find\\b")
]):
'''
Reads the configuration file and searches for included files. This files
will be returned in a list.
@param inc_file: path of the ROS launch file
@param regexp_list: pattern of
@return: the list with all files needed for the configuration
@rtype: C{[str,...]}
'''
result = set()
with open(inc_file, 'r') as f:
content = f.read()
# remove the comments
comment_pattern = QRegExp("<!--.*?-->")
pos = comment_pattern.indexIn(content)
while pos != -1:
content = content[:pos] + content[pos + comment_pattern.
matchedLength():]
pos = comment_pattern.indexIn(content)
lines = content.splitlines()
for line in lines:
index = cls._index(line, regexp_list)
if index > -1:
startIndex = line.find('"', index)
if startIndex > -1:
endIndex = line.find('"', startIndex + 1)
fileName = line[startIndex + 1:endIndex]
if len(fileName) > 0:
try:
path = cls.interpretPath(fileName,
os.path.dirname(inc_file))
if os.path.isfile(path):
result.add(path)
if path.endswith('.launch'):
result.update(
cls.getIncludedFiles(
path, regexp_list))
except:
pass
return list(result)
def __init__(self, filename, parent=None):
self.parent = parent
QTextEdit.__init__(self, parent)
self.setObjectName(' - '.join(['Editor', filename]))
self.setContextMenuPolicy(Qt.CustomContextMenu)
self.customContextMenuRequested.connect(self.show_custom_context_menu)
# self.setFrameStyle(QFrame.StyledPanel | QFrame.Sunken)
self.setAcceptRichText(False)
font = QFont()
font.setFamily("Fixed".decode("utf-8"))
font.setPointSize(12)
self.setFont(font)
self.setLineWrapMode(QTextEdit.NoWrap)
self.setTabStopWidth(25)
self.setAcceptRichText(False)
self.setCursorWidth(2)
self.setFontFamily("courier new")
self.setProperty("backgroundVisible", True)
self.regexp_list = [
QRegExp("\\binclude\\b"),
QRegExp("\\btextfile\\b"),
QRegExp("\\bfile\\b"),
QRegExp("\\bvalue=.*pkg:\/\/\\b"),
QRegExp("\\bvalue=.*package:\/\/\\b"),
QRegExp("\\bvalue=.*\$\(find\\b"),
QRegExp("\\bargs=.*\$\(find\\b"),
QRegExp("\\bdefault=.*\$\(find\\b")
]
self.filename = filename
self.file_info = None
if self.filename:
f = QFile(filename)
if f.open(QIODevice.ReadOnly | QIODevice.Text):
self.file_info = QFileInfo(filename)
self.setText(unicode(f.readAll(), "utf-8"))
self.path = '.'
# enables drop events
self.setAcceptDrops(True)
if filename.endswith('.launch'):
self.hl = XmlHighlighter(self.document())
self.cursorPositionChanged.connect(self._document_position_changed)
else:
self.hl = YamlHighlighter(self.document())
# variables for threaded search
self._search_thread = None
self._stop = False
def __init__(self, nodename, masteruri, layout, parent=None):
'''
Creates a new item.
'''
QObject.__init__(self, parent)
self.setObjectName("LoggerHandler")
self.nodename = nodename
self.masteruri = masteruri
self._filter = QRegExp('', Qt.CaseInsensitive, QRegExp.Wildcard)
self._logger_items = {} # logger name: LoggerItem
self.layout = layout
self._change_all_cancel = False
self._stored_values = {}
self.loggers_signal.connect(self._handle_loggers)
self._thread_update = None
self._thread_set_all = None
def _test_message(self, value):
if not self.is_enabled():
return False
if self._text != '':
if self._regex:
temp = self._text
if temp[0] != '^':
temp = '.*' + temp
if temp[-1] != '$':
temp += '.*'
if QRegExp(temp).exactMatch(value):
return True
else:
if value.find(self._text) != -1:
return True
return False
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 test_message(self, message):
"""
Tests if the message matches the filter.
If the regex flag is False simple 'is this in that' text matching is used
on _text. If the regex flag is True _text is treated as a regular expression
with one exception. If it does not start with a ^ a .* is appended, and if
it does not end with a $ then a .* is added to the end.
:param message: the message to be tested against the filters, ''Message''
:returns: True if the message matches, ''bool''
"""
if self.is_enabled() and self._text != '':
if self._regex:
temp = self._text
if temp[0] != '^':
temp = '.*' + temp
if temp[-1] != '$':
temp += '.*'
if QRegExp(temp).exactMatch(message._location):
return True
else:
if message._location.find(self._text) != -1:
return True
return False
def set_package_filter(self, text):
self.launchlist_proxyModel.setFilterRegExp(QRegExp(text,
Qt.CaseInsensitive,
QRegExp.Wildcard))
def createEditor(self, parent, option, index):
print option
print index.column()
indices = [2, 3, 4]
if index.column() not in indices:
return None
print "create_edit"
if index.column() == 3:
widget = QWidget(parent)
slider = QSlider(Qt.Horizontal, widget)
text_edit = QLineEdit(widget)
text_edit.setFocus()
text_edit.selectAll()
text_edit.setAlignment(Qt.AlignHCenter | Qt.AlignVCenter)
hbox = QVBoxLayout()
# slider.setMinimumWidth(400)
# hbox.setMargin(0);
hbox.setContentsMargins(2,1,2,1);
# min_label = QLabel("min")
# max_label = QLabel("max")
# vbox.addWidget(min_label)
hbox.addWidget(slider)
hbox.addWidget(text_edit)
# vbox.addWidget(max_label)
widget.setLayout(hbox)
# widget.setMinimumWidth(400)
slider.setMinimumHeight(32)
text_edit.setMinimumHeight(36)
widget.setMinimumHeight(80)
widget.setAutoFillBackground(True)
widget.setStyleSheet(".QWidget { background:rgb(200, 200, 200); margin:0px; border:1px solid rgb(170, 170, 170); }")
# parent.setMinimumWidth(300)
row = index.row()
imin = index.sibling(row, self._column_names.index("min"))
imax = index.sibling(row, self._column_names.index("max"))
smin = index.model().data(imin, Qt.EditRole)
smax = index.model().data(imax, Qt.EditRole)
fmin = 0
fmax = 100
def isFloat(s):
try:
float(s)
return True
except:
return False
if isFloat(smin):
fmin = float(smin)
if isFloat(smax):
fmax = float(smax)
print fmin, fmax
slider.setMinimum(int(fmin * 100))
slider.setMaximum(int(fmax * 100))
slider.setMouseTracking(True)
@Slot(int)
def sliderValueChanged(value):
text_edit.setText(str(float(value)/100.))
print "slider value changed to %d" % value
text_edit.setFocus()
text_edit.selectAll()
pass
@Slot()
def sliderDown():
print "slider pressed"
@Slot()
def sliderUp():
print "slider released"
@Slot()
def editingFinished():
text = text_edit.text()
value = float(text)
nvalue = value
nvalue = min(nvalue, fmax)
nvalue = max(nvalue, fmin)
# print "nvalue is", nvalue
if value != nvalue:
text_edit.setText(str(nvalue))
svalue = int(nvalue*100)
print "text changed to %s" % text
print "nvalue is", nvalue
print "svalue is %d" % svalue
slider.blockSignals(True)
slider.setSliderPosition(svalue)
slider.blockSignals(False)
pass
@Slot(str)
def lineEditTextChanged(text):
# text_edit.setText(str(value))
# slider.setSliderDown(True)
# slider.sliderPressed.emit()
print "setSliderDown"
if not isFloat(text):
return
value = float(text)
nvalue = value
# nvalue = min(nvalue, fmax)
# nvalue = max(nvalue, fmin)
# print "nvalue is", nvalue
if value != nvalue:
text_edit.setText(str(nvalue))
svalue = int(nvalue*100)
print "text changed to %s" % text
print "nvalue is", nvalue
print "svalue is %d" % svalue
slider.blockSignals(True)
slider.setSliderPosition(svalue)
slider.blockSignals(False)
pass
slider.valueChanged.connect(sliderValueChanged)
slider.sliderPressed.connect(sliderDown)
slider.sliderReleased.connect(sliderUp)
text_edit.textChanged.connect(lineEditTextChanged)
text_edit.editingFinished.connect(editingFinished)
text_edit.selectAll()
text_edit.setFocus()
rx = QRegExp("^-?([1-9]\d*|0)(\.\d*)?$")
v = QRegExpValidator(rx)
text_edit.setValidator(v)
widget.setFocusProxy(text_edit)
edt = widget
else:
edt = QLineEdit(parent)
if index.column() == 2:
edt.setAlignment(Qt.AlignRight | Qt.AlignVCenter)
elif index.column() == 4:
edt.setAlignment(Qt.AlignLeft | Qt.AlignVCenter)
rx = QRegExp("^-?([1-9]\d*|0)(\.\d*)?$")
v = QRegExpValidator(rx);
edt.setValidator(v)
# edt.setInputMask("#00000000")
return edt
def _create_regexp(self, pattern=''):
_regexp = QRegExp()
_regexp.setMinimal(True)
_regexp.setPattern(pattern)
return _regexp
def mark_block(self, block, position):
text = block.text()
word, idx_word = self._get_current_word(text, position)
for hlblock in self._tag_hl_last:
self.rehighlightBlock(hlblock)
del self._tag_hl_last[:]
self._tag_hl_range = [(idx_word, len(word))]
next_block = block
open_braces = 0
closed_braces = 0
idx_search = idx_word
rindex = -1
loop = 0
tag_len = 0
if self._isclosetag(word):
# we are at the close tag: search for the open tag
opentag = '<%s' % self._get_tag(word)
tag_len = len(opentag)
while rindex == -1 and next_block.isValid():
rindex = text.rfind(opentag, 0, idx_search)
obr, cbr = self._get_braces_count(
text[rindex if rindex != -1 else 0:idx_search])
open_braces += obr
closed_braces += cbr
loop += 1
if loop > 50000:
rindex = -1
break
if rindex == -1:
next_block = next_block.previous()
text = next_block.text()
idx_search = len(text)
elif open_braces <= closed_braces:
idx_search = rindex
rindex = -1
elif self._isopentag(word):
# we are at the open tag: search for the close tag
closetag = QRegExp("</%s>|/>" % self._get_tag(word))
closetag.setMinimal(True)
while rindex == -1 and next_block.isValid():
rindex = closetag.indexIn(text, idx_search)
max_search_idx = rindex + closetag.matchedLength(
) if rindex != -1 else len(text)
obr, cbr = self._get_braces_count(
text[idx_search:max_search_idx])
open_braces += obr
closed_braces += cbr
loop += 1
if loop > 50000:
rindex = -1
break
if rindex == -1:
next_block = next_block.next()
text = next_block.text()
idx_search = 0
elif open_braces > closed_braces:
idx_search = rindex + closetag.matchedLength()
rindex = -1
tag_len = closetag.matchedLength()
else:
self._tag_hl_range = []
self._end_tag_found = rindex != -1
if self._tag_hl_range and block != next_block:
self.rehighlightBlock(block)
self._tag_hl_last.append(block)
if rindex != -1:
self._tag_hl_range.append((rindex, tag_len))
self.rehighlightBlock(next_block)
self._tag_hl_last.append(next_block)
def __init__(self, parent=None, is_launch=True):
QSyntaxHighlighter.__init__(self, parent)
self._is_launch = is_launch
self.rules = []
self.comment_start = QRegExp("<!--")
self.comment_end = QRegExp("-->")
self.comment_format = self._create_format(Qt.darkGray, 'italic')
# self.mark_background = QBrush(QColor(251, 247, 222))
# create patterns for braces
self.rules.append((self._create_regexp("</?|/?>"),
self._create_format(QColor(24, 24, 24))))
# create patterns for TAG
if self._is_launch:
tag_list = '|'.join(
["\\b%s\\b" % t for t in self.LAUNCH_CHILDS.keys()])
self.rules.append((self._create_regexp(tag_list),
self._create_format(Qt.darkRed)))
else:
self.rules.append(
(self._create_regexp(">|/>|<[/.\w:]*[\s\t>]|<[/.\w:]*$"),
self._create_format(Qt.darkRed)))
# create patterns for ATTRIBUTES
if self._is_launch:
attr_list = '|'.join(
set([
"\\b%s" % attr for v in self.LAUNCH_ATTR.values()
for attr in v.keys()
]))
self.rules.append((self._create_regexp(attr_list),
self._create_format(QColor(0, 100,
0)))) # darkGreen
else:
self.rules.append((self._create_regexp("[_.\w]*="),
self._create_format(QColor(0, 100,
0)))) # darkGreen
# create patterns for substitutions
self.rule_arg = (self._create_regexp("\\$\\(.*\\)"),
self._create_format(QColor(77, 0, 38)))
# create patterns for DOCTYPE
self.rules.append((self._create_regexp("<!DOCTYPE.*>"),
self._create_format(Qt.lightGray)))
self.rules.append((self._create_regexp("<\\?xml.*\\?>"),
self._create_format(Qt.lightGray)))
# create patterns for yaml parameter inside
self.rules.append((self._create_regexp("[_.\w]*\s*:"),
self._create_format(Qt.darkBlue)))
# create patterns for yaml oneline strings inside
self.rules.append(
(self._create_regexp("'.*'"), self._create_format(Qt.blue)))
# create pattern for list signes
self.rules.append((self._create_regexp("^\s*-"),
self._create_format(Qt.darkRed, 'bold')))
# create pattern for digits
self.rules.append((self._create_regexp("\\d+"),
self._create_format(QColor(127, 64, 127))))
self.yaml_comment_rule = (self._create_regexp("#[.]*"),
self._create_format(Qt.darkGray))
# create deprecated
self.dep_pattern = []
if self.DEPRECATED_PARAMETER:
attr_list = '|'.join(
set([
r'name="%s"' % attr
for attr in self.DEPRECATED_PARAMETER.keys()
]))
# print(attr_list)
self.dep_pattern.append(
(self._create_regexp(attr_list),
self._create_format(QColor(250, 0, 0), 'bold'))) # red
# create patterns for strings
self.string_pattern = QRegExp("\"")
self.string_format = self._create_format(Qt.blue)
# part to select an XML block
self._tag_hl_range = [] # list with puples (start, length)
self._tag_hl_last = [] # set with blocks of last highlighted tags
self._color_hl_tag = QColor(255, 128, 0)
def _process_highlight_exclude_filter(self,
selection,
selectiontype,
exclude=False):
"""
Modifies the relevant filters (based on selectiontype) to remove (exclude=True)
or highlight (exclude=False) the selection from the dataset in the tableview.
:param selection: the actual selection, ''str''
:param selectiontype: the type of selection, ''str''
:param exclude: If True process as an exclude filter, False process as an highlight filter, ''bool''
"""
types = {
self.tr('Node'): 2,
self.tr('Topic'): 4,
self.tr('Severity'): 1,
self.tr('Message'): 0
}
try:
col = types[selectiontype]
except:
raise RuntimeError(
"Bad Column name in ConsoleWidget._process_highlight_exclude_filter()"
)
if col == 0:
unique_messages = set()
selected_indexes = self.table_view.selectionModel(
).selectedIndexes()
num_selected = len(selected_indexes) / 6
for index in range(num_selected):
unique_messages.add(selected_indexes[num_selected * col +
index].data())
unique_messages = list(unique_messages)
for message in unique_messages:
message = message.replace('\\', '\\\\')
message = message.replace('.', '\\.')
if exclude:
filter_index = self._add_exclude_filter(
selectiontype.lower())
filter_widget = self._exclude_filters[filter_index][
1].findChildren(QWidget,
QRegExp('.*FilterWidget.*'))[0]
else:
filter_index = self._add_highlight_filter(col)
filter_widget = self._highlight_filters[filter_index][
1].findChildren(QWidget,
QRegExp('.*FilterWidget.*'))[0]
filter_widget.set_regex(True)
filter_widget.set_text('^' + message + '$')
else:
if exclude:
# Test if the filter we are adding already exists if it does use the existing filter
if self.filter_factory[selectiontype.lower()][1] not in [
type(item) for sublist in self._exclude_filters
for item in sublist
]:
filter_index = self._add_exclude_filter(
selectiontype.lower())
else:
for index, item in enumerate(self._exclude_filters):
if type(item[0]) == self.filter_factory[
selectiontype.lower()][1]:
filter_index = index
else:
# Test if the filter we are adding already exists if it does use the existing filter
if self.filter_factory[selectiontype.lower()][1] not in [
type(item) for sublist in self._highlight_filters
for item in sublist
]:
filter_index = self._add_highlight_filter(col)
else:
for index, item in enumerate(self._highlight_filters):
if type(item[0]) == self.filter_factory[
selectiontype.lower()][1]:
filter_index = index
if exclude:
filter_widget = self._exclude_filters[filter_index][
1].findChildren(QWidget, QRegExp('.*FilterWidget.*'))[0]
filter_widget.select_item(selection)
else:
filter_widget = self._highlight_filters[filter_index][
1].findChildren(QWidget, QRegExp('.*FilterWidget.*'))[0]
filter_widget.select_item(selection)
def filter(self, text):
self._filter = QRegExp(text, Qt.CaseInsensitive, QRegExp.Wildcard)
for name, item in self._logger_items.items():
hidden = self._filter.indexIn(name) != -1
item.setVisible(hidden)
def __init__(self, document, is_dark=False, default=None):
QSyntaxHighlighter.__init__(self, document)
def contents_changed():
self.highlightBlock("document.toPlainText()")
document.contentsChanged.connect(contents_changed)
self.is_dark = is_dark
self.default = default
global reformat
if is_dark:
STYLES = DARK_STYLES
else:
STYLES = BRIGHT_STYLES
if default != None:
STYLES['defaults'] = reformat(*default)
# Multi-line strings (expression, flag, style)
# FIXME: The triple-quotes in these two lines will mess up the
# syntax highlighting from this point onward
self.tri_single = (QRegExp("'''"), 1, STYLES['string2'])
self.tri_double = (QRegExp('"""'), 2, STYLES['string2'])
rules = []
rules += [(r'%s' % w, 0, STYLES['defaults'])
for w in PythonHighlighter.defaults]
# Keyword, operator, and brace rules
rules += [(r'\b%s\b' % w, 0, STYLES['keyword'])
for w in PythonHighlighter.keywords]
rules += [(r'%s' % o, 0, STYLES['operator'])
for o in PythonHighlighter.operators]
rules += [(r'%s' % b, 0, STYLES['brace'])
for b in PythonHighlighter.braces]
# All other rules
rules += [
# 'self'
(r'\bself\b', 0, STYLES['self']),
# Double-quoted string, possibly containing escape sequences
(r'"[^"\\]*(\\.[^"\\]*)*"', 0, STYLES['string']),
# Single-quoted string, possibly containing escape sequences
(r"'[^'\\]*(\\.[^'\\]*)*'", 0, STYLES['string']),
# 'def' followed by an identifier
(r'\bdef\b\s*(\w+)', 1, STYLES['defclass']),
# 'class' followed by an identifier
(r'\bclass\b\s*(\w+)', 1, STYLES['defclass']),
# From '#' until a newline
(r'#[^\n]*', 0, STYLES['comment']),
# Numeric literals
(r'\b[+-]?[0-9]+[lL]?\b', 0, STYLES['numbers']),
(r'\b[+-]?0[xX][0-9A-Fa-f]+[lL]?\b', 0, STYLES['numbers']),
(r'\b[+-]?[0-9]+(?:\.[0-9]+)?(?:[eE][+-]?[0-9]+)?\b', 0,
STYLES['numbers']),
]
# Build a QRegExp for each pattern
self.rules = [(QRegExp(pat), index, fmt)
for (pat, index, fmt) in rules]
def __init__(self, model):
"""
Initializes the Widget.
:param model: the model of the widget
:type model: ROSModel
"""
super(SelectionWidget, self).__init__()
self.setObjectName('selection_widget')
self.__model = model
# Get path to UI file which is a sibling of this file
self.rp = rospkg.RosPack()
ui_file = os.path.join(self.rp.get_path('arni_rqt_detail_plugin'), 'resources', 'SelectionWidget.ui')
# Extend the widget with all attributes and children from UI file
loadUi(ui_file, self)
self.setObjectName('SelectionWidgetUi')
self.__selected_item = None
self.__draw_graphs = True
self.__current_combo_box_index = 0
self.__last_update = rospy.Time.now()
try:
if rospy.get_param("/enable_statistics") == False:
raise KeyError('/enable_statistics')
except KeyError:
self.__overview_widget = None
raise EnvironmentError("/enable_statistics is either not set or set to false - arni gui would not work correctly. Please make sure to start "
"roscore with the neccesary parameters or to load these while running (see init_params.launch)")
self.__values_dict = {
"bandwidth_mean": 0,
"bandwidth_stddev": 0,
"bandwidth_max": 0,
}
self.__logger = self.__model.get_logger()
self.__log_filter_proxy = LogFilterProxy()
self.__log_filter_proxy.filter_by_item(self.__selected_item)
self.__log_filter_proxy.setDynamicSortFilter(True)
self.__log_filter_proxy.setSourceModel(self.__logger.get_representation())
self.log_tab_tree_view.setModel(self.__log_filter_proxy)
self.__log_delegate = LogDelegate()
self.log_tab_tree_view.setItemDelegate(self.__log_delegate)
self.__style_string = ".detailed_data {\n" \
" font-size: 12\n;" \
"}\n"
self.__style_string = ".erroneous_entry {\n" \
" color: red\n;" \
"}\n"
self.information_tab_text_browser.setStyleSheet(self.__style_string)
self.range_combo_box.clear()
self.range_combo_box.addItem("10 " + self.tr("Seconds"))
self.range_combo_box.addItem("30 " + self.tr("Seconds"))
self.range_combo_box.addItem("60 " + self.tr("Seconds"))
self.range_combo_box.setCurrentIndex(0)
#self.scrollAreaWidgetContents_2.setWidget(self.host_node_label)
self.tab_widget.setTabText(0, self.tr("Information"))
self.tab_widget.setTabText(1, self.tr("Graphs"))
self.tab_widget.setTabText(2, self.tr("Log"))
self.tab_widget.setTabText(3, self.tr("Actions"))
self.stop_push_button.setText(self.tr("Stop Node"))
self.restart_push_button.setText(self.tr("Restart Node"))
self.stop_push_button.setEnabled(False)
self.restart_push_button.setEnabled(False)
### CARSON ADDED ###
# set default values for throttle rate and window sliders
self.throttle_rate_slider.setFocusPolicy(Qt.StrongFocus)
self.throttle_rate_slider.setValue(5000)
self.throttle_window_slider.setFocusPolicy(Qt.StrongFocus)
self.throttle_window_slider.setValue(500)
# set up validator for throttle rate and window text fields
# only allows floating point numbers
regex = QRegExp(r'[0-9]*\.?[0-9]+')
validator = QRegExpValidator(regex)
self.throttle_rate.setValidator(validator)
self.throttle_window.setValidator(validator)
# set up QButtonGroup for message/bandwidth throttle type radio buttons
self.throttle_radio_group = QButtonGroup()
self.throttle_radio_group.addButton(self.throttle_message_radio)
self.throttle_radio_group.addButton(self.throttle_bandwidth_radio)
self.throttle_radio_group.buttonClicked.connect(self.__on_type_button_clicked)
### ###
self.selected_label.setText(self.tr("Selected") + ":")
self.range_label.setText(self.tr("Range") + ":")
self.log_tab_tree_view.setRootIsDecorated(False)
self.log_tab_tree_view.setAlternatingRowColors(True)
self.log_tab_tree_view.setSortingEnabled(True)
self.log_tab_tree_view.sortByColumn(1, Qt.AscendingOrder)
self.__current_range_combo_box_index = 0
self.__current_selected_combo_box_index = 0
self.set_selected_item(self.__selected_item)
self.__model.layoutChanged.connect(self.update)
self.__state = "ok"
self.__previous_state = "ok"
self.__selected_item_changed = True
self.__deleted = False
pg.setConfigOption('background', 'w')
pg.setConfigOption('foreground', 'k')
self.__graph_layout = ResizeableGraphicsLayoutWidget(self.__on_graph_window_size_changed)
self.graph_scroll_area.setWidget(self.__graph_layout)
self.__plotable_items = None#self.__selected_item.get_plotable_items()
self.__items_per_group = 1
self.__expected_items_per_group = 1
self.__number_of_groups = 1
self.__update_graphs_lock = Lock()
self.__first_update_pending = True
self.__graph_dict = {}
self.__plotted_curves = {}
#self.create_graphs()
self.__timer = Timer(Duration(secs=1.0), self.update_graphs)
