feedc0de/qt-creator
1
0
Fork 0
forked from qt-creator/qt-creator
Code Pull Requests Activity

Debugger: Make tooltips use standard text editor tooltips.

Browse Source 
Extend text editor tooltips by a 'widget content', making
it possible to show any widget utilizing the fact that the
QTipLabel actually is a frame (and thus a container).
Introduce concept of 'interactive' tooltips and modify
the tooltip-closing mechanism such that simple interaction
is possible. Emit the base text editor's tooltip signals
with the correct position and add API to calculate the tooltip
position from the cursor position.
Add API for pinning tooltips to the text editor (by removing
them from the QTipLabel layout).
Modify the Debugger's tooltipmanager not to manage tooltips
under TextEditor control and to take over control only once
tooltips are pinned.

Rubber-stamped-by: Leandro T. C. Melo <leandro.melo@nokia.com>
This commit is contained in:
Friedemann Kleint
2011-02-21 16:45:07 +01:00
parent 6507f5ff83
commit cbafc50acc
15 changed files with 421 additions and 173 deletions
Download Patch File Download Diff File Expand all files Collapse all files

250
src/plugins/debugger/debuggertooltipmanager.cpp
View File

@@ -43,9 +43,12 @@
#include <coreplugin/icore.h>
#include <coreplugin/modemanager.h>
#include <coreplugin/imode.h>
#include <coreplugin/coreconstants.h>
#include <coreplugin/editormanager/editormanager.h>
#include <texteditor/itexteditor.h>
#include <texteditor/basetexteditor.h>
#include <texteditor/tooltip/tooltip.h>
#include <texteditor/tooltip/tipcontents.h>
#include <utils/qtcassert.h>
@@ -66,8 +69,6 @@
#include <QtGui/QTextCursor>
#include <QtGui/QTextDocument>
#include <QtGui/QLabel>
#include <QtGui/QMenu>
#include <QtGui/QAction>
#include <QtGui/QClipboard>
#include <QtCore/QVariant>
@@ -76,6 +77,7 @@
#include <QtCore/QTimer>
enum { debugToolTips = 0 };
enum { debugToolTipPositioning = 0 };
// Expire tooltips after n days on (no longer load them) in order
// to avoid them piling up.
@@ -138,28 +140,29 @@ namespace Internal {
// A convenience struct to pass around all tooltip-relevant editor members
// (TextEditor, Widget, File, etc), constructing from a Core::IEditor.
struct DebuggerToolTipEditor
class DebuggerToolTipEditor
{
public:
explicit DebuggerToolTipEditor(Core::IEditor *ie = 0);
inline bool isValid() const { return textEditor != 0 && plainTextEdit != 0 && file != 0; }
inline bool isValid() const { return textEditor != 0 && baseTextEditor != 0 && file != 0; }
inline operator bool() const { return isValid(); }
QString fileName() const { return file ? file->fileName() : QString(); }
static DebuggerToolTipEditor currentToolTipEditor();
TextEditor::ITextEditor *textEditor;
QPlainTextEdit *plainTextEdit;
TextEditor::BaseTextEditor *baseTextEditor;
Core::IFile *file;
};
DebuggerToolTipEditor::DebuggerToolTipEditor(Core::IEditor *ie) :
textEditor(0), plainTextEdit(0), file(0)
textEditor(0), baseTextEditor(0), file(0)
{
if (ie && ie->file() && isEditorDebuggable(ie)) {
if (TextEditor::ITextEditor *te = qobject_cast<TextEditor::ITextEditor *>(ie)) {
if (QPlainTextEdit *pe = qobject_cast<QPlainTextEdit *>(ie->widget())) {
if (TextEditor::BaseTextEditor *pe = qobject_cast<TextEditor::BaseTextEditor *>(ie->widget())) {
textEditor = te;
plainTextEdit = pe;
baseTextEditor = pe;
file = ie->file();
}
}
@@ -436,12 +439,8 @@ PinnableToolTipWidget::PinnableToolTipWidget(QWidget *parent) :
m_pinState(Unpinned),
m_mainVBoxLayout(new QVBoxLayout),
m_toolBar(new QToolBar),
m_toolButton(new QToolButton),
m_menu(new QMenu)
m_toolButton(new QToolButton)
{
setWindowFlags(Qt::ToolTip);
setAttribute(Qt::WA_DeleteOnClose);
m_mainVBoxLayout->setSizeConstraint(QLayout::SetFixedSize);
m_mainVBoxLayout->setContentsMargins(0, 0, 0, 0);
@@ -449,8 +448,6 @@ PinnableToolTipWidget::PinnableToolTipWidget(QWidget *parent) :
const QList<QSize> pinIconSizes = pinIcon.availableSizes();
m_toolButton->setIcon(pinIcon);
m_toolButton->setMenu(m_menu);
m_toolButton->setPopupMode(QToolButton::MenuButtonPopup);
connect(m_toolButton, SIGNAL(clicked()), this, SLOT(toolButtonClicked()));
m_toolBar->setProperty("_q_custom_style_disabled", QVariant(true));
@@ -463,16 +460,6 @@ PinnableToolTipWidget::PinnableToolTipWidget(QWidget *parent) :
setLayout(m_mainVBoxLayout);
}
void PinnableToolTipWidget::addMenuAction(QAction *a)
{
m_menu->addAction(a);
}
void PinnableToolTipWidget::addCloseAllMenuAction()
{
m_menu->addAction(tr("Close All"), this, SIGNAL(closeAllRequested()));
}
void PinnableToolTipWidget::addWidget(QWidget *w)
{
w->setFocusPolicy(Qt::NoFocus);
@@ -489,9 +476,15 @@ void PinnableToolTipWidget::pin()
if (m_pinState == Unpinned) {
m_pinState = Pinned;
m_toolButton->setIcon(style()->standardIcon(QStyle::SP_DockWidgetCloseButton));
doPin();
emit pinned();
}
}
void PinnableToolTipWidget::doPin()
{
}
void PinnableToolTipWidget::toolButtonClicked()
{
switch (m_pinState) {
@@ -504,16 +497,6 @@ void PinnableToolTipWidget::toolButtonClicked()
}
}
void PinnableToolTipWidget::leaveEvent(QEvent *)
{
if (!m_menu->isVisible() && m_pinState == Unpinned
&& QApplication::keyboardModifiers() == Qt::NoModifier) {
if (debugToolTips)
qDebug("ToolTipWidget::leaveEvent: closing %p", this);
close();
}
}
/* A Label that emits a signal when the user drags for moving the parent
* widget around. */
class DraggableLabel : public QLabel
@@ -522,6 +505,9 @@ class DraggableLabel : public QLabel
public:
explicit DraggableLabel(QWidget *parent = 0);
bool isActive() const { return m_active; }
void setActive(bool v) { m_active = v; }
signals:
void dragged(const QPoint &d);
@@ -532,16 +518,17 @@ protected:
private:
QPoint m_moveStartPos;
bool m_active;
};
DraggableLabel::DraggableLabel(QWidget *parent) :
QLabel(parent), m_moveStartPos(-1, -1)
QLabel(parent), m_moveStartPos(-1, -1), m_active(false)
{
}
void DraggableLabel::mousePressEvent(QMouseEvent * event)
{
if (event->button() == Qt::LeftButton) {
if (m_active && event->button() == Qt::LeftButton) {
m_moveStartPos = event->globalPos();
event->accept();
}
@@ -550,22 +537,22 @@ void DraggableLabel::mousePressEvent(QMouseEvent * event)
void DraggableLabel::mouseReleaseEvent(QMouseEvent * event)
{
if (event->button() == Qt::LeftButton)
if (m_active && event->button() == Qt::LeftButton)
m_moveStartPos = QPoint(-1, -1);
QLabel::mouseReleaseEvent(event);
}
void DraggableLabel::mouseMoveEvent(QMouseEvent * event)
{
if (event->buttons() && Qt::LeftButton) {
if (m_active && (event->buttons() & Qt::LeftButton)) {
if (m_moveStartPos != QPoint(-1, -1)) {
const QPoint newPos = event->globalPos();
emit dragged(event->globalPos() - m_moveStartPos);
m_moveStartPos = newPos;
}
event->accept();
QLabel::mouseMoveEvent(event);
}
QLabel::mouseMoveEvent(event);
}
/*!
@@ -622,6 +609,13 @@ QDebug operator<<(QDebug d, const DebuggerToolTipContext &c)
In addition, if the stored line number diverges too much from the current line
number in positionShow(), the tooltip is also closed/discarded.
The widget is that is first shown by the TextEditor's tooltip
class and typically closed by it unless the user pins it.
In that case, it is removed from the tip's layout, added to the DebuggerToolTipManager's
list of pinned tooltips and re-shown as a global tooltip widget.
As the debugger stop and continues, it shows the debugger values or a copy
of them. On closing or session changes, the contents it saved.
*/
static inline QString msgReleasedText() { return AbstractDebuggerToolTipWidget::tr("Previous"); }
@@ -631,14 +625,15 @@ AbstractDebuggerToolTipWidget::AbstractDebuggerToolTipWidget(QWidget *parent) :
m_titleLabel(new DraggableLabel), m_engineAcquired(false),
m_creationDate(QDate::currentDate())
{
QToolButton *copyButton = new QToolButton;
copyButton->setIcon(QIcon(QLatin1String(Core::Constants::ICON_COPY)));
connect(copyButton, SIGNAL(clicked()), this, SLOT(copy()));
addToolBarWidget(copyButton);
m_titleLabel->setText(msgReleasedText());
m_titleLabel->setMinimumWidth(40); // Ensure a draggable area even if text is empty.
connect(m_titleLabel, SIGNAL(dragged(QPoint)), this, SLOT(slotDragged(QPoint)));
addToolBarWidget(m_titleLabel);
QAction *copyAction = new QAction(tr("Copy"), this);
connect(copyAction, SIGNAL(triggered()), this, SLOT(copy()));
addMenuAction(copyAction);
addCloseAllMenuAction();
}
bool AbstractDebuggerToolTipWidget::matches(const QString &fileName,
@@ -698,14 +693,15 @@ void AbstractDebuggerToolTipWidget::slotDragged(const QPoint &p)
m_offset += p;
}
bool AbstractDebuggerToolTipWidget::positionShow(const QPlainTextEdit *pe)
bool AbstractDebuggerToolTipWidget::positionShow(const DebuggerToolTipEditor &te)
{
// Figure out new position of tooltip using the text edit.
// If the line changed too much, close this tip.
QTC_ASSERT(pe, return false; )
QTextCursor cursor(pe->document());
QTC_ASSERT(te, return false; )
QTextCursor cursor(te.baseTextEditor->document());
cursor.setPosition(m_context.position);
const int line = cursor.blockNumber();
const int column = cursor.columnNumber();
if (qAbs(m_context.line - line) > 2) {
if (debugToolTips)
qDebug() << "Closing " << this << " in positionShow() lines "
@@ -713,19 +709,19 @@ bool AbstractDebuggerToolTipWidget::positionShow(const QPlainTextEdit *pe)
close();
return false;
}
const QRect plainTextToolTipArea = QRect(pe->cursorRect(cursor).topLeft(), QSize(sizeHint()));
const QRect plainTextArea = QRect(QPoint(0, 0), QPoint(pe->width(), pe->height()));
const QPoint screenPos = pe->mapToGlobal(plainTextToolTipArea.topLeft() + m_offset);
const bool visible = plainTextArea.contains(plainTextToolTipArea);
if (debugToolTipPositioning)
qDebug() << "positionShow" << this << line << column;
const QPoint screenPos = te.baseTextEditor->toolTipPosition(cursor) + m_offset;
const QRect toolTipArea = QRect(screenPos, QSize(sizeHint()));
const QRect plainTextArea = QRect(te.baseTextEditor->mapToGlobal(QPoint(0, 0)), te.baseTextEditor->size());
const bool visible = plainTextArea.contains(toolTipArea);
if (debugToolTips)
qDebug() << "DebuggerToolTipWidget::positionShow() " << this << m_context
<< " line: " << line << " plainTextPos " << plainTextToolTipArea
<< " line: " << line << " plainTextPos " << toolTipArea
<< " offset: " << m_offset
<< " Area: " << plainTextArea << " Screen pos: "
<< screenPos << pe << " visible=" << visible
<< " on " << pe->parentWidget()
<< " at " << pe->mapToGlobal(QPoint(0, 0));
<< screenPos << te.baseTextEditor << " visible=" << visible;
if (!visible) {
hide();
@@ -737,6 +733,19 @@ bool AbstractDebuggerToolTipWidget::positionShow(const QPlainTextEdit *pe)
return true;
}
void AbstractDebuggerToolTipWidget::doPin()
{
if (parentWidget()) {
// We are currently within a text editor tooltip:
// Rip out of parent widget and re-show as a tooltip
TextEditor::WidgetContent::pinToolTip(this);
} else {
// We have just be restored from session data.
setWindowFlags(Qt::ToolTip);
}
m_titleLabel->setActive(true); // User can now drag
}
// Parse a 'yyyyMMdd' date
static inline QDate dateFromString(const QString &date)
{
@@ -790,6 +799,7 @@ AbstractDebuggerToolTipWidget *AbstractDebuggerToolTipWidget::loadSessionDataI(Q
rc = new DebuggerTreeViewToolTipWidget;
if (rc) {
rc->setContext(context);
rc->setAttribute(Qt::WA_DeleteOnClose);
rc->setEngineType(engineType);
rc->doLoadSessionData(r);
rc->setCreationDate(creationDate);
@@ -827,13 +837,15 @@ void AbstractDebuggerToolTipWidget::saveSessionData(QXmlStreamWriter &w) const
}
// Model for tooltips filtering a local variable using the locals model,
// taking the expression.
// taking the expression. Suppress the tooltip data.
class DebuggerToolTipExpressionFilterModel : public QSortFilterProxyModel
{
public:
explicit DebuggerToolTipExpressionFilterModel(QAbstractItemModel *model, const QString &exp, QObject *parent = 0);
virtual bool filterAcceptsRow(int sourceRow, const QModelIndex &sourceParent) const;
virtual QVariant data(const QModelIndex &index, int role = Qt::DisplayRole) const;
private:
const QString m_expression;
};
@@ -846,6 +858,12 @@ DebuggerToolTipExpressionFilterModel::DebuggerToolTipExpressionFilterModel(QAbst
setSourceModel(model);
}
QVariant DebuggerToolTipExpressionFilterModel::data(const QModelIndex &index, int role) const
{
return role != Qt::ToolTipRole ?
QSortFilterProxyModel::data(index, role) : QVariant();
}
bool DebuggerToolTipExpressionFilterModel::filterAcceptsRow(int sourceRow, const QModelIndex &sourceParent) const
{
// Match on expression for top level, else pass through.
@@ -1092,23 +1110,22 @@ QString DebuggerTreeViewToolTipWidget::clipboardContents() const
/*!
\class DebuggerToolTipManager
Manages the tooltip widgets, listens on editor scroll and main window move
Manages the pinned tooltip widgets, listens on editor scroll and main window move
events and takes care of repositioning the tooltips.
Listens to editor change and mode change. In debug mode, if there tooltips
for the current editor (by file name), position and show them.
In addition, listen on state and stack frame change of the engine.
If a stack frame is activated, have all matching tooltips (by file name)
acquire the engine, other release.
In addition, listens on state change and stack frame completed signals
of the engine. If a stack frame is completed, have all matching tooltips
(by file name and function) acquire the engine, others release.
*/
DebuggerToolTipManager *DebuggerToolTipManager::m_instance = 0;
DebuggerToolTipManager::DebuggerToolTipManager(QObject *parent) :
QObject(parent), m_debugModeActive(false),
m_lastToolTipPos(-1), m_lastToolTipEditor(0)
m_lastToolTipPoint(-1, -1), m_lastToolTipEditor(0)
{
DebuggerToolTipManager::m_instance = this;
}
@@ -1125,33 +1142,49 @@ void DebuggerToolTipManager::registerEngine(DebuggerEngine *engine)
connect(engine, SIGNAL(stackFrameCompleted()), this, SLOT(slotStackFrameCompleted()));
}
void DebuggerToolTipManager::add(const QPoint &p, AbstractDebuggerToolTipWidget *toolTipWidget)
void DebuggerToolTipManager::showToolTip(const QPoint &p, Core::IEditor *editor,
AbstractDebuggerToolTipWidget *toolTipWidget)
{
closeUnpinnedToolTips();
toolTipWidget->move(p);
toolTipWidget->show();
add(toolTipWidget);
QWidget *widget = editor->widget();
if (debugToolTipPositioning)
qDebug() << "DebuggerToolTipManager::showToolTip" << p << " Mouse at " << QCursor::pos();
const TextEditor::WidgetContent widgetContent(toolTipWidget, true);
TextEditor::ToolTip::instance()->show(p, widgetContent, widget);
registerToolTip(toolTipWidget);
}
void DebuggerToolTipManager::add(AbstractDebuggerToolTipWidget *toolTipWidget)
void DebuggerToolTipManager::registerToolTip(AbstractDebuggerToolTipWidget *toolTipWidget)
{
QTC_ASSERT(toolTipWidget->context().isValid(), return; )
connect(toolTipWidget, SIGNAL(closeAllRequested()), this, SLOT(closeAllToolTips()));
m_tooltips.push_back(toolTipWidget);
switch (toolTipWidget->pinState()) {
case PinnableToolTipWidget::Pinned:
m_pinnedTooltips.push_back(toolTipWidget);
break;
case PinnableToolTipWidget::Unpinned:
// Catch the widget once it is pinned.
connect(toolTipWidget, SIGNAL(pinned()), this, SLOT(slotPinnedFirstTime()));
break;
}
}
void DebuggerToolTipManager::slotPinnedFirstTime()
{
if (AbstractDebuggerToolTipWidget *tw = qobject_cast<AbstractDebuggerToolTipWidget *>(sender()))
m_pinnedTooltips.push_back(tw);
}
DebuggerToolTipManager::DebuggerToolTipWidgetList &DebuggerToolTipManager::purgeClosedToolTips()
{
if (!m_tooltips.isEmpty()) {
for (DebuggerToolTipWidgetList::iterator it = m_tooltips.begin(); it != m_tooltips.end() ; ) {
if (!m_pinnedTooltips.isEmpty()) {
for (DebuggerToolTipWidgetList::iterator it = m_pinnedTooltips.begin(); it != m_pinnedTooltips.end() ; ) {
if (it->isNull()) {
it = m_tooltips.erase(it);
it = m_pinnedTooltips.erase(it);
} else {
++it;
}
}
}
return m_tooltips;
return m_pinnedTooltips;
}
void DebuggerToolTipManager::moveToolTipsBy(const QPoint &distance)
@@ -1164,7 +1197,7 @@ void DebuggerToolTipManager::moveToolTipsBy(const QPoint &distance)
bool DebuggerToolTipManager::eventFilter(QObject *, QEvent *e)
{
// Move along with parent (toplevel)
if (e->type() == QEvent::Move && isActive()) {
if (e->type() == QEvent::Move && hasToolTips()) {
const QMoveEvent *me = static_cast<const QMoveEvent *>(e);
moveToolTipsBy(me->pos() - me->oldPos());
}
@@ -1188,10 +1221,10 @@ void DebuggerToolTipManager::loadSessionData()
const double version = r.attributes().value(QLatin1String(sessionVersionAttributeC)).toString().toDouble();
while (!r.atEnd())
if (AbstractDebuggerToolTipWidget *tw = AbstractDebuggerToolTipWidget::loadSessionData(r))
add(tw);
registerToolTip(tw);
if (debugToolTips)
qDebug() << "DebuggerToolTipManager::loadSessionData version " << version << " restored " << m_tooltips.size();
qDebug() << "DebuggerToolTipManager::loadSessionData version " << version << " restored " << m_pinnedTooltips.size();
slotUpdateVisibleToolTips();
}
@@ -1203,12 +1236,12 @@ void DebuggerToolTipManager::saveSessionData()
w.writeStartDocument();
w.writeStartElement(QLatin1String(sessionDocumentC));
w.writeAttribute(QLatin1String(sessionVersionAttributeC), QLatin1String("1.0"));
foreach (const QPointer<AbstractDebuggerToolTipWidget> &tw, m_tooltips)
foreach (const QPointer<AbstractDebuggerToolTipWidget> &tw, m_pinnedTooltips)
tw->saveSessionData(w);
w.writeEndDocument();
}
if (debugToolTips)
qDebug() << "DebuggerToolTipManager::saveSessionData" << m_tooltips.size() << data ;
qDebug() << "DebuggerToolTipManager::saveSessionData" << m_pinnedTooltips.size() << data ;
debuggerCore()->setSessionValue(QLatin1String(sessionSettingsKeyC), QVariant(data));
}
@@ -1219,25 +1252,7 @@ void DebuggerToolTipManager::closeAllToolTips()
foreach (const QPointer<AbstractDebuggerToolTipWidget> &tw, purgeClosedToolTips())
tw->close();
m_tooltips.clear();
}
void DebuggerToolTipManager::closeUnpinnedToolTips()
{
if (debugToolTips)
qDebug() << "DebuggerToolTipManager::closeUnpinnedToolTips";
// Filter out unpinned ones, purge null on that occasion
for (DebuggerToolTipWidgetList::iterator it = m_tooltips.begin(); it != m_tooltips.end() ; ) {
if (it->isNull()) {
it = m_tooltips.erase(it);
} else if ((*it)->pinState() == AbstractDebuggerToolTipWidget::Unpinned) {
(*it)->close();
it = m_tooltips.erase(it);
} else {
++it;
}
}
m_pinnedTooltips.clear();
}
void DebuggerToolTipManager::hide()
@@ -1267,9 +1282,9 @@ void DebuggerToolTipManager::slotUpdateVisibleToolTips()
// Reposition and show all tooltips of that file.
const QString fileName = toolTipEditor.fileName();
foreach (const QPointer<AbstractDebuggerToolTipWidget> &tw, m_tooltips) {
foreach (const QPointer<AbstractDebuggerToolTipWidget> &tw, m_pinnedTooltips) {
if (tw->fileName() == fileName) {
tw->positionShow(toolTipEditor.plainTextEdit);
tw->positionShow(toolTipEditor);
} else {
tw->hide();
}
@@ -1331,7 +1346,7 @@ void DebuggerToolTipManager::slotStackFrameCompleted()
qPrintable(engineName), qPrintable(fileName), lineNumber,
qPrintable(function));
unsigned acquiredCount = 0;
foreach (const QPointer<AbstractDebuggerToolTipWidget> &tw, m_tooltips) {
foreach (const QPointer<AbstractDebuggerToolTipWidget> &tw, m_pinnedTooltips) {
if (tw->matches(fileName, engineName, function)) {
tw->acquireEngine(engine);
acquiredCount++;
@@ -1354,7 +1369,7 @@ void DebuggerToolTipManager::slotEditorOpened(Core::IEditor *e)
{
// Move tooltip along when scrolled.
if (DebuggerToolTipEditor toolTipEditor = DebuggerToolTipEditor(e)) {
connect(toolTipEditor.plainTextEdit->verticalScrollBar(), SIGNAL(valueChanged(int)),
connect(toolTipEditor.baseTextEditor->verticalScrollBar(), SIGNAL(valueChanged(int)),
this, SLOT(slotUpdateVisibleToolTips()));
connect(toolTipEditor.textEditor,
SIGNAL(tooltipOverrideRequested(TextEditor::ITextEditor*,QPoint,int,bool*)),
@@ -1380,7 +1395,7 @@ void DebuggerToolTipManager::debugModeEntered()
foreach (Core::IEditor *e, em->openedEditors())
slotEditorOpened(e);
// Position tooltips delayed once all the editor placeholder layouting is done.
if (!m_tooltips.isEmpty())
if (!m_pinnedTooltips.isEmpty())
QTimer::singleShot(0, this, SLOT(slotUpdateVisibleToolTips()));
}
}
@@ -1399,14 +1414,14 @@ void DebuggerToolTipManager::leavingDebugMode()
if (Core::EditorManager *em = Core::EditorManager::instance()) {
foreach (Core::IEditor *e, em->openedEditors()) {
if (DebuggerToolTipEditor toolTipEditor = DebuggerToolTipEditor(e)) {
toolTipEditor.plainTextEdit->verticalScrollBar()->disconnect(this);
toolTipEditor.baseTextEditor->verticalScrollBar()->disconnect(this);
toolTipEditor.textEditor->disconnect(this);
}
}
em->disconnect(this);
}
m_lastToolTipEditor = 0;
m_lastToolTipPos = -1;
m_lastToolTipPoint = QPoint(-1, -1);
}
}
@@ -1415,12 +1430,18 @@ void DebuggerToolTipManager::slotTooltipOverrideRequested(TextEditor::ITextEdito
int pos, bool *handled)
{
QTC_ASSERT(handled, return);
if (debugToolTips)
qDebug() << ">slotTooltipOverrideRequested() " << editor << point << pos << *handled;
const int movedDistance = (point - m_lastToolTipPoint).manhattanLength();
const bool samePosition = m_lastToolTipEditor == editor && movedDistance < 25;
if (debugToolTipPositioning)
qDebug() << ">slotTooltipOverrideRequested() " << editor << point
<< "from " << m_lastToolTipPoint << ") pos: "
<< pos << *handled
<< " Same position=" << samePosition << " d=" << movedDistance;
DebuggerEngine *currentEngine = 0;
do {
if (*handled || (m_lastToolTipEditor == editor && pos == m_lastToolTipPos))
if (*handled || samePosition)
break; // Avoid flicker.
DebuggerCore *core = debuggerCore();
@@ -1433,11 +1454,9 @@ void DebuggerToolTipManager::slotTooltipOverrideRequested(TextEditor::ITextEdito
const DebuggerToolTipContext context = DebuggerToolTipContext::fromEditor(editor, pos);
if (context.isValid() && currentEngine->setToolTipExpression(point, editor, context)) {
if (TextEditor::ToolTip::instance()->isVisible())
TextEditor::ToolTip::instance()->hide();
*handled = true;
m_lastToolTipEditor = editor;
m_lastToolTipPos = pos;
m_lastToolTipPoint = point;
}
} while (false);
@@ -1446,10 +1465,9 @@ void DebuggerToolTipManager::slotTooltipOverrideRequested(TextEditor::ITextEdito
// and no leave was triggered.
if (!*handled) {
m_lastToolTipEditor = 0;
m_lastToolTipPos = -1;
closeUnpinnedToolTips();
m_lastToolTipPoint = QPoint(-1, -1);
}
if (debugToolTips)
if (debugToolTipPositioning)
qDebug() << "<slotTooltipOverrideRequested() " << currentEngine << *handled;
}
@@ -1458,7 +1476,7 @@ QStringList DebuggerToolTipManager::treeWidgetExpressions(const QString &fileNam
const QString &function) const
{
QStringList rc;
foreach (const QPointer<AbstractDebuggerToolTipWidget> &tw, m_tooltips)
foreach (const QPointer<AbstractDebuggerToolTipWidget> &tw, m_pinnedTooltips)
if (!tw.isNull() && tw->matches(fileName, engineType, function))
if (const DebuggerTreeViewToolTipWidget *ttw = qobject_cast<const DebuggerTreeViewToolTipWidget *>(tw.data()))
rc.push_back(ttw->expression());