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 <q3popupmenu.h>
  12 #include <QContextMenuEvent>
  13 #include <QCloseEvent>
  14 #include <kglobal.h>
  15 #include <kxmlguiwindow.h>
  16 #include <kxmlguifactory.h>
  17 #include <klocale.h>                    /* i18n */
  18 #include "mydebug.h"
  19
  20
  21
  22 WinStack::WinStack(QWidget* parent) :
  23         KTabWidget(parent),
  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     KXmlGuiWindow* mw = static_cast<KXmlGuiWindow*>(top);
  49     Q3PopupMenu* m =
  50         static_cast<Q3PopupMenu*>(mw->factory()->container("popup_files_empty", mw));
  51     m->exec(e->globalPos());
  52 }
  53
  54
  55 void WinStack::reloadAllFiles()
  56 {
  57     for (int i = count()-1; i >= 0; i--) {
  58         windowAt(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 = count()-1; i >= 0; i--) {
  99         if (windowAt(i)->fileName() == pathName) {
 100             fw = windowAt(i);
 101             break;
 102         }
 103     }
 104     if (fw == 0) {
 105         // not found, load it
 106         fw = new SourceWindow(pathName, this);
 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         setTabToolTip(fw, pathName);
 117
 118         connect(fw, SIGNAL(clickedLeft(const QString&,int,const DbgAddr&,bool)),
 119                 SIGNAL(toggleBreak(const QString&,int,const DbgAddr&,bool)));
 120         connect(fw, SIGNAL(clickedMid(const QString&,int,const DbgAddr&)),
 121                 SIGNAL(enadisBreak(const QString&,int,const DbgAddr&)));
 122
 123         // disassemble code
 124         connect(fw, SIGNAL(disassemble(const QString&, int)),
 125                 SIGNAL(disassemble(const QString&, int)));
 126         connect(fw, SIGNAL(expanded(int)), SLOT(slotExpandCollapse(int)));
 127         connect(fw, SIGNAL(collapsed(int)), SLOT(slotExpandCollapse(int)));
 128
 129         // tab width
 130         connect(this, SIGNAL(setTabWidth(int)), fw, SLOT(setTabWidth(int)));
 131         fw->setTabWidth(m_tabWidth);
 132         fw->setFocusPolicy(QWidget::WheelFocus);
 133
 134         // set PC if there is one
 135         emit newFileLoaded();
 136         if (m_pcLine >= 0) {
 137             setPC(true, m_pcFile, m_pcLine, DbgAddr(m_pcAddress), m_pcFrame);
 138         }
 139     }
 140     return activateWindow(fw, lineNo, address);
 141 }
 142
 143 bool WinStack::activateWindow(SourceWindow* fw, int lineNo, const DbgAddr& address)
 144 {
 145     // make the line visible
 146     if (lineNo >= 0) {
 147         fw->scrollTo(lineNo, address);
 148     }
 149
 150     showPage(fw);
 151     fw->setFocus();
 152
 153     return true;
 154 }
 155
 156 bool WinStack::activeLine(QString& fileName, int& lineNo)
 157 {
 158     DbgAddr dummy;
 159     return activeLine(fileName, lineNo, dummy);
 160 }
 161
 162 bool WinStack::activeLine(QString& fileName, int& lineNo, DbgAddr& address)
 163 {
 164     if (activeWindow() == 0) {
 165         return false;
 166     }
 167
 168     fileName = activeFileName();
 169     activeWindow()->activeLine(lineNo, address);
 170     return true;
 171 }
 172
 173 void WinStack::updateLineItems(const KDebugger* dbg)
 174 {
 175     for (int i = count()-1; i >= 0; i--) {
 176         windowAt(i)->updateLineItems(dbg);
 177     }
 178 }
 179
 180 void WinStack::updatePC(const QString& fileName, int lineNo, const DbgAddr& address, int frameNo)
 181 {
 182     if (m_pcLine >= 0) {
 183         setPC(false, m_pcFile, m_pcLine, DbgAddr(m_pcAddress), m_pcFrame);
 184     }
 185     m_pcFile = fileName;
 186     m_pcLine = lineNo;
 187     m_pcAddress = address.asString();
 188     m_pcFrame = frameNo;
 189     if (lineNo >= 0) {
 190         setPC(true, fileName, lineNo, address, frameNo);
 191     }
 192 }
 193
 194 SourceWindow* WinStack::findByFileName(const QString& fileName) const
 195 {
 196     for (int i = count()-1; i >= 0; i--) {
 197         if (windowAt(i)->fileNameMatches(fileName)) {
 198             return windowAt(i);
 199         }
 200     }
 201     return 0;
 202 }
 203
 204 void WinStack::setPC(bool set, const QString& fileName, int lineNo,
 205                      const DbgAddr& address, int frameNo)
 206 {
 207     TRACE((set ? "set PC: " : "clear PC: ") + fileName +
 208           QString().sprintf(":%d#%d ", lineNo, frameNo) + address.asString());
 209     SourceWindow* fw = findByFileName(fileName);
 210     if (fw)
 211         fw->setPC(set, lineNo, address, frameNo);
 212 }
 213
 214 SourceWindow* WinStack::windowAt(int i) const
 215 {
 216     return static_cast<SourceWindow*>(page(i));
 217 }
 218
 219 SourceWindow* WinStack::activeWindow() const
 220 {
 221     return static_cast<SourceWindow*>(currentPage());
 222 }
 223
 224 QString WinStack::activeFileName() const
 225 {
 226     QString f;
 227     if (activeWindow() != 0)
 228         f = activeWindow()->fileName();
 229     return f;
 230 }
 231
 232 void WinStack::slotFindForward()
 233 {
 234     if (activeWindow() != 0)
 235         activeWindow()->find(m_findDlg.searchText(), m_findDlg.caseSensitive(),
 236                              SourceWindow::findForward);
 237 }
 238
 239 void WinStack::slotFindBackward()
 240 {
 241     if (activeWindow() != 0)
 242         activeWindow()->find(m_findDlg.searchText(), m_findDlg.caseSensitive(),
 243                              SourceWindow::findBackward);
 244 }
 245
 246 void WinStack::maybeTip(const QPoint& p)
 247 {
 248     SourceWindow* w = activeWindow();
 249     if (w == 0)
 250         return;
 251
 252     // get the word at the point
 253     QString word;
 254     QRect r;
 255     if (!w->wordAtPoint(w->mapFrom(this, p), word, r))
 256         return;
 257
 258     // must be valid
 259     assert(!word.isEmpty());
 260     assert(r.isValid());
 261
 262     // remember the location
 263     m_tipLocation = QRect(w->mapTo(this, r.topLeft()), r.size());
 264
 265     emit initiateValuePopup(word);
 266 }
 267
 268 void WinStack::slotShowValueTip(const QString& tipText)
 269 {
 270     m_valueTip.tip(m_tipLocation, tipText);
 271 }
 272
 273 void WinStack::slotDisassembled(const QString& fileName, int lineNo,
 274                                 const std::list<DisassembledCode>& disass)
 275 {
 276     SourceWindow* fw = findByFileName(fileName);
 277     if (fw == 0) {
 278         // not found: ignore
 279         return;
 280     }
 281
 282     fw->disassembled(lineNo, disass);
 283 }
 284
 285 void WinStack::slotExpandCollapse(int)
 286 {
 287     // update line items after expanding or collapsing disassembled code
 288
 289     // HACK: we know that this will result in updateLineItems
 290     // should be done more cleanly with a separate signal
 291     emit newFileLoaded();
 292
 293     if (m_pcLine >= 0) {
 294         setPC(true, m_pcFile, m_pcLine, DbgAddr(m_pcAddress), m_pcFrame);
 295     }
 296 }
 297
 298
 299 void WinStack::slotSetTabWidth(int numChars)
 300 {
 301     m_tabWidth = numChars;
 302 }
 303
 304 void WinStack::slotFileReload()
 305 {
 306     if (activeWindow() != 0) {
 307         TRACE("reloading one file");
 308         activeWindow()->reloadFile();
 309     }
 310 }
 311
 312 void WinStack::slotViewFind()
 313 {
 314     if (m_findDlg.isVisible()) {
 315         m_findDlg.done(0);
 316     } else {
 317         m_findDlg.show();
 318     }
 319 }
 320
 321 void WinStack::slotBrkptSet()
 322 {
 323     QString file;
 324     int lineNo;
 325     DbgAddr address;
 326     if (activeLine(file, lineNo, address))
 327         emit toggleBreak(file, lineNo, address, false);
 328 }
 329
 330 void WinStack::slotBrkptSetTemp()
 331 {
 332     QString file;
 333     int lineNo;
 334     DbgAddr address;
 335     if (activeLine(file, lineNo, address))
 336         emit toggleBreak(file, lineNo, address, true);
 337 }
 338
 339 void WinStack::slotBrkptEnable()
 340 {
 341     QString file;
 342     int lineNo;
 343     DbgAddr address;
 344     if (activeLine(file, lineNo, address))
 345         emit enadisBreak(file, lineNo, address);
 346 }
 347
 348 void WinStack::slotMoveProgramCounter()
 349 {
 350     QString file;
 351     int lineNo;
 352     DbgAddr address;
 353     if (activeLine(file, lineNo, address))
 354         emit moveProgramCounter(file, lineNo, address);
 355 }
 356
 357 void WinStack::slotClose()
 358 {
 359     QWidget* w = activeWindow();
 360     if (!w)
 361         return;
 362
 363     removePage(w);
 364     delete w;
 365 }
 366
 367
 368 ValueTip::ValueTip(WinStack* parent) :
 369         QToolTip(parent)
 370 {
 371 }
 372
 373 void ValueTip::maybeTip(const QPoint& p)
 374 {
 375     WinStack* w = static_cast<WinStack*>(parentWidget());
 376     w->maybeTip(p);
 377 }
 378
 379
 380 FindDialog::FindDialog() :
 381         QDialog(0, "find", false),
 382         m_searchText(this, "text"),
 383         m_caseCheck(this, "case"),
 384         m_buttonForward(this, "forward"),
 385         m_buttonBackward(this, "backward"),
 386         m_buttonClose(this, "close"),
 387         m_layout(this, 8),
 388         m_buttons(4)
 389 {
 390     setCaption(KGlobal::caption() + i18n(": Search"));
 391
 392     m_searchText.setMinimumSize(330, 24);
 393     m_searchText.setMaxLength(10000);
 394     m_searchText.setFrame(true);
 395
 396     m_caseCheck.setText(i18n("&Case sensitive"));
 397     m_caseCheck.setChecked(true);
 398     m_buttonForward.setText(i18n("&Forward"));
 399     m_buttonForward.setDefault(true);
 400     m_buttonBackward.setText(i18n("&Backward"));
 401     m_buttonClose.setText(i18n("Close"));
 402
 403     m_caseCheck.setMinimumSize(330, 24);
 404
 405     // get maximum size of buttons
 406     QSize maxSize(80,30);
 407     maxSize.expandedTo(m_buttonForward.sizeHint());
 408     maxSize.expandedTo(m_buttonBackward.sizeHint());
 409     maxSize.expandedTo(m_buttonClose.sizeHint());
 410
 411     m_buttonForward.setMinimumSize(maxSize);
 412     m_buttonBackward.setMinimumSize(maxSize);
 413     m_buttonClose.setMinimumSize(maxSize);
 414
 415     connect(&m_buttonClose, SIGNAL(clicked()), SLOT(reject()));
 416
 417     m_layout.addWidget(&m_searchText);
 418     m_layout.addWidget(&m_caseCheck);
 419     m_layout.addLayout(&m_buttons);
 420     m_layout.addStretch(10);
 421     m_buttons.addWidget(&m_buttonForward);
 422     m_buttons.addStretch(10);
 423     m_buttons.addWidget(&m_buttonBackward);
 424     m_buttons.addStretch(10);
 425     m_buttons.addWidget(&m_buttonClose);
 426
 427     m_layout.activate();
 428
 429     m_searchText.setFocus();
 430     resize( 350, 120 );
 431 }
 432
 433 FindDialog::~FindDialog()
 434 {
 435 }
 436
 437 void FindDialog::closeEvent(QCloseEvent* ev)
 438 {
 439     QDialog::closeEvent(ev);
 440     emit closed();
 441 }
 442
 443 void FindDialog::done(int result)
 444 {
 445     QDialog::done(result);
 446     emit closed();
 447 }
 448
 449 #include "winstack.moc"