예제 #1
0
    def vqRestoreGuiSettings(self, settings, stub=''):
        dwcls = settings.value('DockClasses')

        if not compat_isNone(dwcls):
            for i, clsname in enumerate(dwcls):
                name = 'VQDockWidget%d' % i
                try:
                    # we haven't loaded the extensions yet, so all we'll have is the base clases
                    if str(clsname) not in self._dock_classes:
                        continue
                    tup = self.vqBuildDockWidget(str(clsname), floating=False)
                    if tup is not None:
                        d, obj = tup
                        d.setObjectName(name)
                        d.vqRestoreState(settings, name, stub)
                        d.show()
                except Exception as e:
                    logger.error('Error Building: %s: %s', clsname, e)

        # Once dock widgets are loaded, we can restoreState
        state = settings.value('DockState')
        if not compat_isNone(state):
            self.restoreState(state)

        geom = settings.value('DockGeometry')
        if not compat_isNone(geom):
            self.restoreGeometry(geom)

        # Just get all the resize activities done...
        vq_main.eatevents()
        for w in self.vqGetDockWidgets():
            w.show()

        return True
예제 #2
0
    def vqRestoreGuiSettings(self, settings):

        dwcls = settings.value('DockClasses')
        if not dwcls.isNull():

            for i,clsname in enumerate(dwcls.toStringList()):
                d = self.vqBuildDockWidget(str(clsname), floating=True)
                if d != None:
                    d.setObjectName('VQDockWidget%d' % i)

        # Once dock widgets are loaded, we can restoreState
        state = settings.value('DockState')
        if not state.isNull():
            self.restoreState(state.toByteArray())

        geom = settings.value('DockGeometry')
        if not geom.isNull():
            self.restoreGeometry(geom.toByteArray())

        # Just get all the resize activities done...
        vq_main.eatevents()

        for w in self._dock_widgets:
            w.show()

        return True
예제 #3
0
    def vqRestoreGuiSettings(self, settings):

        dwcls = settings.value('DockClasses')
        if dwcls is not None:

            for i, clsname in enumerate(dwcls):
                name = 'VQDockWidget%d' % i
                try:
                    tup = self.vqBuildDockWidget(str(clsname), floating=True)
                    if tup is not None:
                        d, obj = tup
                        d.setObjectName(name)
                        d.vqRestoreState(settings, name)
                        d.show()
                except Exception as e:
                    print(('Error Building: %s: %s' % (clsname, e)))

        # Once dock widgets are loaded, we can restoreState
        state = settings.value('DockState')
        if state is not None:
            self.restoreState(state)

        geom = settings.value('DockGeometry')
        if geom is not None:
            self.restoreGeometry(geom)

        # Just get all the resize activities done...
        vq_main.eatevents()
        for w in self.vqGetDockWidgets():
            w.show()

        return True
