Ejemplo n.º 1
0
  def g_display(self):
    self.name = 'timeline ' + QString(self.node.name())
    if not self.node.hasChildren():
        self.setStateInfo(self.node.absolute() + ' doesn\'t have any children.')
    else:
        self.vfs = vfs.vfs()

        self.vlayout = QVBoxLayout()
        self.vlayout.setMargin(0)
        self.vlayout.setSpacing(0)
        
        self.hsplitter = QSplitter()
        self.ploter = PaintArea(self)
        self.options = OptionsLayout(self)

        self.hsplitter.addWidget(self.ploter)
        self.hsplitter.addWidget(self.options)
        self.vlayout.addWidget(self.hsplitter)
        self.setLayout(self.vlayout)
        self.draw = Drawer(self)

        # CountThread compute node amount
        self.countThread = CountThread(self, self.countThreadOver)
        self.populateThread = DataThread(self, self.dataThreadOver)
        self.maxOccThread = MaxOccThread(self, self.maxOccThreadOver)
        self.workerThread = WorkerThread(self)

#comment it to avoid redraw everytime painter is resized
        self.connect(self.workerThread, SIGNAL('refresh'), self.reDraw)
Ejemplo n.º 2
0
    def start(self, args):
        self.vfs = vfs.vfs()
        self.dumpnumber = 1
        try :
          self.nor = args['nor'].value()
          self.nand = args['nand'].value()
        except IndexError:
	  return
        try:
          self.spareSize = args["spare-size"].value()
        except IndexError:
          self.spareSize = 16
        try:
          self.pageSize = args["page-size"].value()
        except IndexError:
	  self.pageSize = 512
        self.k800n = Node("k800-base")
        self.k800n.__disown__()
        self.boot = SEBootBlock(self.nor, self.pageSize) 
        self.blockSize = self.boot.blockSize
        self.nandClean = SpareNode(self,  self.nand, "nandfs", self.pageSize, self.spareSize, self.k800n)
        self.norFs = NorFs(self, self.k800n,  self.nor, "norfs", self.boot)
        self.fullFs = FullFs(self, self.k800n, self.norFs, self.nandClean, "fullfs", self.boot)
        self.gdfs = GDFS(self, self.k800n, self.nor, "gdfs", self.boot)
        self.firmware = Firmware(self, self.k800n,  self.nor, "firmware", self.boot.norfsoffset)

        self.tables = Tables(self.fullFs, self.blockSize)
        self.registerTree(self.nand, self.k800n)
Ejemplo n.º 3
0
    def __init__(self, parent, model):
        QWidget.__init__(self)
        Ui_NodeFBox.__init__(parent)
        EventHandler.__init__(self)
        self.parent = parent

        self.setupUi(self)
        self.model = model
        self.translation()

        if IndexerFound:
            self.opt = ModifIndex(self, model)
        self.vfs = vfs()

        if QtCore.PYQT_VERSION_STR >= "4.5.0":
            self.search.clicked.connect(self.searching)
            if IndexerFound:
                self.notIndexed.linkActivated.connect(self.index_opt2)
                self.indexOpt.clicked.connect(self.explain_this_odd_behavior)
            self.advancedSearch.clicked.connect(self.adv_search)
            # self.connect(self, SIGNAL("add_node"), self.parent.model.fillingList)
        else:
            QtCore.QObject.connect(self.search, SIGNAL("clicked(bool)"), self.searching)
            if IndexerFound:
                QtCore.QObject.connect(self.index_opt, SIGNAL("clicked(bool)"), self.explain_this_odd_behavior)
                QtCore.QObject.connect(self.notIndexed, SIGNAL("linkActivated()"), self.index_opt2)
            QtCore.QObject.connect(self.advancedSearch, SIGNAL("clicked(bool)"), self.adv_search)
            # self.connect(self, SIGNAL("add_node"), self.parent.model.fillingList)
        self.filterThread = FilterThread()

        # Future feature
        self.indexOpt.hide()
Ejemplo n.º 4
0
 def getVfsNode(self):
     from api.vfs.vfs import vfs
     vfs = vfs()
     node = vfs.getnode(self.localHashPath())
     if node:
         return node
     return None
Ejemplo n.º 5
0
 def __init__(self):
   Script.__init__(self, "viewerimage")
   self.type = "imageview"
   self.icon = None
   self.vfs = vfs.vfs()
   self.reg_viewer = re.compile(".*(JPEG|JPG|jpg|jpeg|GIF|gif|bmp|png|PNG|pbm|PBM|pgm|PGM|ppm|PPM|xpm|XPM|xbm|XBM|TIFF|tiff).*", re.IGNORECASE)
   self.sceneWidth = 0
