kdbg/memwindow.cpp

   1 // $Id$
   2
   3 // Copyright by Johannes Sixt
   4 // This file is under GPL, the GNU General Public Licence
   5
   6 #include "memwindow.h"
   7 #include <qheader.h>
   8 #if QT_VERSION >= 200
   9 #include <klocale.h>
  10 #else
  11 #include <kapp.h>
  12 #endif
  13 #include <ksimpleconfig.h>
  14 #include "debugger.h"
  15 #include "dbgdriver.h"                  /* memory dump formats */
  16
  17 MemoryWindow::MemoryWindow(QWidget* parent, const char* name) :
  18         QWidget(parent, name),
  19         m_debugger(0),
  20         m_expression(true, this, "expression"),
  21         m_memory(this, "memory"),
  22         m_layout(this, 0, 2),
  23         m_format(MDTword | MDThex)
  24 {
  25     QSize minSize = m_expression.sizeHint();
  26     m_expression.setMinimumSize(minSize);
  27     m_expression.setInsertionPolicy(QComboBox::NoInsertion);
  28     m_expression.setMaxCount(15);
  29
  30     m_memory.addColumn(i18n("Address"), 80);
  31     m_memory.addColumn(i18n("Contents"), 200);
  32     m_memory.setSorting(-1);            /* don't sort */
  33     m_memory.setAllColumnsShowFocus(true);
  34     m_memory.header()->setClickEnabled(false);
  35
  36     // create layout
  37     m_layout.addWidget(&m_expression, 0);
  38     m_layout.addWidget(&m_memory, 10);
  39     m_layout.activate();
  40
  41 #if QT_VERSION < 200
  42     connect(&m_expression, SIGNAL(activated(const char*)),
  43             this, SLOT(slotNewExpression(const char*)));
  44 #else
  45     connect(&m_expression, SIGNAL(activated(const QString&)),
  46             this, SLOT(slotNewExpression(const QString&)));
  47 #endif
  48
  49     // the popup menu
  50     m_popup.insertItem(i18n("B&ytes"), MDTbyte);
  51     m_popup.insertItem(i18n("Halfwords (&2 Bytes)"), MDThalfword);
  52     m_popup.insertItem(i18n("Words (&4 Bytes)"), MDTword);
  53     m_popup.insertItem(i18n("Giantwords (&8 Bytes)"), MDTgiantword);
  54     m_popup.insertSeparator();
  55     m_popup.insertItem(i18n("He&xadecimal"), MDThex);
  56     m_popup.insertItem(i18n("Signed &decimal"), MDTsigned);
  57     m_popup.insertItem(i18n("&Unsigned decimal"), MDTunsigned);
  58     m_popup.insertItem(i18n("&Octal"), MDToctal);
  59     m_popup.insertItem(i18n("&Binary"), MDTbinary);
  60     m_popup.insertItem(i18n("&Addresses"), MDTaddress);
  61     m_popup.insertItem(i18n("&Character"), MDTchar);
  62     m_popup.insertItem(i18n("&Floatingpoint"), MDTfloat);
  63     m_popup.insertItem(i18n("&Strings"), MDTstring);
  64     m_popup.insertItem(i18n("&Instructions"), MDTinsn);
  65     connect(&m_popup, SIGNAL(activated(int)), this, SLOT(slotTypeChange(int)));
  66
  67     /*
  68      * Handle right mouse button. Signal righteButtonClicked cannot be
  69      * used, because it works only over items, not over the blank window.
  70      */
  71     m_memory.viewport()->installEventFilter(this);
  72
  73     m_formatCache.setAutoDelete(true);
  74 }
  75
  76 MemoryWindow::~MemoryWindow()
  77 {
  78 }
  79
  80 #if QT_VERSION < 200
  81 # define MOUSEPRESS Event_MouseButtonPress
  82 #else
  83 # define MOUSEPRESS QEvent::MouseButtonPress
  84 #endif
  85
  86 bool MemoryWindow::eventFilter(QObject* o, QEvent* ev)
  87 {
  88     if (ev->type() == MOUSEPRESS) {
  89         handlePopup(static_cast<QMouseEvent*>(ev));
  90         return true;
  91     }
  92     return false;
  93 }
  94
  95 void MemoryWindow::handlePopup(QMouseEvent* ev)
  96 {
  97     if (ev->button() == RightButton)
  98     {
  99         // show popup menu
 100         if (m_popup.isVisible())
 101         {
 102             m_popup.hide();
 103         }
 104         else
 105         {
 106             m_popup.popup(mapToGlobal(ev->pos()));
 107         }
 108         return;
 109     }
 110 }
 111
 112 // this slot is only needed for Qt 1.44
 113 void MemoryWindow::slotNewExpression(const char* newText)
 114 {
 115     slotNewExpression(QString(newText));
 116 }
 117
 118 void MemoryWindow::slotNewExpression(const QString& newText)
 119 {
 120     QString text = newText.simplifyWhiteSpace();
 121
 122     // see if the string is in the list
 123     // (note: must count downwards because of removeItem!)
 124     for (int i = m_expression.count()-1; i >= 0; i--)
 125     {
 126         if (m_expression.text(i) == text) {
 127             // yes it is!
 128             // look up the format that was used last time for this expr
 129             unsigned* pFormat = m_formatCache[text];
 130             if (pFormat != 0) {
 131                 m_format = *pFormat;
 132                 m_debugger->setMemoryFormat(m_format);
 133             }
 134             // remove this text, will be inserted at the top
 135             m_expression.removeItem(i);
 136         }
 137     }
 138     m_expression.insertItem(text, 0);
 139
 140     if (text.isEmpty()) {
 141         // if format was not in the cache, insert it
 142         if (m_formatCache[text] == 0) {
 143             m_formatCache.insert(text, new unsigned(m_format));
 144
 145         }
 146     }
 147
 148     displayNewExpression(text);
 149 }
 150
 151 void MemoryWindow::displayNewExpression(const QString& expr)
 152 {
 153     m_debugger->setMemoryExpression(expr);
 154     m_expression.setEditText(expr);
 155
 156     // clear memory dump if no dump wanted
 157     if (expr.isEmpty()) {
 158         m_memory.clear();
 159     }
 160 }
 161
 162 void MemoryWindow::slotTypeChange(int id)
 163 {
 164     // compute new type
 165     if (id & MDTsizemask)
 166         m_format = (m_format & ~MDTsizemask) | id;
 167     if (id & MDTformatmask)
 168         m_format = (m_format & ~MDTformatmask) | id;
 169     m_debugger->setMemoryFormat(m_format);
 170
 171     // change the format in the cache
 172     QString expr = m_expression.currentText();
 173     expr = expr.simplifyWhiteSpace();
 174     unsigned* pFormat = m_formatCache[expr];
 175     if (pFormat != 0)
 176         *pFormat = m_format;
 177
 178     // force redisplay
 179     displayNewExpression(expr);
 180 }
 181
 182 void MemoryWindow::slotNewMemoryDump(const QString& msg, QList<MemoryDump>& memdump)
 183 {
 184     m_memory.clear();
 185     if (!msg.isEmpty()) {
 186         new QListViewItem(&m_memory, QString(), msg);
 187         return;
 188     }
 189
 190     QListViewItem* after = 0;
 191     MemoryDump* md = memdump.first();
 192     for (; md != 0; md = memdump.next()) {
 193         QString addr = md->address.asString() + " " + md->address.fnoffs;
 194         after = new QListViewItem(&m_memory, after, addr, md->dump);
 195     }
 196 }
 197
 198 static const char MemoryGroup[] = "Memory";
 199 static const char NumExprs[] = "NumExprs";
 200 static const char ExpressionFmt[] = "Expression%d";
 201 static const char FormatFmt[] = "Format%d";
 202 static const char ColumnWidths[] = "ColumnWidths";
 203
 204 void MemoryWindow::saveProgramSpecific(KSimpleConfig* config)
 205 {
 206     KConfigGroupSaver s(config, MemoryGroup);
 207
 208     int numEntries = m_expression.count();
 209     config->writeEntry(NumExprs, numEntries);
 210     QString exprEntry;
 211     QString fmtEntry;
 212     for (int i = 0; i < numEntries;) {
 213         QString text = m_expression.text(i);
 214         i++;                            /* entries are counted 1-based */
 215         exprEntry.sprintf(ExpressionFmt, i);
 216         fmtEntry.sprintf(FormatFmt, i);
 217         config->writeEntry(exprEntry, text);
 218         unsigned* pFormat = m_formatCache[text];
 219         unsigned fmt = pFormat != 0  ?  *pFormat  :  MDTword | MDThex;
 220         config->writeEntry(fmtEntry, fmt);
 221     }
 222
 223     // column widths
 224     QStrList widths;
 225     QString wStr;
 226     for (int i = 0; i < 2; i++) {
 227         int w = m_memory.columnWidth(i);
 228         wStr.setNum(w);
 229         widths.append(wStr);
 230     }
 231     config->writeEntry(ColumnWidths, widths);
 232 }
 233
 234 void MemoryWindow::restoreProgramSpecific(KSimpleConfig* config)
 235 {
 236     KConfigGroupSaver s(config, MemoryGroup);
 237
 238     int numEntries = config->readNumEntry(NumExprs, 0);
 239     m_expression.clear();
 240
 241     QString exprEntry;
 242     QString fmtEntry;
 243     // entries are counted 1-based
 244     for (int i = 1; i <= numEntries; i++) {
 245         exprEntry.sprintf(ExpressionFmt, i);
 246         fmtEntry.sprintf(FormatFmt, i);
 247         QString expr = config->readEntry(exprEntry);
 248         unsigned fmt = config->readNumEntry(fmtEntry, MDTword | MDThex);
 249         m_expression.insertItem(expr);
 250         m_formatCache.replace(expr, new unsigned(fmt & (MDTsizemask | MDTformatmask)));
 251     }
 252
 253     // initialize with top expression
 254     if (numEntries > 0) {
 255         m_expression.setCurrentItem(0);
 256         QString expr = m_expression.text(0);
 257         m_format = *m_formatCache[expr];
 258         m_debugger->setMemoryFormat(m_format);
 259         displayNewExpression(expr);
 260     }
 261
 262     // column widths
 263     QStrList widths;
 264     int n = config->readListEntry(ColumnWidths, widths);
 265     if (n > 2)
 266         n = 2;
 267     for (int i = 0; i < n; i++) {
 268         QString wStr = widths.at(i);
 269         bool ok;
 270         int w = wStr.toInt(&ok);
 271         if (ok)
 272             m_memory.setColumnWidth(i, w);
 273     }
 274 }
 275
 276
 277 #include "memwindow.moc"