Source Code for Module envi.qt.memcanvas

  1  import cgi 
  2  
 
  3  import vqt.main as vq_main 
  4  import vqt.colors as vq_colors 
  5  import envi.qt.html as e_q_html 
  6  import envi.memcanvas as e_memcanvas 
  7  
 
  8  qt_horizontal   = 1 
  9  qt_vertical     = 2 
 10  
 
 11  from PyQt4    import QtCore, QtGui, QtWebKit 
 12  from vqt.main import idlethread, idlethreadsync 
 13  
 
 14  #class memhotkey:
 
 15      #def __init__(self, 
 
 16  
 
 17  KEY_BACKSPACE = 0x1000003 
 18  
 
 19 -class VQMemoryCanvas(QtWebKit.QWebView, e_memcanvas.MemoryCanvas): 
 20  
 
 21 -    def __init__(self, mem, syms=None, parent=None): 
 22          QtWebKit.QWebView.__init__(self, parent=parent) 
 23          e_memcanvas.MemoryCanvas.__init__(self, mem, syms=syms) 
 24  
 
 25          self.setContent(e_q_html.template, 'application/xhtml+xml') 
 26          #self.setHtml(e_q_html.template)
 
 27          frame = self.page().mainFrame() 
 28          self._canv_cache = None 
 29          self._canv_rend_middle = False 
 30  
 
 31          self._canv_curva = None 
 32          self._canv_rendtagid = '#memcanvas' 
 33          self._canv_hotkeys = {} 
 34  
 
 35          self.page().mainFrame().addToJavaScriptWindowObject('vnav', self) 
 36  
 
 37 -    def keyPressEvent(self, event): 
 38          key = event.key() 
 39          txt = str(event.text()) 
 40          #print 'KEY',hex(key),repr(txt)
 
 41  
 
 42          handler = self._canv_hotkeys.get(txt) 
 43          if handler == None: 
 44              handler = self._canv_hotkeys.get(key) 
 45  
 
 46          if handler != None: 
 47              handler(self, key) 
 48              event.accept() 
 49  
 
 50          return QtWebKit.QWebView.keyPressEvent(self, event) 
 51  
 
 52 -    def vqAddHotKey(self, key, callback): 
 53          self._canv_hotkeys[key] = callback 
 54  
 
 55 -    def renderMemory(self, va, size, rend=None): 
 56  
 
 57          if self._canv_rend_middle: 
 58              vmap = self.mem.getMemoryMap(va) 
 59              origva = va 
 60              va = max(va - size, vmap[0]) 
 61              size += size 
 62  
 
 63          ret = e_memcanvas.MemoryCanvas.renderMemory(self, va, size, rend=rend) 
 64  
 
 65          if self._canv_rend_middle: 
 66              self._scrollToVa(origva) 
 67  
 
 68          return ret 
 69  
 
 70      @idlethread 
 71 -    def _scrollToVa(self, va): 
 72          vq_main.eatevents() # Let all render events go first 
 73          self.page().mainFrame().scrollToAnchor('viv:0x%.8x' % va) 
 74  
 
 75 -    def _beginRenderMemory(self, va, size, rend): 
 76          self._canv_cache = '' 
 77  
 
 78 -    def _endRenderMemory(self, va, size, rend): 
 79          self._appendInside(self._canv_cache) 
 80          self._canv_cache = None 
 81          if self._canv_scrolled: 
 82              self._scrollToEnd() 
 83  
 
 84 -    def _beginRenderVa(self, va): 
 85          self._add_raw('<a name="viv:0x%.8x" id="a_%.8x">' % (va,va)) 
 86  
 
 87 -    def _endRenderVa(self, va): 
 88          self._add_raw('</a>') 
 89  
 
 90 -    def _beginUpdateVas(self, valist): 
 91  
 
 92          self._canv_cache = '' 
 93          frame = self.page().mainFrame() 
 94          elem = frame.findFirstElement('a#a_%.8x' % valist[0][0]) 
 95          elem.prependOutside('<update id="updatetmp"></update>') 
 96  
 
 97          for va,size in valist: 
 98              elem = frame.findFirstElement('a#a_%.8x' % va) 
 99              elem.removeFromDocument() 
