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 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 _create_regexp(self,
pattern='',
cs=Qt.CaseInsensitive,
syntax=QRegExp.Wildcard,
minimal=False):
_regexp = QRegExp(pattern, cs, syntax)
_regexp.setMinimal(minimal)
return _regexp
def included_files(cls, text_or_path,
regexp_retruns=[],
regexp_filelist=[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):
'''
:param regexp_retruns: the list with patterns which are returned as result. If empy it's the same as 'regexp_filelist'
:param regexp_filelist: the list with all patterns to find include files
'''
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_filelist)
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 regexp_retruns or cls._index(line, regexp_retruns) > -1:
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_retruns, regexp_filelist)
except Exception:
import traceback
print traceback.format_exc()
line_index += 1
if unique:
return list(set(result))
return result
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 _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 __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 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 __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 _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 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 __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
class SyncHighlighter(QSyntaxHighlighter):
'''
Enabled the syntax highlightning for the sync interface.
'''
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)))
# f.setForeground(Qt.red)
# f.setFontWeight(QFont.Bold)
# attrList = ["\\s\\*"]
# for attr in attrList:
# r.setPattern(attr)
# self.rules.append((QRegExp(r), QTextCharFormat(f)))
def highlightBlock(self, text):
for pattern, myformat in self.rules:
index = pattern.indexIn(text)
while index >= 0:
length = pattern.matchedLength()
self.setFormat(index, length, myformat)
index = pattern.indexIn(text, index + length)
self.setCurrentBlockState(0)
startIndex = 0
if self.previousBlockState() != 1:
startIndex = self.commentStart.indexIn(text)
if startIndex >= 0:
commentLength = len(text) - startIndex
self.setFormat(startIndex, commentLength, self.commentFormat)
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())
class SyncHighlighter(QSyntaxHighlighter):
'''
Enabled the syntax highlightning for the sync interface.
'''
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)))
# f.setForeground(Qt.red)
# f.setFontWeight(QFont.Bold)
# attrList = ["\\s\\*"]
# for attr in attrList:
# r.setPattern(attr)
# self.rules.append((QRegExp(r), QTextCharFormat(f)))
def highlightBlock(self, text):
for pattern, myformat in self.rules:
index = pattern.indexIn(text)
while index >= 0:
length = pattern.matchedLength()
self.setFormat(index, length, myformat)
index = pattern.indexIn(text, index + length)
self.setCurrentBlockState(0)
startIndex = 0
if self.previousBlockState() != 1:
startIndex = self.commentStart.indexIn(text)
if startIndex >= 0:
commentLength = len(text) - startIndex
self.setFormat(startIndex, commentLength, self.commentFormat)
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 __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 __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 _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):
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 __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 __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
class XmlHighlighter(QSyntaxHighlighter):
'''
Enabled the syntax highlightning for the ROS launch files.
'''
LAUNCH_LAUNCH_CHILDS = [
'group', 'node', 'test', 'env', 'remap', 'rosparam', 'param',
'machine', 'include', 'arg'
]
LAUNCH_LAUNCH_ATTR = {'deprecated=': '"message"'}
LAUNCH_GROUP_CHILDS = [
'node', 'test', 'env', 'remap', 'rosparam', 'param', 'machine',
'include', 'arg'
]
LAUNCH_GROUP_ATTR = {'ns=': '"foo"', 'clear_params=': '"true|false"'}
LAUNCH_MACHINE_CHILDS = ['env']
LAUNCH_MACHINE_ATTR = {
'name=': '"machine-name"',
'address=': '"blah.willowgarage.com"',
'env-loader=': '"/opt/ros/fuerte/env.sh"',
'default=': '"true|false|never"',
'user='******'"username"',
'password='******'"passwhat"',
'timeout=': '"10.0"'
}
LAUNCH_NODE_CHILDS = ['env', 'remap', 'rosparam', 'param']
LAUNCH_NODE_ATTR = {
'pkg=': '"mypackage"',
'type=': '"nodetype"',
'name=': '"nodename"',
'args=': '"arg1"',
'machine=': '"machine-name"',
'respawn=': '"true"',
'required=': '"true"',
'ns=': '"foo"',
'clear_params=': '"true|false"',
'output=': '"log|screen"',
'cwd=': '"ROS_HOME|node"',
'launch-prefix=': '"prefix arguments"'
}
LAUNCH_INCLUDE_CHILDS = ['env', 'arg']
LAUNCH_INCLUDE_ATTR = {
'file=': '"$(find pkg-name)/path/filename.xml"',
'ns=': '"foo"',
'clear_params=': '"true|false"',
'pass_all_args=': '"true|false"'
}
LAUNCH_REMAP_ATTR = {'from=': '"originalname"', 'to=': '"newname"'}
LAUNCH_ENV_ATTR = {'name=': '"name"', 'value=': '"value"'}
LAUNCH_PARAM_ATTR = {
'name=': '"namespace/name"',
'value=': '"value"',
'type=': '"str|int|double|bool"',
'textfile=': '"$(find pkg-name)/path/file.txt"',
'binfile=': '"$(find pkg-name)/path/file"',
'command=': '"$(find pkg-name)/exe \'$(find pkg-name)/arg.txt\'"'
}
LAUNCH_ROSPARAM_ATTR = {
'command=': '"load|dump|delete"',
'file=': '"$(find pkg-name)/path/foo.yaml"',
'param=': '"name"',
'ns=': '"foo"',
'subst_value=': '"true|false"'
}
LAUNCH_ARG_ATTR = {
'name=': '"name"',
'value=': '"bar"',
'default=': '"defbar"'
}
LAUNCH_TEST_CHILDS = ['env', 'remap', 'rosparam', 'param']
LAUNCH_TEST_ATTR = {
'pkg=': '"mypackage"',
'type=': '"nodetype"',
'name=': '"nodename"',
'test-name=': '"test_name"',
'args=': '"arg1"',
'ns=': '"foo"',
'clear_params=': '"true|false"',
'retry=': '"0"',
'cwd=': '"ROS_HOME|node"',
'launch-prefix=': '"prefix arguments"',
'time-limit=': '"60.0"'
}
LAUNCH_CHILDS = {
'launch': LAUNCH_LAUNCH_CHILDS,
'group': LAUNCH_GROUP_CHILDS,
'machine': LAUNCH_MACHINE_CHILDS,
'node': LAUNCH_NODE_CHILDS,
'include': LAUNCH_INCLUDE_CHILDS,
'remap': [],
'env': [],
'param': [],
'rosparam': [],
'arg': [],
'test': LAUNCH_TEST_CHILDS
}
LAUNCH_ATT_GLOBAL = {'if=': '""', 'unless=': '""'}
LAUNCH_LAUNCH_ATTR.update(LAUNCH_ATT_GLOBAL)
LAUNCH_GROUP_ATTR.update(LAUNCH_ATT_GLOBAL)
LAUNCH_MACHINE_ATTR.update(LAUNCH_ATT_GLOBAL)
LAUNCH_NODE_ATTR.update(LAUNCH_ATT_GLOBAL)
LAUNCH_INCLUDE_ATTR.update(LAUNCH_ATT_GLOBAL)
LAUNCH_REMAP_ATTR.update(LAUNCH_ATT_GLOBAL)
LAUNCH_ENV_ATTR.update(LAUNCH_ATT_GLOBAL)
LAUNCH_PARAM_ATTR.update(LAUNCH_ATT_GLOBAL)
LAUNCH_ROSPARAM_ATTR.update(LAUNCH_ATT_GLOBAL)
LAUNCH_ARG_ATTR.update(LAUNCH_ATT_GLOBAL)
LAUNCH_TEST_ATTR.update(LAUNCH_ATT_GLOBAL)
LAUNCH_ATTR = {
'launch': LAUNCH_LAUNCH_ATTR,
'group': LAUNCH_GROUP_ATTR,
'machine': LAUNCH_MACHINE_ATTR,
'node': LAUNCH_NODE_ATTR,
'include': LAUNCH_INCLUDE_ATTR,
'remap': LAUNCH_REMAP_ATTR,
'env': LAUNCH_ENV_ATTR,
'param': LAUNCH_PARAM_ATTR,
'rosparam': LAUNCH_ROSPARAM_ATTR,
'arg': LAUNCH_ARG_ATTR,
'test': LAUNCH_TEST_ATTR,
}
DEPRECATED_PARAMETER = {
'associations': 'nm/associations',
'kill_on_stop': 'nm/kill_on_stop',
}
STATE_COMMENT = 2
STATE_STRING = 4
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 _create_regexp(self, pattern=''):
_regexp = QRegExp()
_regexp.setMinimal(True)
_regexp.setPattern(pattern)
return _regexp
def _create_format(self, color, style=''):
_format = QTextCharFormat()
_format.setForeground(color)
if 'bold' in style:
_format.setFontWeight(QFont.Bold)
else:
_format.setFontWeight(QFont.Normal)
if 'italic' in style:
_format.setFontItalic(True)
return _format
def highlightBlock(self, text):
for pattern, form in self.rules:
index = pattern.indexIn(text)
while index >= 0:
length = pattern.matchedLength()
frmt = form
if self._in_hl_range(index, self._tag_hl_range):
frmt = QTextCharFormat(form)
if not self._end_tag_found:
frmt.setForeground(Qt.red)
else:
frmt.setForeground(self._color_hl_tag)
frmt.setFontWeight(QFont.Bold)
self.setFormat(index, length, frmt)
index = pattern.indexIn(text, index + length)
# search for YAML comments
index = self.yaml_comment_rule[0].indexIn(text)
if index >= 0:
self.setFormat(index, len(text) - index, self.yaml_comment_rule[1])
self._tag_hl_range = []
self.setCurrentBlockState(0)
# detection for XML comments
self._comments_idx = []
idx_start_cmt = 0
comment_length = 0
if self.previousBlockState(
) == -1 or not self.previousBlockState() & self.STATE_COMMENT:
idx_start_cmt = self.comment_start.indexIn(text)
while idx_start_cmt >= 0:
idx_end = self.comment_end.indexIn(text, idx_start_cmt)
comment_length = 0
if idx_end == -1:
self.setCurrentBlockState(self.STATE_COMMENT)
comment_length = len(text) - idx_start_cmt
else:
comment_length = idx_end - idx_start_cmt + self.comment_end.matchedLength(
)
self._comments_idx.append((idx_start_cmt, comment_length))
self.setFormat(idx_start_cmt, comment_length, self.comment_format)
idx_start_cmt = self.comment_start.indexIn(
text, idx_start_cmt + comment_length)
# format string and detection for multiline string
idx_start = self.string_pattern.indexIn(text)
if self.previousBlockState(
) != -1 and self.previousBlockState() & self.STATE_STRING:
strlen = idx_start + self.string_pattern.matchedLength()
if idx_start == -1:
strlen = len(text)
self.setCurrentBlockState(self.currentBlockState() +
self.STATE_STRING)
self.setFormat(0, strlen, self.string_format)
idx_start = self.string_pattern.indexIn(text, strlen)
idx_search = idx_start + 1
while idx_start >= 0:
# skip the strings which are in the comments
if not self._in_hl_range(idx_search, self._comments_idx):
idx_end = self.string_pattern.indexIn(text, idx_search)
strlen = 0
if not self._in_hl_range(idx_end, self._comments_idx):
if idx_end == -1:
self.setCurrentBlockState(self.currentBlockState() +
self.STATE_STRING)
strlen = len(text) - idx_start
else:
strlen = idx_end - idx_start + self.string_pattern.matchedLength(
)
idx_search = idx_start + strlen
self.setFormat(idx_start, strlen, self.string_format)
idx_start = self.string_pattern.indexIn(text, idx_search)
idx_search = idx_start + 1
else:
idx_search = idx_end + 1
else:
idx_start = self.string_pattern.indexIn(text, idx_search)
idx_search = idx_start + 1
# mark arguments
index = self.rule_arg[0].indexIn(text)
while index >= 0:
if not self._in_hl_range(index, self._comments_idx):
length = self.rule_arg[0].matchedLength()
self.setFormat(index, length, self.rule_arg[1])
index = self.rule_arg[0].indexIn(text, index + length)
# mark deprecated parameter
for pattern, form in self.dep_pattern:
index = pattern.indexIn(text)
while index >= 0:
length = pattern.matchedLength()
frmt = form
if self._in_hl_range(index, self._tag_hl_range):
frmt = QTextCharFormat(form)
if not self._end_tag_found:
frmt.setForeground(Qt.red)
else:
frmt.setForeground(self._color_hl_tag)
frmt.setFontWeight(QFont.Bold)
self.setFormat(index, length, frmt)
index = pattern.indexIn(text, index + length)
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 _get_braces_count(self, text):
closed_short = text.count('/>')
closed_long = text.count('</')
cmnt_long = text.count('<!')
openbr = text.count('<') - closed_long - cmnt_long
return openbr, closed_short + closed_long
def _isopentag(self, word):
return word.startswith('<') and '/' not in word
def _isclosetag(self, word):
return '/>' == word or word.startswith('</')
def _get_tag(self, word):
return word.strip('</>')
def _get_current_word(self, text, position):
word = ''
idx_start = position
for i in reversed(range(0, position)):
if text[i] in [' ', '\n', '=', '"']:
break
else:
word = "%s%s" % (text[i], word)
idx_start = i
for i in range(position, len(text)):
if text[i] in [' ', '\n', '=', '"']:
break
else:
word += text[i]
return word, idx_start
def _in_hl_range(self, value, ranges):
for (start, length) in ranges:
if value >= start and value <= start + length:
return True
return False
def get_tag_of_current_block(self, block, position):
text = block.text()
next_block = block
idx_search = position
rindex = -1
loop = 0
# we are at the close tag: search for the open tag
opentag = '<'
while rindex == -1 and next_block.isValid():
rindex = text.rfind(opentag, 0, idx_search)
loop += 1
if loop > 100:
rindex = -1
break
if rindex == -1:
next_block = next_block.previous()
text = next_block.text()
idx_search = len(text)
tag = ''
if rindex != -1:
for i in range(rindex + 1, len(text)):
if text[i] in [' ', '\n', '=', '"', '>']:
break
else:
tag += text[i]
return tag
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)
class YamlHighlighter(QSyntaxHighlighter):
'''
Enabled the syntax highlightning for the yaml files.
'''
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 highlightBlock(self, text):
self.setFormat(0, len(text), self.default_format)
for pattern, form in self.rules:
index = pattern.indexIn(text)
while index >= 0:
length = pattern.matchedLength()
self.setFormat(index, length, form)
index = pattern.indexIn(text, index + length)
# mark comment blocks
self.setCurrentBlockState(0)
startIndex = 0
if self.previousBlockState() != 1:
startIndex = self.commentStart.indexIn(text)
if startIndex >= 0:
commentLength = len(text) - startIndex
self.setFormat(startIndex, commentLength, self.commentFormat)
def _create_regexp(self, pattern=''):
_regexp = QRegExp()
_regexp.setMinimal(True)
_regexp.setPattern(pattern)
return _regexp
def _create_format(self, color, style=''):
_format = QTextCharFormat()
_format.setForeground(color)
if 'bold' in style:
_format.setFontWeight(QFont.Bold)
else:
_format.setFontWeight(QFont.Normal)
if 'italic' in style:
_format.setFontItalic(True)
return _format
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 set_package_filter(self, text):
self.launchlist_proxyModel.setFilterRegExp(QRegExp(text,
Qt.CaseInsensitive,
QRegExp.Wildcard))
class XmlHighlighter(QSyntaxHighlighter):
'''
Enabled the syntax highlightning for the ROS launch files.
'''
LAUNCH_LAUNCH_CHILDS = ['group', 'node', 'test', 'env', 'remap', 'rosparam', 'param', 'machine', 'include', 'arg']
LAUNCH_LAUNCH_ATTR = {'deprecated=': '"message"'}
LAUNCH_GROUP_CHILDS = ['node', 'test', 'env', 'remap', 'rosparam', 'param', 'machine', 'include', 'arg']
LAUNCH_GROUP_ATTR = {'ns=': '"foo"',
'clear_params=': '"true|false"'
}
LAUNCH_MACHINE_CHILDS = ['env']
LAUNCH_MACHINE_ATTR = {'name=': '"machine-name"',
'address=': '"blah.willowgarage.com"',
'env-loader=': '"/opt/ros/fuerte/env.sh"',
'default=': '"true|false|never"',
'user='******'"username"',
'password='******'"passwhat"',
'timeout=': '"10.0"'
}
LAUNCH_NODE_CHILDS = ['env', 'remap', 'rosparam', 'param']
LAUNCH_NODE_ATTR = {'pkg=': '"mypackage"',
'type=': '"nodetype"',
'name=': '"nodename"',
'args=': '"arg1"',
'machine=': '"machine-name"',
'respawn=': '"true"',
'required=': '"true"',
'ns=': '"foo"',
'clear_params=': '"true|false"',
'output=': '"log|screen"',
'cwd=': '"ROS_HOME|node"',
'launch-prefix=': '"prefix arguments"'
}
LAUNCH_INCLUDE_CHILDS = ['env', 'arg']
LAUNCH_INCLUDE_ATTR = {'file=': '"$(find pkg-name)/path/filename.xml"',
'ns=': '"foo"',
'clear_params=': '"true|false"'
}
LAUNCH_REMAP_ATTR = {'from=': '"originalname"',
'to=': '"newname"'
}
LAUNCH_ENV_ATTR = {'name=': '"name"',
'value=': '"value"'
}
LAUNCH_PARAM_ATTR = {'name=': '"namespace/name"',
'value=': '"value"',
'type=': '"str|int|double|bool"',
'textfile=': '"$(find pkg-name)/path/file.txt"',
'binfile=': '"$(find pkg-name)/path/file"',
'command=': '"$(find pkg-name)/exe \'$(find pkg-name)/arg.txt\'"'
}
LAUNCH_ROSPARAM_ATTR = {'command=': '"load|dump|delete"',
'file=': '"$(find pkg-name)/path/foo.yaml"',
'param=': '"name"',
'ns=': '"foo"',
'subst_value=': '"true|false"'
}
LAUNCH_ARG_ATTR = {'name=': '"name"',
'value=': '"bar"',
'default=': '"defbar"'
}
LAUNCH_TEST_CHILDS = ['env', 'remap', 'rosparam', 'param']
LAUNCH_TEST_ATTR = {'pkg=': '"mypackage"',
'type=': '"nodetype"',
'name=': '"nodename"',
'test-name=': '"test_name"',
'args=': '"arg1"',
'ns=': '"foo"',
'clear_params=': '"true|false"',
'retry=': '"0"',
'cwd=': '"ROS_HOME|node"',
'launch-prefix=': '"prefix arguments"',
'time-limit=': '"60.0"'
}
LAUNCH_CHILDS = {'launch': LAUNCH_LAUNCH_CHILDS,
'group': LAUNCH_GROUP_CHILDS,
'machine': LAUNCH_MACHINE_CHILDS,
'node': LAUNCH_NODE_CHILDS,
'include': LAUNCH_INCLUDE_CHILDS,
'remap': [],
'env': [],
'param': [],
'rosparam': [],
'arg': [],
'test': LAUNCH_TEST_CHILDS
}
LAUNCH_ATT_GLOBAL = {'if=': '""', 'unless=': '""'}
LAUNCH_LAUNCH_ATTR.update(LAUNCH_ATT_GLOBAL)
LAUNCH_GROUP_ATTR.update(LAUNCH_ATT_GLOBAL)
LAUNCH_MACHINE_ATTR.update(LAUNCH_ATT_GLOBAL)
LAUNCH_NODE_ATTR.update(LAUNCH_ATT_GLOBAL)
LAUNCH_INCLUDE_ATTR.update(LAUNCH_ATT_GLOBAL)
LAUNCH_REMAP_ATTR.update(LAUNCH_ATT_GLOBAL)
LAUNCH_ENV_ATTR.update(LAUNCH_ATT_GLOBAL)
LAUNCH_PARAM_ATTR.update(LAUNCH_ATT_GLOBAL)
LAUNCH_ROSPARAM_ATTR.update(LAUNCH_ATT_GLOBAL)
LAUNCH_ARG_ATTR.update(LAUNCH_ATT_GLOBAL)
LAUNCH_TEST_ATTR.update(LAUNCH_ATT_GLOBAL)
LAUNCH_ATTR = {'launch': LAUNCH_LAUNCH_ATTR,
'group': LAUNCH_GROUP_ATTR,
'machine': LAUNCH_MACHINE_ATTR,
'node': LAUNCH_NODE_ATTR,
'include': LAUNCH_INCLUDE_ATTR,
'remap': LAUNCH_REMAP_ATTR,
'env': LAUNCH_ENV_ATTR,
'param': LAUNCH_PARAM_ATTR,
'rosparam': LAUNCH_ROSPARAM_ATTR,
'arg': LAUNCH_ARG_ATTR,
'test': LAUNCH_TEST_ATTR,
}
STATE_COMMENT = 2
STATE_STRING = 4
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 _create_regexp(self, pattern=''):
_regexp = QRegExp()
_regexp.setMinimal(True)
_regexp.setPattern(pattern)
return _regexp
def _create_format(self, color, style=''):
_format = QTextCharFormat()
_format.setForeground(color)
if 'bold' in style:
_format.setFontWeight(QFont.Bold)
else:
_format.setFontWeight(QFont.Normal)
if 'italic' in style:
_format.setFontItalic(True)
return _format
def highlightBlock(self, text):
for pattern, form in self.rules:
index = pattern.indexIn(text)
while index >= 0:
length = pattern.matchedLength()
frmt = form
if self._in_hl_range(index, self._tag_hl_range):
frmt = QTextCharFormat(form)
if not self._end_tag_found:
frmt.setForeground(Qt.red)
frmt.setFontWeight(QFont.Bold)
self.setFormat(index, length, frmt)
index = pattern.indexIn(text, index + length)
self._tag_hl_range = []
self.setCurrentBlockState(0)
# detection for comments
self._comments_idx = []
idx_start_cmt = 0
comment_length = 0
if self.previousBlockState() == -1 or not self.previousBlockState() & self.STATE_COMMENT:
idx_start_cmt = self.comment_start.indexIn(text)
while idx_start_cmt >= 0:
idx_end = self.comment_end.indexIn(text, idx_start_cmt)
comment_length = 0
if idx_end == -1:
self.setCurrentBlockState(self.STATE_COMMENT)
comment_length = len(text) - idx_start_cmt
else:
comment_length = idx_end - idx_start_cmt + self.comment_end.matchedLength()
self._comments_idx.append((idx_start_cmt, comment_length))
self.setFormat(idx_start_cmt, comment_length, self.comment_format)
idx_start_cmt = self.comment_start.indexIn(text, idx_start_cmt + comment_length)
# format string and detection for multiline string
idx_start = self.string_pattern.indexIn(text)
if self.previousBlockState() != -1 and self.previousBlockState() & self.STATE_STRING:
strlen = idx_start + self.string_pattern.matchedLength()
if idx_start == -1:
strlen = len(text)
self.setCurrentBlockState(self.currentBlockState() + self.STATE_STRING)
self.setFormat(0, strlen, self.string_format)
idx_start = self.string_pattern.indexIn(text, strlen)
idx_search = idx_start + 1
while idx_start >= 0:
# skip the strings which are in the comments
if not self._in_hl_range(idx_search, self._comments_idx):
idx_end = self.string_pattern.indexIn(text, idx_search)
strlen = 0
if not self._in_hl_range(idx_end, self._comments_idx):
if idx_end == -1:
self.setCurrentBlockState(self.currentBlockState() + self.STATE_STRING)
strlen = len(text) - idx_start
else:
strlen = idx_end - idx_start + self.string_pattern.matchedLength()
idx_search = idx_start + strlen
self.setFormat(idx_start, strlen, self.string_format)
idx_start = self.string_pattern.indexIn(text, idx_search)
idx_search = idx_start + 1
else:
idx_search = idx_end + 1
else:
idx_start = self.string_pattern.indexIn(text, idx_search)
idx_search = idx_start + 1
# mark arguments
index = self.rule_arg[0].indexIn(text)
while index >= 0:
if not self._in_hl_range(index, self._comments_idx):
length = self.rule_arg[0].matchedLength()
self.setFormat(index, length, self.rule_arg[1])
index = self.rule_arg[0].indexIn(text, index + length)
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)
self._tag_hl_last.clear()
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.add(block)
if rindex != -1:
self._tag_hl_range.append((rindex, tag_len))
self.rehighlightBlock(next_block)
self._tag_hl_last.add(next_block)
def _get_braces_count(self, text):
closed_short = text.count('/>')
closed_long = text.count('</')
cmnt_long = text.count('<!')
openbr = text.count('<') - closed_long - cmnt_long
return openbr, closed_short + closed_long
def _isopentag(self, word):
return word.startswith('<') and '/' not in word
def _isclosetag(self, word):
return '/>' == word or word.startswith('</')
def _get_tag(self, word):
return word.strip('</>')
def _get_current_word(self, text, position):
word = ''
idx_start = position
for i in reversed(range(0, position)):
if text[i] in [' ', '\n', '=', '"']:
break
else:
word = "%s%s" % (text[i], word)
idx_start = i
for i in range(position, len(text)):
if text[i] in [' ', '\n', '=', '"']:
break
else:
word += text[i]
return word, idx_start
def _in_hl_range(self, value, ranges):
for (start, length) in ranges:
if value >= start and value <= start + length:
return True
return False
def get_tag_of_current_block(self, block, position):
text = block.text()
next_block = block
idx_search = position
rindex = -1
loop = 0
# we are at the close tag: search for the open tag
opentag = '<'
while rindex == -1 and next_block.isValid():
rindex = text.rfind(opentag, 0, idx_search)
loop += 1
if loop > 100:
rindex = -1
break
if rindex == -1:
next_block = next_block.previous()
text = next_block.text()
idx_search = len(text)
tag = ''
if rindex != -1:
for i in range(rindex + 1, len(text)):
if text[i] in [' ', '\n', '=', '"', '>']:
break
else:
tag += text[i]
return tag
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 _create_regexp(self, pattern=''):
_regexp = QRegExp()
_regexp.setMinimal(True)
_regexp.setPattern(pattern)
return _regexp
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)
self._tag_hl_last.clear()
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.add(block)
if rindex != -1:
self._tag_hl_range.append((rindex, tag_len))
self.rehighlightBlock(next_block)
self._tag_hl_last.add(next_block)
def included_files(cls,
text_or_path,
regexp_retruns=[],
regexp_filelist=[
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):
'''
:param regexp_retruns: the list with patterns which are returned as result. If empy it's the same as 'regexp_filelist'
:param regexp_filelist: the list with all patterns to find include files
'''
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_filelist)
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 regexp_retruns or cls._index(
line, regexp_retruns) > -1:
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_retruns, regexp_filelist)
except Exception:
import traceback
print traceback.format_exc()
line_index += 1
if unique:
return list(set(result))
return result
class YamlHighlighter(QSyntaxHighlighter):
'''
Enabled the syntax highlightning for the yaml files.
'''
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 highlightBlock(self, text):
self.setFormat(0, len(text), self.default_format)
for pattern, form in self.rules:
index = pattern.indexIn(text)
while index >= 0:
length = pattern.matchedLength()
self.setFormat(index, length, form)
index = pattern.indexIn(text, index + length)
# mark comment blocks
self.setCurrentBlockState(0)
startIndex = 0
if self.previousBlockState() != 1:
startIndex = self.commentStart.indexIn(text)
if startIndex >= 0:
commentLength = len(text) - startIndex
self.setFormat(startIndex, commentLength, self.commentFormat)
def _create_regexp(self, pattern=''):
_regexp = QRegExp()
_regexp.setMinimal(True)
_regexp.setPattern(pattern)
return _regexp
def _create_format(self, color, style=''):
_format = QTextCharFormat()
_format.setForeground(color)
if 'bold' in style:
_format.setFontWeight(QFont.Bold)
else:
_format.setFontWeight(QFont.Normal)
if 'italic' in style:
_format.setFontItalic(True)
return _format
class LoggerHandler(QObject):
'''
Handles ROS logger requests
'''
loggers_signal = Signal(list)
level_changed_signal = Signal(list)
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
self._all_item = LoggerItem(self.nodename, self.masteruri, 'all', '')
self._all_item.set_callback(self.change_all)
def update(self):
if self._thread_update is None:
self._thread_update = threading.Thread(target=self._update_loggers)
self._thread_update.setDaemon(True)
self._thread_update.start()
def _update_loggers(self):
try:
service_name = '%s/get_loggers' % self.nodename
master = xmlrpcclient.ServerProxy(self.masteruri)
code, _, serviceuri = master.lookupService(rospy.get_name(),
service_name)
if code == 1:
_req, resp = nm.starter().callService(serviceuri,
service_name,
GetLoggers,
service_args=[])
self.loggers_signal.emit(resp.loggers)
except (rospy.ServiceException, nm.StartException) as e:
rospy.logwarn("Get loggers for %s failed: %s" % (self.nodename, e))
except IOError as err:
rospy.logwarn(
"Get loggers for %s failed; cannot get service URI from %s: %s"
% (self.nodename, self.masteruri, err))
self._thread_update = None
def _handle_loggers(self, loggers):
new_logger = {}
for logger in loggers:
new_logger[logger.name] = logger.level
self._stored_values[logger.name] = logger.level
while self.layout.count() > 1:
item = self.layout.takeAt(0)
wd = item.widget()
if wd.current_level is not None and wd.loggername != 'all':
self._stored_values[wd.loggername] = wd.current_level
wd.setParent(None)
self._logger_items.clear()
index = 0
if not 'all' in self._stored_values:
self.layout.insertWidget(0, self._all_item)
index += 1
for logger_name, logger_level in sorted(self._stored_values.items()):
item = LoggerItem(self.nodename, self.masteruri, logger_name,
logger_level)
self._logger_items[logger_name] = item
if (not logger_name
in new_logger) or new_logger[logger_name] != logger_level:
item.set_level(logger_level, True)
self.layout.insertWidget(index, item)
index += 1
if self._filter.indexIn(logger.name) == -1:
item.setVisible(False)
def change_all(self,
loglevel,
ignore=[
'ros.roscpp.roscpp_internal',
'ros.roscpp.roscpp_internal.connections',
'ros.roscpp.superdebug', 'rospy.tcpros'
]):
'''
Change the log level of all logger in a new thread.
'''
if self._thread_set_all is not None:
self._thread_set_all.cancel()
self._thread_set_all.success_signal.disconnect()
self._thread_set_all.error_signal.disconnect()
index = 1
itemlist = []
while index < self.layout.count():
item = self.layout.itemAt(index).widget()
if isinstance(item, LoggerItem) and item.loggername not in ignore:
itemlist.append((item.loggername, item.current_level))
index += 1
self._thread_set_all = SetAllThread(self.nodename, self.masteruri,
itemlist, loglevel)
self._thread_set_all.success_signal.connect(self.on_success_set)
self._thread_set_all.error_signal.connect(self.on_error_set)
self._thread_set_all.setDaemon(True)
self._thread_set_all.start()
def on_success_set(self, nodename, logger, level):
if logger in self._logger_items:
self._logger_items[logger].on_succes_update(level)
elif logger == 'all':
self._all_item.on_succes_update(level)
def on_error_set(self, nodename, logger, level):
if logger in self._logger_items:
self._logger_items[logger].on_error_update(level)
elif logger == 'all':
self._all_item.on_error_update(level)
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 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, 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)
