def chooseFile(self, event):
     chooseFile = JFileChooser()
     filter = FileNameExtensionFilter("c files", ["c"])
     chooseFile.addChoosableFileFilter(filter)
     chooseFile.showDialog(self.uploadPanel, "Choose File")
     chosenFile = chooseFile.getSelectedFile()
     self.uploadTextField.text = str(chosenFile)
Example #2
0
 def set_plugin_loc(self, event):
     """Attempts to load plugins from a specified location"""
     if self.config['Plugin Folder'] is not None:
         choose_plugin_location = JFileChooser(self.config['Plugin Folder'])
     else:
         choose_plugin_location = JFileChooser()
     choose_plugin_location.setFileSelectionMode(
         JFileChooser.DIRECTORIES_ONLY)
     choose_plugin_location.showDialog(self.tab, "Choose Folder")
     chosen_folder = choose_plugin_location.getSelectedFile()
     self.config['Plugin Folder'] = chosen_folder.getAbsolutePath()
     self._load_plugins(self.config['Plugin Folder'])
Example #3
0
 def set_plugin_loc(self, event):
     """Attempts to load plugins from a specified location"""
     if self.config['Plugin Folder'] is not None:
         choose_plugin_location = JFileChooser(self.config['Plugin Folder'])
     else:
         choose_plugin_location = JFileChooser()
     choose_plugin_location.setFileSelectionMode(
         JFileChooser.DIRECTORIES_ONLY)
     choose_plugin_location.showDialog(self.tab, "Choose Folder")
     chosen_folder = choose_plugin_location.getSelectedFile()
     self.config['Plugin Folder'] = chosen_folder.getAbsolutePath()
     self._load_plugins(self.config['Plugin Folder'])
Example #4
0
 def get_source_input(self, event):
     """Sets the source dir/file for parsing"""
     source_chooser = JFileChooser()
     source_chooser.setFileSelectionMode(
         JFileChooser.FILES_AND_DIRECTORIES)
     source_chooser.showDialog(self.tab, "Choose Source Location")
     chosen_source = source_chooser.getSelectedFile()
     try:
         self.source_input = chosen_source.getAbsolutePath()
     except AttributeError:
         pass
     if self.source_input is not None:
         self.update_scroll("[*] Source location: %s" % self.source_input)
         self.curr_conf.setText(self.source_input)
Example #5
0
 def get_source_input(self, event):
     """Sets the source dir/file for parsing"""
     source_chooser = JFileChooser()
     source_chooser.setFileSelectionMode(
         JFileChooser.FILES_AND_DIRECTORIES)
     source_chooser.showDialog(self.tab, "Choose Source Location")
     chosen_source = source_chooser.getSelectedFile()
     try:
         self.source_input = chosen_source.getAbsolutePath()
     except AttributeError:
         pass
     if self.source_input is not None:
         self.update_scroll("[*] Source location: %s" % self.source_input)
         self.curr_conf.setText(self.source_input)
Example #6
0
    def openFile(self, event):
        '''
        1. Check if current file in text area has unsaved changes
            1.1 Prompt user for file saving
                1.1.1 Save file
        2. Display browser for user to choose file
        3. Load file in text area
        '''
        self.consoleController.addText("NammuController: Opening file...")

        self.handleUnsaved()

        fileChooser = JFileChooser()
        filter = FileNameExtensionFilter("ATF files", ["atf"])
        fileChooser.setFileFilter(filter)
        status = fileChooser.showDialog(self.view, "Choose file")

        if status == JFileChooser.APPROVE_OPTION:
            atfFile = fileChooser.getSelectedFile()
            filename = atfFile.getCanonicalPath()
            atfText = self.readTextFile(filename)
            self.currentFilename = atfFile.getCanonicalPath()
            self.atfAreaController.setAtfAreaText(atfText)

        #TODO: Else, prompt user to choose again before closing

        self.consoleController.addText(" OK\n")
Example #7
0
    def openFile(self, event=None):
        '''
        1. Check if current file in text area has unsaved changes
            1.1 Prompt user for file saving
                1.1.1 Save file
        2. Display browser for user to choose file
        3. Load file in text area
        4. Display file name in title bar
        '''
        if self.handleUnsaved():
            fileChooser = JFileChooser(self.get_working_dir())
            file_filter = FileNameExtensionFilter("ATF files", ["atf"])
            fileChooser.setFileFilter(file_filter)
            status = fileChooser.showDialog(self.view, "Choose file")

            if status == JFileChooser.APPROVE_OPTION:
                atfFile = fileChooser.getSelectedFile()
                filename = atfFile.getCanonicalPath()
                basename = atfFile.getName()
                atfText = self.readTextFile(filename)
                self.currentFilename = atfFile.getCanonicalPath()
                # Clear ATF area before adding next text to clean up tooltips
                # and such
                self.atfAreaController.clearAtfArea()
                self.atfAreaController.setAtfAreaText(atfText)
                self.logger.debug("File %s successfully opened.", filename)
                self.view.setTitle(basename)

            # TODO: Else, prompt user to choose again before closing

            # Update settings with current file's path
            self.update_config_element(self.get_working_dir(),
                                       'default', 'working_dir')
Example #8
0
 def _onExport(control, event):
     component = control.getElement().getRootElement().getComponent()
     openDialog = JFileChooser()
     openDialog.setFileSelectionMode(JFileChooser.DIRECTORIES_ONLY)
     response = openDialog.showDialog(component, 'Export')
     if response == JFileChooser.APPROVE_OPTION:
         sf = openDialog.getSelectedFile()
         if sf is not None:
             filename = sf.getPath()
             if filename is not None and os.path.isdir(filename):
                 response = JOptionPane.showOptionDialog(
                     component,
                     'Existing content will be overwritten. Proceed?',
                     'Overwrite existing content',
                     JOptionPane.YES_NO_OPTION,
                     JOptionPane.WARNING_MESSAGE, None,
                     ['Overwrite', 'Cancel'], 'Cancel')
                 if response == JFileChooser.APPROVE_OPTION:
                     exc = None
                     try:
                         project.export(filename)
                     except:
                         exc = JythonException.getCurrentException()
                     if exc is not None:
                         BubblePopup.popupInBubbleAdjacentTo(
                             DefaultPerspective.instance(exc),
                             control.getElement(), Anchor.BOTTOM, True,
                             True)
Example #9
0
 def getFilePath(self):
     chooseFile = JFileChooser()
     panel = JPanel()
     ret = chooseFile.showDialog(panel, "Choose output file (*.msc)")
     if ret == JFileChooser.APPROVE_OPTION: 
       file=chooseFile.getSelectedFile()
     return file 
Example #10
0
 def selectFile(self, event):
     print("Choose !!")
     chooseFile = JFileChooser()
     ret = chooseFile.showDialog(frm.panel, "Choose file")
     if ret == JFileChooser.APPROVE_OPTION:
         file = chooseFile.getSelectedFile()
         frm.jTextField4.setText(file.getCanonicalPath())
