Source Code for Module envi.qt.memory

  1  import re 
  2  from collections import deque 
  3  
 
  4  from PyQt4 import QtCore, QtGui 
  5  
 
  6  import envi.memcanvas as e_memcanvas 
  7  import envi.qt.memcanvas as e_memcanvas_qt 
  8  import envi.memcanvas.renderers as e_render 
  9  
 
 10  import vqt.colors as vq_colors 
 11  import vqt.menubuilder as vqt_menu 
 12  
 
 13  from vqt.main import idlethread, idlethreadsync 
 14  
 
 15 -class VQMemoryWindow(QtGui.QWidget): 
 16  
 
 17      __canvas_class__ = e_memcanvas_qt.VQMemoryCanvas 
 18  
 
 19 -    def __init__(self, memobj, syms=None, parent=None): 
 20  
 
 21          QtGui.QWidget.__init__(self, parent=parent) 
 22          self._mem_obj = memobj 
 23  
 
 24          self.top_box = QtGui.QWidget(parent=self) 
 25          hbox = QtGui.QHBoxLayout(self.top_box) 
 26          hbox.setMargin(2) 
 27          hbox.setSpacing(4) 
 28  
 
 29          self.hist_button = QtGui.QPushButton('History', parent=self.top_box) 
 30          self.hist_button.clicked.connect(self._histButtonClicked) 
 31          self.addr_entry  = QtGui.QLineEdit(parent=self.top_box) 
 32          self.size_entry  = QtGui.QLineEdit(parent=self.top_box) 
 33          self.size_entry.setText('256') 
 34          self.rend_select = QtGui.QComboBox(parent=self.top_box) 
 35  
 
 36          self.mem_history = deque() 
 37          self.mem_canvas = self.__canvas_class__(memobj, syms=syms, parent=self) 
 38  
 
 39          self.mem_canvas.vqAddHotKey(e_memcanvas_qt.KEY_BACKSPACE, self._hotkey_BS) 
 40  
 
 41          self.loadDefaultRenderers() 
 42          self.loadRendSelect() 
 43  
 
 44          self.addr_entry.returnPressed.connect(self._renderMemory) 
 45          self.size_entry.returnPressed.connect(self._renderMemory) 
 46  
 
 47          self.connect(self.rend_select, QtCore.SIGNAL('currentIndexChanged(QString)'), self._renderMemory) 
 48  
 
 49          hbox.addWidget(self.hist_button) 
 50          hbox.addWidget(self.addr_entry) 
 51          hbox.addWidget(self.size_entry) 
 52          hbox.addWidget(self.rend_select) 
 53  
 
 54          vbox = QtGui.QVBoxLayout(self) 
 55          vbox.setMargin(4) 
 56          vbox.setSpacing(4) 
 57          vbox.addWidget(self.top_box) 
 58          vbox.addWidget(self.mem_canvas, stretch=100) 
 59  
 
 60          self.top_box.setLayout(hbox) 
 61  
 
 62          self.setLayout(vbox) 
 63          self.setWindowTitle('Mem: None') 
 64  
 
 65 -    def _hotkey_BS(self, canv, key): 
 66          if len(self.mem_history) >= 2: 
 67              hinfo = self.mem_history.popleft() 
 68              hinfo = self.mem_history.popleft() 
 69              self._histSelected( hinfo ) 
 70  
 
 71 -    def _histSelected(self, hinfo): 
 72          addrexpr, sizeexpr, rendname = hinfo 
 73          self.addr_entry.setText(addrexpr) 
 74          self.size_entry.setText(sizeexpr) 
 75          self.mem_canvas.setRenderer(rendname) 
 76          self._renderMemory() 
 77  
 
 78 -    def _histButtonClicked(self): 
 79  
 
 80          menu = vqt_menu.VQMenu('context', parent=self.hist_button) 
 81          menu.splitchar = '&&&&&' # Disable splitting 
 82          for hinfo in self.mem_history: 
 83              addrexpr, sizeexpr, rendname = hinfo 
 84              addr = self._mem_obj.parseExpression(addrexpr) 
 85              menustr = '0x%.8x' % addr 
 86              sym = self._mem_obj.getSymByAddr(addr) 
 87              if sym != None: 
 88                  menustr += ' - %s' % repr(sym) 
 89              menu.addField(menustr, self._histSelected, (hinfo,)) 
 90          menu.exec_(self.mapToGlobal(self.hist_button.pos())) 
 91          return 
 92  
 
 93 -    def vqMemNavSlot(self, expr, sizeexpr=None): 
 94          # Used by nav event generators to make us render
 
 95          self.addr_entry.setText(expr) 
 96          if sizeexpr != None: 
 97              self.size_entry.setText(sizeexpr) 
 98          self._renderMemory() 
 99  
 
100 -    def loadRendSelect(self): 
101          self.rend_select.clear() 
102          for name in self.mem_canvas.getRendererNames(): 
103              self.rend_select.addItem(name) 
104  
 
105 -    def loadDefaultRenderers(self): 
106          self.mem_canvas.addRenderer("bytes",    e_render.ByteRend()) 
107          self.mem_canvas.addRenderer("u_int_16", e_render.ShortRend()) 
108          self.mem_canvas.addRenderer("u_int_32", e_render.LongRend()) 
109          self.mem_canvas.addRenderer("u_int_64", e_render.QuadRend()) 
110  
 
111 -    def _getRenderVaSize(self): 
112  
 
113          expr = str(self.addr_entry.text()) 
114          sizeexpr = str(self.size_entry.text()) 
115  
 
116          if not expr: 
117              return None, None 
118  
 
119          if not sizeexpr: 
120              return None, None 
121  
 
122          try: 
123              addr = self._mem_obj.parseExpression(expr) 
124          except Exception, e: 
125              self.mem_canvas.addText('Invalid Address: %s (%s)' % (expr, e)) 
126              return None, None 
127  
 
128          try: 
129              size = self._mem_obj.parseExpression(sizeexpr) 
130          except Exception, e: 
131              self.mem_canvas.addText('Invalid Size: %s (%s)' % (expr, e)) 
132              return None, None 
133  
 
134          self.setWindowTitle('Mem: %s' % expr) 
135          return addr, size 
136  
 
137      @idlethread 
138 -    def _renderMemory(self, *args, **kwargs): 
139  
 
140          self.clearText() 
141  
 
142          addr, size = self._getRenderVaSize() 
143          if addr == None: 
144              return 
145  
 
146          expr = str(self.addr_entry.text()) 
147          rname = str(self.rend_select.currentText()) 
148          sizeexpr = str(self.size_entry.text()) 
149  
 
150          mhist = (expr, sizeexpr, rname) 
151          if mhist not in self.mem_history: 
152              self.mem_history.appendleft( mhist ) 
153              while len(self.mem_history) > 100: 
154                  self.mem_history.pop() 
155  
 
156          self.mem_canvas.setRenderer(rname) 
157          self.mem_canvas.renderMemory(addr, size) 
158  
 
159 -    def clearText(self): 
160          self.mem_canvas.clearCanvas() 
161