Ejemplo n.º 6
0
    def exportClick(self, clickState):
      rect = self.timeline.ploter.selectionRect.rect()
      exportSelDateMin = self.timeline.draw.findXTime(rect.x())
      exportSelDateMax = self.timeline.draw.findXTime(rect.x() + rect.width())

      for family in self.configuration:
        for time in family[1]:
          if time[1][0][1]:
            nodes = []
            everyNodes = self.timeline.elementsInRangeToNodeList(time[1][5][1], self.timeline.toUSec(exportSelDateMin), self.timeline.toUSec(exportSelDateMax))
            for oneGroupNode in everyNodes:
                for node in oneGroupNode:
                    nodes.append(node)
            if len(nodes):
              if not self.exportedNode:
# Create /timeline if needed
                  root = vfs.vfs().getnode('/')
                  baseNode = Node('timeline', 0, root)
	          baseNode.__disown__()
                  baseNode.setDir()
		  e = event()
		  e.value = Variant(baseNode)
                  self.VFS.notify(e)
# Create /timeline/<ParentName>
                  self.exportedNode = Node(self.timeline.node.name(), 0, baseNode)
                  self.exportedNode.__disown__()
                  self.exportedNode.setDir()
              timeBaseName = self.exportedNode.absolute() + '/' + str(exportSelDateMin.strftime('%d.%m.%Y %H:%M:%S')) + ' to ' + str(exportSelDateMax.strftime('%d.%m.%Y %H:%M:%S'))
              timeBaseNode = vfs.vfs().getnode(timeBaseName)
              if not timeBaseNode:
# Create /timeline/<ParentName>/dateStart to dateEnd/<Module:FullTimestampAttributePath>/
                  timeBaseNode = Node(str(exportSelDateMin.strftime('%d.%m.%Y %H:%M:%S')) + ' to ' + str(exportSelDateMax.strftime('%d.%m.%Y %H:%M:%S')), 0, self.exportedNode)
                  timeBaseNode.__disown__()
                  timeBaseNode.setDir()

              baseFamilyName = timeBaseNode.absolute() + '/' + ':'.join([family[0]] + time[0])
              baseFamilyNode = vfs.vfs().getnode(baseFamilyName)
              if not baseFamilyNode:
# Create /timeline/<ParentName>/dateStart to dateEnd//<Module:FullTimestampAttributePath> if needed
                  baseFamilyNode = Node(':'.join([family[0]] + time[0]), 0, timeBaseNode)
		  baseFamilyNode.__disown__()
                  baseFamilyNode.setDir()

              for node in nodes:
# Add each node in array as child
		  l = VLink(node, baseFamilyNode)
		  l.__disown__()
Ejemplo n.º 7
0
    def __init__(self, console, DEBUG = False, VERBOSITY = 0):
        self.DEBUG = DEBUG
        self.VERBOSITY = VERBOSITY
	self.console = console
        self.lp = LineParser(self.DEBUG, self.VERBOSITY - 1)
        self.confmanager = ConfigManager.Get()
        self.loader = loader()
        self.vfs = vfs()
Ejemplo n.º 8
0
Archivo: unzip.py Proyecto: halbbob/dff
 def __init__(self):
   fso.__init__(self, "unzip")
   self.name = "unzip"
   self.VFS = VFS.Get()
   self.vfs = vfs.vfs()
   self.fdm = FdManager()
   self.origin = None
   self.zipcontent = None
   self.file = None
   self.mapped_files = {}
Ejemplo n.º 9
0
 def __init__(self):
     QCompleter.__init__(self)
     self.vfs = vfs()
     self.__model = CompleterModel()
     self.currentNode = self.vfs.getnode("/")
     self.currentPath = self.currentNode
     self.setCompletionPrefix(QString.fromUtf8(self.currentNode.absolute()))
     self.__model.setRootPath(self.currentNode)
     self.__model.setCurrentPath("/")
     self.setModel(self.__model)
     QObject.connect(self, SIGNAL("activated(const QString &)"), self.updatePath)
Ejemplo n.º 10
0
Archivo: find.py Proyecto: halbbob/dff
 def __init__(self, root=None, filtersParam=None, recursive=True):
     EventHandler.__init__(self)
     self.filters = {}
     self.root = root
     self.recursive = recursive
     self.matchingNodes = []
     self.vfs = vfs()
     self.ai = AttributesIndexer.Get()
     self.__stop = False
     if filtersParam != None:
         self.filtersParam = filtersParam
         self.compile(self.filtersParam)