예제 #4
0
    def renderFunctionGraph(self, fva):

        self.fva = fva
        #self.graph = self.vw.getFunctionGraph(fva)
        self.graph = viv_graphutil.buildFunctionGraph(self.vw, fva, revloop=True)

        # Go through each of the nodes and render them so we know sizes
        for node in self.graph.getNodes():
            #cbva,cbsize = self.graph.getCodeBlockBounds(node)
            cbva = node[1].get('cbva')
            cbsize = node[1].get('cbsize')
            self.mem_canvas.renderMemory(cbva, cbsize)

        # Let the renders complete...
        eatevents()

        frame = self.mem_canvas.page().mainFrame()
        frame.evaluateJavaScript(funcgraph_js)

        for nid,nprops in self.graph.getNodes():
            cbva = nprops.get('cbva')

            cbname = 'codeblock_%.8x' % cbva
            girth, ok = frame.evaluateJavaScript('document.getElementById("%s").offsetWidth;' % cbname).toInt()
            height, ok = frame.evaluateJavaScript('document.getElementById("%s").offsetHeight;' % cbname).toInt()
            self.graph.setNodeProp((nid,nprops), "size", (girth, height))

        self.dylayout = vg_dynadag.DynadagLayout(self.graph)
        self.dylayout._barry_count = 20
        self.dylayout.layoutGraph()

        width, height = self.dylayout.getLayoutSize()

        svgid = 'funcgraph_%.8x' % fva
        frame.evaluateJavaScript('svgwoot("vbody", "%s", %d, %d);' % (svgid, width+18, height))

        for nid,nprops in self.graph.getNodes():

            cbva = nprops.get('cbva')
            if cbva == None:
                continue

            xpos, ypos = nprops.get('position')
            girth, height = nprops.get('size')

            foid = 'fo_cb_%.8x' % cbva
            cbid = 'codeblock_%.8x' % cbva

            frame.evaluateJavaScript('addSvgForeignObject("%s", "%s", %d, %d);' % (svgid, foid, girth+16, height))
            frame.evaluateJavaScript('addSvgForeignHtmlElement("%s", "%s");' % (foid, cbid))
            frame.evaluateJavaScript('moveSvgElement("%s", %d, %d);' % (foid, xpos, ypos))

        # Draw in some edge lines!
        for eid, n1, n2, einfo in self.graph.getEdges():
            points = einfo.get('edge_points')
            pointstr = ' '.join(['%d,%d' % (x,y) for (x,y) in points ])

            frame.evaluateJavaScript('drawSvgLine("%s", "edge_%.8s", "%s");' % (svgid, eid, pointstr))

        self.updateWindowTitle()
예제 #5
0
    def vqRestoreGuiSettings(self, settings):

        dwcls = settings.value('DockClasses')
        if not dwcls.isNull():

            for i, clsname in enumerate(dwcls.toStringList()):
                d = self.vqBuildDockWidget(str(clsname), floating=True)
                if d != None:
                    d.setObjectName('VQDockWidget%d' % i)

        # Once dock widgets are loaded, we can restoreState
        state = settings.value('DockState')
        if not state.isNull():
            self.restoreState(state.toByteArray())

        geom = settings.value('DockGeometry')
        if not geom.isNull():
            self.restoreGeometry(geom.toByteArray())

        # Just get all the resize activities done...
        vq_main.eatevents()

        for w in self._dock_widgets:
            w.show()

        return True
예제 #6
0
    def renderFunctionGraph(self, fva):

        self.fva = fva
        #self.graph = self.vw.getFunctionGraph(fva)
        self.graph = viv_graphutil.buildFunctionGraph(self.vw, fva, revloop=True)

        # Go through each of the nodes and render them so we know sizes
        for node in self.graph.getNodes():
            #cbva,cbsize = self.graph.getCodeBlockBounds(node)
            cbva = node[1].get('cbva')
            cbsize = node[1].get('cbsize')
            self.mem_canvas.renderMemory(cbva, cbsize)

        # Let the renders complete...
        eatevents()

        frame = self.mem_canvas.page().mainFrame()
        frame.evaluateJavaScript(funcgraph_js)

        for nid,nprops in self.graph.getNodes():
            cbva = nprops.get('cbva')

            cbname = 'codeblock_%.8x' % cbva
            girth, ok = frame.evaluateJavaScript('document.getElementById("%s").offsetWidth;' % cbname).toInt()
            height, ok = frame.evaluateJavaScript('document.getElementById("%s").offsetHeight;' % cbname).toInt()
            self.graph.setNodeProp((nid,nprops), "size", (girth, height))

        self.dylayout = vg_dynadag.DynadagLayout(self.graph)
        self.dylayout._barry_count = 20
        self.dylayout.layoutGraph()

        width, height = self.dylayout.getLayoutSize()

        svgid = 'funcgraph_%.8x' % fva
        frame.evaluateJavaScript('svgwoot("vbody", "%s", %d, %d);' % (svgid, width+18, height))

        for nid,nprops in self.graph.getNodes():

            cbva = nprops.get('cbva')
            if cbva == None:
                continue

            xpos, ypos = nprops.get('position')
            girth, height = nprops.get('size')

            foid = 'fo_cb_%.8x' % cbva
            cbid = 'codeblock_%.8x' % cbva

            frame.evaluateJavaScript('addSvgForeignObject("%s", "%s", %d, %d);' % (svgid, foid, girth+16, height))
            frame.evaluateJavaScript('addSvgForeignHtmlElement("%s", "%s");' % (foid, cbid))
            frame.evaluateJavaScript('moveSvgElement("%s", %d, %d);' % (foid, xpos, ypos))

        # Draw in some edge lines!
        for eid, n1, n2, einfo in self.graph.getEdges():
            points = einfo.get('edge_points')
            pointstr = ' '.join(['%d,%d' % (x,y) for (x,y) in points ])

            frame.evaluateJavaScript('drawSvgLine("%s", "edge_%.8s", "%s");' % (svgid, eid, pointstr))

        self.updateWindowTitle()