Example #11
0
    def openFile(self, event=None):
        '''
        1. Check if current file in text area has unsaved changes
            1.1 Prompt user for file saving
                1.1.1 Save file
        2. Display browser for user to choose file
        3. Load file in text area
        4. Display file name in title bar
        '''
        if self.handleUnsaved():
            if self.currentFilename:
                default_path = os.path.dirname(self.currentFilename)
            else:
                default_path = os.getcwd()
            fileChooser = JFileChooser(default_path)
            file_filter = FileNameExtensionFilter("ATF files", ["atf"])
            fileChooser.setFileFilter(file_filter)
            status = fileChooser.showDialog(self.view, "Choose file")

            if status == JFileChooser.APPROVE_OPTION:
                atfFile = fileChooser.getSelectedFile()
                filename = atfFile.getCanonicalPath()
                basename = atfFile.getName()
                atfText = self.readTextFile(filename)
                self.currentFilename = atfFile.getCanonicalPath()
                # Clear ATF area before adding next text to clean up tooltips
                # and such
                self.atfAreaController.clearAtfArea()
                self.atfAreaController.setAtfAreaText(atfText)
                self.logger.debug("File %s successfully opened.", filename)
                self.view.setTitle(basename)
Example #12
0
 def onOpenFolder(self, event):
     chooseFile = JFileChooser()
     chooseFile.setFileSelectionMode(JFileChooser.DIRECTORIES_ONLY);
     ret = chooseFile.showDialog(self, "Choose folder")
     if ret == JFileChooser.APPROVE_OPTION:
         self.faile= chooseFile.getSelectedFile()
         self.cbOutDir.addItem(self.faile.getPath())
         self.cbOutDir.selectedItem= self.faile.getPath()
Example #13
0
def _buildProjectJar(element, document):
    component = element.getRootElement().getComponent()

    larchJarURL = app_in_jar.getLarchJarURL()
    chosenJarURL = None
    if larchJarURL is None:
        openDialog = JFileChooser()
        openDialog.setFileFilter(
            FileNameExtensionFilter('Larch executable JAR (*.jar)', ['jar']))
        response = openDialog.showDialog(component, 'Choose Larch JAR')
        if response == JFileChooser.APPROVE_OPTION:
            sf = openDialog.getSelectedFile()
            if sf is not None:
                chosenJarURL = sf.toURI().toURL()
        else:
            return

    jarFile = None
    bFinished = False
    while not bFinished:
        saveDialog = JFileChooser()
        saveDialog.setFileFilter(
            FileNameExtensionFilter('JAR file (*.jar)', ['jar']))
        response = saveDialog.showSaveDialog(component)
        if response == JFileChooser.APPROVE_OPTION:
            sf = saveDialog.getSelectedFile()
            if sf is not None:
                if sf.exists():
                    response = JOptionPane.showOptionDialog(
                        component, 'File already exists. Overwrite?',
                        'File already exists', JOptionPane.YES_NO_OPTION,
                        JOptionPane.WARNING_MESSAGE, None,
                        ['Overwrite', 'Cancel'], 'Cancel')
                    if response == JFileChooser.APPROVE_OPTION:
                        jarFile = sf
                        bFinished = True
                    else:
                        bFinished = False
                else:
                    jarFile = sf
                    bFinished = True
            else:
                bFinished = True
        else:
            bFinished = True

    if jarFile is not None:
        outStream = FileOutputStream(jarFile)

        documentBytes = document.writeAsBytes()

        nameBytesPairs = [('app.larch', documentBytes)]

        app_in_jar.buildLarchJar(outStream,
                                 nameBytesPairs,
                                 larchJarURL=chosenJarURL)

        outStream.close()
Example #14
0
    def onClick(self, e):
        fileChooser = JFileChooser()
        fileChooser.setFileSelectionMode(JFileChooser.DIRECTORIES_ONLY)
        ret = fileChooser.showDialog(self.panel, "Choose folder")

        if ret == JFileChooser.APPROVE_OPTION:
            file = fileChooser.getSelectedFile()
            filename = file.getCanonicalPath()
            self.localSettings.setFace(filename)
Example #15
0
def _imageFileChooser(element, imageValueFn):
	component = element.getRootElement().getComponent()
	fileChooser = JFileChooser()
	response = fileChooser.showDialog(component, 'Open')
	if response == JFileChooser.APPROVE_OPTION:
		sf = fileChooser.getSelectedFile()
		if sf is not None:
			return imageValueFn(sf)
	return None
Example #16
0
 def onClick(self, e):
     chooseFile = JFileChooser()
     filter = FileNameExtensionFilter("c files", ["c"])
     chooseFile.addChoosableFileFilter(filter)
     ret = chooseFile.showDialog(self.panel, "Choose file")
     if ret == JFileChooser.APPROVE_OPTION:
           file = chooseFile.getSelectedFile()
           
           print file
Example #17
0
 def open(self, e):
     filechooser = JFileChooser()
     filter = FileNameExtensionFilter("c files", ["c"])
     filechooser.addChoosableFileFilter(filter)
     ret = filechooser.showDialog(self.panel, "Elegir fichero")
     if ret == JFileChooser.APPROVE_OPTION:
         file = filechooser.getSelectedFile()
         text = self.readFile(file)
         self.area.setText(text)
Example #18
0
    def createDialogBoxForImportExport(self, dialogTitle, extensionFilter, buttonText):

        # create frame
        frameImportExportDialogBox = JFrame()

        # try to load the last used directory
        try:
            # load the directory for future imports/exports
            fileChooserDirectory = self._callbacks.loadExtensionSetting("fileChooserDirectory")

        # there is not a last used directory
        except:
            # set the last used directory to blank
            fileChooserDirectory = ""

        # create file chooser
        fileChooserImportExportDialogBox = JFileChooser(fileChooserDirectory)

        # set dialog title
        fileChooserImportExportDialogBox.setDialogTitle(dialogTitle)

        # create extension filter
        filterImportExportDialogBox = FileNameExtensionFilter(extensionFilter[0], extensionFilter[1])

        # set extension filter
        fileChooserImportExportDialogBox.setFileFilter(filterImportExportDialogBox)

        # show dialog box and get value
        valueFileChooserImportExportDialogBox = fileChooserImportExportDialogBox.showDialog(frameImportExportDialogBox, buttonText)

        # check if a file was not selected
        if valueFileChooserImportExportDialogBox != JFileChooser.APPROVE_OPTION:
        
            # return no path/file selected
            return False, "No Path/File"

        # get the directory
        fileChooserDirectory = fileChooserImportExportDialogBox.getCurrentDirectory()

        # store the directory for future imports/exports
        self._callbacks.saveExtensionSetting("fileChooserDirectory", str(fileChooserDirectory))

        # get absolute path of file
        fileChosenImportExportDialogBox = fileChooserImportExportDialogBox.getSelectedFile().getAbsolutePath()

        # split name and extension
        fileNameImportExportDialogBox, fileExtensionImportExportDialogBox = os.path.splitext(fileChosenImportExportDialogBox)

        # check if file does not have an extention
        if fileExtensionImportExportDialogBox == "":

            # add extension to file
            fileChosenImportExportDialogBox = fileChosenImportExportDialogBox + extensionFilter[2]

        # return dialog box value and path/file
        return True, fileChosenImportExportDialogBox
