3 // Copyright by Johannes Sixt
4 // This file is under GPL, the GNU General Public Licence
11 #include <qscrollbar.h>
13 #include <kiconloader.h> /* icons */
19 VarTree::VarTree(const QString
& name
, NameKind aKind
) :
23 m_valueChanged(false),
26 m_exprIndexUseGuard(false)
34 void VarTree::paintValue(QPainter
* p
)
37 int cellHeight
= height(p
->fontMetrics());
39 int textY
= (cellHeight
- p
->fontMetrics().height()) / 2 +
40 p
->fontMetrics().ascent();
45 // p->setBackgroundColor(cg.base());
46 p
->drawText(textX
, textY
, m_value
, m_value
.length());
50 int VarTree::valueWidth()
53 return owner
->fontMetrics().width(m_value
) + 4;
56 QString
VarTree::computeExpr() const
58 assert(getParent() != 0);
63 // top-level items are special
64 if (getParent()->getParent() == 0)
68 VarTree
* par
= static_cast<VarTree
*>(getParent());
69 QString parentExpr
= par
->computeExpr();
71 /* don't add this item's name if this is a base class sub-item */
72 if (m_nameKind
== NKtype
) {
75 /* augment by this item's text */
77 /* if this is an address, dereference it */
78 if (m_nameKind
== NKaddress
) {
79 ASSERT(par
->m_varKind
== VKpointer
);
80 result
= "*" + parentExpr
;
83 switch (par
->m_varKind
) {
86 QString index
= getText();
88 // skip past the index
89 while (index
[i
].isDigit())
92 * Some array indices are actually ranges due to repeated array
93 * values. We use the first index in these cases.
95 if (index
[i
] != ']') {
96 // remove second index
97 index
.remove(i
, index
.length()-i
-1);
99 result
= "(" + parentExpr
+ ")" + index
;
103 result
= "(" + parentExpr
+ ")." + getText();
105 case VKsimple
: /* parent can't be simple */
106 case VKpointer
: /* handled in NKaddress */
107 case VKdummy
: /* can't occur at all */
109 result
= parentExpr
; /* paranoia */
115 bool VarTree::isToplevelExpr() const
117 return getParent() != 0 && getParent()->getParent() == 0;
120 bool VarTree::isAncestorEq(const VarTree
* child
) const
122 const KTreeViewItem
* c
= child
;
123 while (c
!= 0 && c
!= this) {
129 bool VarTree::updateValue(const QString
& newValue
)
131 // check whether the value changed
132 bool prevValueChanged
= m_valueChanged
;
133 m_valueChanged
= false;
134 if (m_value
!= newValue
) {
136 m_valueChanged
= true;
139 * We must repaint the cell if the value changed. If it did not change,
140 * we still must repaint the cell if the value changed previously,
141 * because the color of the display must be changed (from red to
144 return m_valueChanged
|| prevValueChanged
;
147 void VarTree::inferTypesOfChildren(ProgramTypeTable
& typeTable
)
150 * Type inference works like this: We use type information of those
151 * children that have a type name in their name (base classes) or in
152 * their value (pointers)
155 // first recurse children
156 VarTree
* child
= static_cast<VarTree
*>(getChild());
158 child
->inferTypesOfChildren(typeTable
);
159 child
= static_cast<VarTree
*>(child
->getSibling());
162 // if this is a pointer, get the type from the value (less the pointer)
163 if (m_varKind
== VKpointer
) {
167 * wchart_t pointers must be treated as struct, because the array
168 * of characters is printed similar to how QStrings are decoded.
170 m_varKind
= VKstruct
;
171 setDelayedExpanding(false);
174 #ifndef I_know_a_way_to_do_this_cleanly
177 const char* p
= m_value
.data();
178 const char* start
= p
;
179 // the type of the pointer shows up in the value (sometimes)
180 if (p
== 0 || *p
!= '(')
182 skipNested(p
, '(', ')');
184 * We only recognize pointers to data "(int *)" but not pointers
185 * to functions "(void (*)())".
187 if (p
-start
< 3 && /* at least 3 chars necessary: (*) */
188 p
[-2] != '*') /* skip back before the closing paren */
192 const QString
& typeName
=
193 QString::fromLatin1(start
+1, p
-start
-3) // minus 3 chars
195 m_type
= typeTable
.lookup(typeName
);
197 m_type
= TypeInfo::unknownType();
200 } else if (m_varKind
== VKstruct
) {
201 // check if this is a base class part
202 if (m_nameKind
== NKtype
) {
203 const QString
& typeName
=
204 text
.mid(1, text
.length()-2); // strip < and >
205 m_type
= typeTable
.lookup(typeName
);
207 /* if we don't have a type yet, get it from the base class */
209 m_type
= inferTypeFromBaseClass();
211 * If there is a known type now, it is the one from the
212 * first base class whose type we know.
217 * If we still don't have a type, the type is really unknown.
220 m_type
= TypeInfo::unknownType();
224 * This is not a base class part. We don't assign a type so
225 * that later we can ask gdb.
230 // the value contains the pointer type in parenthesis
231 bool VarTree::isWcharT() const
233 return m_value
.startsWith("(const wchar_t *)") ||
234 m_value
.startsWith("(wchar_t *)");
238 * Get the type of the first base class whose type we know.
240 TypeInfo
* VarTree::inferTypeFromBaseClass()
242 if (m_varKind
== VKstruct
) {
243 VarTree
* child
= static_cast<VarTree
*>(getChild());
245 // only check base class parts (i.e. type names)
246 child
->m_nameKind
== NKtype
)
248 if (child
->m_type
!= 0 &&
249 child
->m_type
!= TypeInfo::unknownType())
252 return child
->m_type
;
254 child
= static_cast<VarTree
*>(child
->getSibling());
261 ExprWnd::ExprWnd(QWidget
* parent
, const char* name
) :
262 KTreeView(parent
, name
),
268 connect(this, SIGNAL(expanded(int)), SLOT(slotExpandOrCollapse(int)));
269 connect(this, SIGNAL(collapsed(int)), SLOT(slotExpandOrCollapse(int)));
271 m_pixPointer
= UserIcon("pointer.xpm");
272 if (m_pixPointer
.isNull())
273 TRACE("Can't load pointer.xpm");
280 void ExprWnd::exprList(QStrList
& exprs
)
282 // ASSERT(exprs does deep-copies)
284 for (item
= itemAt(0); item
!= 0; item
= item
->getSibling()) {
285 exprs
.append(item
->getText());
289 VarTree
* ExprWnd::insertExpr(VarTree
* expr
)
291 // append a new dummy expression
292 VarTree
* display
= new VarTree(expr
->getText(), VarTree::NKplain
);
295 // replace it right away
296 updateExpr(display
, expr
);
300 void ExprWnd::updateExpr(VarTree
* expr
)
302 // search the root variable
304 path
.push(expr
->getText());
305 KTreeViewItem
* item
= itemAt(path
);
310 if (updateExprRec(static_cast<VarTree
*>(item
), expr
)) {
311 updateVisibleItems();
315 collectUnknownTypes(static_cast<VarTree
*>(item
));
318 void ExprWnd::updateExpr(VarTree
* display
, VarTree
* newValues
)
320 if (updateExprRec(display
, newValues
) && display
->isVisible()) {
321 updateVisibleItems();
325 collectUnknownTypes(display
);
329 * returns true if there's a visible change
331 bool ExprWnd::updateExprRec(VarTree
* display
, VarTree
* newValues
)
333 bool isExpanded
= display
->isExpanded();
336 * If we are updating a pointer without children by a dummy, we don't
337 * collapse it, but simply insert the new children. This happens when a
338 * pointer has just been expanded by the user.
340 if (display
->m_varKind
== VarTree::VKpointer
&&
341 display
->childCount() == 0 &&
342 newValues
->m_varKind
== VarTree::VKdummy
)
344 replaceChildren(display
, newValues
);
345 return isExpanded
; /* no visible change if not expanded */
349 * If the display and newValues have different kind or if their number
350 * of children is different, replace the whole sub-tree.
352 if (// the next two lines mean: not(m_varKind remains unchanged)
353 !(newValues
->m_varKind
== VarTree::VKdummy
||
354 display
->m_varKind
== newValues
->m_varKind
)
356 (display
->childCount() != newValues
->childCount() &&
358 * If this is a pointer and newValues doesn't have children, we
359 * don't replace the sub-tree; instead, below we mark this
360 * sub-tree for requiring an update.
362 (display
->m_varKind
!= VarTree::VKpointer
||
363 newValues
->childCount() != 0)))
366 collapseSubTree(display
, false);
369 // since children changed, it is likely that the type has also changed
370 display
->m_type
= 0; /* will re-evaluate the type */
372 // display the new value
373 updateSingleExpr(display
, newValues
);
374 replaceChildren(display
, newValues
);
376 // update the m_varKind
377 if (newValues
->m_varKind
!= VarTree::VKdummy
) {
378 display
->m_varKind
= newValues
->m_varKind
;
379 display
->setDelayedExpanding(newValues
->m_varKind
== VarTree::VKpointer
);
382 // (note that the new value might not have a sub-tree at all)
383 return display
->m_valueChanged
|| isExpanded
; /* no visible change if not expanded */
386 // display the new value
387 updateSingleExpr(display
, newValues
);
390 * If this is an expanded pointer, record it for being updated.
392 if (display
->m_varKind
== VarTree::VKpointer
) {
394 // if newValues is a dummy, we have already updated this pointer
395 newValues
->m_varKind
!= VarTree::VKdummy
)
397 m_updatePtrs
.append(display
);
400 * If the visible sub-tree has children, but newValues doesn't, we
403 if (newValues
->childCount() == 0) {
404 return display
->m_valueChanged
;
408 ASSERT(display
->childCount() == newValues
->childCount());
411 bool childChanged
= false;
413 VarTree
* vDisplay
= static_cast<VarTree
*>(display
->getChild());
414 VarTree
* vNew
= static_cast<VarTree
*>(newValues
->getChild());
415 while (vDisplay
!= 0) {
416 // check whether the names are the same
417 if (strcmp(vDisplay
->getText(), vNew
->getText()) != 0) {
419 vDisplay
->setText(vNew
->getText());
420 int i
= itemRow(vDisplay
);
422 updateCell(i
, 0, true);
427 if (updateExprRec(vDisplay
, vNew
)) {
430 vDisplay
= static_cast<VarTree
*>(vDisplay
->getSibling());
431 vNew
= static_cast<VarTree
*>(vNew
->getSibling());
434 // update of children propagates only if this node is expanded
435 return display
->m_valueChanged
|| (display
->isExpanded() && childChanged
);
438 void ExprWnd::updateSingleExpr(VarTree
* display
, VarTree
* newValue
)
441 * If newValues is a VKdummy, we are only interested in its children.
442 * No need to update anything here.
444 if (newValue
->m_varKind
== VarTree::VKdummy
) {
449 * If this node is a struct and we know its type then don't update its
450 * value now. This is a node for which we know how to find a nested
451 * value. So register the node for an update.
453 * wchar_t types are also treated specially here: We consider them
454 * as struct (has been set in inferTypesOfChildren()).
456 if (display
->m_varKind
== VarTree::VKstruct
&&
457 display
->m_type
!= 0 &&
458 display
->m_type
!= TypeInfo::unknownType())
460 ASSERT(newValue
->m_varKind
== VarTree::VKstruct
);
461 if (display
->m_type
== TypeInfo::wchartType())
464 * We do not copy the new pointer value to the destination right
465 * away, but consider it as the first part of the nested value.
466 * Then the display will change its color only when the new value
469 display
->m_partialValue
= formatWCharPointer(newValue
->m_value
);
472 display
->m_partialValue
= display
->m_type
->m_displayString
[0];
473 m_updateStruct
.append(display
);
477 if (display
->updateValue(newValue
->m_value
)) {
478 int i
= itemRow(display
);
480 updateCell(i
, 1, true);
486 void ExprWnd::updateStructValue(VarTree
* display
)
488 ASSERT(display
->m_varKind
== VarTree::VKstruct
);
490 if (display
->updateValue(display
->m_partialValue
)) {
491 int i
= itemRow(display
);
494 updateCell(i
, 1, true);
498 display
->m_partialValue
= "";
499 display
->m_exprIndex
= -1;
502 void ExprWnd::replaceChildren(VarTree
* display
, VarTree
* newValues
)
504 ASSERT(display
->childCount() == 0 || display
->m_varKind
!= VarTree::VKsimple
);
506 // delete all children of display
507 while (VarTree
* c
= static_cast<VarTree
*>(display
->getChild())) {
509 display
->removeChild(c
);
512 // insert copies of the newValues
513 for (KTreeViewItem
* c
= newValues
->getChild(); c
!= 0; c
= c
->getSibling()) {
514 VarTree
* v
= static_cast<VarTree
*>(c
);
515 VarTree
* vNew
= new VarTree(v
->getText(), v
->m_nameKind
);
516 vNew
->m_varKind
= v
->m_varKind
;
517 vNew
->m_value
= v
->m_value
;
518 vNew
->m_type
= v
->m_type
;
519 vNew
->setDelayedExpanding(vNew
->m_varKind
== VarTree::VKpointer
);
520 vNew
->setExpanded(v
->isExpanded());
521 display
->appendChild(vNew
);
523 replaceChildren(vNew
, v
);
527 void ExprWnd::collectUnknownTypes(VarTree
* var
)
530 * forEveryItem does not scan the root item itself. So we must do it
533 ASSERT(var
->m_varKind
!= VarTree::VKpointer
|| var
->m_nameKind
!= VarTree::NKtype
);
534 if (var
->m_type
== 0 &&
535 var
->m_varKind
== VarTree::VKstruct
&&
536 var
->m_nameKind
!= VarTree::NKtype
)
538 if (!var
->isWcharT())
540 /* this struct node doesn't have a type yet: register it */
541 m_updateType
.append(var
);
545 var
->m_type
= TypeInfo::wchartType();
546 // see updateSingleExpr() why we move the value
547 var
->m_partialValue
= formatWCharPointer(var
->m_value
);
548 var
->m_value
.truncate(0);
549 m_updateStruct
.append(var
);
553 // add pointer pixmap to pointers
554 if (var
->m_varKind
== VarTree::VKpointer
) {
555 var
->setPixmap(m_pixPointer
);
558 forEveryItem(collectUnknownTypes
, this, var
);
561 bool ExprWnd::collectUnknownTypes(KTreeViewItem
* item
, void* user
)
563 VarTree
* var
= static_cast<VarTree
*>(item
);
564 ExprWnd
* tree
= static_cast<ExprWnd
*>(user
);
565 ASSERT(var
->m_varKind
!= VarTree::VKpointer
|| var
->m_nameKind
!= VarTree::NKtype
);
566 if (var
->m_type
== 0 &&
567 var
->m_varKind
== VarTree::VKstruct
&&
568 var
->m_nameKind
!= VarTree::NKtype
)
570 if (!var
->isWcharT())
572 /* this struct node doesn't have a type yet: register it */
573 tree
->m_updateType
.append(var
);
577 var
->m_type
= TypeInfo::wchartType();
578 // see updateSingleExpr() why we move the value
579 var
->m_partialValue
= formatWCharPointer(var
->m_value
);
580 var
->m_value
.truncate(0);
581 tree
->m_updateStruct
.append(var
);
584 // add pointer pixmap to pointers
585 if (var
->m_varKind
== VarTree::VKpointer
) {
586 var
->setPixmap(tree
->m_pixPointer
);
591 QString
ExprWnd::formatWCharPointer(QString value
)
593 int pos
= value
.find(") ");
595 value
= value
.mid(pos
+2);
600 VarTree
* ExprWnd::topLevelExprByName(const char* name
)
604 KTreeViewItem
* item
= itemAt(path
);
606 return static_cast<VarTree
*>(item
);
609 VarTree
* ExprWnd::ptrMemberByName(VarTree
* v
, const QString
& name
)
611 // v must be a pointer variable, must have children
612 if (v
->m_varKind
!= VarTree::VKpointer
|| v
->childCount() == 0)
615 // the only child of v is the pointer value that represents the struct
616 KTreeViewItem
* item
= v
->getChild();
617 return memberByName(static_cast<VarTree
*>(item
), name
);
620 VarTree
* ExprWnd::memberByName(VarTree
* v
, const QString
& name
)
622 // search immediate children for name
623 KTreeViewItem
* item
= v
->getChild();
624 while (item
!= 0 && item
->getText() != name
)
625 item
= item
->getSibling();
628 return static_cast<VarTree
*>(item
);
630 // try in base classes
631 item
= v
->getChild();
633 static_cast<VarTree
*>(item
)->m_nameKind
== VarTree::NKtype
)
635 v
= memberByName(static_cast<VarTree
*>(item
), name
);
638 item
= item
->getSibling();
643 void ExprWnd::removeExpr(VarTree
* item
)
653 void ExprWnd::unhookSubtree(VarTree
* subTree
)
655 // must remove any pointers scheduled for update from the list
656 unhookSubtree(m_updatePtrs
, subTree
);
657 unhookSubtree(m_updateType
, subTree
);
658 unhookSubtree(m_updateStruct
, subTree
);
659 emit
removingItem(subTree
);
662 void ExprWnd::unhookSubtree(QList
<VarTree
>& list
, VarTree
* subTree
)
667 VarTree
* checkItem
= list
.first();
668 while (checkItem
!= 0) {
669 if (!subTree
->isAncestorEq(checkItem
)) {
670 // checkItem is not an item from subTree
672 checkItem
= list
.next();
674 // checkItem is an item from subTree
676 * If checkItem is the last item in the list, we need a special
677 * treatment, because remove()ing it steps the current item of
678 * the list in the "wrong" direction.
680 if (checkItem
== list
.getLast()) { // does not set current item
682 /* we deleted the last element, so we've finished */
686 /* remove() advanced already */
687 checkItem
= list
.current();
693 void ExprWnd::clearPendingUpdates()
695 m_updatePtrs
.clear();
696 m_updateType
.clear();
697 m_updateStruct
.clear();
700 VarTree
* ExprWnd::nextUpdatePtr()
702 VarTree
* ptr
= m_updatePtrs
.first();
704 m_updatePtrs
.remove();
709 VarTree
* ExprWnd::nextUpdateType()
711 VarTree
* ptr
= m_updateType
.first();
713 m_updateType
.remove();
718 VarTree
* ExprWnd::nextUpdateStruct()
720 VarTree
* ptr
= m_updateStruct
.first();
722 m_updateStruct
.remove();
727 void ExprWnd::paintCell(QPainter
* painter
, int row
, int col
)
730 KTreeView::paintCell(painter
, row
, col
);
732 VarTree
* item
= static_cast<VarTree
*>(itemAt(row
));
734 item
->paintValue(painter
);
739 int ExprWnd::cellWidth(int col
) const
742 return KTreeView::cellWidth(col
);
744 return maxValueWidth
;
748 void ExprWnd::updateValuesWidth()
751 forEveryVisibleItem(static_cast<KForEveryFunc
>(&getMaxValueWidth
), &maxW
);
752 maxValueWidth
= maxW
;
756 // called by updateValuesWidth() for each item in the visible list
757 bool ExprWnd::getMaxValueWidth(KTreeViewItem
* item
, void* user
)
759 int *maxW
= (int *)user
;
760 VarTree
* v
= static_cast<VarTree
*>(item
);
761 int w
= v
->valueWidth();
767 void ExprWnd::slotExpandOrCollapse(int)
772 void ExprWnd::editValue(int row
, const QString
& text
)
778 int w
= cellWidth(1);
779 int h
= cellHeight(row
);
780 QScrollBar
* sbV
= static_cast<QScrollBar
*>(child("table_sbV"));
783 * Make the edit widget at least 5 characters wide (but not wider than
784 * this widget). If less than half of this widget is used to display
785 * the text, scroll this widget so that half of it shows the text (or
786 * less than half of it if the text is shorter).
788 QFontMetrics metr
= m_edit
.font();
789 int wMin
= metr
.width("88888");
793 if (sbV
->isVisible()) // subtract width of scrollbar
794 wThis
-= sbV
->width();
795 if (x
>= wThis
/2 && // less than half the width displays text
796 x
+w
> wThis
) // not all text is visible
798 // scroll so that more text is visible
799 int wScroll
= QMIN(x
-wThis
/2, x
+w
-wThis
);
800 sbHor(xOffset()+wScroll
);
805 // don't let the edit move out at the left
809 // make the edit box as wide as the visible column
810 QRect
rect(x
,y
, wThis
-x
,h
);
811 m_edit
.setText(text
);
814 m_edit
.setGeometry(rect
);
815 m_edit
.m_finished
= false;
821 bool ExprWnd::isEditing() const
823 return m_edit
.isVisible();
827 ValueEdit::ValueEdit(ExprWnd
* parent
) :
828 QLineEdit(parent
, "valueedit")
832 lower(); // lower the window below scrollbars
833 connect(parent
, SIGNAL(selected(int)), SLOT(slotSelectionChanged()));
834 connect(parent
, SIGNAL(collapsed(int)), SLOT(slotSelectionChanged()));
835 connect(parent
, SIGNAL(expanded(int)), SLOT(slotSelectionChanged()));
836 connect(this, SIGNAL(done(int, const QString
&)),
837 parent
, SIGNAL(editValueCommitted(int, const QString
&)));
840 ValueEdit::~ValueEdit()
844 void ValueEdit::terminate(bool commit
)
846 TRACE(commit
?"ValueEdit::terminate(true)":"ValueEdit::terminate(false)");
850 hide(); // will call focusOutEvent, that's why we need m_finished
852 emit
done(m_row
, text());
857 void ValueEdit::keyPressEvent(QKeyEvent
*e
)
859 if(e
->key() == Qt::Key_Return
|| e
->key() == Qt::Key_Enter
)
861 else if(e
->key() == Qt::Key_Escape
)
864 QLineEdit::keyPressEvent(e
);
867 void ValueEdit::paintEvent(QPaintEvent
* e
)
869 QLineEdit::paintEvent(e
);
875 void ValueEdit::focusOutEvent(QFocusEvent
* ev
)
877 TRACE("ValueEdit::focusOutEvent");
878 QFocusEvent
* focusEv
= static_cast<QFocusEvent
*>(ev
);
879 // Don't let a RMB close the editor
880 if (focusEv
->reason() != QFocusEvent::Popup
&&
881 focusEv
->reason() != QFocusEvent::ActiveWindow
)
887 void ValueEdit::slotSelectionChanged()
889 TRACE("ValueEdit::slotSelectionChanged");