예제 #7
0
    def vqRestoreGuiSettings(self, settings):

        dwcls = settings.value('DockClasses')
        if dwcls is not None:

            for i, clsname in enumerate(dwcls):
                name = 'VQDockWidget%d' % i
                try:
                    tup = self.vqBuildDockWidget(str(clsname), floating=True)
                    if tup is not None:
                        d, obj = tup
                        d.setObjectName(name)
                        d.vqRestoreState(settings, name)
                        d.show()
                except Exception as e:
                    print(('Error Building: %s: %s' % (clsname, e)))

        # Once dock widgets are loaded, we can restoreState
        state = settings.value('DockState')
        if state is not None:
            self.restoreState(state)

        geom = settings.value('DockGeometry')
        if geom is not None:
            self.restoreGeometry(geom)

        # Just get all the resize activities done...
        vq_main.eatevents()
        for w in self.vqGetDockWidgets():
            w.show()

        return True
예제 #8
0
 def _scrollToVa(self, va, cb=None):
     vq_main.eatevents()  # Let all render events go first
     page = self.page()
     selector = 'viv:0x%.8x' % va
     js = f'''
     var nodes = document.getElementsByName("{selector}");
     if (nodes != null && nodes.length > 0) {{
         nodes[0].scrollIntoView()
     }}
     '''
     if cb:
         page.runJavaScript(js, cb)
     else:
         page.runJavaScript(js)
예제 #9
0
    def vqRestoreGuiSettings(self, settings):
        guid = self.vw.getVivGuid()
        dwcls = settings.value('%s/DockClasses' % guid)
        state = settings.value('%s/DockState' % guid)
        geom = settings.value('%s/DockGeometry' % guid)
        stub = '%s/' % guid

        if compat_isNone(dwcls):
            names = self.vw.filemeta.keys()
            names.sort()
            name = '+'.join(names)
            dwcls = settings.value('%s/DockClasses' % name)
            state = settings.value('%s/DockState' % name)
            geom = settings.value('%s/DockGeometry' % name)
            stub = '%s/' % name

        if compat_isNone(dwcls):
            dwcls = settings.value('DockClasses')
            state = settings.value('DockState')
            geom = settings.value('DockGeometry')
            stub = ''

        if not compat_isNone(dwcls):
            for i, clsname in enumerate(compat_strList(dwcls)):
                name = 'VQDockWidget%d' % i
                try:
                    tup = self.vqBuildDockWidget(str(clsname), floating=False)
                    if tup is not None:
                        d, obj = tup
                        d.setObjectName(name)
                        d.vqRestoreState(settings, name, stub)
                        d.show()
                except Exception as e:
                    print('Error Building: %s: %s' % (clsname, e))

        # Once dock widgets are loaded, we can restoreState
        if not compat_isNone(state):
            self.restoreState(compat_toByteArray(state))

        if not compat_isNone(geom):
            self.restoreGeometry(compat_toByteArray(geom))

        # Just get all the resize activities done...
        vq_main.eatevents()
        for w in self.vqGetDockWidgets():
            w.show()

        return True
예제 #10
0
파일: memcanvas.py 프로젝트: BwRy/vivisect
 def _scrollToVa(self, va):
     vq_main.eatevents() # Let all render events go first
     self.page().mainFrame().scrollToAnchor('viv:0x%.8x' % va)