Example #19
0
 def _onOpen(button, event):
     component = button.getElement().getRootElement().getComponent()
     fileChooser = JFileChooser()
     self._initFileChooser(fileChooser)
     response = fileChooser.showDialog(component, 'Open')
     if response == JFileChooser.APPROVE_OPTION:
         sf = fileChooser.getSelectedFile()
         if sf is not None:
             filename = sf.getPath()
             if filename is not None:
                 self._model.liveValue.setLiteralValue(filename)
Example #20
0
    def chooseFolder(self, e):
        button = e.getSource()
        code = button.getActionCommand()
        fileChooser = JFileChooser()
        fileChooser.setFileSelectionMode(JFileChooser.FILES_ONLY)

        ret = fileChooser.showDialog(self, "Choose folder")
        if ret == JFileChooser.APPROVE_OPTION:
            ff = fileChooser.getSelectedFile()
            path = ff.getCanonicalPath()
            self.textInputs[code].text = path
Example #21
0
    def openFile(self, event=None):
        '''
        1. Check if current file in text area has unsaved changes
            1.1 Prompt user for file saving
                1.1.1 Save file
        2. Display browser for user to choose file
        3. Load file in text area
        4. Display file name in title bar
        '''
        if self.handleUnsaved():
            fileChooser = JFileChooser(self.get_working_dir())
            file_filter = FileNameExtensionFilter("ATF files", ["atf"])
            fileChooser.setFileFilter(file_filter)
            status = fileChooser.showDialog(self.view, "Choose file")

            if status == JFileChooser.APPROVE_OPTION:
                atfFile = fileChooser.getSelectedFile()
                filename = atfFile.getCanonicalPath()
                basename = atfFile.getName()
                atfText = self.readTextFile(filename)
                self.currentFilename = atfFile.getCanonicalPath()
                # Clear ATF area before adding next text to clean up tooltips
                # and such
                self.atfAreaController.clearAtfArea()

                # Turn off caret movement and highligting for file load
                self.atfAreaController.caret.setUpdatePolicy(
                    DefaultCaret.NEVER_UPDATE)
                syntax_highlight = self.atfAreaController.syntax_highlighter
                syntax_highlight.syntax_highlight_on = False
                self.atfAreaController.setAtfAreaText(atfText)

                self.consoleController.clearConsole()
                self.logger.info("File %s successfully opened.", filename)
                self.view.setTitle(basename)

                # Re-enable caret updating and syntax highlighting after load
                self.atfAreaController.caret.setUpdatePolicy(
                    DefaultCaret.ALWAYS_UPDATE)
                syntax_highlight.syntax_highlight_on = True

                # Now dispatch syntax highlighting in a new thread so
                # we dont highlight before the full file is loaded
                runSwingLater(self.initHighlighting)

            # TODO: Else, prompt user to choose again before closing

            # Update settings with current file's path
            self.update_config_element(self.get_working_dir(), 'default',
                                       'working_dir')

            # Finally, refresh the edit area to propagate custom font settings
            self.atfAreaController.refreshEditArea()
Example #22
0
    def onClick(self, e):

        chooseFile = JFileChooser()
        filter = FileNameExtensionFilter("SQLite", ["sqlite"])
        chooseFile.addChoosableFileFilter(filter)

        ret = chooseFile.showDialog(self.panel, "Select SQLite")

        if ret == JFileChooser.APPROVE_OPTION:
            file = chooseFile.getSelectedFile()
            text = self.readPath(file)
            self.area.setText(text)
Example #23
0
def promptOpenDocument(world, component, handleOpenedDocumentFn):
	openDialog = JFileChooser()
	openDialog.setFileFilter( FileNameExtensionFilter( 'Larch project (*.larch)', [ 'larch' ] ) )
	response = openDialog.showDialog( component, 'Open' )
	if response == JFileChooser.APPROVE_OPTION:
		sf = openDialog.getSelectedFile()
		if sf is not None:
			filename = sf.getPath()
			if filename is not None:
				document = Document.readFile( world, filename )
				if document is not None:
					handleOpenedDocumentFn( filename, document )
Example #24
0
		def _onNew(hyperlink, event):
			component = hyperlink.getElement().getRootElement().getComponent()
			openDialog = JFileChooser()
			openDialog.setFileSelectionMode( JFileChooser.DIRECTORIES_ONLY )
			response = openDialog.showDialog( component, 'Choose path' )
			if response == JFileChooser.APPROVE_OPTION:
				sf = openDialog.getSelectedFile()
				if sf is not None:
					filename = sf.getPath()
					if filename is not None  and  os.path.isdir( filename ):
						pathList.append( filename )
						self._incr.onChanged()
    def onClick(self, e):

        chooseFile = JFileChooser()
        filter = FileNameExtensionFilter("SQLite", ["sqlite"])
        chooseFile.addChoosableFileFilter(filter)

        ret = chooseFile.showDialog(self.panel, "Select SQLite")

        if ret == JFileChooser.APPROVE_OPTION:
            file = chooseFile.getSelectedFile()
            text = self.readPath(file)
            self.area.setText(text)
Example #26
0
    def chooseFolder(self, e):
        button = e.getSource()
        code = button.getActionCommand()
        fileChooser = JFileChooser()
        fileChooser.setFileSelectionMode(JFileChooser.DIRECTORIES_ONLY)
        text = "Choose folder"

        ret = fileChooser.showDialog(self, text)
        if ret == JFileChooser.APPROVE_OPTION:
            ff = fileChooser.getSelectedFile()
            path = ff.getCanonicalPath()
            self.localSettings.setPath(code, path)
            self.textInputs[code].text = path
Example #27
0
def new_home_page():
	openDialog = JFileChooser()
	openDialog.setFileSelectionMode( JFileChooser.DIRECTORIES_ONLY )
	openDialog.setDialogTitle('Choose directory to search for Mallard .page files')
	response = openDialog.showDialog( None, 'Choose' )
	if response == JFileChooser.APPROVE_OPTION:
		sf = openDialog.getSelectedFile()
		if sf is not None:
			filename = sf.getPath()
			if filename is not None  and  os.path.isdir( filename ):
				return HomePage(filename)

	return HomePage('.')
