kdbg/exprwnd.cpp

   1 // $Id$
   2
   3 // Copyright by Johannes Sixt
   4 // This file is under GPL, the GNU General Public Licence
   5
   6 #include "exprwnd.h"
   7 #include "exprwnd.moc"
   8 #include "typetable.h"
   9 #include <qstrlist.h>
  10 #include <qpainter.h>
  11 #include <qscrollbar.h>
  12 #include <kapp.h>
  13 #include <kiconloader.h>                /* icons */
  14 #include <klocale.h>                    /* i18n */
  15 #ifdef HAVE_CONFIG_H
  16 #include "config.h"
  17 #endif
  18 #include "mydebug.h"
  19
  20 VarTree::VarTree(VarTree* parent, QListViewItem* after, ExprValue* v) :
  21         QListViewItem(parent, after),
  22         m_varKind(v->m_varKind),
  23         m_nameKind(v->m_nameKind),
  24         m_valueChanged(false),
  25         m_type(0),
  26         m_exprIndex(0),
  27         m_exprIndexUseGuard(false)
  28 {
  29     QListViewItem::setText(0, v->m_name);
  30     QListViewItem::setText(1, v->m_value);
  31     setExpandable(m_varKind == VarTree::VKpointer);
  32     setOpen(v->m_initiallyExpanded);
  33 }
  34
  35 VarTree::VarTree(ExprWnd* parent, QListViewItem* after, const QString& name) :
  36         QListViewItem(parent, after),
  37         m_varKind(VKsimple),
  38         m_nameKind(VarTree::NKplain),
  39         m_valueChanged(false),
  40         m_type(0),
  41         m_exprIndex(0),
  42         m_exprIndexUseGuard(false)
  43 {
  44     QListViewItem::setText(0, name);
  45 }
  46
  47 VarTree::~VarTree()
  48 {
  49 }
  50
  51 void VarTree::paintCell(QPainter* p, const QColorGroup& cg, int column, int width, int align)
  52 {
  53     if (column == 1 && m_valueChanged) {
  54         QColorGroup cgChg = cg;
  55         cgChg.setColor(QColorGroup::Text, Qt::red);
  56         QListViewItem::paintCell(p, cgChg, column, width, align);
  57     } else {
  58         QListViewItem::paintCell(p, cg, column, width, align);
  59     }
  60 }
  61
  62 QString VarTree::computeExpr() const
  63 {
  64     // top-level items are special
  65     if (isToplevelExpr())
  66         return getText();
  67
  68     // get parent expr
  69     VarTree* par = static_cast<VarTree*>(parent());
  70     QString parentExpr = par->computeExpr();
  71
  72     /* don't add this item's name if this is a base class sub-item */
  73     if (m_nameKind == NKtype) {
  74         return parentExpr;
  75     }
  76     /* augment by this item's text */
  77     QString result;
  78     /* if this is an address, dereference it */
  79     if (m_nameKind == NKaddress) {
  80         ASSERT(par->m_varKind == VKpointer);
  81         result = "*" + parentExpr;
  82         return result;
  83     }
  84     switch (par->m_varKind) {
  85     case VKarray:
  86         {
  87             QString index = getText();
  88             int i = 1;
  89             // skip past the index
  90             while (index[i].isDigit())
  91                 i++;
  92             /*
  93              * Some array indices are actually ranges due to repeated array
  94              * values. We use the first index in these cases.
  95              */
  96             if (index[i] != ']') {
  97                 // remove second index
  98                 index.remove(i, index.length()-i-1);
  99             }
 100             result = "(" + parentExpr + ")" + index;
 101         }
 102         break;
 103     case VKstruct:
 104         result = "(" + parentExpr + ")." + getText();
 105         break;
 106     case VKsimple:                      /* parent can't be simple */
 107     case VKpointer:                     /* handled in NKaddress */
 108     case VKdummy:                       /* can't occur at all */
 109         ASSERT(false);
 110         result = parentExpr;            /* paranoia */
 111         break;
 112     }
 113     return result;
 114 }
 115
 116 bool VarTree::isToplevelExpr() const
 117 {
 118     return parent() == 0;
 119 }
 120
 121 bool VarTree::isAncestorEq(const VarTree* child) const
 122 {
 123     const QListViewItem* c = child;
 124     while (c != 0 && c != this) {
 125         c = c->parent();
 126     }
 127     return c != 0;
 128 }
 129
 130 bool VarTree::updateValue(const QString& newValue)
 131 {
 132     // check whether the value changed
 133     bool prevValueChanged = m_valueChanged;
 134     m_valueChanged = false;
 135     if (value() != newValue) {
 136         setValue(newValue);
 137         m_valueChanged = true;
 138     }
 139     /*
 140      * We must repaint the cell if the value changed. If it did not change,
 141      * we still must repaint the cell if the value changed previously,
 142      * because the color of the display must be changed (from red to
 143      * black).
 144      */
 145     return m_valueChanged || prevValueChanged;
 146 }
 147
 148 void VarTree::inferTypesOfChildren(ProgramTypeTable& typeTable)
 149 {
 150     /*
 151      * Type inference works like this: We use type information of those
 152      * children that have a type name in their name (base classes) or in
 153      * their value (pointers)
 154      */
 155
 156     // first recurse children
 157     VarTree* child = firstChild();
 158     while (child != 0) {
 159         child->inferTypesOfChildren(typeTable);
 160         child = child->nextSibling();
 161     }
 162
 163     // if this is a pointer, get the type from the value (less the pointer)
 164     if (m_varKind == VKpointer) {
 165         if (isWcharT())
 166         {
 167             /*
 168              * wchart_t pointers must be treated as struct, because the array
 169              * of characters is printed similar to how QStrings are decoded.
 170              */
 171             m_varKind = VKstruct;
 172             setExpandable(false);
 173         }
 174         // don't know how to do this cleanly
 175     } else if (m_varKind == VKstruct) {
 176         // check if this is a base class part
 177         if (m_nameKind == NKtype) {
 178             const QString& typeName =
 179                 getText().mid(1, getText().length()-2); // strip < and >
 180             m_type = typeTable.lookup(typeName);
 181
 182             /* if we don't have a type yet, get it from the base class */
 183             if (m_type == 0) {
 184                 m_type = inferTypeFromBaseClass();
 185                 /*
 186                  * If there is a known type now, it is the one from the
 187                  * first base class whose type we know.
 188                  */
 189             }
 190
 191             /*
 192              * If we still don't have a type, the type is really unknown.
 193              */
 194             if (m_type == 0) {
 195                 m_type = TypeInfo::unknownType();
 196             }
 197         } // else
 198             /*
 199              * This is not a base class part. We don't assign a type so
 200              * that later we can ask gdb.
 201              */
 202     }
 203 }
 204
 205 // the value contains the pointer type in parenthesis
 206 bool VarTree::isWcharT() const
 207 {
 208     return value().startsWith("(const wchar_t *)") ||
 209             value().startsWith("(wchar_t *)");
 210 }
 211
 212 /*
 213  * Get the type of the first base class whose type we know.
 214  */
 215 TypeInfo* VarTree::inferTypeFromBaseClass()
 216 {
 217     if (m_varKind == VKstruct) {
 218         VarTree* child = firstChild();
 219         while (child != 0 &&
 220                // only check base class parts (i.e. type names)
 221                child->m_nameKind == NKtype)
 222         {
 223             if (child->m_type != 0 &&
 224                 child->m_type != TypeInfo::unknownType())
 225             {
 226                 // got a type!
 227                 return child->m_type;
 228             }
 229             child = child->nextSibling();
 230         }
 231     }
 232     return 0;
 233 }
 234
 235 ExprValue::ExprValue(const QString& name, VarTree::NameKind aKind) :
 236         m_name(name),
 237         m_varKind(VarTree::VKsimple),
 238         m_nameKind(aKind),
 239         m_child(0),
 240         m_next(0),
 241         m_initiallyExpanded(false)
 242 {
 243 }
 244
 245 ExprValue::~ExprValue()
 246 {
 247     delete m_child;
 248     delete m_next;
 249 }
 250
 251 void ExprValue::appendChild(ExprValue* newChild)
 252 {
 253     if (m_child == 0) {
 254         m_child = newChild;
 255     } else {
 256         // walk chain of children to find the last one
 257         ExprValue* last = m_child;
 258         while (last->m_next != 0)
 259             last = last->m_next;
 260         last->m_next = newChild;
 261     }
 262     newChild->m_next = 0;       // just to be sure
 263 }
 264
 265 int ExprValue::childCount() const
 266 {
 267     int i = 0;
 268     ExprValue* c = m_child;
 269     while (c) {
 270         ++i;
 271         c = c->m_next;
 272     }
 273     return i;
 274 }
 275
 276
 277
 278 ExprWnd::ExprWnd(QWidget* parent, const QString& colHeader, const char* name) :
 279         QListView(parent, name),
 280         m_edit(0)
 281 {
 282     addColumn(colHeader);
 283     addColumn(i18n("Value"));
 284     setSorting(-1);             // do not sort items
 285     setColumnWidthMode(0, Manual);
 286     setColumnWidthMode(1, Maximum);
 287     setRootIsDecorated(true);
 288
 289     m_pixPointer = UserIcon("pointer.xpm");
 290     if (m_pixPointer.isNull())
 291         TRACE("Can't load pointer.xpm");
 292 }
 293
 294 ExprWnd::~ExprWnd()
 295 {
 296 }
 297
 298 void ExprWnd::exprList(QStrList& exprs)
 299 {
 300     // ASSERT(exprs does deep-copies)
 301     VarTree* item;
 302     for (item = firstChild(); item != 0; item = item->nextSibling()) {
 303         exprs.append(item->getText());
 304     }
 305 }
 306
 307 VarTree* ExprWnd::insertExpr(ExprValue* expr, ProgramTypeTable& typeTable)
 308 {
 309     // append a new dummy expression
 310     VarTree* last = 0;  // last top-level item
 311     for (VarTree* i = firstChild(); i != 0; i = i->nextSibling()) {
 312         last = i;
 313     }
 314     VarTree* display = new VarTree(this, last, expr->m_name);
 315
 316     // replace it right away
 317     updateExpr(display, expr, typeTable);
 318     return display;
 319 }
 320
 321 void ExprWnd::updateExpr(ExprValue* expr, ProgramTypeTable& typeTable)
 322 {
 323     // search the root variable
 324     VarTree* item = firstChild();
 325     while (item != 0 && item->getText() != expr->m_name)
 326         item = item->nextSibling();
 327     if (item == 0) {
 328         return;
 329     }
 330     // now update it
 331     if (updateExprRec(item, expr, typeTable)) {
 332         triggerUpdate();
 333     }
 334     collectUnknownTypes(item);
 335 }
 336
 337 void ExprWnd::updateExpr(VarTree* display, ExprValue* newValues, ProgramTypeTable& typeTable)
 338 {
 339     if (updateExprRec(display, newValues, typeTable) &&
 340         display->isVisible())
 341     {
 342         triggerUpdate();
 343     }
 344     collectUnknownTypes(display);
 345 }
 346
 347 /*
 348  * returns true if there's a visible change
 349  */
 350 bool ExprWnd::updateExprRec(VarTree* display, ExprValue* newValues, ProgramTypeTable& typeTable)
 351 {
 352     bool isExpanded = display->isOpen();
 353
 354     /*
 355      * If we are updating a pointer without children by a dummy, we don't
 356      * collapse it, but simply insert the new children. This happens when a
 357      * pointer has just been expanded by the user.
 358      */
 359     if (display->m_varKind == VarTree::VKpointer &&
 360         display->childCount() == 0 &&
 361         newValues->m_varKind == VarTree::VKdummy)
 362     {
 363         replaceChildren(display, newValues);
 364         return isExpanded;              /* no visible change if not expanded */
 365     }
 366
 367     /*
 368      * If the display and newValues have different kind or if their number
 369      * of children is different, replace the whole sub-tree.
 370      */
 371     if (// the next two lines mean: not(m_varKind remains unchanged)
 372         !(newValues->m_varKind == VarTree::VKdummy ||
 373           display->m_varKind == newValues->m_varKind)
 374         ||
 375         (display->childCount() != newValues->childCount() &&
 376          /*
 377           * If this is a pointer and newValues doesn't have children, we
 378           * don't replace the sub-tree; instead, below we mark this
 379           * sub-tree for requiring an update.
 380           */
 381          (display->m_varKind != VarTree::VKpointer ||
 382           newValues->m_child != 0)))
 383     {
 384         if (isExpanded) {
 385             display->setOpen(false);
 386         }
 387
 388         // since children changed, it is likely that the type has also changed
 389         display->m_type = 0;            /* will re-evaluate the type */
 390
 391         // display the new value
 392         updateSingleExpr(display, newValues);
 393         replaceChildren(display, newValues);
 394
 395         // update the m_varKind
 396         if (newValues->m_varKind != VarTree::VKdummy) {
 397             display->m_varKind = newValues->m_varKind;
 398             display->setExpandable(newValues->m_varKind == VarTree::VKpointer);
 399         }
 400
 401         // get some types (after the new m_varKind has been set!)
 402         display->inferTypesOfChildren(typeTable);
 403
 404         // (note that the new value might not have a sub-tree at all)
 405         return display->m_valueChanged || isExpanded;   /* no visible change if not expanded */
 406     }
 407
 408     // display the new value
 409     updateSingleExpr(display, newValues);
 410
 411     /*
 412      * If this is an expanded pointer, record it for being updated.
 413      */
 414     if (display->m_varKind == VarTree::VKpointer) {
 415         if (isExpanded &&
 416             // if newValues is a dummy, we have already updated this pointer
 417             newValues->m_varKind != VarTree::VKdummy)
 418         {
 419             m_updatePtrs.append(display);
 420         }
 421         /*
 422          * If the visible sub-tree has children, but newValues doesn't, we
 423          * can stop here.
 424          */
 425         if (newValues->m_child == 0) {
 426             return display->m_valueChanged;
 427         }
 428     }
 429
 430     ASSERT(display->childCount() == newValues->childCount());
 431
 432     // go for children
 433     bool childChanged = false;
 434
 435     VarTree* vDisplay = display->firstChild();
 436     ExprValue* vNew = newValues->m_child;
 437     while (vDisplay != 0) {
 438         // check whether the names are the same
 439         if (vDisplay->getText() != vNew->m_name) {
 440             // set new name
 441             vDisplay->setText(vNew->m_name);
 442             {
 443                 childChanged = true;
 444             }
 445         }
 446         // recurse
 447         if (updateExprRec(vDisplay, vNew, typeTable)) {
 448             childChanged = true;
 449         }
 450         vDisplay = vDisplay->nextSibling();
 451         vNew = vNew->m_next;
 452     }
 453
 454     // update of children propagates only if this node is expanded
 455     return display->m_valueChanged || (display->isOpen() && childChanged);
 456 }
 457
 458 void ExprWnd::updateSingleExpr(VarTree* display, ExprValue* newValue)
 459 {
 460     /*
 461      * If newValues is a VKdummy, we are only interested in its children.
 462      * No need to update anything here.
 463      */
 464     if (newValue->m_varKind == VarTree::VKdummy) {
 465         return;
 466     }
 467
 468     /*
 469      * If this node is a struct and we know its type then don't update its
 470      * value now. This is a node for which we know how to find a nested
 471      * value. So register the node for an update.
 472      *
 473      * wchar_t types are also treated specially here: We consider them
 474      * as struct (has been set in inferTypesOfChildren()).
 475      */
 476     if (display->m_varKind == VarTree::VKstruct &&
 477         display->m_type != 0 &&
 478         display->m_type != TypeInfo::unknownType())
 479     {
 480         ASSERT(newValue->m_varKind == VarTree::VKstruct);
 481         if (display->m_type == TypeInfo::wchartType())
 482         {
 483             /*
 484              * We do not copy the new pointer value to the destination right
 485              * away, but consider it as the first part of the nested value.
 486              * Then the display will change its color only when the new value
 487              * is completed.
 488              */
 489             display->m_partialValue = formatWCharPointer(newValue->m_value);
 490         }
 491         else
 492             display->m_partialValue = display->m_type->m_displayString[0];
 493         m_updateStruct.append(display);
 494     }
 495     else
 496     {
 497         if (display->updateValue(newValue->m_value)) {
 498             triggerUpdate();
 499         }
 500     }
 501 }
 502
 503 void ExprWnd::updateStructValue(VarTree* display)
 504 {
 505     ASSERT(display->m_varKind == VarTree::VKstruct);
 506
 507     if (display->updateValue(display->m_partialValue)) {
 508         triggerUpdate();
 509     }
 510     // reset the value
 511     display->m_partialValue = "";
 512     display->m_exprIndex = -1;
 513 }
 514
 515 void ExprWnd::replaceChildren(VarTree* display, ExprValue* newValues)
 516 {
 517     ASSERT(display->childCount() == 0 || display->m_varKind != VarTree::VKsimple);
 518
 519     // delete all children of display
 520     while (VarTree* c = display->firstChild()) {
 521         unhookSubtree(c);
 522         delete c;
 523     }
 524     // insert copies of the newValues
 525     VarTree* vNew = 0;
 526     for (ExprValue* v = newValues->m_child; v != 0; v = v->m_next)
 527     {
 528         vNew = new VarTree(display, vNew, v);
 529         // recurse
 530         replaceChildren(vNew, v);
 531     }
 532 }
 533
 534 void ExprWnd::collectUnknownTypes(VarTree* var)
 535 {
 536     QListViewItemIterator i(var);
 537     for (; i.current(); ++i)
 538     {
 539         checkUnknownType(static_cast<VarTree*>(i.current()));
 540     }
 541 }
 542
 543 void ExprWnd::checkUnknownType(VarTree* var)
 544 {
 545     ASSERT(var->m_varKind != VarTree::VKpointer || var->m_nameKind != VarTree::NKtype);
 546     if (var->m_type == 0 &&
 547         var->m_varKind == VarTree::VKstruct &&
 548         var->m_nameKind != VarTree::NKtype)
 549     {
 550         if (!var->isWcharT())
 551         {
 552             /* this struct node doesn't have a type yet: register it */
 553             m_updateType.append(var);
 554         }
 555         else
 556         {
 557             var->m_type = TypeInfo::wchartType();
 558             // see updateSingleExpr() why we move the value
 559             var->m_partialValue = formatWCharPointer(var->value());
 560             var->setValue(QString());
 561             m_updateStruct.append(var);
 562         }
 563     }
 564     // add pointer pixmap to pointers
 565     if (var->m_varKind == VarTree::VKpointer) {
 566         var->setPixmap(m_pixPointer);
 567     }
 568 }
 569
 570 QString ExprWnd::formatWCharPointer(QString value)
 571 {
 572     int pos = value.find(") ");
 573     if (pos > 0)
 574         value = value.mid(pos+2);
 575     return value + " L";
 576 }
 577
 578
 579 VarTree* ExprWnd::topLevelExprByName(const char* name)
 580 {
 581     VarTree* item = firstChild();
 582     while (item != 0 && item->getText() != name)
 583         item = item->nextSibling();
 584
 585     return item;
 586 }
 587
 588 VarTree* ExprWnd::ptrMemberByName(VarTree* v, const QString& name)
 589 {
 590     // v must be a pointer variable, must have children
 591     if (v->m_varKind != VarTree::VKpointer || v->childCount() == 0)
 592         return 0;
 593
 594     // the only child of v is the pointer value that represents the struct
 595     VarTree* item = v->firstChild();
 596     return memberByName(item, name);
 597 }
 598
 599 VarTree* ExprWnd::memberByName(VarTree* v, const QString& name)
 600 {
 601     // search immediate children for name
 602     VarTree* item = v->firstChild();
 603     while (item != 0 && item->getText() != name)
 604         item = item->nextSibling();
 605
 606     if (item != 0)
 607         return item;
 608
 609     // try in base classes
 610     item = v->firstChild();
 611     while (item != 0 &&
 612            item->m_nameKind == VarTree::NKtype)
 613     {
 614         v = memberByName(item, name);
 615         if (v != 0)
 616             return v;
 617         item = item->nextSibling();
 618     }
 619     return 0;
 620 }
 621
 622 void ExprWnd::removeExpr(VarTree* item)
 623 {
 624     unhookSubtree(item);
 625
 626     delete item;
 627 }
 628
 629 void ExprWnd::unhookSubtree(VarTree* subTree)
 630 {
 631     // must remove any pointers scheduled for update from the list
 632     unhookSubtree(m_updatePtrs, subTree);
 633     unhookSubtree(m_updateType, subTree);
 634     unhookSubtree(m_updateStruct, subTree);
 635     emit removingItem(subTree);
 636 }
 637
 638 void ExprWnd::unhookSubtree(QList<VarTree>& list, VarTree* subTree)
 639 {
 640     if (subTree == 0)
 641         return;
 642
 643     VarTree* checkItem = list.first();
 644     while (checkItem != 0) {
 645         if (!subTree->isAncestorEq(checkItem)) {
 646             // checkItem is not an item from subTree
 647             // advance
 648             checkItem = list.next();
 649         } else {
 650             // checkItem is an item from subTree
 651             /*
 652              * If checkItem is the last item in the list, we need a special
 653              * treatment, because remove()ing it steps the current item of
 654              * the list in the "wrong" direction.
 655              */
 656             if (checkItem == list.getLast()) { // does not set current item
 657                 list.remove();
 658                 /* we deleted the last element, so we've finished */
 659                 checkItem = 0;
 660             } else {
 661                 list.remove();
 662                 /* remove() advanced already */
 663                 checkItem = list.current();
 664             }
 665         }
 666     }
 667 }
 668
 669 void ExprWnd::clearPendingUpdates()
 670 {
 671     m_updatePtrs.clear();
 672     m_updateType.clear();
 673     m_updateStruct.clear();
 674 }
 675
 676 VarTree* ExprWnd::nextUpdatePtr()
 677 {
 678     VarTree* ptr = m_updatePtrs.first();
 679     if (ptr != 0) {
 680         m_updatePtrs.remove();
 681     }
 682     return ptr;
 683 }
 684
 685 VarTree* ExprWnd::nextUpdateType()
 686 {
 687     VarTree* ptr = m_updateType.first();
 688     if (ptr != 0) {
 689         m_updateType.remove();
 690     }
 691     return ptr;
 692 }
 693
 694 VarTree* ExprWnd::nextUpdateStruct()
 695 {
 696     VarTree* ptr = m_updateStruct.first();
 697     if (ptr != 0) {
 698         m_updateStruct.remove();
 699     }
 700     return ptr;
 701 }
 702
 703
 704 void ExprWnd::editValue(VarTree* item, const QString& text)
 705 {
 706     if (m_edit == 0)
 707         m_edit = new ValueEdit(this);
 708
 709     QRect r = itemRect(item);
 710     int x = r.x()+columnWidth(0);
 711     int y = r.y();
 712     int w = columnWidth(1);
 713     int h = r.height();
 714     QListView* lv = item->listView();
 715
 716     /*
 717      * Make the edit widget at least 5 characters wide (but not wider than
 718      * this widget). If less than half of this widget is used to display
 719      * the text, scroll this widget so that half of it shows the text (or
 720      * less than half of it if the text is shorter).
 721      */
 722     QFontMetrics metr = m_edit->font();
 723     int wMin = metr.width("88888");
 724     if (w < wMin)
 725         w = wMin;
 726     int wThis = lv->visibleWidth();
 727     if (x >= wThis/2 &&         // less than half the width displays text
 728         x+w > wThis)            // not all text is visible
 729     {
 730         // scroll so that more text is visible
 731         int wScroll = QMIN(x-wThis/2, x+w-wThis);
 732         lv->scrollBy(wScroll, 0);
 733         x -= wScroll;
 734     }
 735     else if (x < 0)
 736     {
 737         // don't let the edit move out at the left
 738         x = 0;
 739     }
 740
 741     // make the edit box as wide as the visible column
 742     QRect rect(x,y, wThis-x,h);
 743     m_edit->setText(text);
 744     m_edit->selectAll();
 745
 746     m_edit->setGeometry(rect);
 747     m_edit->m_finished = false;
 748     m_edit->m_item = item;
 749     m_edit->show();
 750     m_edit->setFocus();
 751 }
 752
 753 bool ExprWnd::isEditing() const
 754 {
 755     return m_edit != 0 && m_edit->isVisible();
 756 }
 757
 758
 759 ValueEdit::ValueEdit(ExprWnd* parent) :
 760         QLineEdit(parent->viewport(), "valueedit")
 761 {
 762     setFrame(false);
 763     hide();
 764     lower();    // lower the window below scrollbars
 765     connect(parent, SIGNAL(selectionChanged()), SLOT(slotSelectionChanged()));
 766     connect(parent, SIGNAL(currentChanged(QListViewItem*)), SLOT(slotSelectionChanged()));
 767     connect(parent, SIGNAL(expanded(QListViewItem*)), SLOT(slotSelectionChanged()));
 768     connect(parent, SIGNAL(collapsed(QListViewItem*)), SLOT(slotSelectionChanged()));
 769     connect(this, SIGNAL(done(VarTree*, const QString&)),
 770             parent, SIGNAL(editValueCommitted(VarTree*, const QString&)));
 771 }
 772
 773 ValueEdit::~ValueEdit()
 774 {
 775 }
 776
 777 void ValueEdit::terminate(bool commit)
 778 {
 779     TRACE(commit?"ValueEdit::terminate(true)":"ValueEdit::terminate(false)");
 780     if (!m_finished)
 781     {
 782         m_finished = true;
 783         hide(); // will call focusOutEvent, that's why we need m_finished
 784         if (commit) {
 785             emit done(m_item, text());
 786         }
 787     }
 788 }
 789
 790 void ValueEdit::keyPressEvent(QKeyEvent *e)
 791 {
 792     if(e->key() == Qt::Key_Return || e->key() == Qt::Key_Enter)
 793         terminate(true);
 794     else if(e->key() == Qt::Key_Escape)
 795         terminate(false);
 796     else
 797         QLineEdit::keyPressEvent(e);
 798 }
 799
 800 void ValueEdit::paintEvent(QPaintEvent* e)
 801 {
 802     QLineEdit::paintEvent(e);
 803
 804     QPainter p(this);
 805     p.drawRect(rect());
 806 }
 807
 808 void ValueEdit::focusOutEvent(QFocusEvent* ev)
 809 {
 810     TRACE("ValueEdit::focusOutEvent");
 811     QFocusEvent* focusEv = static_cast<QFocusEvent*>(ev);
 812     // Don't let a RMB close the editor
 813     if (focusEv->reason() != QFocusEvent::Popup &&
 814         focusEv->reason() != QFocusEvent::ActiveWindow)
 815     {
 816         terminate(true);
 817     }
 818 }
 819
 820 void ValueEdit::slotSelectionChanged()
 821 {
 822     TRACE("ValueEdit::slotSelectionChanged");
 823     terminate(false);
 824 }