BVB Source Codes

x64dbg Show HexDump.cpp Source code

Return Download x64dbg: download HexDump.cpp Source code - Download x64dbg Source code - Type:.cpp
  1. #include "HexDump.h"
  2. #include "Configuration.h"
  3. #include "Bridge.h"
  4. #include "StringUtil.h"
  5. #include <QMessageBox>
  6.  
  7. HexDump::HexDump(QWidget* parent)
  8.     : AbstractTableView(parent)
  9. {
  10.     SelectionData_t data;
  11.     memset(&data, 0, sizeof(SelectionData_t));
  12.     mSelection = data;
  13.  
  14.     mGuiState = HexDump::NoState;
  15.  
  16.     setRowCount(0);
  17.  
  18.     mMemPage = new MemoryPage(0, 0);
  19.     mForceColumn = -1;
  20.  
  21.     clearDescriptors();
  22.  
  23.     backgroundColor = ConfigColor("HexDumpBackgroundColor");
  24.     textColor = ConfigColor("HexDumpTextColor");
  25.     selectionColor = ConfigColor("HexDumpSelectionColor");
  26.  
  27.     mRvaDisplayEnabled = false;
  28.     mSyncAddrExpression = "";
  29.     mNonprintReplace = QChar('.'); //QChar(0x25CA);
  30.     mNullReplace = QChar('.'); //QChar(0x2022);
  31.  
  32.     historyClear();
  33.  
  34.     // Slots
  35.     connect(Bridge::getBridge(), SIGNAL(updateDump()), this, SLOT(updateDumpSlot()));
  36.     connect(Bridge::getBridge(), SIGNAL(dbgStateChanged(DBGSTATE)), this, SLOT(debugStateChanged(DBGSTATE)));
  37.     setupCopyMenu();
  38.  
  39.     Initialize();
  40. }
  41.  
  42. HexDump::~HexDump()
  43. {
  44.     delete mMemPage;
  45. }
  46.  
  47. void HexDump::updateColors()
  48. {
  49.     AbstractTableView::updateColors();
  50.  
  51.     backgroundColor = ConfigColor("HexDumpBackgroundColor");
  52.     textColor = ConfigColor("HexDumpTextColor");
  53.     selectionColor = ConfigColor("HexDumpSelectionColor");
  54.  
  55.     mModifiedBytesColor = ConfigColor("HexDumpModifiedBytesColor");
  56.     mModifiedBytesBackgroundColor = ConfigColor("HexDumpModifiedBytesBackgroundColor");
  57.     mRestoredBytesColor = ConfigColor("HexDumpRestoredBytesColor");
  58.     mRestoredBytesBackgroundColor = ConfigColor("HexDumpRestoredBytesBackgroundColor");
  59.     mByte00Color = ConfigColor("HexDumpByte00Color");
  60.     mByte00BackgroundColor = ConfigColor("HexDumpByte00BackgroundColor");
  61.     mByte7FColor = ConfigColor("HexDumpByte7FColor");
  62.     mByte7FBackgroundColor = ConfigColor("HexDumpByte7FBackgroundColor");
  63.     mByteFFColor = ConfigColor("HexDumpByteFFColor");
  64.     mByteFFBackgroundColor = ConfigColor("HexDumpByteFFBackgroundColor");
  65.     mByteIsPrintColor = ConfigColor("HexDumpByteIsPrintColor");
  66.     mByteIsPrintBackgroundColor = ConfigColor("HexDumpByteIsPrintBackgroundColor");
  67.  
  68.     mUserModuleCodePointerHighlightColor = ConfigColor("HexDumpUserModuleCodePointerHighlightColor");
  69.     mUserModuleDataPointerHighlightColor = ConfigColor("HexDumpUserModuleDataPointerHighlightColor");
  70.     mSystemModuleCodePointerHighlightColor = ConfigColor("HexDumpSystemModuleCodePointerHighlightColor");
  71.     mSystemModuleDataPointerHighlightColor = ConfigColor("HexDumpSystemModuleDataPointerHighlightColor");
  72.     mUnknownCodePointerHighlightColor = ConfigColor("HexDumpUnknownCodePointerHighlightColor");
  73.     mUnknownDataPointerHighlightColor = ConfigColor("HexDumpUnknownDataPointerHighlightColor");
  74.  
  75.     reloadData();
  76. }
  77.  
  78. void HexDump::updateFonts()
  79. {
  80.     duint setting;
  81.     if(BridgeSettingGetUint("Gui", "NonprintReplaceCharacter", &setting))
  82.         mNonprintReplace = QChar(uint(setting));
  83.     if(BridgeSettingGetUint("Gui", "NullReplaceCharacter", &setting))
  84.         mNullReplace = QChar(uint(setting));
  85.     setFont(ConfigFont("HexDump"));
  86.     invalidateCachedFont();
  87. }
  88.  
  89. void HexDump::updateShortcuts()
  90. {
  91.     AbstractTableView::updateShortcuts();
  92.     mCopyAddress->setShortcut(ConfigShortcut("ActionCopyAddress"));
  93.     mCopyRva->setShortcut(ConfigShortcut("ActionCopyRva"));
  94.     mCopySelection->setShortcut(ConfigShortcut("ActionCopy"));
  95. }
  96.  
  97. void HexDump::updateDumpSlot()
  98. {
  99.     if(mSyncAddrExpression.length() && DbgFunctions()->ValFromString)
  100.     {
  101.         duint syncAddr;
  102.         if(DbgFunctions()->ValFromString(mSyncAddrExpression.toUtf8().constData(), &syncAddr)
  103.                 && DbgMemIsValidReadPtr(syncAddr))
  104.         {
  105.             printDumpAt(syncAddr, false, false, true);
  106.         }
  107.     }
  108.     reloadData();
  109. }
  110.  
  111. void HexDump::copySelectionSlot()
  112. {
  113.     Bridge::CopyToClipboard(makeCopyText());
  114. }
  115.  
  116. void HexDump::printDumpAt(dsint parVA, bool select, bool repaint, bool updateTableOffset)
  117. {
  118.     duint wSize;
  119.     auto wBase = DbgMemFindBaseAddr(parVA, &wSize); //get memory base
  120.     unsigned char test;
  121.     if(!wBase || !wSize || !DbgMemRead(wBase, &test, sizeof(test)))
  122.         return;
  123.     dsint wRVA = parVA - wBase; //calculate rva
  124.     int wBytePerRowCount = getBytePerRowCount(); //get the number of bytes per row
  125.     dsint wRowCount;
  126.  
  127.     // Byte offset used to be aligned on the given RVA
  128.     mByteOffset = (int)((dsint)wRVA % (dsint)wBytePerRowCount);
  129.     mByteOffset = mByteOffset > 0 ? wBytePerRowCount - mByteOffset : 0;
  130.  
  131.     // Compute row count
  132.     wRowCount = wSize / wBytePerRowCount;
  133.     wRowCount += mByteOffset > 0 ? 1 : 0;
  134.  
  135.     if(mRvaDisplayEnabled && mMemPage->getBase() != mRvaDisplayPageBase)
  136.         mRvaDisplayEnabled = false;
  137.  
  138.     setRowCount(wRowCount); //set the number of rows
  139.  
  140.     mMemPage->setAttributes(wBase, wSize);  // Set base and size (Useful when memory page changed)
  141.  
  142.     if(updateTableOffset)
  143.     {
  144.         setTableOffset(-1); //make sure the requested address is always first
  145.         setTableOffset((wRVA + mByteOffset) / wBytePerRowCount); //change the displayed offset
  146.     }
  147.  
  148.     if(select)
  149.     {
  150.         setSingleSelection(wRVA);
  151.         dsint wEndingAddress = wRVA + getSizeOf(mDescriptor.at(0).data.itemSize) - 1;
  152.         expandSelectionUpTo(wEndingAddress);
  153.     }
  154.  
  155.     if(repaint)
  156.         reloadData();
  157. }
  158.  
  159. void HexDump::printDumpAt(dsint parVA)
  160. {
  161.     printDumpAt(parVA, true);
  162. }
  163.  
  164. duint HexDump::rvaToVa(dsint rva)
  165. {
  166.     return mMemPage->va(rva);
  167. }
  168.  
  169. duint HexDump::getTableOffsetRva()
  170. {
  171.     return getTableOffset() * getBytePerRowCount() - mByteOffset;
  172. }
  173.  
  174. QString HexDump::makeAddrText(duint va)
  175. {
  176.     char label[MAX_LABEL_SIZE] = "";
  177.     QString addrText = "";
  178.     dsint cur_addr = va;
  179.     if(mRvaDisplayEnabled) //RVA display
  180.     {
  181.         dsint rva = cur_addr - mRvaDisplayBase;
  182.         if(rva == 0)
  183.         {
  184. #ifdef _WIN64
  185.             addrText = "$ ==>            ";
  186. #else
  187.             addrText = "$ ==>    ";
  188. #endif //_WIN64
  189.         }
  190.         else if(rva > 0)
  191.         {
  192. #ifdef _WIN64
  193.             addrText = "$+" + QString("%1").arg(rva, -15, 16, QChar(' ')).toUpper();
  194. #else
  195.             addrText = "$+" + QString("%1").arg(rva, -7, 16, QChar(' ')).toUpper();
  196. #endif //_WIN64
  197.         }
  198.         else if(rva < 0)
  199.         {
  200. #ifdef _WIN64
  201.             addrText = "$-" + QString("%1").arg(-rva, -15, 16, QChar(' ')).toUpper();
  202. #else
  203.             addrText = "$-" + QString("%1").arg(-rva, -7, 16, QChar(' ')).toUpper();
  204. #endif //_WIN64
  205.         }
  206.     }
  207.     addrText += ToPtrString(cur_addr);
  208.     if(DbgGetLabelAt(cur_addr, SEG_DEFAULT, label)) //has label
  209.     {
  210.         char module[MAX_MODULE_SIZE] = "";
  211.         if(DbgGetModuleAt(cur_addr, module) && !QString(label).startsWith("JMP.&"))
  212.             addrText += " <" + QString(module) + "." + QString(label) + ">";
  213.         else
  214.             addrText += " <" + QString(label) + ">";
  215.     }
  216.     else
  217.         *label = 0;
  218.     return std::move(addrText);
  219. }
  220.  
  221. QString HexDump::makeCopyText()
  222. {
  223.     dsint deltaRowBase = getSelectionStart() % getBytePerRowCount() + mByteOffset;
  224.     if(deltaRowBase >= getBytePerRowCount())
  225.         deltaRowBase -= getBytePerRowCount();
  226.     auto curRow = getSelectionStart() - deltaRowBase;
  227.     QString result;
  228.     while(curRow <= getSelectionEnd())
  229.     {
  230.         for(int col = 0; col < getColumnCount(); col++)
  231.         {
  232.             if(col)
  233.                 result += " ";
  234.             RichTextPainter::List richText;
  235.             getColumnRichText(col, curRow, richText);
  236.             QString colText;
  237.             for(auto & r : richText)
  238.                 colText += r.text;
  239.             if(col + 1 == getColumnCount())
  240.                 result += colText;
  241.             else
  242.                 result += colText.leftJustified(getColumnWidth(col) / getCharWidth(), QChar(' '), true);
  243.         }
  244.         curRow += getBytePerRowCount();
  245.         result += "\n";
  246.     }
  247.     return std::move(result);
  248. }
  249.  
  250. void HexDump::addVaToHistory(dsint parVa)
  251. {
  252.     //truncate everything right from the current VA
  253.     if(mVaHistory.size() && mCurrentVa < mVaHistory.size() - 1) //mCurrentVa is not the last
  254.         mVaHistory.erase(mVaHistory.begin() + mCurrentVa + 1, mVaHistory.end());
  255.  
  256.     //do not have 2x the same va in a row
  257.     if(!mVaHistory.size() || mVaHistory.last() != parVa)
  258.     {
  259.         mCurrentVa++;
  260.         mVaHistory.push_back(parVa);
  261.     }
  262. }
  263.  
  264. bool HexDump::historyHasPrev()
  265. {
  266.     if(!mCurrentVa || !mVaHistory.size()) //we are at the earliest history entry
  267.         return false;
  268.     return true;
  269. }
  270.  
  271. bool HexDump::historyHasNext()
  272. {
  273.     int size = mVaHistory.size();
  274.     if(!size || mCurrentVa >= mVaHistory.size() - 1) //we are at the newest history entry
  275.         return false;
  276.     return true;
  277. }
  278.  
  279. void HexDump::historyPrev()
  280. {
  281.     if(!historyHasPrev())
  282.         return;
  283.     mCurrentVa--;
  284.     printDumpAt(mVaHistory.at(mCurrentVa));
  285. }
  286.  
  287. void HexDump::historyNext()
  288. {
  289.     if(!historyHasNext())
  290.         return;
  291.     mCurrentVa++;
  292.     printDumpAt(mVaHistory.at(mCurrentVa));
  293. }
  294.  
  295. void HexDump::historyClear()
  296. {
  297.     mCurrentVa = -1;
  298.     mVaHistory.clear();
  299. }
  300.  
  301. void HexDump::setupCopyMenu()
  302. {
  303.     // Copy -> Data
  304.     mCopySelection = new QAction(DIcon("copy_selection.png"), tr("&Selected lines"), this);
  305.     connect(mCopySelection, SIGNAL(triggered(bool)), this, SLOT(copySelectionSlot()));
  306.     mCopySelection->setShortcutContext(Qt::WidgetShortcut);
  307.     addAction(mCopySelection);
  308.  
  309.     // Copy -> Address
  310.     mCopyAddress = new QAction(DIcon("copy_address.png"), tr("&Address"), this);
  311.     connect(mCopyAddress, SIGNAL(triggered()), this, SLOT(copyAddressSlot()));
  312.     mCopyAddress->setShortcutContext(Qt::WidgetShortcut);
  313.     addAction(mCopyAddress);
  314.  
  315.     // Copy -> RVA
  316.     mCopyRva = new QAction(DIcon("copy_address.png"), "&RVA", this);
  317.     connect(mCopyRva, SIGNAL(triggered()), this, SLOT(copyRvaSlot()));
  318.     mCopyRva->setShortcutContext(Qt::WidgetShortcut);
  319.     addAction(mCopyRva);
  320. }
  321.  
  322. void HexDump::copyAddressSlot()
  323. {
  324.     QString addrText = ToPtrString(rvaToVa(getInitialSelection()));
  325.     Bridge::CopyToClipboard(addrText);
  326. }
  327.  
  328. void HexDump::copyRvaSlot()
  329. {
  330.     duint addr = rvaToVa(getInitialSelection());
  331.     duint base = DbgFunctions()->ModBaseFromAddr(addr);
  332.     if(base)
  333.     {
  334.         QString addrText = ToHexString(addr - base);
  335.         Bridge::CopyToClipboard(addrText);
  336.     }
  337.     else
  338.         QMessageBox::warning(this, tr("Error!"), tr("Selection not in a module..."));
  339. }
  340.  
  341. void HexDump::mouseMoveEvent(QMouseEvent* event)
  342. {
  343.     bool wAccept = true;
  344.  
  345.     int x = event->x();
  346.     int y = event->y();
  347.  
  348.     if(mGuiState == HexDump::MultiRowsSelectionState)
  349.     {
  350.         //qDebug() << "State = MultiRowsSelectionState";
  351.  
  352.         if((transY(y) >= 0) && y <= this->height())
  353.         {
  354.             int wColIndex = getColumnIndexFromX(x);
  355.  
  356.             if(mForceColumn != -1)
  357.             {
  358.                 wColIndex = mForceColumn;
  359.                 x = getColumnPosition(mForceColumn) + 1;
  360.             }
  361.  
  362.             if(wColIndex > 0) // No selection for first column (addresses)
  363.             {
  364.                 dsint wStartingAddress = getItemStartingAddress(x, y);
  365.                 dsint dataSize = getSizeOf(mDescriptor.at(wColIndex - 1).data.itemSize) - 1;
  366.                 dsint wEndingAddress = wStartingAddress + dataSize;
  367.  
  368.                 if(wEndingAddress < (dsint)mMemPage->getSize())
  369.                 {
  370.                     if(wStartingAddress < getInitialSelection())
  371.                     {
  372.                         expandSelectionUpTo(wStartingAddress);
  373.                         mSelection.toIndex += dataSize;
  374.                         emit selectionUpdated();
  375.                     }
  376.                     else
  377.                         expandSelectionUpTo(wEndingAddress);
  378.  
  379.                     mGuiState = HexDump::MultiRowsSelectionState;
  380.  
  381.                     updateViewport();
  382.                 }
  383.             }
  384.             else
  385.             {
  386.                 dsint wStartingAddress = getItemStartingAddress(getColumnPosition(1) + 1, y);
  387.                 dsint dataSize = getSizeOf(mDescriptor.at(0).data.itemSize) * mDescriptor.at(0).itemCount - 1;
  388.                 dsint wEndingAddress = wStartingAddress + dataSize;
  389.  
  390.                 if(wEndingAddress < (dsint)mMemPage->getSize())
  391.                 {
  392.                     if(wStartingAddress < getInitialSelection())
  393.                     {
  394.                         expandSelectionUpTo(wStartingAddress);
  395.                         mSelection.toIndex += dataSize;
  396.                         emit selectionUpdated();
  397.                     }
  398.                     else
  399.                         expandSelectionUpTo(wEndingAddress);
  400.  
  401.                     mGuiState = HexDump::MultiRowsSelectionState;
  402.  
  403.                     updateViewport();
  404.                 }
  405.             }
  406.  
  407.             wAccept = true;
  408.         }
  409.         else if(y > this->height() && mGuiState == HexDump::MultiRowsSelectionState)
  410.         {
  411.             verticalScrollBar()->triggerAction(QAbstractSlider::SliderSingleStepAdd);
  412.         }
  413.         else if(transY(y) < 0 && mGuiState == HexDump::MultiRowsSelectionState)
  414.         {
  415.             verticalScrollBar()->triggerAction(QAbstractSlider::SliderSingleStepSub);
  416.         }
  417.     }
  418.  
  419.     if(wAccept == true)
  420.         AbstractTableView::mouseMoveEvent(event);
  421. }
  422.  
  423. void HexDump::mousePressEvent(QMouseEvent* event)
  424. {
  425.     if(event->buttons() == Qt::MiddleButton) //copy address to clipboard
  426.     {
  427.         if(!DbgIsDebugging())
  428.             return;
  429.         MessageBeep(MB_OK);
  430.         QString addrText = ToPtrString(rvaToVa(getInitialSelection()));
  431.         Bridge::CopyToClipboard(addrText);
  432.         return;
  433.     }
  434.     //qDebug() << "HexDump::mousePressEvent";
  435.  
  436.     int x = event->x();
  437.     int y = event->y();
  438.  
  439.     bool wAccept = false;
  440.  
  441.     if(((event->buttons() & Qt::LeftButton) != 0) && ((event->buttons() & Qt::RightButton) == 0))
  442.     {
  443.         if(getGuiState() == AbstractTableView::NoState)
  444.         {
  445.             if(y > getHeaderHeight() && y <= this->height())
  446.             {
  447.                 int wColIndex = getColumnIndexFromX(x);
  448.  
  449.                 if(mForceColumn != -1)
  450.                 {
  451.                     wColIndex = mForceColumn;
  452.                     x = getColumnPosition(mForceColumn) + 1;
  453.                 }
  454.  
  455.                 if(wColIndex > 0 && mDescriptor.at(wColIndex - 1).isData == true) // No selection for first column (addresses) and no data columns
  456.                 {
  457.                     dsint wStartingAddress = getItemStartingAddress(x, y);
  458.                     dsint dataSize = getSizeOf(mDescriptor.at(wColIndex - 1).data.itemSize) - 1;
  459.                     dsint wEndingAddress = wStartingAddress + dataSize;
  460.  
  461.                     if(wEndingAddress < (dsint)mMemPage->getSize())
  462.                     {
  463.                         bool bUpdateTo = false;
  464.                         if(!(event->modifiers() & Qt::ShiftModifier))
  465.                             setSingleSelection(wStartingAddress);
  466.                         else if(getInitialSelection() > wEndingAddress)
  467.                         {
  468.                             wEndingAddress -= dataSize;
  469.                             bUpdateTo = true;
  470.                         }
  471.                         expandSelectionUpTo(wEndingAddress);
  472.                         if(bUpdateTo)
  473.                         {
  474.                             mSelection.toIndex += dataSize;
  475.                             emit selectionUpdated();
  476.                         }
  477.  
  478.                         mGuiState = HexDump::MultiRowsSelectionState;
  479.  
  480.                         updateViewport();
  481.                     }
  482.                 }
  483.                 else if(wColIndex == 0)
  484.                 {
  485.                     dsint wStartingAddress = getItemStartingAddress(getColumnPosition(1) + 1, y);
  486.                     dsint dataSize = getSizeOf(mDescriptor.at(0).data.itemSize) * mDescriptor.at(0).itemCount - 1;
  487.                     dsint wEndingAddress = wStartingAddress + dataSize;
  488.  
  489.                     if(wEndingAddress < (dsint)mMemPage->getSize())
  490.                     {
  491.                         bool bUpdateTo = false;
  492.                         if(!(event->modifiers() & Qt::ShiftModifier))
  493.                             setSingleSelection(wStartingAddress);
  494.                         else if(getInitialSelection() > wEndingAddress)
  495.                         {
  496.                             wEndingAddress -= dataSize;
  497.                             bUpdateTo = true;
  498.                         }
  499.                         expandSelectionUpTo(wEndingAddress);
  500.                         if(bUpdateTo)
  501.                         {
  502.                             mSelection.toIndex += dataSize;
  503.                             emit selectionUpdated();
  504.                         }
  505.  
  506.                         mGuiState = HexDump::MultiRowsSelectionState;
  507.  
  508.                         updateViewport();
  509.                     }
  510.                 }
  511.  
  512.                 wAccept = true;
  513.             }
  514.         }
  515.     }
  516.  
  517.     if(wAccept == false)
  518.         AbstractTableView::mousePressEvent(event);
  519. }
  520.  
  521. void HexDump::mouseReleaseEvent(QMouseEvent* event)
  522. {
  523.     bool wAccept = true;
  524.  
  525.     if((event->buttons() & Qt::LeftButton) == 0)
  526.     {
  527.         if(mGuiState == HexDump::MultiRowsSelectionState)
  528.         {
  529.             mGuiState = HexDump::NoState;
  530.  
  531.             updateViewport();
  532.  
  533.             wAccept = false;
  534.         }
  535.     }
  536.     if((event->button() & Qt::BackButton) != 0)
  537.     {
  538.         wAccept = true;
  539.         historyPrev();
  540.     }
  541.     else if((event->button() & Qt::ForwardButton) != 0)
  542.     {
  543.         wAccept = true;
  544.         historyNext();
  545.     }
  546.  
  547.     if(wAccept == true)
  548.         AbstractTableView::mouseReleaseEvent(event);
  549. }
  550.  
  551. void HexDump::keyPressEvent(QKeyEvent* event)
  552. {
  553.     if(event->key() == Qt::Key_Up && event->modifiers() == Qt::ControlModifier)
  554.     {
  555.         duint offsetVa = rvaToVa(getTableOffsetRva()) - 1;
  556.         if(DbgMemFindBaseAddr(rvaToVa(getTableOffsetRva()), nullptr) == DbgMemFindBaseAddr(offsetVa, nullptr))
  557.         {
  558.             printDumpAt(offsetVa);
  559.             addVaToHistory(offsetVa);
  560.         }
  561.     }
  562.     else if(event->key() == Qt::Key_Down && event->modifiers() == Qt::ControlModifier)
  563.     {
  564.         duint offsetVa = rvaToVa(getTableOffsetRva()) + 1;
  565.         if(DbgMemFindBaseAddr(rvaToVa(getTableOffsetRva()), nullptr) == DbgMemFindBaseAddr(offsetVa, nullptr))
  566.         {
  567.             printDumpAt(offsetVa);
  568.             addVaToHistory(offsetVa);
  569.         }
  570.     }
  571.     else
  572.         AbstractTableView::keyPressEvent(event);
  573. }
  574.  
  575. QString HexDump::paintContent(QPainter* painter, dsint rowBase, int rowOffset, int col, int x, int y, int w, int h)
  576. {
  577.     // Reset byte offset when base address is reached
  578.     if(rowBase == 0 && mByteOffset != 0)
  579.         printDumpAt(mMemPage->getBase(), false, false);
  580.  
  581.     // Compute RVA
  582.     int wBytePerRowCount = getBytePerRowCount();
  583.     dsint wRva = (rowBase + rowOffset) * wBytePerRowCount - mByteOffset;
  584.  
  585.     if(col && mDescriptor.at(col - 1).isData)
  586.         printSelected(painter, rowBase, rowOffset, col, x, y, w, h);
  587.  
  588.     RichTextPainter::List richText;
  589.     getColumnRichText(col, wRva, richText);
  590.     RichTextPainter::paintRichText(painter, x, y, w, h, 4, richText, mFontMetrics);
  591.  
  592.     return "";
  593. }
  594.  
  595. void HexDump::printSelected(QPainter* painter, dsint rowBase, int rowOffset, int col, int x, int y, int w, int h)
  596. {
  597.     if((col > 0) && ((col - 1) < mDescriptor.size()))
  598.     {
  599.         ColumnDescriptor_t curDescriptor = mDescriptor.at(col - 1);
  600.         int wBytePerRowCount = getBytePerRowCount();
  601.         dsint wRva = (rowBase + rowOffset) * wBytePerRowCount - mByteOffset;
  602.         int wItemPixWidth = getItemPixelWidth(curDescriptor);
  603.         int wCharWidth = getCharWidth();
  604.         if(wItemPixWidth == wCharWidth)
  605.             x += 4;
  606.  
  607.         for(int i = 0; i < curDescriptor.itemCount; i++)
  608.         {
  609.             int wSelectionX = x + i * wItemPixWidth;
  610.             if(isSelected(wRva + i * getSizeOf(curDescriptor.data.itemSize)) == true)
  611.             {
  612.                 int wSelectionWidth = wItemPixWidth > w - (wSelectionX - x) ? w - (wSelectionX - x) : wItemPixWidth;
  613.                 wSelectionWidth = wSelectionWidth < 0 ? 0 : wSelectionWidth;
  614.                 painter->setPen(textColor);
  615.                 painter->fillRect(QRect(wSelectionX, y, wSelectionWidth, h), QBrush(selectionColor));
  616.             }
  617.             int separator = curDescriptor.separator;
  618.             if(i && separator && !(i % separator))
  619.             {
  620.                 painter->setPen(separatorColor);
  621.                 painter->drawLine(wSelectionX, y, wSelectionX, y + h);
  622.             }
  623.         }
  624.     }
  625. }
  626.  
  627. /************************************************************************************
  628.                                 Selection Management
  629. ************************************************************************************/
  630. void HexDump::expandSelectionUpTo(dsint rva)
  631. {
  632.     if(rva < mSelection.firstSelectedIndex)
  633.     {
  634.         mSelection.fromIndex = rva;
  635.         mSelection.toIndex = mSelection.firstSelectedIndex;
  636.         emit selectionUpdated();
  637.     }
  638.     else if(rva > mSelection.firstSelectedIndex)
  639.     {
  640.         mSelection.fromIndex = mSelection.firstSelectedIndex;
  641.         mSelection.toIndex = rva;
  642.         emit selectionUpdated();
  643.     }
  644.     else if(rva == mSelection.firstSelectedIndex)
  645.     {
  646.         setSingleSelection(rva);
  647.     }
  648. }
  649.  
  650. void HexDump::setSingleSelection(dsint rva)
  651. {
  652.     mSelection.firstSelectedIndex = rva;
  653.     mSelection.fromIndex = rva;
  654.     mSelection.toIndex = rva;
  655.     emit selectionUpdated();
  656. }
  657.  
  658. dsint HexDump::getInitialSelection()
  659. {
  660.     return mSelection.firstSelectedIndex;
  661. }
  662.  
  663. dsint HexDump::getSelectionStart()
  664. {
  665.     return mSelection.fromIndex;
  666. }
  667.  
  668. dsint HexDump::getSelectionEnd()
  669. {
  670.     return mSelection.toIndex;
  671. }
  672.  
  673. bool HexDump::isSelected(dsint rva)
  674. {
  675.     if(rva >= mSelection.fromIndex && rva <= mSelection.toIndex)
  676.         return true;
  677.     else
  678.         return false;
  679. }
  680.  
  681. void HexDump::getColumnRichText(int col, dsint rva, RichTextPainter::List & richText)
  682. {
  683.     RichTextPainter::CustomRichText_t curData;
  684.     curData.highlight = false;
  685.     curData.flags = RichTextPainter::FlagAll;
  686.     curData.textColor = textColor;
  687.     curData.textBackground = Qt::transparent;
  688.     curData.highlightColor = Qt::transparent;
  689.  
  690.     RichTextPainter::CustomRichText_t spaceData;
  691.     spaceData.highlight = false;
  692.     spaceData.flags = RichTextPainter::FlagNone;
  693.     spaceData.highlightColor = Qt::transparent;
  694.  
  695.     if(!col) //address
  696.     {
  697.         curData.text = makeAddrText(rvaToVa(rva));
  698.         richText.push_back(curData);
  699.     }
  700.     else if(mDescriptor.at(col - 1).isData == true)
  701.     {
  702.         const ColumnDescriptor_t & desc = mDescriptor.at(col - 1);
  703.         int wI;
  704.  
  705.         int wByteCount = getSizeOf(desc.data.itemSize);
  706.         int wBufferByteCount = desc.itemCount * wByteCount;
  707.  
  708.         wBufferByteCount = wBufferByteCount > (dsint)(mMemPage->getSize() - rva) ? mMemPage->getSize() - rva : wBufferByteCount;
  709.  
  710.         byte_t* wData = new byte_t[wBufferByteCount];
  711.         mMemPage->read(wData, rva, wBufferByteCount);
  712.  
  713.         if(desc.textCodec) //convert the row bytes to unicode
  714.         {
  715.             //This might produce invalid characters in variables-width encodings. This is currently ignored.
  716.             curData.text = desc.textCodec->toUnicode(QByteArray((const char*)wData, wBufferByteCount));
  717.             curData.text.replace('\t', "\\t");
  718.             curData.text.replace('\f', "\\f");
  719.             curData.text.replace('\v', "\\v");
  720.             curData.text.replace('\n', "\\n");
  721.             curData.text.replace('\r', "\\r");
  722.             richText.push_back(curData);
  723.         }
  724.         else
  725.         {
  726.             for(wI = 0; wI < desc.itemCount && (rva + wI) < (dsint)mMemPage->getSize(); wI++)
  727.             {
  728.                 curData.text.clear();
  729.                 curData.textColor = textColor;
  730.                 curData.textBackground = Qt::transparent;
  731.                 curData.flags = RichTextPainter::FlagAll;
  732.  
  733.                 int maxLen = getStringMaxLength(desc.data);
  734.                 if((rva + wI + wByteCount - 1) < (dsint)mMemPage->getSize())
  735.                 {
  736.                     toString(desc.data, rva + wI * wByteCount, wData + wI * wByteCount, curData);
  737.                     if(curData.text.length() < maxLen)
  738.                     {
  739.                         spaceData.text = QString(' ').repeated(maxLen - curData.text.length());
  740.                         richText.push_back(spaceData);
  741.                     }
  742.                     if(wI % sizeof(duint) == 0 && wByteCount == 1 && desc.data.byteMode == HexByte) //pointer underlining
  743.                     {
  744.                         auto ptr = *(duint*)(wData + wI * wByteCount);
  745.                         if(spaceData.highlight = curData.highlight = DbgMemIsValidReadPtr(ptr))
  746.                         {
  747.                             auto codePage = DbgFunctions()->MemIsCodePage(ptr, false);
  748.                             auto modbase = DbgFunctions()->ModBaseFromAddr(ptr);
  749.                             if(modbase)
  750.                             {
  751.                                 if(DbgFunctions()->ModGetParty(modbase) == 1) //system
  752.                                     spaceData.highlightColor = curData.highlightColor = codePage ? mSystemModuleCodePointerHighlightColor : mSystemModuleDataPointerHighlightColor;
  753.                                 else //user
  754.                                     spaceData.highlightColor = curData.highlightColor = codePage ? mUserModuleCodePointerHighlightColor : mUserModuleDataPointerHighlightColor;
  755.                             }
  756.                             else
  757.                                 spaceData.highlightColor = curData.highlightColor = codePage ? mUnknownCodePointerHighlightColor : mUnknownDataPointerHighlightColor;
  758.                         }
  759.                     }
  760.                     richText.push_back(curData);
  761.                     if(maxLen)
  762.                     {
  763.                         spaceData.text = QString(' ');
  764.                         if(wI % sizeof(duint) == sizeof(duint) - 1)
  765.                             spaceData.highlight = false;
  766.                         richText.push_back(spaceData);
  767.                     }
  768.                 }
  769.                 else
  770.                 {
  771.                     curData.text = QString("?").rightJustified(maxLen, ' ');
  772.                     if(maxLen)
  773.                         curData.text.append(' ');
  774.                     richText.push_back(curData);
  775.                 }
  776.             }
  777.         }
  778.  
  779.         delete[] wData;
  780.     }
  781. }
  782.  
  783. void HexDump::toString(DataDescriptor_t desc, duint rva, byte_t* data, RichTextPainter::CustomRichText_t & richText) //convert data to string
  784. {
  785.     switch(desc.itemSize)
  786.     {
  787.     case Byte:
  788.     {
  789.         byteToString(rva, *((byte_t*)data), desc.byteMode, richText);
  790.     }
  791.     break;
  792.  
  793.     case Word:
  794.     {
  795.         wordToString(rva, *((uint16*)data), desc.wordMode, richText);
  796.     }
  797.     break;
  798.  
  799.     case Dword:
  800.     {
  801.         dwordToString(rva, *((uint32*)data), desc.dwordMode, richText);
  802.     }
  803.     break;
  804.  
  805.     case Qword:
  806.     {
  807.         qwordToString(rva, *((uint64*)data), desc.qwordMode, richText);
  808.     }
  809.     break;
  810.  
  811.     case Tword:
  812.     {
  813.         twordToString(rva, data, desc.twordMode, richText);
  814.     }
  815.     break;
  816.  
  817.     default:
  818.     {
  819.  
  820.     }
  821.     break;
  822.     }
  823.  
  824.     if(desc.itemSize == Byte) //byte patches are handled in byteToString
  825.         return;
  826.  
  827.     dsint start = rvaToVa(rva);
  828.     dsint end = start + getSizeOf(desc.itemSize) - 1;
  829.     if(DbgFunctions()->PatchInRange(start, end))
  830.         richText.textColor = ConfigColor("HexDumpModifiedBytesColor");
  831. }
  832.  
  833. void HexDump::byteToString(duint rva, byte_t byte, ByteViewMode_e mode, RichTextPainter::CustomRichText_t & richText)
  834. {
  835.     QString wStr = "";
  836.  
  837.     switch(mode)
  838.     {
  839.     case HexByte:
  840.     {
  841.         wStr = ToByteString((unsigned char)byte);
  842.     }
  843.     break;
  844.  
  845.     case AsciiByte:
  846.     {
  847.         QChar wChar = QChar::fromLatin1((char)byte);
  848.  
  849.         if(wChar.isPrint())
  850.             wStr = QString(wChar);
  851.         else if(!wChar.unicode())
  852.             wStr = mNullReplace;
  853.         else
  854.             wStr = mNonprintReplace;
  855.     }
  856.     break;
  857.  
  858.     case SignedDecByte:
  859.     {
  860.         wStr = QString::number((int)((char)byte));
  861.     }
  862.     break;
  863.  
  864.     case UnsignedDecByte:
  865.     {
  866.         wStr = QString::number((unsigned int)byte);
  867.     }
  868.     break;
  869.  
  870.     default:
  871.     {
  872.  
  873.     }
  874.     break;
  875.     }
  876.  
  877.     richText.text = wStr;
  878.  
  879.     DBGPATCHINFO patchInfo;
  880.     if(DbgFunctions()->PatchGetEx(rvaToVa(rva), &patchInfo))
  881.     {
  882.         if(byte == patchInfo.newbyte)
  883.         {
  884.             richText.textColor = mModifiedBytesColor;
  885.             richText.textBackground = mModifiedBytesBackgroundColor;
  886.         }
  887.         else
  888.         {
  889.             richText.textColor = mRestoredBytesColor;
  890.             richText.textBackground = mRestoredBytesBackgroundColor;
  891.         }
  892.     }
  893.     else
  894.     {
  895.         switch(byte)
  896.         {
  897.         case 0x00:
  898.             richText.textColor = mByte00Color;
  899.             richText.textBackground = mByte00BackgroundColor;
  900.             break;
  901.         case 0x7F:
  902.             richText.textColor = mByte7FColor;
  903.             richText.textBackground = mByte7FBackgroundColor;
  904.             break;
  905.         case 0xFF:
  906.             richText.textColor = mByteFFColor;
  907.             richText.textBackground = mByteFFBackgroundColor;
  908.             break;
  909.         default:
  910.             if(isprint(byte) || isspace(byte))
  911.             {
  912.                 richText.textColor = mByteIsPrintColor;
  913.                 richText.textBackground = mByteIsPrintBackgroundColor;
  914.             }
  915.             break;
  916.         }
  917.     }
  918. }
  919.  
  920. void HexDump::wordToString(duint rva, uint16 word, WordViewMode_e mode, RichTextPainter::CustomRichText_t & richText)
  921. {
  922.     Q_UNUSED(rva);
  923.     QString wStr;
  924.  
  925.     switch(mode)
  926.     {
  927.     case HexWord:
  928.     {
  929.         wStr = ToWordString((unsigned short)word);
  930.     }
  931.     break;
  932.  
  933.     case UnicodeWord:
  934.     {
  935.         QChar wChar = QChar::fromLatin1((char)word & 0xFF);
  936.         if(wChar.isPrint() && (word >> 8) == 0)
  937.             wStr = QString(wChar);
  938.         else if(!wChar.unicode())
  939.             wStr = mNullReplace;
  940.         else
  941.             wStr = mNonprintReplace;
  942.     }
  943.     break;
  944.  
  945.     case SignedDecWord:
  946.     {
  947.         wStr = QString::number((int)((short)word));
  948.     }
  949.     break;
  950.  
  951.     case UnsignedDecWord:
  952.     {
  953.         wStr = QString::number((unsigned int)word);
  954.     }
  955.     break;
  956.  
  957.     default:
  958.     {
  959.  
  960.     }
  961.     break;
  962.     }
  963.  
  964.     richText.text = wStr;
  965. }
  966.  
  967. void HexDump::dwordToString(duint rva, uint32 dword, DwordViewMode_e mode, RichTextPainter::CustomRichText_t & richText)
  968. {
  969.     Q_UNUSED(rva);
  970.     QString wStr;
  971.  
  972.     switch(mode)
  973.     {
  974.     case HexDword:
  975.     {
  976.         wStr = QString("%1").arg((unsigned int)dword, 8, 16, QChar('0')).toUpper();
  977.     }
  978.     break;
  979.  
  980.     case SignedDecDword:
  981.     {
  982.         wStr = QString::number((int)dword);
  983.     }
  984.     break;
  985.  
  986.     case UnsignedDecDword:
  987.     {
  988.         wStr = QString::number((unsigned int)dword);
  989.     }
  990.     break;
  991.  
  992.     case FloatDword:
  993.     {
  994.         wStr = ToFloatString(&dword);
  995.     }
  996.     break;
  997.  
  998.     default:
  999.     {
  1000.  
  1001.     }
  1002.     break;
  1003.     }
  1004.  
  1005.     richText.text = wStr;
  1006. }
  1007.  
  1008. void HexDump::qwordToString(duint rva, uint64 qword, QwordViewMode_e mode, RichTextPainter::CustomRichText_t & richText)
  1009. {
  1010.     Q_UNUSED(rva);
  1011.     QString wStr;
  1012.  
  1013.     switch(mode)
  1014.     {
  1015.     case HexQword:
  1016.     {
  1017.         wStr = QString("%1").arg((unsigned long long)qword, 16, 16, QChar('0')).toUpper();
  1018.     }
  1019.     break;
  1020.  
  1021.     case SignedDecQword:
  1022.     {
  1023.         wStr = QString::number((long long)qword);
  1024.     }
  1025.     break;
  1026.  
  1027.     case UnsignedDecQword:
  1028.     {
  1029.         wStr = QString::number((unsigned long long)qword);
  1030.     }
  1031.     break;
  1032.  
  1033.     case DoubleQword:
  1034.     {
  1035.         wStr = ToDoubleString(&qword);
  1036.     }
  1037.     break;
  1038.  
  1039.     default:
  1040.     {
  1041.  
  1042.     }
  1043.     break;
  1044.     }
  1045.  
  1046.     richText.text = wStr;
  1047. }
  1048.  
  1049. void HexDump::twordToString(duint rva, void* tword, TwordViewMode_e mode, RichTextPainter::CustomRichText_t & richText)
  1050. {
  1051.     Q_UNUSED(rva);
  1052.     QString wStr;
  1053.  
  1054.     switch(mode)
  1055.     {
  1056.     case FloatTword:
  1057.     {
  1058.         wStr = ToLongDoubleString(tword);
  1059.     }
  1060.     break;
  1061.  
  1062.     default:
  1063.     {
  1064.  
  1065.     }
  1066.     break;
  1067.     }
  1068.  
  1069.     richText.text = wStr;
  1070. }
  1071.  
  1072. int HexDump::getSizeOf(DataSize_e size)
  1073. {
  1074.     return int(size);
  1075. }
  1076.  
  1077. int HexDump::getStringMaxLength(DataDescriptor_t desc)
  1078. {
  1079.     int wLength = 0;
  1080.  
  1081.     switch(desc.itemSize)
  1082.     {
  1083.     case Byte:
  1084.     {
  1085.         wLength = byteStringMaxLength(desc.byteMode);
  1086.     }
  1087.     break;
  1088.  
  1089.     case Word:
  1090.     {
  1091.         wLength = wordStringMaxLength(desc.wordMode);
  1092.     }
  1093.     break;
  1094.  
  1095.     case Dword:
  1096.     {
  1097.         wLength = dwordStringMaxLength(desc.dwordMode);
  1098.     }
  1099.     break;
  1100.  
  1101.     case Qword:
  1102.     {
  1103.         wLength = qwordStringMaxLength(desc.qwordMode);
  1104.     }
  1105.     break;
  1106.  
  1107.     case Tword:
  1108.     {
  1109.         wLength = twordStringMaxLength(desc.twordMode);
  1110.     }
  1111.     break;
  1112.  
  1113.     default:
  1114.     {
  1115.  
  1116.     }
  1117.     break;
  1118.     }
  1119.  
  1120.     return wLength;
  1121. }
  1122.  
  1123. int HexDump::byteStringMaxLength(ByteViewMode_e mode)
  1124. {
  1125.     int wLength = 0;
  1126.  
  1127.     switch(mode)
  1128.     {
  1129.     case HexByte:
  1130.     {
  1131.         wLength = 2;
  1132.     }
  1133.     break;
  1134.  
  1135.     case AsciiByte:
  1136.     {
  1137.         wLength = 0;
  1138.     }
  1139.     break;
  1140.  
  1141.     case SignedDecByte:
  1142.     {
  1143.         wLength = 4;
  1144.     }
  1145.     break;
  1146.  
  1147.     case UnsignedDecByte:
  1148.     {
  1149.         wLength = 3;
  1150.     }
  1151.     break;
  1152.  
  1153.     default:
  1154.     {
  1155.  
  1156.     }
  1157.     break;
  1158.     }
  1159.  
  1160.     return wLength;
  1161. }
  1162.  
  1163. int HexDump::wordStringMaxLength(WordViewMode_e mode)
  1164. {
  1165.     int wLength = 0;
  1166.  
  1167.     switch(mode)
  1168.     {
  1169.     case HexWord:
  1170.     {
  1171.         wLength = 4;
  1172.     }
  1173.     break;
  1174.  
  1175.     case UnicodeWord:
  1176.     {
  1177.         wLength = 0;
  1178.     }
  1179.     break;
  1180.  
  1181.     case SignedDecWord:
  1182.     {
  1183.         wLength = 6;
  1184.     }
  1185.     break;
  1186.  
  1187.     case UnsignedDecWord:
  1188.     {
  1189.         wLength = 5;
  1190.     }
  1191.     break;
  1192.  
  1193.     default:
  1194.     {
  1195.  
  1196.     }
  1197.     break;
  1198.     }
  1199.  
  1200.     return wLength;
  1201. }
  1202.  
  1203. int HexDump::dwordStringMaxLength(DwordViewMode_e mode)
  1204. {
  1205.     int wLength = 0;
  1206.  
  1207.     switch(mode)
  1208.     {
  1209.     case HexDword:
  1210.     {
  1211.         wLength = 8;
  1212.     }
  1213.     break;
  1214.  
  1215.     case SignedDecDword:
  1216.     {
  1217.         wLength = 11;
  1218.     }
  1219.     break;
  1220.  
  1221.     case UnsignedDecDword:
  1222.     {
  1223.         wLength = 10;
  1224.     }
  1225.     break;
  1226.  
  1227.     case FloatDword:
  1228.     {
  1229.         wLength = 13;
  1230.     }
  1231.     break;
  1232.  
  1233.     default:
  1234.     {
  1235.  
  1236.     }
  1237.     break;
  1238.     }
  1239.  
  1240.     return wLength;
  1241. }
  1242.  
  1243. int HexDump::qwordStringMaxLength(QwordViewMode_e mode)
  1244. {
  1245.     int wLength = 0;
  1246.  
  1247.     switch(mode)
  1248.     {
  1249.     case HexQword:
  1250.     {
  1251.         wLength = 16;
  1252.     }
  1253.     break;
  1254.  
  1255.     case SignedDecQword:
  1256.     {
  1257.         wLength = 20;
  1258.     }
  1259.     break;
  1260.  
  1261.     case UnsignedDecQword:
  1262.     {
  1263.         wLength = 20;
  1264.     }
  1265.     break;
  1266.  
  1267.     case DoubleQword:
  1268.     {
  1269.         wLength = 23;
  1270.     }
  1271.     break;
  1272.  
  1273.     default:
  1274.     {
  1275.  
  1276.     }
  1277.     break;
  1278.     }
  1279.  
  1280.     return wLength;
  1281. }
  1282.  
  1283. int HexDump::twordStringMaxLength(TwordViewMode_e mode)
  1284. {
  1285.     int wLength = 0;
  1286.  
  1287.     switch(mode)
  1288.     {
  1289.     case FloatTword:
  1290.     {
  1291.         wLength = 29;
  1292.     }
  1293.     break;
  1294.  
  1295.     default:
  1296.     {
  1297.  
  1298.     }
  1299.     break;
  1300.     }
  1301.  
  1302.     return wLength;
  1303. }
  1304.  
  1305. int HexDump::getItemIndexFromX(int x)
  1306. {
  1307.     int wColIndex = getColumnIndexFromX(x);
  1308.  
  1309.     if(wColIndex > 0)
  1310.     {
  1311.         int wColStartingPos = getColumnPosition(wColIndex);
  1312.         int wRelativeX = x - wColStartingPos;
  1313.  
  1314.         int wItemPixWidth = getItemPixelWidth(mDescriptor.at(wColIndex - 1));
  1315.         int wCharWidth = getCharWidth();
  1316.         if(wItemPixWidth == wCharWidth)
  1317.             wRelativeX -= 4;
  1318.  
  1319.         int wItemIndex = wRelativeX / wItemPixWidth;
  1320.  
  1321.         wItemIndex = wItemIndex < 0 ? 0 : wItemIndex;
  1322.         wItemIndex = wItemIndex > (mDescriptor.at(wColIndex - 1).itemCount - 1) ? (mDescriptor.at(wColIndex - 1).itemCount - 1) : wItemIndex;
  1323.  
  1324.         return wItemIndex;
  1325.     }
  1326.     else
  1327.     {
  1328.         return 0;
  1329.     }
  1330. }
  1331.  
  1332. dsint HexDump::getItemStartingAddress(int x, int y)
  1333. {
  1334.     int wRowOffset = getIndexOffsetFromY(transY(y));
  1335.     int wItemIndex = getItemIndexFromX(x);
  1336.     int wColIndex = getColumnIndexFromX(x);
  1337.     dsint wStartingAddress = 0;
  1338.  
  1339.     if(wColIndex > 0)
  1340.     {
  1341.         wColIndex -= 1;
  1342.         wStartingAddress = (getTableOffset() + wRowOffset) * (mDescriptor.at(wColIndex).itemCount * getSizeOf(mDescriptor.at(wColIndex).data.itemSize)) + wItemIndex * getSizeOf(mDescriptor.at(wColIndex).data.itemSize) - mByteOffset;
  1343.     }
  1344.  
  1345.     return wStartingAddress;
  1346. }
  1347.  
  1348. int HexDump::getBytePerRowCount()
  1349. {
  1350.     return mDescriptor.at(0).itemCount * getSizeOf(mDescriptor.at(0).data.itemSize);
  1351. }
  1352.  
  1353. int HexDump::getItemPixelWidth(ColumnDescriptor_t desc)
  1354. {
  1355.     int wCharWidth = getCharWidth();
  1356.     int wItemPixWidth = getStringMaxLength(desc.data) * wCharWidth + wCharWidth;
  1357.  
  1358.     return wItemPixWidth;
  1359. }
  1360.  
  1361. void HexDump::appendDescriptor(int width, QString title, bool clickable, ColumnDescriptor_t descriptor)
  1362. {
  1363.     addColumnAt(width, title, clickable);
  1364.     mDescriptor.append(descriptor);
  1365. }
  1366.  
  1367. //Clears the descriptors, append a new descriptor and fix the tableOffset (use this instead of clearDescriptors()
  1368. void HexDump::appendResetDescriptor(int width, QString title, bool clickable, ColumnDescriptor_t descriptor)
  1369. {
  1370.     mAllowPainting = false;
  1371.     if(mDescriptor.size())
  1372.     {
  1373.         dsint wRVA = getTableOffset() * getBytePerRowCount() - mByteOffset;
  1374.         clearDescriptors();
  1375.         appendDescriptor(width, title, clickable, descriptor);
  1376.         printDumpAt(rvaToVa(wRVA), true, false);
  1377.     }
  1378.     else
  1379.         appendDescriptor(width, title, clickable, descriptor);
  1380.     mAllowPainting = true;
  1381. }
  1382.  
  1383. void HexDump::clearDescriptors()
  1384. {
  1385.     deleteAllColumns();
  1386.     mDescriptor.clear();
  1387.     int charwidth = getCharWidth();
  1388.     addColumnAt(8 + charwidth * 2 * sizeof(duint), tr("Address"), false); //address
  1389. }
  1390.  
  1391. void HexDump::debugStateChanged(DBGSTATE state)
  1392. {
  1393.     if(state == stopped)
  1394.     {
  1395.         mMemPage->setAttributes(0, 0);
  1396.         setRowCount(0);
  1397.         reloadData();
  1398.     }
  1399. }
  1400.  