Example #28
0
    def Find_Plaso_File(self, e):

        chooseFile = JFileChooser()
        filter = FileNameExtensionFilter("All", ["*.*"])
        chooseFile.addChoosableFileFilter(filter)

        ret = chooseFile.showDialog(self.panel0, "Find Plaso Storage File")

        if ret == JFileChooser.APPROVE_OPTION:
            file = chooseFile.getSelectedFile()
            Canonical_file = file.getCanonicalPath()
            #text = self.readPath(file)
            self.local_settings.setPlaso_Storage_File(Canonical_file)
            self.Plaso_Storage_File_TF.setText(Canonical_file)
    def Find_Plaso_File(self, e):

       chooseFile = JFileChooser()
       filter = FileNameExtensionFilter("All", ["*.*"])
       chooseFile.addChoosableFileFilter(filter)

       ret = chooseFile.showDialog(self.panel0, "Find Plaso Storage File")

       if ret == JFileChooser.APPROVE_OPTION:
           file = chooseFile.getSelectedFile()
           Canonical_file = file.getCanonicalPath()
           #text = self.readPath(file)
           self.local_settings.setSetting('Plaso_Storage_File', Canonical_file)
           self.Plaso_Storage_File_TF.setText(Canonical_file)
    def onClick(self, e):

        chooseFile = JFileChooser()
        filter = FileNameExtensionFilter("SQLite", ["sqlite"])
        chooseFile.addChoosableFileFilter(filter)

        ret = chooseFile.showDialog(self.panel0, "Select SQLite")

        if ret == JFileChooser.APPROVE_OPTION:
            file = chooseFile.getSelectedFile()
            Canonical_file = file.getCanonicalPath()
            #text = self.readPath(file)
            self.local_settings.setSetting('ExecFile', Canonical_file)
            self.Program_Executable_TF.setText(Canonical_file)
    def onClick(self, e):

       chooseFile = JFileChooser()
       filter = FileNameExtensionFilter("SQLite", ["sqlite"])
       chooseFile.addChoosableFileFilter(filter)

       ret = chooseFile.showDialog(self.panel0, "Select SQLite")

       if ret == JFileChooser.APPROVE_OPTION:
           file = chooseFile.getSelectedFile()
           Canonical_file = file.getCanonicalPath()
           #text = self.readPath(file)
           self.local_settings.setSetting('ExecFile', Canonical_file)
           self.Program_Executable_TF.setText(Canonical_file)
Example #32
0
    def FindFTKTxtFile(self, e):

       chooseFile = JFileChooser()
       filter = FileNameExtensionFilter("ALL", ["*.*"])
       chooseFile.addChoosableFileFilter(filter)

       ret = chooseFile.showDialog(self.panel0, "Find FTK Log File")
       
       if ret == JFileChooser.APPROVE_OPTION:
           file = chooseFile.getSelectedFile()
           Canonical_file = file.getCanonicalPath()
           #text = self.readPath(file)
           self.local_settings.setSetting('FTKLogFile', Canonical_file)
           setSetting('FTKLogFile', Canonical_file)
           self.FTKLogFile_TF.setText(Canonical_file)
    def Find_Dir(self, e):

        chooseFile = JFileChooser()
        filter = FileNameExtensionFilter("All", ["*.*"])
        chooseFile.addChoosableFileFilter(filter)
        #chooseFile.setFileSelectionMode(JFileChooser.DIRECTORIES_ONLY)

        ret = chooseFile.showDialog(self.panel0, "Find Volatility Directory")

        if ret == JFileChooser.APPROVE_OPTION:
            file = chooseFile.getSelectedFile()
            Canonical_file = file.getCanonicalPath()
            #text = self.readPath(file)
            self.local_settings.setVolatility_Directory(Canonical_file)
            self.Program_Executable_TF.setText(Canonical_file)
    def Find_Dir(self, e):

       chooseFile = JFileChooser()
       filter = FileNameExtensionFilter("All", ["*.*"])
       chooseFile.addChoosableFileFilter(filter)
       #chooseFile.setFileSelectionMode(JFileChooser.DIRECTORIES_ONLY)

       ret = chooseFile.showDialog(self.panel0, "Find Volatility Directory")

       if ret == JFileChooser.APPROVE_OPTION:
           file = chooseFile.getSelectedFile()
           Canonical_file = file.getCanonicalPath()
           #text = self.readPath(file)
           self.local_settings.setSetting('Volatility_Directory', Canonical_file)
           self.Program_Executable_TF.setText(Canonical_file)
Example #35
0
 def onOpenFile(self, event):
     ''' remember to change the path'''
     chooseFile = JFileChooser()
     chooseFile.setCurrentDirectory(File('C:\Users\fragom\PhD_CIM\Modelica\Models')) 
     filtro = FileNameExtensionFilter("mo files", ["mo"])
     chooseFile.addChoosableFileFilter(filtro)
     ret = chooseFile.showDialog(self, "Choose file")
     if ret == JFileChooser.APPROVE_OPTION:
         self.faile= chooseFile.getSelectedFile()
         if event.getActionCommand() == "Load Model":
             self.cbMoFile.addItem(self.faile.getPath())
             self.cbMoFile.selectedItem= self.faile.getPath()
         if event.getActionCommand() == "Load Library":
             self.cbMoLib.addItem(self.faile.getPath())
             self.cbMoLib.selectedItem= self.faile.getPath()
Example #36
0
    def loadSimOut(self, event):
        chooseFile = JFileChooser()
        filtro = FileNameExtensionFilter("Output files (.h5)", ['h5'])
        chooseFile.addChoosableFileFilter(filtro)
        ret = chooseFile.showDialog(self.frame, "Choose simulation result")
        if ret == JFileChooser.APPROVE_OPTION:
            faile= chooseFile.getSelectedFile()
            self.cbfilesimOut.addItem(faile.getPath())
            self.cbfilesimOut.selectedItem(faile.getPath())

        h5pmu= PhasorMeasH5.PhasorMeasH5(faile)
        h5pmu.open_h5()
        h5pmu.load_h5('pwLine4', 'V')
        # result: 2 vectors per variable, work with pwLine4.n.vr, pwLine4.n.vi
        senyal= h5pmu.get_senyal()
        print senyal
Example #37
0
    def _select_sql_file(self, e):
        """ Shows a JFileChooser dialog to select the SQL file to use for creating
        the model. """
        try:
            chooseFile = JFileChooser()
            filter_ = FileNameExtensionFilter("txt files", ["txt"])
            chooseFile.addChoosableFileFilter(filter_)

            ret = chooseFile.showDialog(self._panel, "Choose file")

            if ret == JFileChooser.APPROVE_OPTION:
                self._sql_file = chooseFile.getSelectedFile().getPath()
            else:
                self._sql_file = None
            self._text_field_sql_file.setText("" + self._sql_file)
        except Exception as e:
            print(e)
 def _import(actionEvent):
     openDialog = JFileChooser()
     openDialog.setFileFilter(
         FileNameExtensionFilter(pageImporter.fileType,
                                 [pageImporter.filePattern]))
     response = openDialog.showDialog(component, 'Import')
     if response == JFileChooser.APPROVE_OPTION:
         sf = openDialog.getSelectedFile()
         if sf is not None:
             filename = sf.getPath()
             if filename is not None:
                 pageName = os.path.splitext(filename)[0]
                 pageName = os.path.split(pageName)[1]
                 t1 = datetime.now()
                 page = pageImporter.importPage(pageName, filename)
                 t2 = datetime.now()
                 if page is not None:
                     print 'ProjectEditor.View: IMPORT TIME = %s' % (
                         t2 - t1, )
                     handleImportedPageFn(page)