예제 #11
0
 def _scrollToEnd(self):
     vq_main.eatevents()  # Let all render events go first
     frame = self.page().mainFrame()
     frame.setScrollBarValue(qt_vertical, 0x0fffffff)
예제 #12
0
                        d, obj = tup
                        d.setObjectName(name)
                        d.vqRestoreState(settings,name,stub)
                        d.show()
                except Exception, e:
                    print('Error Building: %s: %s'  % (clsname,e))

        # Once dock widgets are loaded, we can restoreState
        if not compat_isNone(state):
            self.restoreState(compat_toByteArray(state))

        if not compat_isNone(geom):
            self.restoreGeometry(compat_toByteArray(geom))

        # Just get all the resize activities done...
        vq_main.eatevents()
        for w in self.vqGetDockWidgets():
            w.show()

        return True

    def vqSaveGuiSettings(self, settings):

        dock_classes = []
        guid = self.vw.getVivGuid()
        names = self.vw.filemeta.keys()
        names.sort()
        vivname = '+'.join(names)

        # Enumerate the current dock windows and set
        # their names by their list order...
예제 #13
0
class VQVivFuncgraphView(vq_hotkey.HotKeyMixin, e_qt_memory.EnviNavMixin,
                         QWidget, vq_save.SaveableWidget,
                         viv_base.VivEventCore):
    _renderDoneSignal = pyqtSignal()

    viewidx = itertools.count()

    def __init__(self, vw, vwqgui):
        self.vw = vw
        self.fva = None
        self.graph = None
        self.vwqgui = vwqgui
        self._last_viewpt = None
        self.history = collections.deque((), 100)

        QWidget.__init__(self, parent=vwqgui)
        vq_hotkey.HotKeyMixin.__init__(self)
        viv_base.VivEventCore.__init__(self, vw)
        e_qt_memory.EnviNavMixin.__init__(self)
        self.setEnviNavName('FuncGraph%d' % self.viewidx.next())

        self._renderDoneSignal.connect(self._refresh_cb)

        self.top_box = QWidget(parent=self)
        hbox = QHBoxLayout(self.top_box)
        hbox.setContentsMargins(2, 2, 2, 2)
        hbox.setSpacing(4)

        self.histmenu = QMenu(parent=self)
        self.histmenu.aboutToShow.connect(self._histSetupMenu)

        self.hist_button = QPushButton('History', parent=self.top_box)
        self.hist_button.setMenu(self.histmenu)

        self.addr_entry = QLineEdit(parent=self.top_box)

        self.mem_canvas = VQVivFuncgraphCanvas(vw, syms=vw, parent=self)
        self.mem_canvas.setNavCallback(self.enviNavGoto)
        self.mem_canvas.refreshSignal.connect(self.refresh)
        self.mem_canvas.paintUp.connect(self._hotkey_paintUp)
        self.mem_canvas.paintDown.connect(self._hotkey_paintDown)
        self.mem_canvas.paintMerge.connect(self._hotkey_paintMerge)

        self.loadDefaultRenderers()

        self.addr_entry.returnPressed.connect(self._renderMemory)

        hbox.addWidget(self.hist_button)
        hbox.addWidget(self.addr_entry)

        vbox = QVBoxLayout(self)
        vbox.setContentsMargins(4, 4, 4, 4)
        vbox.setSpacing(4)
        vbox.addWidget(self.top_box)
        vbox.addWidget(self.mem_canvas, stretch=100)

        self.top_box.setLayout(hbox)

        self.setLayout(vbox)
        self.updateWindowTitle()

        # Do these last so we are all setup...
        vwqgui.addEventCore(self)
        vwqgui.vivMemColorSignal.connect(self.mem_canvas._applyColorMap)

        self.addHotKey('esc', 'mem:histback')
        self.addHotKeyTarget('mem:histback', self._hotkey_histback)
        self.addHotKey('ctrl+0', 'funcgraph:resetzoom')
        self.addHotKeyTarget('funcgraph:resetzoom', self._hotkey_resetzoom)
        self.addHotKey('ctrl+=', 'funcgraph:inczoom')
        self.addHotKeyTarget('funcgraph:inczoom', self._hotkey_inczoom)
        self.addHotKey('ctrl+-', 'funcgraph:deczoom')
        self.addHotKeyTarget('funcgraph:deczoom', self._hotkey_deczoom)
        self.addHotKey('f5', 'funcgraph:refresh')
        self.addHotKeyTarget('funcgraph:refresh', self.refresh)
        self.addHotKey('ctrl+u', 'funcgraph:paintup')
        self.addHotKeyTarget('funcgraph:paintup', self._hotkey_paintUp)
        self.addHotKey('ctrl+d', 'funcgraph:paintdown')
        self.addHotKeyTarget('funcgraph:paintdown', self._hotkey_paintDown)
        self.addHotKey('ctrl+m', 'funcgraph:paintmerge')
        self.addHotKeyTarget('funcgraph:paintmerge', self._hotkey_paintMerge)

    def _hotkey_histback(self):
        if len(self.history) >= 2:
            self.history.pop()
            expr = self.history.pop()
            self.enviNavGoto(expr)

    def _hotkey_resetzoom(self):
        self.mem_canvas.setZoomFactor(1)

    def _hotkey_inczoom(self):
        newzoom = self.mem_canvas.zoomFactor()
        if 1 > newzoom > .75:
            newzoom = 1
        elif newzoom < .5:
            newzoom += .125
        else:
            newzoom += .25

        if newzoom < 0: return

        #self.vw.vprint("NEW ZOOM    %f" % newzoom)
        self.mem_canvas.setZoomFactor(newzoom)

    def _hotkey_deczoom(self):
        newzoom = self.mem_canvas.zoomFactor()
        if newzoom <= .5:
            newzoom -= .125
        else:
            newzoom -= .25

        #self.vw.vprint("NEW ZOOM    %f" % newzoom)
        self.mem_canvas.setZoomFactor(newzoom)

    def refresh(self):
        '''
        Cause the Function Graph to redraw itself.
        This is particularly helpful because comments and name changes don't
        immediately display.  Perhaps someday this will update only the blocks
        that have changed since last update, and be fast, so we can update
        after every change.  
        '''
        self._last_viewpt = self.mem_canvas.page().mainFrame().scrollPosition()
        # FIXME: history should track this as well and return to the same place
        self.clearText()
        self.fva = None
        self._renderMemory()

    @workthread
    def _refresh_cb(self):
        '''
        This is a hack to make sure that when _renderMemory() completes,
        _refresh_3() gets run after all other rendering events yet to come.
        '''
        if self._last_viewpt == None:
            return

        self.mem_canvas.setScrollPosition(self._last_viewpt.x(),
                                          self._last_viewpt.y())
        self._last_viewpt = None

    def _histSetupMenu(self):
        self.histmenu.clear()

        history = []
        for expr in self.history:
            addr = self.vw.parseExpression(expr)
            menustr = '0x%.8x' % addr
            sym = self.vw.getSymByAddr(addr)
            if sym != None:
                menustr += ' - %s' % repr(sym)

            history.append((menustr, expr))

        history.reverse()
        for menustr, expr in history:
            self.histmenu.addAction(menustr, ACT(self._histSelected, expr))

    def _histSelected(self, expr):
        while self.history.pop() != expr:
            pass
        self.enviNavGoto(expr)

    def enviNavGoto(self, expr, sizeexpr=None):
        self.addr_entry.setText(expr)
        self.history.append(expr)
        self.updateWindowTitle()
        self._renderMemory()

    def vqGetSaveState(self):
        return {
            'expr': str(self.addr_entry.text()),
        }

    def vqSetSaveState(self, state):
        expr = state.get('expr', '')
        self.enviNavGoto(expr)

    def updateWindowTitle(self):
        ename = self.getEnviNavName()
        expr = str(self.addr_entry.text())
        try:
            va = self.vw.parseExpression(expr)
            smartname = self.vw.getName(va, smart=True)
            self.setWindowTitle('%s: %s (0x%x)' % (ename, smartname, va))
        except:
            self.setWindowTitle('%s: %s (0x----)' % (ename, expr))

    def _buttonSaveAs(self):
        frame = self.mem_canvas.page().mainFrame()
        elem = frame.findFirstElement('#mainhtml')
        h = elem.toOuterXml()
        #h = frame.toHtml()
        file('test.html', 'wb').write(str(h))

    def renderFunctionGraph(self, fva, graph=None):

        self.fva = fva
        #self.graph = self.vw.getFunctionGraph(fva)
        if graph == None:
            try:
                graph = viv_graphutil.buildFunctionGraph(self.vw,
                                                         fva,
                                                         revloop=True)
            except Exception, e:
                import sys
                sys.excepthook(*sys.exc_info())
                return

        self.graph = graph

        # Go through each of the nodes and render them so we know sizes
        for node in self.graph.getNodes():
            #cbva,cbsize = self.graph.getCodeBlockBounds(node)
            cbva = node[1].get('cbva')
            cbsize = node[1].get('cbsize')
            self.mem_canvas.renderMemory(cbva, cbsize)

        # Let the renders complete...
        eatevents()

        frame = self.mem_canvas.page().mainFrame()
        frame.evaluateJavaScript(funcgraph_js)

        for nid, nprops in self.graph.getNodes():
            cbva = nprops.get('cbva')

            cbname = 'codeblock_%.8x' % cbva
            #girth, ok = frame.evaluateJavaScript('document.getElementById("%s").offsetWidth;' % cbname).toInt()
            #girth = int(frame.evaluateJavaScript('document.getElementById("%s").offsetWidth;' % cbname))
            #height, ok = frame.evaluateJavaScript('document.getElementById("%s").offsetHeight;' % cbname).toInt()
            #height = frame.evaluateJavaScript('document.getElementById("%s").offsetHeight;' % cbname)
            girth, height = compat_getFrameDimensions(frame, cbname)
            self.graph.setNodeProp((nid, nprops), "size", (girth, height))

        self.dylayout = vg_dynadag.DynadagLayout(self.graph)
        self.dylayout._barry_count = 20
        self.dylayout.layoutGraph()

        width, height = self.dylayout.getLayoutSize()

        svgid = 'funcgraph_%.8x' % fva
        frame.evaluateJavaScript('svgwoot("vbody", "%s", %d, %d);' %
                                 (svgid, width + 18, height))

        for nid, nprops in self.graph.getNodes():

            cbva = nprops.get('cbva')
            if cbva == None:
                continue

            xpos, ypos = nprops.get('position')
            girth, height = nprops.get('size')

            foid = 'fo_cb_%.8x' % cbva
            cbid = 'codeblock_%.8x' % cbva

            frame.evaluateJavaScript(
                'addSvgForeignObject("%s", "%s", %d, %d);' %
                (svgid, foid, girth + 16, height))
            frame.evaluateJavaScript('addSvgForeignHtmlElement("%s", "%s");' %
                                     (foid, cbid))
            frame.evaluateJavaScript('moveSvgElement("%s", %d, %d);' %
                                     (foid, xpos, ypos))

        # Draw in some edge lines!
        for eid, n1, n2, einfo in self.graph.getEdges():
            points = einfo.get('edge_points')
            pointstr = ' '.join(['%d,%d' % (x, y) for (x, y) in points])

            frame.evaluateJavaScript('drawSvgLine("%s", "edge_%.8s", "%s");' %
                                     (svgid, eid, pointstr))

        self.updateWindowTitle()