Ejemplo n.º 11
0
  def __init__(self, parent):
    QWidget.__init__(self)
    self.setupUi(self)
    #self.search.hide()
    self.vfs = vfs()
    self.VFS = libvfs.VFS.Get()
    self.parent = parent
    self.button = {}
    
     # Force thumbSize height to be the same as viewbox height, because
    # thumbSize comboBox doesn't have any icon, height is smaller.
    self.thumbSize.setFixedHeight(self.viewbox.sizeHint().height())
    
    self.history = []
    self.history.append("/")
    self.currentPathId = -1

    self.model = self.parent.model
    self.connect(self.model, SIGNAL("rootPathChanged"), self.rootpathchanged)

    self.bookmarkCategories = []
    self.bookmarkNode = self.vfs.getnode('/Bookmarks/')

    self.addPropertyTable()

    self.parent.connect(self.previous, SIGNAL("clicked()"), self.moveToPrevious)
    self.setPrevDropButton()
    self.parent.connect(self.next, SIGNAL("clicked()"), self.moveToNext)
    self.setNextDropButton()
    self.parent.connect(self.top, SIGNAL("clicked()"), self.moveToTop)
    self.parent.connect(self.root, SIGNAL("clicked()"), self.goHome)

    self.completerWidget = CompleterWidget()
    self.pathedit.addWidget(self.completerWidget)
    self.connect(self.completerWidget, SIGNAL("returnPressed()"), self.completerChanged)

    self.connect(self.viewbox, SIGNAL("activated(int)"), self.viewboxChanged)

    # No more checkBoxAttributes there is now an attributes panel icon
    self.connect(self.attrSelect, SIGNAL("clicked()"), self.attrSelectView)

    self.connect(self.addToBookmark, SIGNAL("clicked()"), self.bookmark)
    self.connect(self.search, SIGNAL("clicked()"), self.searchActivated)
    self.connect(self.imagethumb, SIGNAL("clicked()"), self.imagethumbActivated)
    self.connect(self.attrView, SIGNAL("clicked()"), self.attrViewActivated)


    self.parent.connect(self.thumbSize, SIGNAL("currentIndexChanged(QString)"), self.parent.sizeChanged)
    
    self.tableActivated()
    self.translation()
Ejemplo n.º 12
0
 def __init__(self, DEBUG = False, VERBOSITY = 0):
     self.DEBUG = DEBUG
     self.VERBOSITY = VERBOSITY
     self.confmanager = ConfigManager.Get()
     self.config = None
     self.keylessarg = None
     self.currentArgument = None
     self.parsedArgument = None
     self.providedArguments = {}
     self.remainingArguments = []
     self.threaded = False
     self.currentStr = ""
     self.vfs = vfs()
     self.currentStrScope = 0
     self.paramsplit = re.compile('(?<!\\\)\,')
     self.badargs = []
     self.tokens = []
Ejemplo n.º 13
0
 def __init__(self, parent):
     QObject.__init__(self)
     self.parent = parent
     self.vfs = vfs.vfs()
     self.taskmanager = TaskManager()
     self.loader = loader.loader()
Ejemplo n.º 14
0
  def __init__(self, parent):
    super(QWidget, self).__init__()
    EventHandler.__init__(self)
    self.filterThread = FilterThread(self)
    self.parent = parent
    self.vfs = vfs()
    self.setupUi(self)
    self.name = self.windowTitle()
    self.setObjectName(self.name)

    self.clause_list = []
    self.operator_list = []

    self.completeClause.setText("")
    self.__totalnodes = 0
    self.__totalhits = 0
    self.__processednodes = 0

    self.icon = ":search.png"
    self.translation()
    self.xtd_attr = PropertyTable(None)

    self.attrsTree.addWidget(self.xtd_attr)

    self.model = ListNodeModel(self)
    self.searchResults = SearchNodeBrowser(self)
    self.nodeBrowserLayout.addWidget(self.searchResults)
    self.node_name = QLineEdit()
    self.node_name.setReadOnly(True)
    self.nodeBrowserLayout.addWidget(self.node_name)

    self.searchResults.addTableView()
    self.searchResults.tableView.setModel(self.model)    
    self.connect(self.searchResults.tableView, SIGNAL("nodeClicked"), self.change_node_name)
    
    if QtCore.PYQT_VERSION_STR >= "4.5.0":
      self.nameContain.textChanged.connect(self.rebuildQuery)

      self.caseSensitiveName.stateChanged.connect(self.case_sens_changed)
      self.typeName.currentIndexChanged.connect(self.case_sens_changed)

      self.launchSearchButton.clicked.connect(self.launchSearch)
      self.stopSearchButton.clicked.connect(self.stopSearch)
      self.exportButton.clicked.connect(self.export)
    else:
      QtCore.QObject.connect(self.nameContain.textChanged, SIGNAL("clicked(bool)"), self.rebuildQuery)

      QtCore.QObject.connect(self.caseSensitiveName, SIGNAL("stateChanged(int)"), \
                               self.case_sens_changed)

      QtCore.QObject.connect(self.typeName, SIGNAL("currentIndexChanged(int)"), \
                               self.case_sens_changed)

      QtCore.QObject.connect(self.launchSearchButton, SIGNAL("clicked(bool)"), self.launchSearch)
      QtCore.QObject.connect(self.stopSearchButton, SIGNAL("clicked(bool)"), self.stopSearch)
      QtCore.QObject.connect(self.exportButton, SIGNAL("clicked(bool)"), self.export)

    self.typeName.addItem("Fixed string", QVariant("f"))
    self.typeName.addItem("Wildcard", QVariant("w"))
    self.typeName.addItem("Fuzzy", QVariant("fz"))
    self.typeName.addItem("Reg exp", QVariant("re"))

    self.stopSearchButton.hide()
    self.exportButton.setEnabled(False)
    self.addedOpt = []

    if QtCore.PYQT_VERSION_STR >= "4.5.0":
      self.addOption.clicked.connect(self.addSearchOptions)
    else:
      QtCore.QObject.connect(self.addOption, SIGNAL("clicked(bool)"), self.addSearchOptions)


    self.connect(self.filterThread, SIGNAL("CountNodes"), self.__progressUpdate)
    self.connect(self.filterThread, SIGNAL("finished"), self.searchFinished)
    QtCore.QObject.connect(self.selectAll, SIGNAL("stateChanged(int)"), self.select_all)
