kdbg/winstack.cpp

   1 /*
   2  * Copyright Johannes Sixt
   3  * This file is licensed under the GNU General Public License Version 2.
   4  * See the file COPYING in the toplevel directory of the source directory.
   5  */
   6
   7 #include "winstack.h"
   8 #include "sourcewnd.h"
   9 #include <qbrush.h>
  10 #include <qfileinfo.h>
  11 #include <qpopupmenu.h>
  12 #include <kapplication.h>
  13 #include <kmainwindow.h>
  14 #include <klocale.h>                    /* i18n */
  15 #ifdef HAVE_CONFIG_H
  16 #include "config.h"
  17 #endif
  18 #include "mydebug.h"
  19
  20
  21
  22 WinStack::WinStack(QWidget* parent, const char* name) :
  23         KTabWidget(parent, name),
  24         m_pcLine(-1),
  25         m_valueTip(this),
  26         m_tipLocation(1,1,10,10),
  27         m_tabWidth(0)
  28 {
  29     connect(&m_findDlg.m_buttonForward,
  30             SIGNAL(clicked()), SLOT(slotFindForward()));
  31     connect(&m_findDlg.m_buttonBackward,
  32             SIGNAL(clicked()), SLOT(slotFindBackward()));
  33
  34     connect(this, SIGNAL(setTabWidth(int)), this, SLOT(slotSetTabWidth(int)));
  35 }
  36
  37 WinStack::~WinStack()
  38 {
  39 }
  40
  41 void WinStack::contextMenuEvent(QContextMenuEvent* e)
  42 {
  43     // get the context menu from the GUI factory
  44     QWidget* top = this;
  45     do
  46         top = top->parentWidget();
  47     while (!top->isTopLevel());
  48     KMainWindow* mw = static_cast<KMainWindow*>(top);
  49     QPopupMenu* m =
  50         static_cast<QPopupMenu*>(mw->factory()->container("popup_files_empty", mw));
  51     m->exec(e->globalPos());
  52 }
  53
  54
  55 void WinStack::reloadAllFiles()
  56 {
  57     for (int i = 0; i < m_fileList.size(); i++) {
  58         m_fileList[i]->reloadFile();
  59     }
  60 }
  61
  62 QSize WinStack::sizeHint() const
  63 {
  64     return QSize(640, 480);
  65 }
  66
  67 void WinStack::activate(const QString& fileName, int lineNo, const DbgAddr& address)
  68 {
  69     QFileInfo fi(fileName);
  70
  71     if (!fi.isFile()) {
  72         /*
  73          * We didn't find that file. Now check if it is a relative path and
  74          * try m_lastOpenDir as prefix.
  75          */
  76         TRACE(fi.filePath() + (" not found, looking in " + m_lastOpenDir));
  77         if (!fi.isRelative() || m_lastOpenDir.isEmpty()) {
  78             return;
  79         }
  80         fi.setFile(m_lastOpenDir + "/" + fi.filePath());
  81         if (!fi.isFile()) {
  82             return;
  83         }
  84     }
  85     // if this is not an absolute path name, make it one
  86     activatePath(fi.absFilePath(), lineNo, address);
  87 }
  88
  89 void WinStack::activateFile(const QString& fileName)
  90 {
  91     activatePath(fileName, 0, DbgAddr());
  92 }
  93
  94 bool WinStack::activatePath(QString pathName, int lineNo, const DbgAddr& address)
  95 {
  96     // check whether the file is already open
  97     SourceWindow* fw = 0;
  98     for (int i = 0; i < m_fileList.size(); i++) {
  99         if (m_fileList[i]->fileName() == pathName) {
 100             fw = m_fileList[i];
 101             break;
 102         }
 103     }
 104     if (fw == 0) {
 105         // not found, load it
 106         fw = new SourceWindow(pathName, this, "fileWindow");
 107
 108         // slurp the file in
 109         if (!fw->loadFile()) {
 110             // read failed
 111             delete fw;
 112             return false;
 113         }
 114
 115         addTab(fw, QFileInfo(pathName).fileName());
 116         m_fileList.insertAt(0, fw);
 117         connect(fw, SIGNAL(clickedLeft(const QString&,int,const DbgAddr&,bool)),
 118                 SIGNAL(toggleBreak(const QString&,int,const DbgAddr&,bool)));
 119         connect(fw, SIGNAL(clickedMid(const QString&,int,const DbgAddr&)),
 120                 SIGNAL(enadisBreak(const QString&,int,const DbgAddr&)));
 121
 122         // disassemble code
 123         connect(fw, SIGNAL(disassemble(const QString&, int)),
 124                 SIGNAL(disassemble(const QString&, int)));
 125         connect(fw, SIGNAL(expanded(int)), SLOT(slotExpandCollapse(int)));
 126         connect(fw, SIGNAL(collapsed(int)), SLOT(slotExpandCollapse(int)));
 127
 128         // tab width
 129         connect(this, SIGNAL(setTabWidth(int)), fw, SLOT(setTabWidth(int)));
 130         fw->setTabWidth(m_tabWidth);
 131         fw->setFocusPolicy(QWidget::WheelFocus);
 132
 133         // set PC if there is one
 134         emit newFileLoaded();
 135         if (m_pcLine >= 0) {
 136             setPC(true, m_pcFile, m_pcLine, DbgAddr(m_pcAddress), m_pcFrame);
 137         }
 138     }
 139     return activateWindow(fw, lineNo, address);
 140 }
 141
 142 bool WinStack::activateWindow(SourceWindow* fw, int lineNo, const DbgAddr& address)
 143 {
 144     // lookup fw
 145     int index = m_fileList.size()-1;
 146     while (index >= 0 && m_fileList[index] != fw)
 147         --index;
 148     ASSERT(index >= 0);
 149     if (index < 0) {
 150         return false;
 151     }
 152     /*
 153      * If the file is not in the list of those that would appear in the
 154      * window menu, move it to the first position.
 155      */
 156     if (index >= 9) {
 157         m_fileList.removeAt(index);
 158         m_fileList.insertAt(0, fw);
 159     }
 160
 161     // make the line visible
 162     if (lineNo >= 0) {
 163         fw->scrollTo(lineNo, address);
 164     }
 165
 166     showPage(fw);
 167     fw->setFocus();
 168
 169     emit fileChanged();
 170
 171     return true;
 172 }
 173
 174 bool WinStack::activeLine(QString& fileName, int& lineNo)
 175 {
 176     DbgAddr dummy;
 177     return activeLine(fileName, lineNo, dummy);
 178 }
 179
 180 bool WinStack::activeLine(QString& fileName, int& lineNo, DbgAddr& address)
 181 {
 182     if (activeWindow() == 0) {
 183         return false;
 184     }
 185
 186     fileName = activeFileName();
 187     activeWindow()->activeLine(lineNo, address);
 188     return true;
 189 }
 190
 191 void WinStack::updateLineItems(const KDebugger* dbg)
 192 {
 193     for (int i = 0; i < m_fileList.size(); i++) {
 194         m_fileList[i]->updateLineItems(dbg);
 195     }
 196 }
 197
 198 void WinStack::updatePC(const QString& fileName, int lineNo, const DbgAddr& address, int frameNo)
 199 {
 200     if (m_pcLine >= 0) {
 201         setPC(false, m_pcFile, m_pcLine, DbgAddr(m_pcAddress), m_pcFrame);
 202     }
 203     m_pcFile = fileName;
 204     m_pcLine = lineNo;
 205     m_pcAddress = address.asString();
 206     m_pcFrame = frameNo;
 207     if (lineNo >= 0) {
 208         setPC(true, fileName, lineNo, address, frameNo);
 209     }
 210 }
 211
 212 SourceWindow* WinStack::findByFileName(const QString& fileName) const
 213 {
 214     for (int i = 0; i < m_fileList.size(); i++) {
 215         if (m_fileList[i]->fileNameMatches(fileName)) {
 216             return m_fileList[i];
 217         }
 218     }
 219     return 0;
 220 }
 221
 222 void WinStack::setPC(bool set, const QString& fileName, int lineNo,
 223                      const DbgAddr& address, int frameNo)
 224 {
 225     TRACE((set ? "set PC: " : "clear PC: ") + fileName +
 226           QString().sprintf(":%d#%d ", lineNo, frameNo) + address.asString());
 227     SourceWindow* fw = findByFileName(fileName);
 228     if (fw)
 229         fw->setPC(set, lineNo, address, frameNo);
 230 }
 231
 232 SourceWindow* WinStack::activeWindow() const
 233 {
 234     return static_cast<SourceWindow*>(currentPage());
 235 }
 236
 237 QString WinStack::activeFileName() const
 238 {
 239     QString f;
 240     if (activeWindow() != 0)
 241         f = activeWindow()->fileName();
 242     return f;
 243 }
 244
 245 void WinStack::slotFindForward()
 246 {
 247     if (activeWindow() != 0)
 248         activeWindow()->find(m_findDlg.searchText(), m_findDlg.caseSensitive(),
 249                              SourceWindow::findForward);
 250 }
 251
 252 void WinStack::slotFindBackward()
 253 {
 254     if (activeWindow() != 0)
 255         activeWindow()->find(m_findDlg.searchText(), m_findDlg.caseSensitive(),
 256                              SourceWindow::findBackward);
 257 }
 258
 259 void WinStack::maybeTip(const QPoint& p)
 260 {
 261     if (activeWindow() == 0)
 262         return;
 263
 264     // get the word at the point
 265     QString word;
 266     QRect r;
 267     if (!activeWindow()->wordAtPoint(p, word, r))
 268         return;
 269
 270     // must be valid
 271     assert(!word.isEmpty());
 272     assert(r.isValid());
 273
 274     // remember the location
 275     m_tipLocation = r;
 276
 277     emit initiateValuePopup(word);
 278 }
 279
 280 void WinStack::slotShowValueTip(const QString& tipText)
 281 {
 282     m_valueTip.tip(m_tipLocation, tipText);
 283 }
 284
 285 void WinStack::slotDisassembled(const QString& fileName, int lineNo,
 286                                 const QList<DisassembledCode>& disass)
 287 {
 288     SourceWindow* fw = findByFileName(fileName);
 289     if (fw == 0) {
 290         // not found: ignore
 291         return;
 292     }
 293
 294     fw->disassembled(lineNo, disass);
 295 }
 296
 297 void WinStack::slotExpandCollapse(int)
 298 {
 299     // update line items after expanding or collapsing disassembled code
 300
 301     // HACK: we know that this will result in updateLineItems
 302     // should be done more cleanly with a separate signal
 303     emit newFileLoaded();
 304
 305     if (m_pcLine >= 0) {
 306         setPC(true, m_pcFile, m_pcLine, DbgAddr(m_pcAddress), m_pcFrame);
 307     }
 308 }
 309
 310
 311 void WinStack::slotSetTabWidth(int numChars)
 312 {
 313     m_tabWidth = numChars;
 314 }
 315
 316 void WinStack::slotFileReload()
 317 {
 318     if (activeWindow() != 0) {
 319         TRACE("reloading one file");
 320         activeWindow()->reloadFile();
 321     }
 322 }
 323
 324 void WinStack::slotViewFind()
 325 {
 326     if (m_findDlg.isVisible()) {
 327         m_findDlg.done(0);
 328     } else {
 329         m_findDlg.show();
 330     }
 331 }
 332
 333 void WinStack::slotBrkptSet()
 334 {
 335     QString file;
 336     int lineNo;
 337     DbgAddr address;
 338     if (activeLine(file, lineNo, address))
 339         emit toggleBreak(file, lineNo, address, false);
 340 }
 341
 342 void WinStack::slotBrkptSetTemp()
 343 {
 344     QString file;
 345     int lineNo;
 346     DbgAddr address;
 347     if (activeLine(file, lineNo, address))
 348         emit toggleBreak(file, lineNo, address, true);
 349 }
 350
 351 void WinStack::slotBrkptEnable()
 352 {
 353     QString file;
 354     int lineNo;
 355     DbgAddr address;
 356     if (activeLine(file, lineNo, address))
 357         emit enadisBreak(file, lineNo, address);
 358 }
 359
 360 void WinStack::slotMoveProgramCounter()
 361 {
 362     QString file;
 363     int lineNo;
 364     DbgAddr address;
 365     if (activeLine(file, lineNo, address))
 366         emit moveProgramCounter(file, lineNo, address);
 367 }
 368
 369
 370 ValueTip::ValueTip(WinStack* parent) :
 371         QToolTip(parent)
 372 {
 373 }
 374
 375 void ValueTip::maybeTip(const QPoint& p)
 376 {
 377     WinStack* w = static_cast<WinStack*>(parentWidget());
 378     w->maybeTip(p);
 379 }
 380
 381
 382 FindDialog::FindDialog() :
 383         QDialog(0, "find", false),
 384         m_searchText(this, "text"),
 385         m_caseCheck(this, "case"),
 386         m_buttonForward(this, "forward"),
 387         m_buttonBackward(this, "backward"),
 388         m_buttonClose(this, "close"),
 389         m_layout(this, 8),
 390         m_buttons(4)
 391 {
 392     setCaption(QString(kapp->caption()) + i18n(": Search"));
 393
 394     m_searchText.setMinimumSize(330, 24);
 395     m_searchText.setMaxLength(10000);
 396     m_searchText.setFrame(true);
 397
 398     m_caseCheck.setText(i18n("&Case sensitive"));
 399     m_caseCheck.setChecked(true);
 400     m_buttonForward.setText(i18n("&Forward"));
 401     m_buttonForward.setDefault(true);
 402     m_buttonBackward.setText(i18n("&Backward"));
 403     m_buttonClose.setText(i18n("Close"));
 404
 405     m_caseCheck.setMinimumSize(330, 24);
 406
 407     // get maximum size of buttons
 408     QSize maxSize(80,30);
 409     maxSize.expandedTo(m_buttonForward.sizeHint());
 410     maxSize.expandedTo(m_buttonBackward.sizeHint());
 411     maxSize.expandedTo(m_buttonClose.sizeHint());
 412
 413     m_buttonForward.setMinimumSize(maxSize);
 414     m_buttonBackward.setMinimumSize(maxSize);
 415     m_buttonClose.setMinimumSize(maxSize);
 416
 417     connect(&m_buttonClose, SIGNAL(clicked()), SLOT(reject()));
 418
 419     m_layout.addWidget(&m_searchText);
 420     m_layout.addWidget(&m_caseCheck);
 421     m_layout.addLayout(&m_buttons);
 422     m_layout.addStretch(10);
 423     m_buttons.addWidget(&m_buttonForward);
 424     m_buttons.addStretch(10);
 425     m_buttons.addWidget(&m_buttonBackward);
 426     m_buttons.addStretch(10);
 427     m_buttons.addWidget(&m_buttonClose);
 428
 429     m_layout.activate();
 430
 431     m_searchText.setFocus();
 432     resize( 350, 120 );
 433 }
 434
 435 FindDialog::~FindDialog()
 436 {
 437 }
 438
 439 void FindDialog::closeEvent(QCloseEvent* ev)
 440 {
 441     QDialog::closeEvent(ev);
 442     emit closed();
 443 }
 444
 445 void FindDialog::done(int result)
 446 {
 447     QDialog::done(result);
 448     emit closed();
 449 }
 450
 451 #include "winstack.moc"