downloadHexDump.cpp Source code - Download x64dbg Source code
Related Source Codes/Software:
pencil - Multiplatform GUI Prototyping/Wireframing 2017-04-16
rainloop-webmail - Simple, modern & fast web-based email client ... 2017-04-16
qt - Qt binding for Go (Golang) which supports Windows ... 2017-04-16
MLeaksFinder - Find memory leaks in your iOS app at develop time. 2017-04-16
jsfeat - JavaScript Computer Vision library. 2017-04-16
later - A javascript library for defining recurring schedu... 2017-04-16
Android-ItemTouchHelper-Demo - Basic example of using ItemTouchHelper to add drag... 2017-04-16
onionshare - Securely and anonymously share a file of any size ... 2017-04-16
android-viewflow - A horizontal view scroller library for Android 2017-04-16
css-in-js - React: CSS in JS techniques comparison. 2017-04-16
mama2 - Mother plan - all firewood high flame 2017-04-23
BlurEffectForAndroidDesign - Sample to show how to implement blur graphical tri... 2017-04-23
sphinx_rtd_theme - Sphinx theme for readthedocs.org 2017-04-23
rouge - A pure-ruby code highlighter that is compatible wi... 2017-04-23
spring-security-oauth - Support for adding OAuth1(a) and OAuth2 features (... 2017-04-23
Toucan - Fabulous Image Processing in Swift 2017-04-23
CoffeeScriptRedux - 2017-04-23
breakpoint - Really simple media queries in Sa 2017-04-23
libsvm - 2017-04-22
grr - GRR Rapid Response: remote live forensics for inci... 2017-04-22

 Back to top