Ejemplo n.º 15
0
    def __init__(self,  app, debug = False):
        super(MainWindow,  self).__init__()
        self.app = app
        self.debug = debug
        self.sched = scheduler.sched
#        self.vfs = VFS.Get()
        self.vfs = vfs.vfs()
        self.createRootNodes()

        self.dialog = Dialog(self)
	
	self.initCallback()


        # Set up the user interface from Qt Designer
        self.setupUi(self)
        self.translation()

        # Customization
        self.setWindowModality(QtCore.Qt.ApplicationModal)
        self.resize(QtCore.QSize(QtCore.QRect(0,0,1014,693).size()).expandedTo(self.minimumSizeHint()))

	self.shellActions = ShellActions(self)
	self.interpreterActions = InterpreterActions(self)
        self.initDockWidgets()
        self.setCentralWidget(None)
        # Signals handling
        ## File menu
        self.connect(self.actionOpen_evidence, SIGNAL("triggered()"), self.dialog.addFiles)
        self.connect(self.actionOpen_device, SIGNAL("triggered()"), self.dialog.addDevices)
        self.connect(self.actionExit, SIGNAL("triggered()"), self.close)
        ## Edit menu
        self.connect(self.actionPreferences, SIGNAL("triggered()"), self.dialog.preferences)
        ## Module menu
        self.connect(self.actionLoadModule, SIGNAL("triggered()"), self.dialog.loadDriver)
        self.connect(self.actionBrowse_modules, SIGNAL("triggered()"), self.dialog.manager)
        ## Ide menu
        self.connect(self.actionIdeOpen, SIGNAL("triggered()"), self.addIde)
        ## View menu
        self.connect(self.actionMaximize, SIGNAL("triggered()"), self.maximizeDockwidget)
        self.connect(self.actionFullscreen_mode, SIGNAL("triggered()"), self.fullscreenMode)
        self.connect(self.actionNodeBrowser, SIGNAL("triggered()"), self.addNodeBrowser)
        self.connect(self.actionShell, SIGNAL("triggered()"), self.shellActions.create)
        self.connect(self.actionPython_interpreter, SIGNAL("triggered()"), self.interpreterActions.create)        ## About menu
        self.connect(self.actionHelp, SIGNAL("triggered()"), self.addHelpWidget)
        self.connect(self.actionAbout, SIGNAL("triggered()"), self.dialog.about)
        # list used to build toolbar
        # None will be a separator
        self.toolbarList = [self.actionOpen_evidence,
                            self.actionOpen_device,
                            None,
                            self.actionNodeBrowser,
                            self.actionShell,
                            self.actionPython_interpreter,
                            self.actionIdeOpen,
                            self.actionHelp,
                            None,
                            self.actionMaximize,
                            self.actionFullscreen_mode,
                            self.actionBrowse_modules,
                            ]

        # Set up toolbar
        self.setupToolBar()

        # Set up modules menu
        self.MenuTags = MenuTags(self, self)

        self.refreshTabifiedDockWidgets()
Ejemplo n.º 16
0
 def __init__(self, inheritfromvfsname, filename, flags):
   self.vfs = vfs()
   self.node = self.vfs.getnode(filename)
   self.vfile = self.node.open()