Example #39
0
    def _save_model(self, e):
        """ Saves the current Aslan++ model and concretization file. """
        try:
            chooseFile = JFileChooser()
            filter_ = FileNameExtensionFilter("txt files", ["txt"])
            chooseFile.addChoosableFileFilter(filter_)

            ret = chooseFile.showDialog(self._panel, "Choose file")

            if ret == JFileChooser.APPROVE_OPTION:
                self._model_name = chooseFile.getSelectedFile().getPath()
                with open("{}.aslan++".format(self._model_name), "w") as f:
                    skeleton = self._jfxp_aslanpp._editor.getText()
                    skeleton = skeleton.replace("@filename",
                                                basename(self._model_name))
                    f.write(skeleton)
                print("model created")

                with open("{}.txt".format(self._model_name), "w") as f:
                    f.write(self._jfxp_concretization._editor.getText())

        except Exception as e:
            print(e)
Example #40
0
class BurpExtender(IBurpExtender, ITab, IHttpListener,
                   IMessageEditorController, AbstractTableModel,
                   IContextMenuFactory, IScannerCheck):
    name = "Femida XSS"
    conf_path = "./config.py"
    _jTabbedPane = JTabbedPane()
    _jPanel = JPanel()
    _jAboutPanel = JPanel()
    _jPanelConstraints = GridBagConstraints()
    _jLabelParameters = None
    _jTextFieldParameters = None
    _jLabelTechniques = None
    _jTextFieldURL = None
    _jLabelFuzzFactor = None
    _jTextFieldFuzzFactor = None
    _jLabelAdditionalCmdLine = None
    _jTextFieldAdditionalCmdLine = None
    _jButtonSetCommandLine = None
    _jLabelAbout = None
    _overwriteHeader = False
    _overwriteParam = False
    _forkRequestParam = False

    def doActiveScan(self, baseRequestResponse, insertionPoint):
        scan_issues = []
        try:
            requestString = str(baseRequestResponse.getRequest().tostring())
            newRequestString = self.prepareRequest(requestString)

            vulnerable, verifyingRequestResponse = self.quickCheckScan(
                newRequestString, baseRequestResponse)

        except Exception as msg:
            print(msg)

        return []

    def quickCheckScan(self, preparedRequest, requestResponse):
        check = self._callbacks.makeHttpRequest(
            requestResponse.getHttpService(),
            self._helpers.stringToBytes(preparedRequest))
        vulner = self._helpers.analyzeResponse(
            check.getResponse()).getStatusCode() == 200
        return vulner, check

    #
    # implement IBurpExtender
    #
    def registerExtenderCallbacks(self, callbacks):
        self._callbacks = callbacks
        self._helpers = callbacks.getHelpers()
        self._callbacks.setExtensionName(self.name)
        self._callbacks.registerScannerCheck(self)

        self._dictPayloads = {}
        self._dictHeaders = {}
        self._dictParams = {}
        self.status_flag = False

        self.jfc = JFileChooser("./")
        self.jfc.setDialogTitle("Upload Payloads")
        self.jfc.setFileFilter(FileNameExtensionFilter("TXT file", ["txt"]))

        self._layout = GridBagLayout()
        self._jPanel.setLayout(self._layout)

        self._jLabelTechniques = JLabel("Press to start:")
        self.createAnyView(self._jLabelTechniques, 0, 0, 3, 1,
                           Insets(0, 0, 10, 0))

        self.submitSearchButton = swing.JButton(
            'Run proxy', actionPerformed=self.active_flag)
        self.submitSearchButton.setBackground(Color.WHITE)
        self.createAnyView(self.submitSearchButton, 3, 0, 6, 1,
                           Insets(0, 0, 10, 0))

        self._jPanel.setBounds(0, 0, 1000, 1000)
        self._jLabelTechniques = JLabel("Your URL (my.burpcollaborator.net):")
        self.createAnyView(self._jLabelTechniques, 0, 1, 3, 1,
                           Insets(0, 0, 10, 0))

        self._jTextFieldURL = JTextField("", 30)
        self._jTextFieldURL.addActionListener(self.setCallbackUrl)
        self.createAnyView(self._jTextFieldURL, 3, 1, 5, 1,
                           Insets(0, 0, 10, 0))

        self._forkRequestButton = swing.JButton(
            'Parallel Request', actionPerformed=self.forkRequest)
        self._forkRequestButton.setBackground(Color.WHITE)
        self.createAnyView(self._forkRequestButton, 8, 1, 1, 1,
                           Insets(0, 0, 10, 0))

        self._tableModelPayloads = DefaultTableModel()
        self._tableModelPayloads.addColumn("Payload")
        self._tableModelPayloads.addColumn("Active")

        self._tableModelHeaders = DefaultTableModel()
        self._tableModelHeaders.addColumn("Header")
        self._tableModelHeaders.addColumn("Active")

        self._tableModelParams = DefaultTableModel()
        self._tableModelParams.addColumn("Parameter")
        self._tableModelParams.addColumn("Active")

        self._payloadTable = self.createAnyTable(self._tableModelPayloads, 1,
                                                 Dimension(300, 200))
        self.createAnyView(self._payloadTable, 0, 2, 3, 1, Insets(0, 0, 0, 10))

        self._headerTable = self.createAnyTable(self._tableModelHeaders, 2,
                                                Dimension(300, 200))
        self.createAnyView(self._headerTable, 3, 2, 3, 1, Insets(0, 0, 0, 10))

        self._paramTable = self.createAnyTable(self._tableModelParams, 3,
                                               Dimension(300, 200))
        self.createAnyView(self._paramTable, 6, 2, 3, 1, Insets(0, 0, 0, 0))

        deletePayloadButton = swing.JButton(
            'Delete', actionPerformed=self.deleteToPayload)
        deletePayloadButton.setBackground(Color.WHITE)
        self.createAnyView(deletePayloadButton, 0, 3, 1, 1, Insets(3, 0, 0, 0))

        deletePayloadButton = swing.JButton(
            'Upload', actionPerformed=self.uploadToPayload)
        deletePayloadButton.setBackground(Color.WHITE)
        self.createAnyView(deletePayloadButton, 1, 3, 1, 1, Insets(3, 0, 0, 0))

        addPayloadButton = swing.JButton('Add',
                                         actionPerformed=self.addToPayload)
        addPayloadButton.setBackground(Color.WHITE)
        self.createAnyView(addPayloadButton, 2, 3, 1, 1, Insets(3, 0, 0, 10))

        deleteHeaderButton = swing.JButton('Delete',
                                           actionPerformed=self.deleteToHeader)
        deleteHeaderButton.setBackground(Color.WHITE)
        self.createAnyView(deleteHeaderButton, 3, 3, 1, 1, Insets(3, 0, 0, 0))

        self._overwriteHeaderButton = swing.JButton(
            'Overwrite', actionPerformed=self.overwriteHeader)
        self._overwriteHeaderButton.setBackground(Color.WHITE)
        self.createAnyView(self._overwriteHeaderButton, 4, 3, 1, 1,
                           Insets(3, 0, 0, 0))

        addHeaderButton = swing.JButton('Add',
                                        actionPerformed=self.addToHeader)
        addHeaderButton.setBackground(Color.WHITE)
        self.createAnyView(addHeaderButton, 5, 3, 1, 1, Insets(3, 0, 0, 10))

        deleteParamsButton = swing.JButton('Delete',
                                           actionPerformed=self.deleteToParams)
        deleteParamsButton.setBackground(Color.WHITE)
        self.createAnyView(deleteParamsButton, 6, 3, 1, 1, Insets(3, 0, 0, 0))

        self._overwriteParamButton = swing.JButton(
            'Overwrite', actionPerformed=self.overwriteParam)
        self._overwriteParamButton.setBackground(Color.WHITE)
        self.createAnyView(self._overwriteParamButton, 7, 3, 1, 1,
                           Insets(3, 0, 0, 0))

        addParamsButton = swing.JButton('Add',
                                        actionPerformed=self.addToParams)
        addParamsButton.setBackground(Color.WHITE)
        self.createAnyView(addParamsButton, 8, 3, 1, 1, Insets(3, 0, 0, 0))

        self._resultsTextArea = swing.JTextArea()
        resultsOutput = swing.JScrollPane(self._resultsTextArea)
        resultsOutput.setMinimumSize(Dimension(800, 200))
        self.createAnyView(resultsOutput, 0, 4, 9, 1, Insets(10, 0, 0, 0))

        self.clearSearchButton = swing.JButton(
            'Clear Search Output', actionPerformed=self.clearOutput)
        self.createAnyView(self.clearSearchButton, 3, 6, 3, 1,
                           Insets(3, 0, 0, 0))

        self._callbacks.customizeUiComponent(self._jPanel)
        self._callbacks.addSuiteTab(self)
        self.starterPack()

        self._callbacks.registerHttpListener(self)
        self._callbacks.registerContextMenuFactory(self)

        return

    def createAnyTable(self, table_model, table_number, min_size):
        _table = JTable(table_model)
        _table.setAutoResizeMode(JTable.AUTO_RESIZE_ALL_COLUMNS)
        for i in range(2):
            column = _table.getColumnModel().getColumn(i)
            if i == 0:
                column.setPreferredWidth(250)
            else:
                column.setPreferredWidth(50)

        _scrolltable = JScrollPane(_table)
        _scrolltable.setMinimumSize(min_size)
        return _scrolltable

    def insertAnyTable(self, table, data):
        def detectTable(table):
            name = table.getColumnName(0)
            if name == 'Payloads':
                return 0
            elif name == 'Headers':
                return 1
            elif name == 'Parameters':
                return 2

        tableNum = detectTable(table)
        new_data = [str(x) for x in data]
        table.insertRow(table.getRowCount(), new_data)
        return table.getRowCount()

    def replaceLine(self, file_path, new_line):
        from tempfile import mkstemp
        from shutil import move
        from os import fdopen, remove
        #Create temp file
        fh, abs_path = mkstemp()
        with fdopen(fh, 'w') as new_file:
            with open(file_path) as old_file:
                for line in old_file:
                    a = re.findall('^Callback_url[ =]+(.+)$', line)
                    if a:
                        for k in a:
                            temp = k.replace("\'", "").replace("\"", "")
                            new_file.write(line.replace(temp, new_line))
                    else:
                        new_file.write(line)
        #Remove original file
        remove(file_path)
        #Move new file
        move(abs_path, file_path)

    def createAnyView(self, _component, gridx, gridy, gridwidth, gridheight,
                      insets):
        self._jPanelConstraints.fill = GridBagConstraints.HORIZONTAL
        self._jPanelConstraints.gridx = gridx
        self._jPanelConstraints.gridy = gridy
        self._jPanelConstraints.gridwidth = gridwidth
        self._jPanelConstraints.gridheight = gridheight
        self._jPanelConstraints.insets = insets
        self._jPanel.add(_component, self._jPanelConstraints)

    def createMenuItems(self, contextMenuInvocation):
        context = contextMenuInvocation.getInvocationContext()
        filterMenu = JMenu("Femida XSS")
        self._contextMenuData = contextMenuInvocation
        if (context == 0 or context == 1 or context == 2 or context == 3
                or context == 8 or context == 9):
            filterMenu.add(
                JMenuItem("Add to Headers",
                          actionPerformed=self.addToHeadersItem))
            filterMenu.add(
                JMenuItem("Add to Parameters",
                          actionPerformed=self.addToParametersItem))
            return Arrays.asList(filterMenu)
        return Arrays.asList([])

    def addToHeadersItem(self, event):
        start, end = self._contextMenuData.getSelectionBounds()
        message = self._contextMenuData.getSelectedMessages()[0]
        ctx = self._contextMenuData.getInvocationContext()

        if ctx == 0 or ctx == 2:
            message = message.getRequest()
        elif ctx == 1 or ctx == 3:
            message = message.getResponse()
        else:
            print(ctx)
            return
        try:
            selected_text = self._helpers.bytesToString(message)[start:end]
            self.insertAnyTable(self._tableModelHeaders,
                                [str(selected_text), '1'])
        except Exception:
            pass

    def addToParametersItem(self, event):
        start, end = self._contextMenuData.getSelectionBounds()
        message = self._contextMenuData.getSelectedMessages()[0]
        ctx = self._contextMenuData.getInvocationContext()

        if ctx == 0 or ctx == 2:
            message = message.getRequest()
        elif ctx == 1 or ctx == 3:
            message = message.getResponse()
        else:
            print(ctx)
            return
        try:
            selected_text = self._helpers.bytesToString(message)[start:end]
            self.insertAnyTable(self._tableModelParams,
                                [str(selected_text), '1'])
        except Exception:
            pass

    def starterPack(self):
        self.addFromFileAsync(config.Payloads, self._tableModelPayloads)
        self.addFromFileAsync(config.Headers, self._tableModelHeaders)
        self.addFromFileAsync(config.Parameters, self._tableModelParams)
        self._jTextFieldURL.setText(config.Callback_url)
        self._tableModelPayloads.addTableModelListener(
            MyTableModelListener(self._tableModelPayloads, self,
                                 self._dictPayloads, config.Payloads))
        self._tableModelHeaders.addTableModelListener(
            MyTableModelListener(self._tableModelHeaders, self,
                                 self._dictHeaders, config.Headers))
        self._tableModelParams.addTableModelListener(
            MyTableModelListener(self._tableModelParams, self,
                                 self._dictParams, config.Parameters))

    def setCallbackUrl(self, event):
        self.replaceLine(self.conf_path, self._jTextFieldURL.getText())
        self.appendToResults('New url={} saved.'.format(
            self._jTextFieldURL.getText()))

    def addToPayload(self, button):
        self.insertAnyTable(self._tableModelPayloads, ['', '1'])

    def addToHeader(self, button):
        self.insertAnyTable(self._tableModelHeaders, ['', '1'])

    def addToParams(self, button):
        self.insertAnyTable(self._tableModelParams, ['', '1'])

    def uploadToPayload(self, button):
        self._returnFileChooser = self.jfc.showDialog(None, "Open")
        if (self._returnFileChooser == JFileChooser.APPROVE_OPTION):
            selectedFile = self.jfc.getSelectedFile()
            self.fileUpload(selectedFile, self._tableModelPayloads)

    def deleteToPayload(self, button):
        try:
            val = self._tableModelPayloads.getValueAt(
                self._tableModelPayloads.getRowCount() - 1, 0)
            self._tableModelPayloads.removeRow(
                self._tableModelPayloads.getRowCount() - 1)
            self._dictPayloads.pop(val)
            self.saveToFileAsync(config.Payloads, self._dictPayloads)
        except Exception as msg:
            # print(msg)
            pass

    def deleteToHeader(self, button):
        try:
            val = self._tableModelHeaders.getValueAt(
                self._tableModelHeaders.getRowCount() - 1, 0)
            self._tableModelHeaders.removeRow(
                self._tableModelHeaders.getRowCount() - 1)
            self._dictHeaders.pop(val)
            self.saveToFileAsync(config.Headers, self._dictHeaders)
        except Exception as msg:
            # print(msg)
            pass

    def deleteToParams(self, button):
        try:
            val = self._tableModelParams.getValueAt(
                self._tableModelParams.getRowCount() - 1, 0)
            self._tableModelParams.removeRow(
                self._tableModelParams.getRowCount() - 1)
            self._dictParams.pop(val)
            self.saveToFileAsync(config.Parameters, self._dictParams)
        except Exception as msg:
            # print(msg)
            pass

    def clearOutput(self, button):
        self._resultsTextArea.setText("")

    def fileUpload(self, path, table):
        with open(str(path), "r") as f:
            for line in f:
                self.insertAnyTable(table, [str(line), '1'])

    def active_flag(self, button):
        if not self.status_flag:
            self.status_flag = True
            self.submitSearchButton.setBackground(Color.GRAY)
            self.appendToResults("Proxy start...\n")
        else:
            self.status_flag = False
            self.submitSearchButton.setBackground(Color.WHITE)
            self.appendToResults("Proxy stop...\n")

    def overwriteHeader(self, button):
        if not self._overwriteHeader:
            self._overwriteHeader = True
            self._overwriteHeaderButton.setBackground(Color.GRAY)
        else:
            self._overwriteHeader = False
            self._overwriteHeaderButton.setBackground(Color.WHITE)

    def overwriteParam(self, button):
        if not self._overwriteParam:
            self._overwriteParam = True
            self._overwriteParamButton.setBackground(Color.GRAY)
        else:
            self._overwriteParam = False
            self._overwriteParamButton.setBackground(Color.WHITE)

    def forkRequest(self, button):
        if not self._forkRequestParam:
            self._forkRequestParam = True
            self._forkRequestButton.setBackground(Color.GRAY)
        else:
            self._forkRequestParam = False
            self._forkRequestButton.setBackground(Color.WHITE)

    def prepareRequest(self, requestString, messageInfo=None):
        requestString = str(requestString)
        listHeader = re.findall('([\w-]+):\s?(.*)', requestString)
        dictRealHeaders = {x[0].lower(): x[1] for x in listHeader}

        selectedPayloads = {}
        for ind, k in enumerate(self._dictPayloads):
            if self._dictPayloads[k] == '1':
                selectedPayloads[k] = '1'
            else:
                continue

        for index, key in enumerate(self._dictHeaders):
            if key.lower() in dictRealHeaders.keys(
            ) and self._dictHeaders[key] == '1':
                if len(self._dictPayloads.keys()) == 0:
                    pass
                elif self._overwriteHeader:
                    payload = random.choice(selectedPayloads.keys())
                    payload = payload.replace(r"{URL}",
                                              self._jTextFieldURL.getText(), 1)
                    requestString = requestString.replace(
                        dictRealHeaders.get(key.lower()), payload, 1)
                elif not self._overwriteHeader:
                    payload = random.choice(selectedPayloads.keys())
                    payload = payload.replace(r"{URL}",
                                              self._jTextFieldURL.getText(), 1)
                    payload = dictRealHeaders.get(key.lower()) + payload
                    requestString = requestString.replace(
                        dictRealHeaders.get(key.lower()), payload, 1)
            else:
                pass

        for index, key in enumerate(self._dictParams):
            analyzed = self._helpers.analyzeRequest(requestString.encode())
            param = analyzed.getParameters()
            dictRealParams = {
                x.getName().lower():
                [x.getValue(),
                 x.getValueStart(),
                 x.getValueEnd()]
                for x in param
            }
            if key.lower() in dictRealParams.keys(
            ) and self._dictParams[key] == '1':
                if len(self._dictPayloads.keys()) == 0:
                    pass
                elif self._overwriteParam:
                    payload = random.choice(selectedPayloads.keys())
                    payload = payload.replace(r"{URL}",
                                              self._jTextFieldURL.getText(), 1)
                    start_word = dictRealParams[key.lower()][1]
                    end_word = dictRealParams[key.lower()][2]
                    requestString = requestString[:
                                                  start_word] + payload + requestString[
                                                      end_word:]

                elif not self._overwriteParam:
                    payload = random.choice(selectedPayloads.keys())
                    payload = payload.replace(r"{URL}",
                                              self._jTextFieldURL.getText(), 1)
                    payload = dictRealParams[key.lower()][0] + payload
                    start_word = dictRealParams[key.lower()][1]
                    end_word = dictRealParams[key.lower()][2]
                    requestString = requestString[:
                                                  start_word] + payload + requestString[
                                                      end_word:]
            else:
                pass
        return requestString

    def processHttpMessage(self, toolFlag, messageIsRequest, messageInfo):
        if not self.status_flag:
            return
        # only process requests
        if not messageIsRequest:
            return

        if self._forkRequestParam:
            requestString = messageInfo.getRequest().tostring()
            # SOOOO HARD FIX! It should be better
            if requestString[0] == '@':
                messageInfo.setRequest(
                    self._helpers.stringToBytes(requestString[1:]))
            else:
                newRequestString = self.prepareRequest(requestString,
                                                       messageInfo)
                self.appendToResults('Parallel Request:')
                self.appendToResults(newRequestString.encode())
                newRequestString = '@' + newRequestString
                func = self._callbacks.makeHttpRequest
                thread = Thread(
                    target=func,
                    args=(messageInfo.getHttpService(),
                          self._helpers.stringToBytes(newRequestString)))
                thread.start()
        else:
            requestString = messageInfo.getRequest().tostring()
            newRequestString = self.prepareRequest(requestString, messageInfo)
            self.appendToResults(newRequestString.encode())
            messageInfo.setRequest(
                self._helpers.stringToBytes(newRequestString))

    # Fnction to provide output to GUI
    def appendToResults(self, s):
        def appendToResults_run(s):
            self._resultsTextArea.append(s)
            self._resultsTextArea.append('\n')

        swing.SwingUtilities.invokeLater(
            PyRunnable(appendToResults_run, str(s)))

    def addFromFileAsync(self, file, table):
        def addFromFile_run(file, table):
            if os.path.exists(file):
                with open(file, 'r') as f:
                    for row in f.readlines():
                        if row != '':
                            temp = row[:-1] if row[-1] == '\n' else row
                            self.insertAnyTable(table, [str(temp), '1'])

        swing.SwingUtilities.invokeLater(
            PyRunnable(addFromFile_run, file, table))

    def saveToFileAsync(self, file, data, isAppend=False):
        def saveToFile_run(file, data, isAppend):
            isAppend = 'w'
            with open(file, isAppend) as f:
                for i, k in enumerate(data):
                    f.write("{}\n".format(k))
                f.seek(-1, os.SEEK_END)
                f.truncate()

        swing.SwingUtilities.invokeLater(
            PyRunnable(saveToFile_run, file, data, isAppend))

    def getTabCaption(self):
        return self.name

    def getUiComponent(self):
        return self._jPanel