예제 #14
0
파일: memcanvas.py 프로젝트: wflk/vivisect
 def _scrollToVa(self, va):
     vq_main.eatevents()  # Let all render events go first
     self.page().mainFrame().scrollToAnchor('viv:0x%.8x' % va)
예제 #15
0
 def setScrollPosition(self, x, y):
     '''
     Sets the view reticle to an absolute scroll position
     '''
     self.page().runJavaScript(f'window.scroll({x}, {y})')
     eatevents()
예제 #16
0
                        d, obj = tup
                        d.setObjectName(name)
                        d.vqRestoreState(settings, name, stub)
                        d.show()
                except Exception, e:
                    print('Error Building: %s: %s' % (clsname, e))

        # Once dock widgets are loaded, we can restoreState
        if not compat_isNone(state):
            self.restoreState(compat_toByteArray(state))

        if not compat_isNone(geom):
            self.restoreGeometry(compat_toByteArray(geom))

        # Just get all the resize activities done...
        vq_main.eatevents()
        for w in self.vqGetDockWidgets():
            w.show()

        return True

    def vqSaveGuiSettings(self, settings):

        dock_classes = []
        guid = self.vw.getVivGuid()
        names = self.vw.filemeta.keys()
        names.sort()
        vivname = '+'.join(names)

        # Enumerate the current dock windows and set
        # their names by their list order...
