def setToolTip(self, active = True):
'''Turn on/off the tooltips for this Widget.
The tooltip will display the index and value for the matrix
at the current mouse position.
Arguments
---------
active : bool or str
Will turn the tooltips on or off. When a string is provided
that string will be used as tooltip. The string can have
up to three placeholders, being filled with 1=row, 2=column,
3=matrix value.
'''
self.toolTipActive = active != False
if isinstance(active, str):
self.toolTipText = active
elif active:
self.toolTipText = "C({},{}) = {:.2f}"
else:
self.toolTipText = ""
self.setMouseTracking(self.toolTipActive)
if not self.toolTipActive:
QToolTip.hideText()
def mouseMoveEvent(self, event):
if self._show_tooltips:
tooltip = self.get_tooltip_at_mouse_position(event.pos())
if not tooltip:
QToolTip.hideText()
self.setToolTip(tooltip)
return super().mouseMoveEvent(event)
def eventFilter(self, obj, event):
# text = ''
# if event.type() == QEvent.UpdateRequest:text = 'UpdateRequest'
# elif event.type() == QEvent.Leave:text = 'Leave'
# elif event.type() == QEvent.Enter:text = 'Enter'
# elif event.type() == QEvent.ToolTip:text = 'ToolTip'
# elif event.type() == QEvent.StatusTip:text = 'StatusTip'
# elif event.type() == QEvent.ZOrderChange:text = 'ZOrderChange'
# elif event.type() == QEvent.Show:text = 'Show'
# elif event.type() == QEvent.ShowToParent:text = 'ShowToParent'
# elif event.type() == QEvent.UpdateLater:text = 'UpdateLater'
# elif event.type() == QEvent.MouseMove:text = 'MouseMove'
# elif event.type() == QEvent.Close:text = 'Close'
# elif event.type() == QEvent.Hide:text = 'Hide'
# elif event.type() == QEvent.HideToParent:text = 'HideToParent'
# elif event.type() == QEvent.Timer:text = 'Timer'
# elif event.type() == QEvent.Paint:text = 'Paint'
# elif event.type() == QEvent.MouseButtonPress:
# text = 'MouseButtonPress(%d %d)'%(event.globalPos().x(), event.globalPos().y())
# logging.info("%s %d %s"%(self.title(), event.type(), text))
if obj == self:
if event.type() == QEvent.WindowDeactivate:
self.Hide()
elif event.type() == QEvent.ToolTip:
act = self.activeAction()
if act != 0 and act.toolTip() != act.text():
QToolTip.showText(event.globalPos(), act.toolTip())
else:
QToolTip.hideText()
return False
def makeTT(self, mpos, curs):
""" Converts a mouse position and text cursor into a tooltip by getting the true residue IDs """
# Such elegance.
resn = curs.selectedText()
pos = self.textCursor().position()
row_pos = self.textCursor().positionInBlock()
resids = self.getSeqPos(pos, row_pos)
if resids and resn in [
'A', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'K', 'L', 'M', 'N',
'P', 'Q', 'R', 'S', 'T', 'V', 'W', 'Y'
]:
string = []
for i, each in enumerate(resids):
name = self.names[each[0]]
resi = each[1]
if resi == 0:
resi = "N/A"
text = str(resi) + " of " + name
if i > 0:
text = " --->" + text
string.append(text)
if 0 < i < len(resids):
string.insert(-1, "\n")
string = "".join(string)
QToolTip.showText(mpos, resn + " at " + string)
del string
else:
QToolTip.hideText()
del mpos, curs, resn, pos, row_pos, resids,
def on_mouse_moved(self, pos, index):
# This method controls for which rows the buttons/box should be drawn
if self.hover_index != index:
self.hover_index = index
if not self.button_box.contains(pos):
# Hide the tooltip when cell hover changes
QToolTip.hideText()
# Check if we hover over the 'edit tags' button
new_hovering_state = False
if (self.hover_index != self.no_index and self.hover_index.column()
== index.model().column_position[Column.NAME]):
if index in index.model().edit_tags_rects:
rect = index.model().edit_tags_rects[index]
if rect.contains(pos):
QApplication.setOverrideCursor(
QCursor(Qt.PointingHandCursor))
new_hovering_state = True
if new_hovering_state != self.hovering_over_tag_edit_button:
self.redraw_required.emit(index, False)
self.hovering_over_tag_edit_button = new_hovering_state
for controls in self.controls:
controls.on_mouse_moved(pos, index)
def mouseMoveEvent(self, event):
"""
When mouse moves, we show tooltip when appropriate.
"""
textEditView.mouseMoveEvent(self, event)
onRect = [r for r in self.clickRects if r.rect.contains(event.pos())]
if not onRect:
qApp.restoreOverrideCursor()
QToolTip.hideText()
return
ct = onRect[0]
if not qApp.overrideCursor():
qApp.setOverrideCursor(Qt.PointingHandCursor)
if ct.regex == self.automaticLinkRegex:
tooltip = ct.texts[2] or ct.texts[4]
elif ct.regex == self.imageRegex:
tt = ("<p><b>" + ct.texts[1] + "</b></p>" +
"<p><img src='data:image/png;base64,{}'></p>")
tooltip = None
pos = event.pos() + QPoint(0, ct.rect.height())
ImageTooltip.fromUrl(ct.texts[2], pos, self)
elif ct.regex == self.inlineLinkRegex:
tooltip = ct.texts[1] or ct.texts[2]
if tooltip:
tooltip = self.tr("{} (CTRL+Click to open)").format(tooltip)
QToolTip.showText(self.mapToGlobal(event.pos()), tooltip)
def execute_queries(self, query=''):
""" This function executes queries """
# Hide tooltip if visible
if QToolTip.isVisible():
QToolTip.hideText()
# If text is selected, then this text is the query,
# otherwise the query is all text that has the editor
editor_widget = self.currentWidget().get_editor()
if editor_widget.textCursor().hasSelection():
query = editor_widget.textCursor().selectedText()
else:
query = editor_widget.toPlainText()
relations = self.currentWidget().relations
central = Pireal.get_service("central")
table_widget = central.get_active_db().table_widget
# Restore
relations.clear()
self.currentWidget().clear_results()
# Parse query
sc = scanner.Scanner(query)
lex = lexer.Lexer(sc)
try:
par = parser.Parser(lex)
interpreter = parser.Interpreter(par)
interpreter.clear()
interpreter.to_python()
except Exception as reason:
pireal = Pireal.get_service("pireal")
pireal.show_error_message(self.parse_error(reason.__str__()))
return
relations.update(table_widget.relations)
for relation_name, expression in list(interpreter.SCOPE.items()):
if relation_name in relations:
QMessageBox.critical(self,
self.tr("Query Error"),
self.tr("<b>{}</b> is a duplicate "
"relation name.<br><br> "
"Please choose a unique name "
"and re-execute the "
"queries.".format(
relation_name)))
del interpreter.SCOPE[relation_name]
return
try:
new_relation = eval(expression, {}, relations)
except Exception as reason:
pireal = Pireal.get_service("pireal")
pireal.show_error_message(self.parse_error(reason.__str__()),
syntax_error=False)
return
relations[relation_name] = new_relation
self.__add_table(new_relation, relation_name)
def _on_key_released(self, event):
if event.key() in (Qt.Key_ParenLeft, Qt.Key_Comma):
self._neditor._intellisense.process("signatures")
elif event.key() in (Qt.Key_ParenRight, Qt.Key_Return, Qt.Key_Left,
Qt.Key_Right, Qt.Key_Down, Qt.Key_Up,
Qt.Key_Backspace, Qt.Key_Escape):
QToolTip.hideText()
def mouseMoveEvent(self, event):
blockNumber = self._qpart.cursorForPosition(event.pos()).blockNumber()
if blockNumber in self._qpart._lintMarks:
msgType, msgText = self._qpart._lintMarks[blockNumber]
QToolTip.showText(event.globalPos(), msgText)
else:
QToolTip.hideText()
return QWidget.mouseMoveEvent(self, event)
def event(self, e):
action = self.activeAction()
if e.type() == QEvent.ToolTip and \
action and \
action.toolTip() != action.text():
QToolTip.showText(e.globalPos(), self.activeAction().toolTip())
else:
QToolTip.hideText()
return super(Menu, self).event(e)
def update_show_tooltips(self):
"""Toggles wordwrap in the script editor
"""
self._show_tooltips = self.show_tooltips_action.isChecked()
config = get_config()
config.persist['script_editor_tooltips'] = self._show_tooltips
if not self._show_tooltips:
QToolTip.hideText()
self.setToolTip('')
def update_tooltip(self):
if self.underMouse() and self.toolTip():
position = self.mapFromGlobal(QCursor.pos())
tooltip = self.get_tooltip_at_mouse_position(position)
if tooltip != self.toolTip():
# Hide tooltip if the entity causing this tooltip
# was moved away from the mouse position
QToolTip.hideText()
self.setToolTip(tooltip)
def mouseMoveEvent(self, event):
blockNumber = self._qpart.cursorForPosition(event.pos()).blockNumber()
if blockNumber in self._qpart._lintMarks:
msgType, msgText = self._qpart._lintMarks[blockNumber]
QToolTip.showText(event.globalPos(), msgText)
else:
QToolTip.hideText()
return QWidget.mouseMoveEvent(self, event)
def show_tooltip(self, evt: QHelpEvent) -> bool:
assert isinstance(evt, QHelpEvent)
for feat in self.features:
if feat.rect.contains(evt.pos()):
QToolTip.showText(evt.globalPos(), feat.tooltip())
break
else:
QToolTip.hideText()
evt.ignore()
return True
def _show_tip(self, it: bool = False):
self._last_mouse = self._mouse_pos
star = self.renderer.find_star(*self._mouse_pos, 1)
if star is not None:
if self._last_star is None or star.star != self._last_star or it:
self._last_star = star.star
QToolTip.showText(QPoint(*self._mouse_gpos), str(star.star))
else:
QToolTip.hideText()
self._last_star = None
def set_id_tooltip(self, valid, message):
if valid is True:
self.input_id.setStyleSheet("")
self.input_id.setToolTip("Insert abbreviation")
QToolTip.hideText()
else:
self.input_id.setToolTip(message)
QToolTip.showText(self.input_id.mapToGlobal(QtCore.QPoint(0, 0)),
message)
self.input_id.setStyleSheet("border: 1px solid red;")
def event(self, e):
action = self.activeAction()
if e.type() == QEvent.ToolTip and \
action and \
action.toolTip() != action.text():
QToolTip.showText(e.globalPos(),
self.activeAction().toolTip())
else:
QToolTip.hideText()
return super(Menu, self).event(e)
def leaveEvent(self, event):
"""Handle the mouse leave event.
When tooltips are shown in this widgets, they should
be removed when the mouse leaves the widget.
Parameters
----------
event : QEvent
"""
if self.toolTipActive:
QToolTip.hideText()
def leaveEvent(self, event):
'''Handle the mouse leave event.
When tooltips are shown in this widgets, they should
be removed when the mouse leaves the widget.
Arguments
---------
event : QEvent
'''
if self.toolTipActive:
QToolTip.hideText()
def event(self, event: QEvent) -> bool:
if event.type() == QEvent.ToolTip:
tt = self.isValidIndex(self._hoverIndex) and self.tabToolTip(
self._hoverIndex)
if tt:
QToolTip.showText(event.globalPos(), tt, self, self._hoverRect)
else:
QToolTip.hideText()
event.ignore()
return True
return super().event(event)
def event(self, event):
if event.type() == QEvent.ToolTip:
helpEvent = event
index = self.itemAt(helpEvent.pos())
if index != -1:
QToolTip.showText(helpEvent.globalPos(), self.shapeItems[index].toolTip())
else:
QToolTip.hideText()
event.ignore()
return True
return super(SortingBox, self).event(event)
def event(self, ev):
if not self.enabled:
super().event(ev)
if ev.type() == QEvent.ToolTip:
key = self.hit_test(ev.pos())[0]
if key is not None:
QToolTip.showText(ev.globalPos(), key.tooltip)
else:
QToolTip.hideText()
if ev.type() == QEvent.LayoutRequest:
self.update_layout()
return super().event(ev)
def event(self, event):
if event.type() == QEvent.ToolTip:
index = None
for recordIndex, rect in self._tabsRects.items():
if QRect(*rect).contains(event.pos()):
index = recordIndex
if index is not None:
QToolTip.showText(event.globalPos(), self._tabs[index])
else:
QToolTip.hideText()
event.ignore()
return True
return super().event(event)
def event(self, event):
if event.type() == QEvent.ToolTip:
helpEvent = event
index = self.itemAt(helpEvent.pos())
if index != -1:
QToolTip.showText(helpEvent.globalPos(),
self.shapeItems[index].toolTip())
else:
QToolTip.hideText()
event.ignore()
return True
return super(SortingBox, self).event(event)
def mouseMoveEvent(self, mouse_event):
result = self.find_star_on_screen(mouse_event.x(), mouse_event.y())
if result is not None:
tool_tip, constellation = result
QToolTip\
.showText(QPoint(mouse_event.globalX(),
mouse_event.globalY()),
tool_tip)
self._change_rotation_angle(0, 0, 0)
self.draw_stars_and_sides_on_picture(constellation, 50)
else:
QToolTip.hideText()
self._change_rotation_angle(0, 0, 0)
self.draw_stars_and_sides_on_picture()
def setToolTip(self, active: bool = True) -> None:
"""Turn on/off the tooltips for this Widget.
The tooltip will display the index and value for the matrix
at the current mouse position.
Parameters
----------
active: bool
Will turn the tooltips on or off.
"""
self.toolTipActive = active
self.setMouseTracking(self.toolTipActive)
if not self.toolTipActive:
QToolTip.hideText()
def event(self, ev):
if not self.enabled:
super().event(ev)
if ev.type() == QEvent.ToolTip:
key = self.hit_test(ev.pos())[0]
if key is not None:
QToolTip.showText(ev.globalPos(), key.tooltip)
else:
QToolTip.hideText()
elif ev.type() == QEvent.LayoutRequest:
self.update_layout()
elif ev.type() == QEvent.MouseButtonDblClick and self.active_key:
self.anykey.emit()
return super().event(ev)
def event(self, e):
if e.type() == QEvent.ToolTip:
index = self.itemIndexAt(e.pos())
if index != -1:
QToolTip.showText(e.globalPos(), self.shapes[index].toolTip())
else:
QToolTip.hideText()
e.ignore()
return True
return super(Example, self).event(e)
def mouseMoveEvent(self, event):
MDEditView.mouseMoveEvent(self, event)
onRef = [r for r in self.refRects if r.contains(event.pos())]
if not onRef:
qApp.restoreOverrideCursor()
QToolTip.hideText()
return
cursor = self.cursorForPosition(event.pos())
ref = self.refUnderCursor(cursor)
if ref:
if not qApp.overrideCursor():
qApp.setOverrideCursor(Qt.PointingHandCursor)
QToolTip.showText(self.mapToGlobal(event.pos()), Ref.tooltip(ref))
def mouseMoveEvent(self, event):
textEditView.mouseMoveEvent(self, event)
onRef = [r for r in self.refRects if r.contains(event.pos())]
if not onRef:
qApp.restoreOverrideCursor()
QToolTip.hideText()
return
cursor = self.cursorForPosition(event.pos())
ref = self.refUnderCursor(cursor)
if ref:
if not qApp.overrideCursor():
qApp.setOverrideCursor(Qt.PointingHandCursor)
QToolTip.showText(self.mapToGlobal(event.pos()), Ref.tooltip(ref))
def mouseMoveEvent(self, ev):
"""Track the mouse move to show the tooltip"""
super(View, self).mouseMoveEvent(ev)
cursor_at_mouse = self.cursorForPosition(ev.pos())
cur_block = cursor_at_mouse.block()
# Only check tooltip when changing line/block or after invalidating
if self.include_target or not cur_block == self.block_at_mouse:
self.block_at_mouse = cur_block
self.include_target = open_file_at_cursor.includeTarget(cursor_at_mouse)
if self.include_target:
if ev.modifiers() == Qt.ControlModifier:
self.viewport().setCursor(QCursor(Qt.PointingHandCursor))
self.showIncludeToolTip()
else:
self.include_target = []
self.block_at_mouse = None
self.viewport().setCursor(Qt.IBeamCursor)
QToolTip.hideText()
def updateKineticCursor(self, active):
"""Cursor handling when kinetic move starts/stops.
- reset the cursor and hide tooltips if visible at start,
- update the cursor and show the appropriate tooltips at stop.
Used as a slot linked to the kineticStarted() signal.
"""
if active:
self.unsetCursor()
if QToolTip.isVisible():
QToolTip.hideText()
else:
self.updateCursor(QCursor.pos())
if self._linksEnabled:
page, link = self.pageLayout().linkAt(self.mapFromGlobal(QCursor.pos()))
if link:
self.linkHelpEvent(QCursor.pos(), page, link)
def helpEvent(self, event, view, option, index):
if event is None or view is None:
return False
if event.type() == QEvent.ToolTip and index.isValid():
if option.rect.width() <= self.sizeHint(option, index).width():
tooltip = index.data(Qt.DisplayRole)
# If text is elided, show tooltip
if tooltip != '':
QToolTip.showText(event.globalPos(), tooltip, view)
return True
if not super().helpEvent(event, view, option, index):
QToolTip.hideText()
return True
return super().helpEvent(event, view, option, index)
def mouseMoveEvent(self, ev):
"""Track the mouse move to show the tooltip"""
super(View, self).mouseMoveEvent(ev)
cursor_at_mouse = self.cursorForPosition(ev.pos())
cur_block = cursor_at_mouse.block()
# Only check tooltip when changing line/block or after invalidating
if self.include_target or not cur_block == self.block_at_mouse:
self.block_at_mouse = cur_block
self.include_target = open_file_at_cursor.includeTarget(
cursor_at_mouse)
if self.include_target:
if ev.modifiers() == Qt.ControlModifier:
self.viewport().setCursor(QCursor(Qt.PointingHandCursor))
self.showIncludeToolTip()
else:
self.include_target = []
self.block_at_mouse = None
self.viewport().setCursor(Qt.IBeamCursor)
QToolTip.hideText()
def updateKineticCursor(self, active):
"""Cursor handling when kinetic move starts/stops.
- reset the cursor and hide tooltips if visible at start,
- update the cursor and show the appropriate tooltips at stop.
Used as a slot linked to the kineticStarted() signal.
"""
if active:
self.unsetCursor()
if QToolTip.isVisible():
QToolTip.hideText()
else:
self.updateCursor(QCursor.pos())
if self._linksEnabled:
page, link = self.pageLayout().linkAt(
self.mapFromGlobal(QCursor.pos()))
if link:
self.linkHelpEvent(QCursor.pos(), page, link)
def helpEvent(self, event, view, option, index):
if not event or not view:
return False
if event.type() == QEvent.ToolTip:
rect = view.visualRect(index)
size = self.sizeHint(option, index)
if rect.width() < size.width():
tooltip = index.data(Qt.DisplayRole)
QToolTip.showText(event.globalPos(), tooltip)
return True
if not QStyledItemDelegate.helpEvent(self, event, view, option, index):
QToolTip.hideText()
return True
return QStyledItemDelegate.helpEvent(self, event, view, option, index)
def on_mouse_moved(self, pos, index):
# This method controls for which rows the buttons/box should be drawn
redraw = False
if self.hover_index != index:
self.hover_index = index
self.hoverrow = index.row()
if not self.button_box.contains(pos):
redraw = True
# Hide the tooltip when cell hover changes
QToolTip.hideText()
# Redraw when the mouse leaves the table
if index.row() == -1 and self.hoverrow != -1:
self.hoverrow = -1
redraw = True
for controls in self.controls:
redraw = controls.on_mouse_moved(pos, index) or redraw
if redraw:
# TODO: optimize me to only redraw the rows that actually changed!
self.redraw_required.emit()
def mouseMoveEvent(self, event):
if self.pressedKey:
return
widgetPosition = self.mapFromGlobal(event.globalPos())
self.currentKey = (widgetPosition.y() // self.cell_size) * \
self.columns + widgetPosition.x() // self.cell_size
if self.currentKey != self.lastKey:
self.lastKey = self.currentKey
name = self.parent.table._symbol_list[self.currentKey]
if name == "no info":
QToolTip.hideText()
else:
info_str = (
'<i style="text-align:center">{0}</i>'
'<pre style="text-align:center">Hex: {1:04X} | Dec: {1}</pre>'
'<p style="font-size:48px;text-align:center">{2}</p>'
).format(name, self.currentKey, chr(self.currentKey))
# info_str = '{0}\nU+{1:04X} | Dec:{1}'.format(name, self.currentKey)
QToolTip.showText(event.globalPos(), info_str, self)
self.update()
def viewportEvent(self, event):
if event.type() == QEvent.ToolTip:
pos = event.pos()
tc = self.cursorForPosition(pos)
block = tc.block()
line = block.layout().lineForTextPosition(tc.positionInBlock())
if line.isValid():
if pos.x() <= self.blockBoundingRect(block).left() + \
line.naturalTextRect().right():
column = tc.positionInBlock()
line = self.line_from_position(pos.y())
checkers = self._neditable.sorted_checkers
for items in checkers:
checker, _, _ = items
messages_for_line = checker.message(line)
if messages_for_line is not None:
for (start, end), message, content in \
messages_for_line:
if column >= start and column <= end:
QToolTip.showText(
self.mapToGlobal(pos), message, self)
return True
QToolTip.hideText()
return super().viewportEvent(event)
def hide_tooltip(self):
QToolTip.hideText()
def hide_tool_tip(self, e):
QToolTip.hideText()