Example #41
0
 def export(self, event):
     chooseFile = JFileChooser()
     ret = chooseFile.showDialog(self.logPane, "Choose file")
     filename = chooseFile.getSelectedFile().getCanonicalPath()
     print("\n" + "Export to : " + filename)
     open(filename, 'w', 0).write(self.outputTxtArea.text)
 def exportPy(self,event):
     chooseFile = JFileChooser()
     ret = chooseFile.showDialog(self._mainpane, "Choose file")
     filename = chooseFile.getSelectedFile().getCanonicalPath()
     self._stdout.println("Export to : " + filename )
     open(filename, 'w', 0).write( self._pyViewer.getText() )
Example #43
0
    def restoreState(self):
        parentFrame = JFrame()
        fileChooser = JFileChooser()
        fileChooser.setDialogTitle("State import file")
        userSelection = fileChooser.showDialog(parentFrame, "Restore")

        if userSelection == JFileChooser.APPROVE_OPTION:
            importFile = fileChooser.getSelectedFile()

            with open(importFile.getAbsolutePath(), 'r') as csvfile:

                csvreader = csv.reader(csvfile, delimiter='\t', quotechar='|')

                for row in csvreader:

                    tempRequestResponseHost = row[0]
                    tempRequestResponsePort = row[1]
                    tempRequestResponseProtocol = row[2]
                    tempRequestResponseRequest = base64.b64decode(row[3])
                    tempRequestResponseResponse = base64.b64decode(row[4])

                    tempRequestResponseHttpService = self._extender._helpers.buildHttpService(
                        tempRequestResponseHost, int(tempRequestResponsePort),
                        tempRequestResponseProtocol)
                    tempRequestResponse = IHttpRequestResponseImplementation(
                        tempRequestResponseHttpService,
                        tempRequestResponseRequest,
                        tempRequestResponseResponse)

                    tempOriginalRequestResponseHost = row[5]
                    tempOriginalRequestResponsePort = row[6]
                    tempOriginalRequestResponseProtocol = row[7]
                    tempOriginalRequestResponseRequest = base64.b64decode(
                        row[8])
                    tempOriginalRequestResponseResponse = base64.b64decode(
                        row[9])

                    tempOriginalRequestResponseHttpService = self._extender._helpers.buildHttpService(
                        tempOriginalRequestResponseHost,
                        int(tempOriginalRequestResponsePort),
                        tempOriginalRequestResponseProtocol)
                    tempOriginalRequestResponse = IHttpRequestResponseImplementation(
                        tempOriginalRequestResponseHttpService,
                        tempOriginalRequestResponseRequest,
                        tempOriginalRequestResponseResponse)

                    checkAuthentication = True
                    if row[10] != '':
                        tempUnauthorizedRequestResponseHost = row[10]
                        tempUnauthorizedRequestResponsePort = row[11]
                        tempUnauthorizedRequestResponseProtocol = row[12]
                        tempUnauthorizedRequestResponseRequest = base64.b64decode(
                            row[13])
                        tempUnauthorizedRequestResponseResponse = base64.b64decode(
                            row[14])
                        tempUnauthorizedRequestResponseHttpService = self._extender._helpers.buildHttpService(
                            tempUnauthorizedRequestResponseHost,
                            int(tempUnauthorizedRequestResponsePort),
                            tempUnauthorizedRequestResponseProtocol)
                        tempUnauthorizedRequestResponse = IHttpRequestResponseImplementation(
                            tempUnauthorizedRequestResponseHttpService,
                            tempUnauthorizedRequestResponseRequest,
                            tempUnauthorizedRequestResponseResponse)
                    else:
                        checkAuthentication = False
                        tempUnauthorizedRequestResponse = None

                    tempEnforcementStatus = row[15]
                    tempEnforcementStatusUnauthorized = row[16]

                    self._extender._lock.acquire()

                    row = self._extender._log.size()

                    if checkAuthentication:
                        self._extender._log.add(
                            LogEntry(
                                self._extender.currentRequestNumber,
                                self._extender._callbacks.
                                saveBuffersToTempFiles(tempRequestResponse),
                                self._extender._helpers.analyzeRequest(
                                    tempRequestResponse).getMethod(),
                                self._extender._helpers.analyzeRequest(
                                    tempRequestResponse).getUrl(),
                                self._extender._callbacks.
                                saveBuffersToTempFiles(
                                    tempOriginalRequestResponse),
                                tempEnforcementStatus,
                                self._extender._callbacks.
                                saveBuffersToTempFiles(
                                    tempUnauthorizedRequestResponse),
                                tempEnforcementStatusUnauthorized))
                    else:
                        self._extender._log.add(
                            LogEntry(
                                self._extender.currentRequestNumber,
                                self._extender._callbacks.
                                saveBuffersToTempFiles(tempRequestResponse),
                                self._extender._helpers.analyzeRequest(
                                    tempRequestResponse).getMethod(),
                                self._extender._helpers.analyzeRequest(
                                    tempRequestResponse).getUrl(),
                                self._extender._callbacks.
                                saveBuffersToTempFiles(
                                    tempOriginalRequestResponse),
                                tempEnforcementStatus, None,
                                tempEnforcementStatusUnauthorized))

                    SwingUtilities.invokeLater(
                        UpdateTableEDT(self._extender, "insert", row, row))
                    self._extender.currentRequestNumber = self._extender.currentRequestNumber + 1
                    self._extender._lock.release()

                lastRow = self._extender._log.size()
                if lastRow > 0:
                    cookies = self._extender.getCookieFromMessage(
                        self._extender._log.get(lastRow - 1)._requestResponse)
                    if cookies:
                        self._extender.lastCookies = cookies
                        self._extender.fetchButton.setEnabled(True)