class VQMainCmdWindow(vq_hotkey.HotKeyMixin, QtGui.QMainWindow):
    '''
    A base class for application window's to inherit from.
    '''

    __cli_widget_class__ = vq_cli.VQCli

    def __init__(self, appname, cmd):

        QtGui.QMainWindow.__init__(self)
        vq_hotkey.HotKeyMixin.__init__(self)

        self._vq_appname = appname
        self._vq_dockwidgets = []

        self._vq_settings = QtCore.QSettings('invisigoth',
                                             application=appname,
                                             parent=self)
        self._vq_histfile = os.path.join(os.path.expanduser('~'),
                                         '.%s_history' % appname)

        self._dock_classes = {}

        self.vqInitDockWidgetClasses()

        self._vq_mbar = vq_menu.VQMenuBar()
        self.setMenuBar(self._vq_mbar)

        # AnimatedDocks, AllowNestedDocks, AllowTabbedDocks, ForceTabbedDocks, VerticalTabs
        self.setDockOptions(self.AnimatedDocks | self.AllowTabbedDocks)

        self._vq_cli = self.__cli_widget_class__(cmd)
        self._vq_cli.input.loadHistory(self._vq_histfile)
        self._vq_cli.sigCliQuit.connect(self.close)

        self.setCentralWidget(self._vq_cli)
        self.vqRestoreGuiSettings(self._vq_settings)

    def vqAddMenuField(self, fname, callback, args=()):
        self._vq_mbar.addField(fname, callback, args=args)

    def vqAddDynMenu(self, fname, callback):
        self._vq_mbar.addDynMenu(fname, callback)

    def vqInitDockWidgetClasses(self):
        # apps can over-ride
        pass

    def vqAddDockWidgetClass(self, cls, args=()):
        self._dock_classes[cls.__name__] = (cls, args)

    def vqBuildDockWidget(self,
                          clsname,
                          floating=False,
                          area=QtCore.Qt.TopDockWidgetArea):
        res = self._dock_classes.get(clsname)
        if res == None:
            print('vqBuildDockWidget Failed For: %s' % clsname)
            return
        cls, args = res
        obj = cls(*args)
        return self.vqDockWidget(obj, area, floating=floating), obj

    def vqRestoreGuiSettings(self, settings):

        dwcls = settings.value('DockClasses')
        if not dwcls.isNull():

            for i, clsname in enumerate(dwcls.toStringList()):
                name = 'VQDockWidget%d' % i
                try:
                    tup = self.vqBuildDockWidget(str(clsname), floating=True)
                    if tup != None:
                        d, obj = tup
                        d.setObjectName(name)
                        d.vqRestoreState(settings, name)
                        d.show()
                except Exception, e:
                    print('Error Building: %s: %s' % (clsname, e))

        # Once dock widgets are loaded, we can restoreState
        state = settings.value('DockState')
        if not state.isNull():
            self.restoreState(state.toByteArray())

        geom = settings.value('DockGeometry')
        if not geom.isNull():
            self.restoreGeometry(geom.toByteArray())

        # Just get all the resize activities done...
        vq_main.eatevents()
        for w in self.vqGetDockWidgets():
            w.show()

        return True
예제 #18
0
 def _scrollToEnd(self):
     vq_main.eatevents()  # Let all render events go first
     frame = self.page().mainFrame()
     frame.setScrollBarValue(qt_vertical, 0x0FFFFFFF)