100  
 
101 -    def _endUpdateVas(self): 
102          elem = self.page().mainFrame().findFirstElement('update#updatetmp') 
103          elem.appendOutside(self._canv_cache) 
104          elem.removeFromDocument() 
105          self._canv_cache = None 
106  
 
107 -    def _beginRenderPrepend(self): 
108          self._canv_cache = '' 
109          self._canv_ppjump = self._canv_rendvas[0][0] 
110  
 
111 -    def _endRenderPrepend(self): 
112          frame = self.page().mainFrame() 
113          elem = frame.findFirstElement(self._canv_rendtagid) 
114          elem.prependInside(self._canv_cache) 
115          self._canv_cache = None 
116          self._scrollToVa(self._canv_ppjump) 
117  
 
118 -    def _beginRenderAppend(self): 
119          self._canv_cache = '' 
120  
 
121 -    def _endRenderAppend(self): 
122          frame = self.page().mainFrame() 
123          elem = frame.findFirstElement(self._canv_rendtagid) 
124          elem.appendInside(self._canv_cache) 
125          self._canv_cache = None 
126  
 
127 -    def getNameTag(self, name, typename=None): 
128          '''
 
129          Return a "tag" for this memory canvas.  In the case of the
 
130          qt tags, they are a tuple of html text (<opentag>, <closetag>)
 
131          ''' 
132          if typename == None: 
133              typename = 'name' 
134          return ('<%s class="name_%s" onclick="nameclick(this)">' % (typename,name), '</%s>' % typename) 
135  
 
136 -    def getVaTag(self, va): 
137          # The "class" will be the same that we get back from goto event
 
138          return ('<va class="va_0x%.8x" ondblclick="vagoto(this)" oncontextmenu="vaclick(this)" onclick="vaclick(this)">' % va, '</va>') 
139  
 
140      @QtCore.pyqtSlot(str)   
141 -    def _jsGotoExpr(self, expr): 
142          # The routine used by the javascript code to trigger nav events
 
143          if self._canv_navcallback: 
144              self._canv_navcallback(expr) 
145  
 
146      @QtCore.pyqtSlot(str) 
147 -    def _jsSetCurVa(self, vastr): 
148          self._canv_curva = int(str(vastr), 0) 
149  
 
150      # NOTE: doing append / scroll seperately allows render to catch up
 
151      @idlethread 
152 -    def _appendInside(self, text): 
153          frame = self.page().mainFrame() 
154          elem = frame.findFirstElement(self._canv_rendtagid) 
155          elem.appendInside(text) 
156  
 
157      @idlethread 
158 -    def _scrollToEnd(self): 
159          vq_main.eatevents() # Let all render events go first 
160          frame = self.page().mainFrame() 
161          frame.setScrollBarValue(qt_vertical, 0x0fffffff) 
162  
 
163 -    def _add_raw(self, text): 
164          # If we are in a call to renderMemory, cache til the end.
 
165          if self._canv_cache != None: 
166              self._canv_cache += text 
167              return 
168  
 
169          self._appendInside(text) 
170          if self._canv_scrolled: 
171              self._scrollToEnd() 
172  
 
173 -    def addText(self, text, tag=None): 
174          text = cgi.escape(text) 
175          text = text.replace('\n','<br/>') 
176          text = text.replace(' ', '&nbsp;') 
177  
 
178          if tag != None: 
179              otag, ctag = tag 
180              text = otag + text + ctag 
181  
 
182          self._add_raw(text) 
183  
 
184      @idlethreadsync 
185 -    def clearCanvas(self): 
186          frame = self.page().mainFrame() 
187          elem = frame.findFirstElement(self._canv_rendtagid) 
188          elem.setInnerXml('') 
189