Esempio n. 1
0
class win(JFrame):
    def __init__(self, title="Consumo Electrico"):
        JFrame(title)
        self.setLayout(None)
        self.setBounds(10, 10, 300, 180)
        self.show()
        self.build()

    def build(self):
        self.label = JLabel("Cup")
        self.label.setBounds(120, 10, 45, 15)
        self.label2 = JLabel("KWh")
        self.label2.setBounds(20, 10, 45, 15)
        self.label3 = JLabel()
        self.label3.setBounds(120, 30, 55, 15)
        self.textfield = JTextField()
        self.textfield.setBounds(15, 30, 75, 20)
        self.textfield.addActionListener(lambda x: self.label3.setText(
            str(calculate(self.textfield.getText()))))
        button = JButton("Calcular")
        button.setBounds(10, 55, 290, 35)
        button.addActionListener(lambda x: self.label3.setText(
            str(calculate(self.textfield.getText()))))

        for var in [
                self.label, self.label2, self.label3, self.textfield, button
        ]:
            self.add(var)
Esempio n. 2
0
    def _buildInspectorGUI(self, beh):
        """Builds the inspector GUI for the given behaviour object.
        
        @param beh: The behaviour object.
        @type beh: C{Behaviour}
        """
        inspectors = beh.getInspectors()
        # ignore behaviours that don't provide any inspectors
        if not inspectors:
            return []

        # class to modify the behaviour state from the GUI
        class UpdateBehaviourState(ActionListener):
            def __init__(self, modifier, component):
                self._modifier = modifier
                self._component = component

            def actionPerformed(self, evt):
                self._modifier(str(self._component.getText()))

        # build the list
        propertyList = LabelledList(beh.getName())
        properties = []
        for inspector in inspectors:
            # create textfield if mutator is available
            component = None
            state_str = str(inspector[1]())
            if inspector[2]:
                component = JTextField(state_str)
                # react on changes of values by the user
                component.addActionListener(
                    UpdateBehaviourState(inspector[2], component))
            else:
                component = JLabel(state_str)
            properties.append((component, inspector[1]))
            propertyList.addLabelled("%s " % inspector[0], component)
            # Needs to create an actual list of properties of class Properties
            #propertyList.add(None,
            #                 JLabel("%s " % inspector[0]),
            #                 PropertyInspector(properties, index, guistate),
            #                 component,
            #                 None)
        # add it to the GUI and return the list of properties with its
        # accessors and components
        # need to restrict maximum size to allow for glue at end of panel to
        # expand
        propertyList.setMaximumSize(
            Dimension(int(propertyList.getMaximumSize().getWidth()),
                      int(propertyList.getMinimumSize().getHeight())))
        self.add(propertyList)
        return properties
Esempio n. 3
0
 def build(self):
     #labels
     cl = JLabel("Celcius")
     cl.setBounds(10, 10, 60, 20)
     fl = JLabel("Farenheit")
     fl.setBounds(120, 10, 60, 20)
     kl = JLabel("Kelvin")
     kl.setBounds(230, 10, 60, 20)
     #celcius textfield
     c = JTextField()
     c.setBounds(10, 40, 60, 20)
     c.addActionListener(lambda x: log(x))
     #farenheit textfield
     f = JTextField()
     f.setBounds(120, 40, 60, 20)
     f.addActionListener(lambda x: log(x))
     #kelvin textfield
     k = JTextField()
     k.setBounds(230, 40, 60, 20)
     k.addActionListener(lambda x: log(x))
     #buttons
     cv = JButton("Convert")
     cv.addActionListener(lambda x: self.convert(x))
     cv.setBounds(10, 70, 300 - 10, 30)
     clean = JButton("Clean")
     clean.addActionListener(lambda x: self.clean())
     clean.setBounds(10, 110, 300 - 10, 30)
     #add vars to frame
     list(map(lambda x: self.add(x), [cl, kl, fl, c, f, k, cv, clean]))
     self.k = k
     self.c = c
     self.f = f
     self.textfields = {self.c, self.f, self.k}
Esempio n. 4
0
class EmulatorComponentProvider(ComponentProviderAdapter):
    def __init__(self, plugin):
        super(EmulatorComponentProvider,
              self).__init__(plugin.getTool(), "Emulator", "emulate_function")
        self.plugin = plugin

        self.panel = JPanel(GridBagLayout())
        c = GridBagConstraints()
        c.fill = GridBagConstraints.HORIZONTAL
        c.gridy = 0

        c.gridx = 0
        c.weightx = 0.8
        self.panel_label = JLabel("")
        self.panel.add(self.panel_label, c)

        c.gridx = 1
        c.weightx = 0.2
        self.panel_btn = JButton("Start")
        self.panel_btn.addActionListener(EmulatorBtnAction(self))
        self.panel.add(self.panel_btn, c)

        c.gridy = 1
        c.gridx = 0
        c.gridwidth = 2
        self.panel_input = JTextField()
        self.panel_input.addActionListener(EmulatorInputAction(self))
        self.panel.add(self.panel_input, c)

        self.setStatus("Stopped")

    def getComponent(self):
        return self.panel

    def setStatus(self, status):
        self.panel_label.setText(status)
Esempio n. 5
0
class CustomCellEditor(TreeCellEditor, ActionListener):
    """Renders the various tree edit controls (checkbox, tristate checkbox, text box etc.)"""
    def __init__(self, tree):
        TreeCellEditor.__init__(self)
        self.editor = None
        self.tree = tree

        flowLayout = FlowLayout(FlowLayout.LEFT, 0, 0)

        self.cbPanel = JPanel(flowLayout)
        self.cb = JCheckBox(actionPerformed=self.checked)
        self.cbPanel.add(self.cb)
        self.cbLabel = JLabel()
        self.cbPanel.add(self.cbLabel)

        self.tcbPanel = JPanel(flowLayout)
        self.tcb = TristateCheckBox(self.checked)
        self.tcbPanel.add(self.tcb)
        self.tcbLabel = JLabel()
        self.tcbPanel.add(self.tcbLabel)

        self.rbPanel = JPanel(flowLayout)
        self.rb = JRadioButton(actionPerformed=self.checked)
        self.rbPanel.add(self.rb)
        self.rbLabel = JLabel()
        self.rbPanel.add(self.rbLabel)

        self.tfPanel = JPanel(flowLayout)
        self.tfLabel = JLabel()
        self.tfPanel.add(self.tfLabel)
        self.tf = JTextField()
        self.tf.setColumns(12)
        self.tf.addActionListener(self)
        self.tfPanel.add(self.tf)

    def addCellEditorListener(self, l):
        """Register for edit events"""
        self.listener = l

    def isCellEditable(self, event):
        if event != None and isinstance(
                event.getSource(), JTree) and isinstance(event, MouseEvent):
            tree = event.getSource()
            path = tree.getPathForLocation(event.getX(), event.getY())
            userData = path.getLastPathComponent().getUserObject()
            if isinstance(userData,
                          TreeNodeData) and (not userData.getNodeType().isType(
                              [NodeType._comment, NodeType._menu
                               ])) and (userData.getVisible() > 0):
                return True

        return False

    def shouldSelectCell(self, event):
        # log.info("shouldSelectCell")
        return True

    def cancelCellEditing(self):
        # log.info("Cancel editing, please!")
        # super(CustomCellEditor, self).cancelCellEditing()
        pass

    def stopCellEditing(self):
        # log.info("stopCellEditing")
        if self.nodeData.getNodeType().isType([NodeType._text]):
            # log.info("stopCellEditing for sure!")
            self.nodeData.setValue(str(self.tf.getText()))
        return True

    def getTreeCellEditorComponent(self, tree, value, selected, expanded, leaf,
                                   row):
        """Return a swing edit control appropriate for the node type of the supplied value"""
        self.nodeData = self.getNodeUserData(value)
        if self.nodeData:
            text = self.nodeData.getText()
            t = self.nodeData.getNodeType()

            # Boolean checkbox
            if t.isType([NodeType._bool]):
                self.editor = self.cbPanel
                self.cbLabel.setText(text)
                if self.nodeData.getTriValue() > 0:
                    self.cb.setSelected(True)
                else:
                    self.cb.setSelected(False)

            # Tristate checkbox
            elif t.isType([NodeType._tri]):
                # log.info("getTreeCellEditorComponent tristate")
                self.editor = self.tcbPanel
                self.tcbLabel.setText(text)
                self.tcb.setTriState(self.nodeData.getTriValue())

            # Radio button
            elif t.isType([NodeType._radio]):
                self.editor = self.rbPanel
                self.rbLabel.setText(text)
                if self.nodeData.getTriValue() > 0:
                    self.rb.setSelected(True)
                else:
                    self.rb.setSelected(False)

            # Text field
            elif t.isType([NodeType._text]):
                self.editor = self.tfPanel
                self.tfLabel.setText(str(self.nodeData.getText()) + ":")
                self.tf.setText(str(self.nodeData.getValue()))

            else:
                self.editor = self.tcb
                self.editor.setText(text)

        return self.editor

    def getNodeUserData(self, value):
        """Gets the TreeNodeData from the tree node"""
        if isinstance(value, DefaultMutableTreeNode):
            nodeData = value.getUserObject()
            if isinstance(nodeData, TreeNodeData):
                return nodeData

        return None

    def getCellEditorValue(self):
        newNode = TreeNodeData(self.nodeData.knode, self.tree)

        if isinstance(self.editor, JTextField):
            newNode.setValue(str(self.editor.getText()))

        return newNode

    def checked(self, e):
        """Updates the node data when a checkbox has been clicked"""
        control = e.getSource()

        if isinstance(control, TristateCheckBox):
            # log.info("tristate checked")
            self.nodeData.setTriValue(control.getTriState())
        else:
            # log.info("checkbox checked")
            if control.isSelected():
                self.nodeData.setValue(2)
            else:
                self.nodeData.setValue(0)

    def actionPerformed(self, event):
        """ ENTER pressed in text field, stop editing."""
        tf = event.getSource()
        self.listener.editingStopped(ChangeEvent(tf))
Esempio n. 6
0
class BobGui(JFrame):
    def choose_dir_al(self, e):

        dc = DirectoryChooser('Choose a bob_py experiment folder')
        self.dir_path = dc.getDirectory()

        self.choose_dir_textField.setText(self.dir_path)

    def textField_al(self, e):
        self.dir_path = self.choose_dir_textField.getText()

    def run_button_al(self, e):
        print('run button al')
        self.exper = bob_py.Exper(self.dir_path)
        # self.exper.hsegs()[0].nuc_bin().show()
        self.make_tree()

    def make_tree(self):
        root = DefaultMutableTreeNode(self.exper.name)
        for hseg in self.exper.hsegs():
            hseg_node = DefaultMutableTreeNode(hseg.name)
            root.add(hseg_node)
            for file_suf in hseg.file_dict():
                hseg_node.add(DefaultMutableTreeNode(file_suf))
        self.tree = JTree(root)
        scrollPane = JScrollPane()
        scrollPane.getViewport().setView((self.tree))
        # scrollPane.setPreferredSize(Dimension(300,250))

        tree_panel = JPanel()
        tree_panel.add(scrollPane)
        box_layout = BoxLayout(self.panel, BoxLayout.Y_AXIS)
        self.panel.setLayout(box_layout)
        self.panel.add(tree_panel)
        self.revalidate()

    def __init__(self):
        self.dir_path = ''

        self.panel = JPanel()
        box_layout = BoxLayout(self.panel, BoxLayout.Y_AXIS)
        self.panel.setLayout(box_layout)
        self.panel.setBorder(BorderFactory.createEmptyBorder(10, 10, 10, 10))

        self.choose_dir_label = JLabel('Experiment Folder:')
        self.choose_dir_textField = JTextField(30)
        self.choose_dir_textField.addActionListener(
            ActionListenerFactory(self, self.textField_al))
        self.choose_dir_button = JButton('open')
        self.choose_dir_button.addActionListener(
            ActionListenerFactory(self, self.choose_dir_al))

        self.choose_dir_panel = JPanel()
        self.choose_dir_panel.add(self.choose_dir_label)
        self.choose_dir_panel.add(self.choose_dir_textField)
        self.choose_dir_panel.add(self.choose_dir_button)

        self.panel.add(self.choose_dir_panel)

        # root = DefaultMutableTreeNode()

        # self.meta_data_mode_label = JLabel('Autogenerated meta_data file mode')
        # self.raw_stack_mode = JRadioButton('raw stack mode')
        # self.projection_mode = JRadioButton('projection files mode')
        #
        # self.meta_data_mode = ButtonGroup()
        # self.meta_data_mode.add(self.raw_stack_mode)
        # self.meta_data_mode.add(self.projection_mode)
        #
        # self.meta_data_mode_panel = JPanel(GridLayout(0, 1))
        # self.meta_data_mode_panel.add(self.meta_data_mode_label)
        # self.meta_data_mode_panel.add(self.raw_stack_mode)
        # self.meta_data_mode_panel.add(self.projection_mode)
        #
        # self.panel.add(self.meta_data_mode_panel)

        self.run_button = JButton('Run')
        self.run_button.addActionListener(
            ActionListenerFactory(self, self.run_button_al))
        self.panel.add(self.run_button)

        super(BobGui, self).__init__("BobPy")
        self.getContentPane().add(self.panel)
        self.pack()
        self.setLocationRelativeTo(None)
        self.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE)
        self.setVisible(True)
Esempio n. 7
0
class BobGui(JFrame):
    def choose_dir_al(self, e):

        dc = DirectoryChooser('Choose a bob_py experiment folder')
        self.dir_path = dc.getDirectory()

        self.choose_dir_textField.setText(self.dir_path)
        self.got_exper(self.dir_path)

    def textField_al(self, e):
        self.dir_path = self.choose_dir_textField.getText()
        self.got_exper(self.dir_path)

    def got_exper(self, dir_path):
        self.exper = bob_py.Exper(dir_path)
        self.make_tree()

    def make_tree(self):
        print('make_tree')
        root = DefaultMutableTreeNode(self.exper.name)

        sb = br.SimilarityBuilder()

        for hseg in self.exper.hsegs():
            all_file_dict = hseg.file_dict()
            all_file_dict.update(hseg.cell_file_dict())
            all_file_dict.update(hseg.bin_file_dict())
            sb.add_group(hseg.name, all_file_dict)

        simprofile, comparisons = sb.simprofile_comparison()

        sim_str = ''
        for val in simprofile:
            sim_str += str(val) + '\n'

        tp = JTextArea(sim_str)

        stp = JScrollPane()
        stp.getViewport().setView(tp)
        #
        # stp.setVerticalScrollBarPolicy(JScrollPane.VERTICAL_SCROLLBAR_ALWAYS);
        # stp.setPreferredSize(Dimension(250, 250));
        # tp.setPreferredSize(Dimension(250, 250))
        stp_panel = JPanel(BorderLayout())
        stp_panel.add(tp, BorderLayout.CENTER)

        # self.add(stp_panel, 'grow')

        for hseg in self.exper.hsegs():
            hseg_node = DefaultMutableTreeNode(hseg.name)
            root.add(hseg_node)
            if len(comparisons[hseg.name]) > 0:
                for definer, file_names in comparisons[hseg.name].items():
                    for file_name in file_names:
                        node_str = definer + ': ' + file_name
                        hseg_node.add(DefaultMutableTreeNode(node_str))
            # for file_suf in hseg.file_dict() :
            # hseg_node.add(DefaultMutableTreeNode(file_suf))

        self.tree = JTree(root)
        scrollPane = JScrollPane()
        scrollPane.getViewport().setView((self.tree))
        # scrollPan
        # scrollPane.setPreferredSize(Dimension(300,250))

        tree_panel = JPanel(BorderLayout())
        tree_panel.add(scrollPane, BorderLayout.CENTER)

        combo_panel = JPanel(GridLayout(0, 2, 10, 10))
        # combo_panel.setLayout(BoxLayout(combo_panel, BoxLayout.X_AXIS))
        combo_panel.add(stp_panel)  #, BorderLayout.LINE_START)
        combo_panel.add(tree_panel)  #, BorderLayout.LINE_END)
        self.panel.add(combo_panel)
        # self.add(scrollPane, 'grow')
        self.revalidate()

    def __init__(self):
        super(BobGui, self).__init__("BobPy")

        self.dir_path = ''

        # ml = MigLayout('fill')
        # self.setLayout(ml)
        self.panel = JPanel()
        self.panel.setBorder(BorderFactory.createEmptyBorder(10, 10, 10, 10))

        box_layout = BoxLayout(self.panel, BoxLayout.Y_AXIS)

        self.panel.setLayout(box_layout)

        self.choose_dir_label = JLabel('Experiment Folder:')
        self.choose_dir_textField = JTextField(20)
        self.choose_dir_textField.addActionListener(
            ActionListenerFactory(self, self.textField_al))
        self.choose_dir_button = JButton('open')
        self.choose_dir_button.addActionListener(
            ActionListenerFactory(self, self.choose_dir_al))

        self.choose_dir_panel = JPanel()
        self.choose_dir_panel.add(self.choose_dir_label)
        self.choose_dir_panel.add(self.choose_dir_textField)
        self.choose_dir_panel.add(self.choose_dir_button)

        self.panel.add(self.choose_dir_panel)

        self.add(self.panel)
        self.setPreferredSize(Dimension(500, 300))

        self.pack()
        self.setLocationRelativeTo(None)
        self.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE)
        self.setVisible(True)
Esempio n. 8
0
class ConsolePanel(Panel):

	def __init__(self):
		
		self.console = None
		self.outText = None
		self.inText = None
		self.outTextScroller = None
		self.nestedInputPanel = None
		self.directoryText = None
		Panel.__init__(self, "insets 0 0 0 0")

	def sendCommand(self, command):
		print str(self)
		oldText = self.inText.getText()
		self.inText.setText(command)

		self.inText.getActionListeners()[0].actionPerformed(None)
		self.inText.setText(oldText)

	def setDirectoryText(self, dirText):
		self.directoryText.setText(dirText)
		self.nestedInputPanel.revalidate()

	def write_out(self,text):
		if not self.outText:
			return
		self.outText.setText(self.outText.getText() + text)

	def initUI(self):

		font = Font("Courier New", Font.BOLD, 14)

		#create the output text panel
		self.outText = JTextArea()
		self.outText.setEditable(False)
		self.outText.setFont(font)
		self.outText.setWrapStyleWord(True)
		self.outText.setLineWrap(True)
		#self.outText.setLineWrap(True)
		#self.outText.setWrapStyleWord(True)
		class NoGhostScroller(JScrollPane):
			def paintComponent(self, g):
				
				g.setColor(self.getBackground())
				g.fillRect(0, 0, self.getWidth(), self.getHeight())
				#super(NoGhostScroller, self).paintComponent(g)

		self.outTextScroller = JScrollPane(self.outText)
		self.outTextScroller.setHorizontalScrollBarPolicy(ScrollPaneConstants.HORIZONTAL_SCROLLBAR_NEVER)
		self.outTextScroller.getVerticalScrollBar().setForeground(Color(255, 0, 0))
		#self.outText.setOpaque(False)
		self.outText.setBackground(Color(0, 20, 0))
		self.outText.setForeground(Color.WHITE)

		#self.outTextScroller.setOpaque(False)
		self.outTextScroller.setBackground(Color(0, 20, 0))

		#self.outText.repaint()

		#self.layered = JLayeredPane()
		#self.layered.setLayer(self.outTextScroller, 0)

		#create the input text box
		self.inText = JTextField()
		self.inText.setFocusTraversalKeysEnabled(False)
		self.inText.setFont(font)
		self.inText.setBackground(Color(0, 20, 0))
		self.inText.setForeground(Color.WHITE)
		self.inText.getCaret().setVisible(True)
		self.inText.getCaret().setBlinkRate(500)
		self.inText.setCaretColor(Color(200,255,200))
		
		class InFocusAdapter(FocusAdapter):
			def focusLost(adap, e):
				self.inText.setVisible(True)
		self.inText.addFocusListener(InFocusAdapter())

		self.nestedInputPanel = Panel("Insets 0 0 0 0")

		#create the directory text box
		self.directoryText = JTextField()
		self.directoryText.setEditable(False)
		self.directoryText.setFont(font)
		self.directoryText.setBackground(Color(0, 20, 0))
		self.directoryText.setForeground(Color.WHITE)
		#set up the console
		sys.stdout = FakeOut(self.outText)
		self.console = BashED_Console(stdout=sys.stdout)
		self.directoryText.setText(self.console.get_prompt())
		self.revalidate();


		dirTex = self.directoryText;

		#create the listener that fires when the 'return' key is pressed
		class InputTextActionListener(ActionListener):
			def __init__(self,parent,inp,out,console):
				self.parent = parent
				self.inp = inp
				self.out = out
				self.console = console

			def actionPerformed(self, e):
				#print self.getCommandText()
				# print(self.console.get_prompt())
				# self.console.onecmd(self.inp.getText())
				# self.parent.write_out("\n" + self.inp.getText())
				# dirTex.setText(self.console.get_prompt())
				# self.inp.setText("")

				self.parent.write_out(self.console.get_prompt() + self.inp.getText() + '\n')
				if 'clear' in self.inp.getText().split(' ')[0]:
					self.out.setText("") #clear the screen
				else:
					self.console.onecmd(self.inp.getText())
				
				dirTex.setText(self.console.get_prompt())
				self.inp.setText("")

		#create the listener that fires whenever a user hits a key
		class InputKeyActionListener(KeyAdapter):
			def __init__(self,parent,inp,out,console):
				self.parent = parent
				self.inp = inp
				self.out = out
				self.console = console

			def keyReleased(self, k):
				inp = self.inp.getText()
				if k.getKeyCode() == 9: #tab character
					autos = self.console.tabcomplete(self.inp.getText())
					if len(autos) == 1:
						self.inp.setText(autos[0])
					else:
						i = 0
						for option in autos:
							self.parent.write_out(option)
							if i % 3 == 0:
								print('\n')
							else:
								print('\t')
				hist = None
				if k.getKeyCode() == 38:
					hist = self.console.next_hist()
				if k.getKeyCode() == 40:
					hist = self.console.last_hist()

				if hist:
					self.inp.setText(hist.rstrip('\n'))#prevent from firing

		self.inText.addActionListener(InputTextActionListener(self,self.inText,self.outText,self.console))
		self.inText.addKeyListener(InputKeyActionListener(self,self.inText,self.outText,self.console))




	def addUI(self):
		
		self.add(self.outTextScroller, "cell 0 0, push, grow")
		self.add(self.nestedInputPanel, "cell 0 1, pushx, growx")
		self.nestedInputPanel.add(self.directoryText, "cell 0 0")
		self.nestedInputPanel.add(self.inText, "cell 1 0, spanx, pushx, growx")
Esempio n. 9
0
class BobGui(JFrame):
    def __init__(self):
        super(BobGui, self).__init__('BobPy')
        # IJ.log('okay?')
        # print('okay??')
        self.setLayout(BorderLayout())
        self.main_panel = JPanel()
        # self.main_panel.setLayout(MigLayout('insets 1 10 1 1'))
        self.main_panel.setLayout(MigLayout())

        dir_panel = JPanel()
        dir_panel.setLayout(BoxLayout(dir_panel, BoxLayout.X_AXIS))

        dir_label = JLabel('Experiment Folder:')
        dir_panel.add(dir_label)

        self.dir_text_field = JTextField(10)
        self.dir_text_field.addActionListener(
            ActionListenerFactory(self, self.text_field_al))
        dir_panel.add(self.dir_text_field)

        dir_button = JButton('open')
        dir_button.addActionListener(
            ActionListenerFactory(self, self.choose_dir_al))
        dir_panel.add(dir_button)

        self.main_panel.add(dir_panel, 'wrap, growx, spanx, pushx')

        add_key_args(self.main_panel, 'close_w',
                     ActionListenerFactory(self, self.close_al), KeyEvent.VK_W,
                     Toolkit.getDefaultToolkit().getMenuShortcutKeyMask())

        self.add(self.main_panel, BorderLayout.CENTER)

        self.setPreferredSize(Dimension(650, 600))

        self.pack()
        self.setLocationRelativeTo(None)
        self.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE)
        self.setVisible(True)

    def show_exper_info(self):

        chf_panel = self.make_chf_panel()
        hseg_tree_panel = self.make_hseg_tree_panel()

        self.split_pane = JSplitPane(JSplitPane.HORIZONTAL_SPLIT)

        self.split_pane.setOneTouchExpandable(True)
        self.split_pane.setContinuousLayout(True)
        self.split_pane.setResizeWeight(0.5)

        self.split_pane.add(chf_panel)
        self.split_pane.add(hseg_tree_panel)
        self.main_panel.add(self.split_pane, 'grow, wrap')

        # self.log_text = JTextArea()
        self.main_panel.add(self.log_text, 'grow, wrap')
        self.log_text.setLineWrap(True)
        self.log_text.setWrapStyleWord(True)

        self.revalidate()

    def make_chf_panel(self):
        """ chf --> common hseg files """

        chf_panel = JPanel()
        chf_panel.setLayout(MigLayout('insets 0'))

        chf_files_label = JLabel('Hemisegment cells')
        chf_files_text = JTextArea(
            BobGui.archetype_to_str(
                self.exper.hseg_cell_files_cab().archetype))

        chf_panel.add(chf_files_label, 'growx, wrap')
        chf_panel.add(chf_files_text, 'grow, wrap')

        chf_files_label = JLabel('Hemisegment binary image files')
        chf_files_text = JTextArea(
            BobGui.archetype_to_str(self.exper.hseg_bin_files_cab().archetype))

        chf_panel.add(chf_files_label, 'growx, wrap')
        chf_panel.add(chf_files_text, 'grow, wrap')

        chf_files_label = JLabel('Intensity Image Files')
        # chf_files_text = JTextArea(BobGui.archetype_to_str(self.exper.hseg_intens_im_files_cab().archetype))
        # print(self.exper.hseg_intens_im_files_cab().archetype)

        # chf_panel.add(chf_files_label, 'growx, wrap')
        # chf_panel.add(chf_files_text, 'grow, wrap')

        self.intens_im_boxes = []
        intens_im_panel = JPanel()
        intens_im_panel.setLayout(MigLayout('insets 0'))
        for poss_im_file in self.exper.hseg_intens_im_files_cab().archetype:
            self.intens_im_boxes.append(JCheckBox(poss_im_file))
            intens_im_panel.add(self.intens_im_boxes[-1], 'wrap')

        chf_panel.add(chf_files_label, 'growx, wrap')
        chf_panel.add(intens_im_panel, 'grow, wrap')

        mdf_create_button = JButton(
            'Create meta_data file from default outline')
        # mdf_create_button = JButton('<html>Create meta_data file<br>from default outline</html>')
        mdf_create_button.addActionListener(
            ActionListenerFactory(self, self.mdf_create_al))
        mdf_open_button = JButton('Open existing meta_data file')
        mdf_open_button.addActionListener(
            ActionListenerFactory(self, self.mdf_open_al))

        # meta_data_file_buttton = JButton('Open/Create meta_data file')
        # meta_data_file_buttton.addActionListener(ActionListenerFactory(self, self.meta_data_al))

        # chf_panel.add(meta_data_file_buttton)
        chf_panel.add(mdf_create_button, 'wrap')
        chf_panel.add(mdf_open_button, 'wrap')
        chf_scroll_pane = JScrollPane()
        chf_scroll_pane.getViewport().setView(chf_panel)

        return chf_scroll_pane

    @staticmethod
    def archetype_to_str(archetype):

        at_str = ''
        for val in archetype:
            at_str += str(val) + '\n'
        return at_str

    def make_hseg_tree_panel(self):
        root = DefaultMutableTreeNode(self.exper.name)

        for hseg in self.exper.hsegs():
            hseg_node = DefaultMutableTreeNode(hseg.name)
            root.add(hseg_node)
            hseg_at_deviations = self.exper.hseg_files_cab(
            ).archetype_deviations
            if len(hseg_at_deviations[hseg.name]) > 0:
                for definer, file_names in hseg_at_deviations[
                        hseg.name].items():
                    for file_name in file_names:
                        node_str = definer + ': ' + file_name

                        temp = DefaultMutableTreeNode(node_str)
                        hseg_node.add(temp)

        hseg_tree = JTree(root)
        hseg_tree.setCellRenderer(BobPyTreeCellRenderer())

        hseg_scroll_pane = JScrollPane()
        hseg_scroll_pane.getViewport().setView((hseg_tree))

        hseg_panel = JPanel(MigLayout('insets 0'))
        hseg_panel.add(hseg_scroll_pane, 'grow, span, push, wrap')

        run_button = JButton('Run')
        run_button.addActionListener(ActionListenerFactory(self, self.run_al))
        rerun_button = JButton('Rerun')
        rerun_button.addActionListener(
            ActionListenerFactory(self, self.rerun_al))

        hseg_panel.add(run_button)
        hseg_panel.add(rerun_button)

        return hseg_panel

    def log(self, text):
        self.log_text.append(str(text) + '\n')

    def text_field_al(self, e):
        # self.dir_path =
        self.got_exper(self.dir_text_field.getText())

    def choose_dir_al(self, e):

        dc = DirectoryChooser('Choose a bob_py experiment folder')
        # self.dir_path = dc.getDirectory()

        # self.dir_text_field.setText(self.dir_path)
        # self.dir_text_field.setText('blerg')
        # IJ.log('blerg')
        # print('boop')
        self.got_exper(dc.getDirectory())

    def close_al(self, e):
        self.dispatchEvent(WindowEvent(self, WindowEvent.WINDOW_CLOSING))

    def run_al(self, e):
        # dt = br.dtic('Processed experiment {}'.format(self.exper.name))
        t = br.tic()
        self.exper.make_data()
        self.exper.output_cell_cols_def()
        self.exper.output_nuc_cols_def()
        self.exper.output_new_hdings()

        self.exper.log('Processed experiment {} in {:.3f} seconds'.format(
            self.exper.name, br.toc(t)))
        # br.dtoc(dt)

    def rerun_al(self, e):
        # dt = br.dtic('Processed experiment {}'.format(self.exper.name))
        # t = br.tic()
        self.exper = None
        self.got_exper(self.dir_path)
        self.run_al(None)
        # self.exper =
        # self.exper.make_data()
        # self.exper.output_cell_cols_def()
        # self.exper.output_nuc_cols_def()
        # self.exper.output_new_hdings()
        #
        # self.exper.log('Created and processed experiment {} in {:.3f} seconds'.format(self.exper.name, br.toc(t)))
        # br.dtoc(dt)

    # def meta_data_al(self, e) :
    #     meta_data_path = self.exper.meta_data_path()
    #     if not os.path.exists(meta_data_path) :
    #         txt = make_meta_data_str(self.exper)
    #         with open(meta_data_path, 'w') as f :
    #             f.write(txt)
    #
    #     IJ.open(meta_data_path)

    def mdf_create_al(self, e):
        meta_data_path = self.exper.meta_data_path()
        # if not os.path.exists(meta_data_path) :
        intens_im_list = []
        for check_box in self.intens_im_boxes:
            if check_box.isSelected():
                intens_im_list.append(check_box.getLabel())
        txt = make_meta_data_str2(self.exper, intens_im_list)
        with open(meta_data_path, 'w') as f:
            f.write(txt)

        # IJ.open(meta_data_path)

    def mdf_open_al(self, e):
        meta_data_path = self.exper.meta_data_path()

        IJ.open(meta_data_path)

    def got_exper(self, dir_path):
        # IJ.log('exper')
        self.dir_path = dir_path
        self.dir_text_field.setText(self.dir_path)

        self.log_text = JTextArea()

        self.exper = bob_py.Exper(dir_path, gui=self)
        self.show_exper_info()
Esempio n. 10
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
Esempio n. 11
0
class ConsolePanel(Panel):
    def __init__(self):

        self.console = None
        self.outText = None
        self.inText = None
        self.outTextScroller = None
        self.nestedInputPanel = None
        self.directoryText = None
        Panel.__init__(self, "insets 0 0 0 0")

    def sendCommand(self, command):
        print str(self)
        oldText = self.inText.getText()
        self.inText.setText(command)

        self.inText.getActionListeners()[0].actionPerformed(None)
        self.inText.setText(oldText)

    def setDirectoryText(self, dirText):
        self.directoryText.setText(dirText)
        self.nestedInputPanel.revalidate()

    def write_out(self, text):
        if not self.outText:
            return
        self.outText.setText(self.outText.getText() + text)

    def initUI(self):

        font = Font("Courier New", Font.BOLD, 14)

        #create the output text panel
        self.outText = JTextArea()
        self.outText.setEditable(False)
        self.outText.setFont(font)
        self.outText.setWrapStyleWord(True)
        self.outText.setLineWrap(True)

        #self.outText.setLineWrap(True)
        #self.outText.setWrapStyleWord(True)
        class NoGhostScroller(JScrollPane):
            def paintComponent(self, g):

                g.setColor(self.getBackground())
                g.fillRect(0, 0, self.getWidth(), self.getHeight())
                #super(NoGhostScroller, self).paintComponent(g)

        self.outTextScroller = JScrollPane(self.outText)
        self.outTextScroller.setHorizontalScrollBarPolicy(
            ScrollPaneConstants.HORIZONTAL_SCROLLBAR_NEVER)
        self.outTextScroller.getVerticalScrollBar().setForeground(
            Color(255, 0, 0))
        #self.outText.setOpaque(False)
        self.outText.setBackground(Color(0, 20, 0))
        self.outText.setForeground(Color.WHITE)

        #self.outTextScroller.setOpaque(False)
        self.outTextScroller.setBackground(Color(0, 20, 0))

        #self.outText.repaint()

        #self.layered = JLayeredPane()
        #self.layered.setLayer(self.outTextScroller, 0)

        #create the input text box
        self.inText = JTextField()
        self.inText.setFocusTraversalKeysEnabled(False)
        self.inText.setFont(font)
        self.inText.setBackground(Color(0, 20, 0))
        self.inText.setForeground(Color.WHITE)
        self.inText.getCaret().setVisible(True)
        self.inText.getCaret().setBlinkRate(500)
        self.inText.setCaretColor(Color(200, 255, 200))

        class InFocusAdapter(FocusAdapter):
            def focusLost(adap, e):
                self.inText.setVisible(True)

        self.inText.addFocusListener(InFocusAdapter())

        self.nestedInputPanel = Panel("Insets 0 0 0 0")

        #create the directory text box
        self.directoryText = JTextField()
        self.directoryText.setEditable(False)
        self.directoryText.setFont(font)
        self.directoryText.setBackground(Color(0, 20, 0))
        self.directoryText.setForeground(Color.WHITE)
        #set up the console
        sys.stdout = FakeOut(self.outText)
        self.console = BashED_Console(stdout=sys.stdout)
        self.directoryText.setText(self.console.get_prompt())
        self.revalidate()

        dirTex = self.directoryText

        #create the listener that fires when the 'return' key is pressed
        class InputTextActionListener(ActionListener):
            def __init__(self, parent, inp, out, console):
                self.parent = parent
                self.inp = inp
                self.out = out
                self.console = console

            def actionPerformed(self, e):
                #print self.getCommandText()
                # print(self.console.get_prompt())
                # self.console.onecmd(self.inp.getText())
                # self.parent.write_out("\n" + self.inp.getText())
                # dirTex.setText(self.console.get_prompt())
                # self.inp.setText("")

                self.parent.write_out(self.console.get_prompt() +
                                      self.inp.getText() + '\n')
                if 'clear' in self.inp.getText().split(' ')[0]:
                    self.out.setText("")  #clear the screen
                else:
                    self.console.onecmd(self.inp.getText())

                dirTex.setText(self.console.get_prompt())
                self.inp.setText("")

        #create the listener that fires whenever a user hits a key
        class InputKeyActionListener(KeyAdapter):
            def __init__(self, parent, inp, out, console):
                self.parent = parent
                self.inp = inp
                self.out = out
                self.console = console

            def keyReleased(self, k):
                inp = self.inp.getText()
                if k.getKeyCode() == 9:  #tab character
                    autos = self.console.tabcomplete(self.inp.getText())
                    if len(autos) == 1:
                        self.inp.setText(autos[0])
                    else:
                        i = 0
                        for option in autos:
                            self.parent.write_out(option)
                            if i % 3 == 0:
                                print('\n')
                            else:
                                print('\t')
                hist = None
                if k.getKeyCode() == 38:
                    hist = self.console.next_hist()
                if k.getKeyCode() == 40:
                    hist = self.console.last_hist()

                if hist:
                    self.inp.setText(hist.rstrip('\n'))  #prevent from firing

        self.inText.addActionListener(
            InputTextActionListener(self, self.inText, self.outText,
                                    self.console))
        self.inText.addKeyListener(
            InputKeyActionListener(self, self.inText, self.outText,
                                   self.console))

    def addUI(self):

        self.add(self.outTextScroller, "cell 0 0, push, grow")
        self.add(self.nestedInputPanel, "cell 0 1, pushx, growx")
        self.nestedInputPanel.add(self.directoryText, "cell 0 0")
        self.nestedInputPanel.add(self.inText, "cell 1 0, spanx, pushx, growx")
Esempio n. 12
0
class BobGui(JFrame):
    def __init__(self):
        super(BobGui, self).__init__('BobPy')

        # cls = self.getClass()
        # print(cls)

        # self.setLayout(MigLayout())
        self.setLayout(BorderLayout())
        self.main_panel = JPanel()
        self.main_panel.setLayout(MigLayout())

        dir_panel = JPanel()
        dir_panel.setLayout(BoxLayout(dir_panel, BoxLayout.X_AXIS))

        dir_label = JLabel('Experiment Folder:')
        dir_panel.add(dir_label)

        self.dir_text_field = JTextField(10)
        self.dir_text_field.addActionListener(
            ActionListenerFactory(self, self.text_field_al))
        dir_panel.add(self.dir_text_field)

        dir_button = JButton('open')
        dir_button.addActionListener(
            ActionListenerFactory(self, self.choose_dir_al))
        dir_panel.add(dir_button)

        self.main_panel.add(dir_panel, 'growx, spanx, pushx, wrap')

        add_key_args(self.main_panel, 'close_w',
                     ActionListenerFactory(self, self.close_al), KeyEvent.VK_W,
                     Toolkit.getDefaultToolkit().getMenuShortcutKeyMask())

        self.add(self.main_panel, BorderLayout.CENTER)

        self.setPreferredSize(Dimension(500, 400))

        self.pack()
        self.setLocationRelativeTo(None)
        self.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE)
        self.setVisible(True)

    def show_exper_info_old(self):
        # sb = br.SimilarityBuilder()
        cab = br.CollectionArchetypeBuilder()

        for hseg in self.exper.hsegs():
            all_file_dict = hseg.file_dict()
            all_file_dict.update(hseg.cell_file_dict())
            all_file_dict.update(hseg.bin_file_dict())
            cab.add_collection(hseg.name, all_file_dict)

        hseg_at, hseg_at_deviations = cab.get_archetype_info()

        at_str = ''
        for val in hseg_at:
            at_str += str(val) + '\n'

        chf_panel = self.make_chf_panel(at_str)
        hseg_tree_panel = self.make_hseg_tree_panel(hseg_at_deviations)

        self.split_pane = JSplitPane(JSplitPane.HORIZONTAL_SPLIT)

        self.split_pane.setOneTouchExpandable(True)
        self.split_pane.setContinuousLayout(True)
        self.split_pane.setResizeWeight(0.5)

        self.split_pane.add(chf_panel)
        self.split_pane.add(hseg_tree_panel)
        self.main_panel.add(self.split_pane, 'grow')
        self.revalidate()

    def show_exper_info(self):
        # sb = br.SimilarityBuilder()
        # cab = br.CollectionArchetypeBuilder()
        #
        # for hseg in self.exper.hsegs() :
        #     all_file_dict = hseg.file_dict()
        #     all_file_dict.update(hseg.cell_file_dict())
        #     all_file_dict.update(hseg.bin_file_dict())
        #     cab.add_collection(hseg.name, all_file_dict)
        #
        # hseg_at, hseg_at_deviations = cab.get_archetype_info()
        #
        # at_str = ''
        # for val in hseg_at :
        #     at_str += str(val) + '\n'

        chf_panel = self.make_chf_panel()
        hseg_tree_panel = self.make_hseg_tree_panel()

        self.split_pane = JSplitPane(JSplitPane.HORIZONTAL_SPLIT)

        self.split_pane.setOneTouchExpandable(True)
        self.split_pane.setContinuousLayout(True)
        self.split_pane.setResizeWeight(0.5)

        self.split_pane.add(chf_panel)
        self.split_pane.add(hseg_tree_panel)
        self.main_panel.add(self.split_pane, 'grow')
        self.revalidate()

    def make_chf_panel_old(self, at_str):
        """ cf --> common hseg files """

        chf_panel = JPanel()
        # chf_panel.setLayout(BoxLayout(chf_panel, BoxLayout.Y_AXIS))
        chf_panel.setLayout(MigLayout('insets 0'))
        # chf_panel.setAlignmentX(Component.LEFT_ALIGNMENT)

        chf_label = JLabel('Common Hemeisegment Files')
        # chf_label.setAlignmentX(Component.LEFT_ALIGNMENT)

        chf_panel.add(chf_label, 'grow, wrap')

        chf_text_area = JTextArea(at_str)
        chf_panel.add(chf_text_area, 'grow, push, span')
        return chf_panel

    def make_chf_panel(self):
        """ chf --> common hseg files """

        chf_panel = JPanel()
        # chf_panel.setLayout(BoxLayout(chf_panel, BoxLayout.Y_AXIS))
        chf_panel.setLayout(MigLayout('insets 0'))
        # chf_panel.setAlignmentX(Component.LEFT_ALIGNMENT)

        chf_files_label = JLabel('Hemisegment cells')
        chf_files_text = JTextArea(
            BobGui.archetype_to_str(
                self.exper.hseg_cell_files_cab().archetype))

        chf_panel.add(chf_files_label, 'growx, wrap')
        chf_panel.add(chf_files_text, 'grow, wrap')

        chf_files_label = JLabel('Hemisegment binary image files')
        chf_files_text = JTextArea(
            BobGui.archetype_to_str(self.exper.hseg_bin_files_cab().archetype))

        chf_panel.add(chf_files_label, 'growx, wrap')
        chf_panel.add(chf_files_text, 'grow, wrap')

        chf_files_label = JLabel('Other hemisegment files')
        chf_files_text = JTextArea(
            BobGui.archetype_to_str(self.exper.hseg_files_cab().archetype))

        chf_panel.add(chf_files_label, 'growx, wrap')
        chf_panel.add(chf_files_text, 'grow')
        # chf_label = JLabel('Common Hemeisegment Files')
        # # chf_label.setAlignmentX(Component.LEFT_ALIGNMENT)
        #
        # chf_panel.add(chf_label, 'grow, wrap')
        #
        # chf_text_area = JTextArea(at_str)
        # chf_panel.add(chf_text_area, 'grow, push, span')
        return chf_panel

    @staticmethod
    def archetype_to_str(archetype):

        at_str = ''
        for val in archetype:
            at_str += str(val) + '\n'
        return at_str

    # def make_hseg_tree_panel(self, hseg_at_deviations) :
    def make_hseg_tree_panel(self):
        root = DefaultMutableTreeNode(self.exper.name)

        for hseg in self.exper.hsegs():
            hseg_node = DefaultMutableTreeNode(hseg.name)
            root.add(hseg_node)
            hseg_at_deviations = self.exper.hseg_all_files_cab(
            ).archetype_deviations
            if len(hseg_at_deviations[hseg.name]) > 0:
                for definer, file_names in hseg_at_deviations[
                        hseg.name].items():
                    for file_name in file_names:
                        node_str = definer + ': ' + file_name

                        temp = DefaultMutableTreeNode(node_str)
                        hseg_node.add(temp)

        hseg_tree = JTree(root)
        hseg_tree.setCellRenderer(BobPyTreeCellRenderer())

        hseg_scroll_pane = JScrollPane()
        hseg_scroll_pane.getViewport().setView((hseg_tree))

        return hseg_scroll_pane

    def text_field_al(self, e):
        self.dir_path = self.dir_text_field.getText()
        self.got_exper(self.dir_path)

    def choose_dir_al(self, e):

        dc = DirectoryChooser('Choose a bob_py experiment folder')
        self.dir_path = dc.getDirectory()

        self.dir_text_field.setText(self.dir_path)
        self.got_exper(self.dir_path)

    def close_al(self, e):
        self.dispatchEvent(WindowEvent(self, WindowEvent.WINDOW_CLOSING))

    def got_exper(self, dir_path):
        self.exper = bob_py.Exper(dir_path)
        self.show_exper_info()
Esempio n. 13
0
class ProfelisPanel(JPanel):
    def __init__(self, frame, name):
        self.frame = frame
        self.exception = None
        self.name = name
        self.searchTerm = None
        self.searchIndex = -1

        self.searchField = JTextField("")
        self.searchField.addActionListener(SearchListener(self))

        self.newGeneFrom = JTextField("")
        self.newGeneTo = JTextField("")
        self.newGeneButton = JButton("New Gene")
        newGeneActionListener = NewGeneActionListener(self)
        self.newGeneFrom.addActionListener(newGeneActionListener)
        self.newGeneTo.addActionListener(newGeneActionListener)
        self.newGeneButton.addActionListener(newGeneActionListener)

        self.markForRemovalButton = JButton("Mark For Removal")
        self.markForRemovalButton.addActionListener(
            MarkForRemovalListener(self))

        self.inGenes = JList(DefaultListModel())
        self.inGenes.selectionMode = ListSelectionModel.SINGLE_SELECTION
        self.inGenes.cellRenderer = ProfelisCellRenderer()
        self.markButtonLabelerTimer = Timer(100, MarkButtonLabeler(self))
        self.markButtonLabelerTimer.start()
        self.loadFile()

        self.outGenes = JList(DefaultListModel())
        self.outGenes.selectionMode = ListSelectionModel.SINGLE_SELECTION
        self.outGenes.cellRenderer = ProfelisCellRenderer()

        constraints = GridBagConstraints()
        self.layout = GridBagLayout()

        constraints.gridx, constraints.gridy = 0, 0
        constraints.gridwidth, constraints.gridheight = 1, 1
        constraints.fill = GridBagConstraints.NONE
        constraints.weightx, constraints.weighty = 0, 0
        self.add(JLabel("Genes In Artemis File"), constraints)
        constraints.gridx, constraints.gridy = 0, 1
        self.add(JButton(RemoveAction(self)), constraints)
        constraints.gridx, constraints.gridy = 1, 1
        self.add(self.markForRemovalButton, constraints)
        constraints.gridx, constraints.gridy = 2, 1
        self.add(JLabel("Search"), constraints)
        constraints.gridx, constraints.gridy = 3, 1
        constraints.fill = GridBagConstraints.HORIZONTAL
        self.add(self.searchField, constraints)
        constraints.gridx, constraints.gridy = 0, 2
        constraints.gridwidth, constraints.gridheight = 4, 2
        constraints.fill = GridBagConstraints.BOTH
        constraints.weightx, constraints.weighty = 1, 1
        self.add(JScrollPane(self.inGenes), constraints)

        constraints.gridx, constraints.gridy = 4, 0
        constraints.gridwidth, constraints.gridheight = 1, 1
        constraints.fill = GridBagConstraints.NONE
        constraints.weightx, constraints.weighty = 0, 0
        self.add(JLabel("Genes To Add To Artemis File"), constraints)
        constraints.gridx, constraints.gridy = 4, 1
        self.add(self.newGeneButton, constraints)
        constraints.weightx = 1
        constraints.fill = GridBagConstraints.BOTH
        constraints.gridx, constraints.gridy = 5, 1
        self.add(self.newGeneFrom, constraints)
        constraints.weightx = 0
        constraints.fill = GridBagConstraints.NONE
        constraints.gridx, constraints.gridy = 6, 1
        self.add(JLabel("To"), constraints)
        constraints.weightx = 1
        constraints.fill = GridBagConstraints.BOTH
        constraints.gridx, constraints.gridy = 7, 1
        self.add(self.newGeneTo, constraints)

        constraints.weightx = 0
        constraints.fill = GridBagConstraints.NONE
        constraints.gridx, constraints.gridy = 4, 2
        self.add(JButton(AddGenesAction(self)), constraints)
        constraints.gridx, constraints.gridy = 4, 3
        constraints.gridwidth, constraints.gridheight = 4, 1
        constraints.fill = GridBagConstraints.BOTH
        constraints.weightx, constraints.weighty = 1, 1
        self.add(JScrollPane(self.outGenes), constraints)

    def loadFile(self):
        self.inGenes.model.clear()
        self.database, self.evalue, genes = utils.parseBlast(self.name +
                                                             ".blastp.xml")
        [self.inGenes.model.addElement(gene) for gene in genes]

        artemisInput = open(self.name + ".art", "r")
        lines = artemisInput.readlines()
        artemisInput.close()
        self.restOfFile = self.genome = []
        while lines:
            if re.match("\s+CDS\s+(complement\()?\d+\.\.\d+\)?\n", lines[0]):
                lines = lines[4:]
            elif lines[0].find("ORIGIN") == 0:
                self.genome = map(lambda x: re.sub("\s+", "", x), lines[1:])
                lines = []
            else:
                if lines[0].strip():
                    self.restOfFile.append(lines[0])
                lines = lines[1:]

        self.genome = "".join(self.genome)
        self.restOfFile = "".join(self.restOfFile)

    def writeArtemisFile(self):
        output = open(self.name + ".art", "w")
        output.write(self.restOfFile)
        for element in self.inGenes.model.elements():
            output.write(element.toArtemis())
        output.write("\nORIGIN\n\n")
        for i in range(0, len(self.genome), 50):
            output.write(self.genome[i:min(i + 50, len(self.genome))] + "\n")
        output.close()
Esempio n. 14
0
class FEA_BC_ConfigPanel(JPanel):

    cbBlockchainCheck = None
    tbHitlist = None
    blockchainCheck = True
    hitlist = "testlist"
    maxTimeout = 5
    tbMaxBCHits = None

    def __init__(self):

        self.initComponents()

        #get previous settings selected by the user

        if (ModuleSettings.getConfigSetting("FEA", "hitlist") != None) and (
                ModuleSettings.getConfigSetting("FEA", "hitlist") != ""):
            if ModuleSettings.getConfigSetting("FEA", "hitlist"):
                self.tbHitlist.text = ModuleSettings.getConfigSetting(
                    "FEA", "hitlist")
            else:
                self.tbHitlist.text = "testlist"

        if (ModuleSettings.getConfigSetting("FEA", "maxTimeout") != None) and (
                ModuleSettings.getConfigSetting("FEA", "maxTimeout") != ""):
            if ModuleSettings.getConfigSetting("FEA", "maxTimeout"):
                self.tbMaxBCHits.text = ModuleSettings.getConfigSetting(
                    "FEA", "maxTimeout")
            else:
                self.tbMaxBCHits.text = "5"

        if (ModuleSettings.getConfigSetting("FEA", "blockchainCheck") !=
                None) and (ModuleSettings.getConfigSetting(
                    "FEA", "blockchainCheck") != ""):
            if ModuleSettings.getConfigSetting("FEA", "blockchainCheck"):
                self.cbBlockchainCheck.setSelected(True)
                self.blockchainCheck = True
            else:
                self.cbBlockchainCheck.setSelected(False)
                self.blockchainCheck = False

    def addStatusLabel(self, msg):
        gbc = GridBagConstraints()
        gbc.anchor = GridBagConstraints.NORTHWEST
        gbc.gridx = 0
        gbc.gridy = 7
        lab = JLabel(msg)
        self.add(lab, gbc)

    def getHitlist(self):
        return self.hitlist

    def getBlockchainCheck(self):
        return self.blockchainCheck

    def getMaxTimeout(self):
        return self.maxTimeout

    def initComponents(self):

        self.setLayout(GridBagLayout())

        gbc = GridBagConstraints()
        gbc.anchor = GridBagConstraints.NORTHWEST
        gbc.gridx = 0
        gbc.gridy = 0

        descriptionLabel = JLabel("FEA - BitCoin Validation module")
        self.add(descriptionLabel, gbc)

        tlHitlist = JLabel("Base list of hashes to analyze: ")
        gbc.gridy = 1
        self.add(tlHitlist, gbc)

        self.tbHitlist = JTextField("testlist", 20)
        self.tbHitlist.addActionListener(self.tbHitlistActionPerformed)
        gbc.gridx = 1
        self.add(self.tbHitlist, gbc)

        gbc.gridx = 0
        self.cbBlockchainCheck = JCheckBox(
            "Query Blockchain.info",
            actionPerformed=self.cbBlockchainCheckActionPerformed)
        self.cbBlockchainCheck.setSelected(True)
        gbc.gridy = 2
        self.add(self.cbBlockchainCheck, gbc)

        tlBCMaxHits = JLabel(
            "Timeout (in seconds) between calls to Blockchain.info: ")
        gbc.gridy = 3
        self.add(tlBCMaxHits, gbc)

        self.tbMaxBCHits = JTextField("5", 5)
        self.tbMaxBCHits.addActionListener(self.tbMaxBCHitsActionPerformed)
        gbc.gridx = 1
        self.add(self.tbMaxBCHits, gbc)

    def tbMaxBCHitsActionPerformed(self, event):
        source = event.getSource()
        self.maxTimeout = int(float(source.getText()))
        ModuleSettings.setConfigSetting("FEA", "maxTimeout", self.maxTimeout)

    def tbHitlistActionPerformed(self, event):
        source = event.getSource()
        self.hitlist = source.getText()
        ModuleSettings.setConfigSetting("FEA", "hitlist", self.hitlist)

    def cbBlockchainCheckActionPerformed(self, event):
        source = event.getSource()
        if (source.isSelected()):
            ModuleSettings.setConfigSetting("FEA", "blockchainCheck", "true")
            self.blockchainCheck = True
        else:
            ModuleSettings.setConfigSetting("FEA", "blockchainCheck", "false")
            self.blockchainCheck = False
Esempio n. 15
0
class spyTailMonitor(JPanel, ActionListener):
    length = 10  # Number of words per line

    def __init__(self, parentCrate=None):
        JPanel.__init__(self)
        self.spy = None
        self.parentCrate = parentCrate
        self.nw = 10  # Number of words (total)
        self.upperPanel = JPanel()
        self.lowerPanel = JPanel()
        self.add(self.upperPanel)
        self.add(self.lowerPanel)
        self.nameLabel = JLabel("n/a")
        self.slotLabel = JLabel("n/a")
        self.textArea = JTextArea("n/a", 1, 70, editable=0)
        self.scrollPane = JScrollPane(self.textArea)
        self.textField = JTextField(3,
                                    actionCommand="textField",
                                    text=("%d" % self.nw))
        self.textField.addActionListener(self)
        self.clearButton = JButton("Stop", actionCommand="button")
        self.clearButton.addActionListener(self)
        self.border = BorderFactory.createEmptyBorder(5, 5, 5, 5)
        self.layout = BoxLayout(self, BoxLayout.Y_AXIS)
        self.upperPanel.layout = BoxLayout(self.upperPanel, BoxLayout.X_AXIS)
        self.lowerPanel.layout = BoxLayout(self.lowerPanel, BoxLayout.X_AXIS)
        self.upperPanel.add(self.clearButton)
        self.upperPanel.add(Box.createRigidArea(Dimension(20, 0)))
        self.upperPanel.add(JLabel("Spy:"))
        self.upperPanel.add(Box.createRigidArea(Dimension(5, 0)))
        self.upperPanel.add(self.nameLabel)
        self.upperPanel.add(Box.createRigidArea(Dimension(20, 0)))
        self.upperPanel.add(JLabel("Slot:"))
        self.upperPanel.add(Box.createRigidArea(Dimension(5, 0)))
        self.upperPanel.add(self.slotLabel)
        self.upperPanel.add(Box.createRigidArea(Dimension(20, 0)))
        self.upperPanel.add(JLabel("Number of words:"))
        self.upperPanel.add(Box.createRigidArea(Dimension(5, 0)))
        self.upperPanel.add(self.textField)
        self.upperPanel.add(Box.createHorizontalGlue())
        self.lowerPanel.add(JLabel("Tail contents:"))
        self.lowerPanel.add(Box.createRigidArea(Dimension(5, 0)))
        self.lowerPanel.add(self.scrollPane)
        self.lowerPanel.add(Box.createHorizontalGlue())

    def setSpy(self, spy):
        self.spy = spy
        self.nameLabel.text = spy.name
        self.slotLabel.text = "%d" % spy.board.slot
        self.textArea.text = "n/a"

    def update(self):
        if self.spy != None:
            array = self.spy.readTail(self.nw)
            text = "%6.6x" % array[0]
            for i in range(1, len(array)):  # len(array) = len(array[1:])+1
                if i % 10:
                    text = text + " %6.6x" % array[i]
                else:
                    text = text + "\n%6.6x" % array[i]
            self.textArea.text = text

    def actionPerformed(self, event):
        if event.actionCommand == "button":
            self.spy = None
            self.nameLabel.text = "n/a"
            self.slotLabel.text = "n/a"
            self.textArea.text = "n/a"
            self.textArea.rows = 1
        elif event.actionCommand == "textField":
            self.nw = eval(self.textField.text)
            self.textArea.rows = min(
                [int(math.ceil(self.nw / self.length)), 10])
            if self.parentCrate != None:
                self.parentCrate.frame.pack()
Esempio n. 16
0


###########################################################################
#####                       Main code                                 #####
###########################################################################

# Set up the fields for the SWING interface
minField = JFormattedTextField( 0 )
minField.addActionListener( ChangedMin(minField) )

maxField = JFormattedTextField( 255 )
maxField.addActionListener( ChangedMax(maxField) )

scoreField = JTextField( "" )
scoreField.addActionListener( NextImage(scoreField) )
scoreField.addActionListener( WriteScore(scoreField) )

button = JButton("Previous image")
button.addActionListener( PreviousImage(scoreField) )

    # Pack all the fields into a JPanel
all = JPanel()
layout = GridLayout(4, 1)
all.setLayout(layout)
all.add( JLabel("  ") )
all.add( button )
all.add( JLabel("Min") )
all.add( minField )
all.add( JLabel("Max") )
all.add(maxField )
Esempio n. 17
0
    class ConsoleController:
        def __init__(self, parent):
            self._parent = parent
            self._sessions = self._parent.sessions()
            self._request = None #TODO I'll need a request in order to connect to something
            self._position = None #TODO I'll need a position, something to change in the header to insert the command
            self._pwd = None
            self._commandHistory = []
            self._historyIndex = 0
            self._tabComplete = []

        def getMainComponent(self):
            self._mainPanel = JPanel(BorderLayout())
            # input
            self._consolePwd = JTextField()
            self._consolePwd.setEditable(False)
            self._consolePwd.setText("Not initialized")
            self._consoleInput = JTextField()
            #Remove 'tab' low-level tab-function of jumping to other component, so I can use it
            self._consoleInput.setFocusTraversalKeys(KeyboardFocusManager.FORWARD_TRAVERSAL_KEYS, Collections.EMPTY_SET)
            self._consoleInput.addActionListener(self.EnterPress())
            self._consoleInput.addKeyListener(self.KeyPress())
            self._inputPanel = JPanel(BorderLayout())
            self._inputPanel.add(self._consolePwd, BorderLayout.WEST)
            self._inputPanel.add(self._consoleInput, BorderLayout.CENTER)
            # output
            self._consoleOutput = JTextArea()
            self._consoleOutput.setEditable(False)
            self._consoleOutput.setForeground(Color.WHITE)
            self._consoleOutput.setBackground(Color.BLACK)
            self._consoleOutput.setFont(self._consoleOutput.getFont().deriveFont(12.0))

            self._scrollPaneConsoleOutput = JScrollPane(self._consoleOutput)

            # Add to main panel and return the main panel
            self._mainPanel.add(self._scrollPaneConsoleOutput, BorderLayout.CENTER)
            self._mainPanel.add(self._inputPanel, BorderLayout.SOUTH)
            return self._mainPanel

        def sendCommand(self, requestId, cmd, directTo):
            Utils.out("ConsoleController > sendCommand > 'cmd'")
            Utils.out(cmd)
            if cmd == 'clear':
                self.resetOutput()
                self._commandHistory.append(cmd)
                self.resetHistoryIndex()
                self.clearCmd()
                return
            cmdModified = cmd
            requestHttpMethod = self._parent.getRequestHttpService(requestId)
            #If I use virtual persistence and there's already a pwd set
            if Utils.shellController._virtualPersistence and self.pwd():
                #Then always prepend 'cd <pwd>' to any command executed. In reality we
                # always enter in the same directory, but because this shell keeps track
                # of where the user thinks he is, and always goes to that directory first
                # the illusion of a persistence is created
                cmdVirtual = "cd " + self.pwd()
                cmdModified = cmdVirtual + "; " + cmd
            requestWithCommand = self._parent.getRequestWithCommand(requestId, cmdModified)
            Thread(GetThreadForRequest(requestHttpMethod, requestWithCommand, directTo)).start()
            self._commandHistory.append(cmd)
            self.resetHistoryIndex()
            self.clearCmd()

            if Utils.shellController._virtualPersistence:
                if cmd.startswith('cd '):
                    Utils.out("ConsoleController > sendCommand: detected 'cd '")
                    #ask for pwd
                    cmdPwd = cmdModified + "; " + Commands.pwd(Commands.OS_LINUX)
                    requestWithCommand = self._parent.getRequestWithCommand(requestId, cmdPwd)
                    Thread(GetThreadForRequest(requestHttpMethod, requestWithCommand, 'pwd')).start()
                if Utils.shellController._tabCompletion:
                    #ask 'ls -1a' for tab-completion
                    # The first command, pwd is set here, but cmdVirtual ain't. But this
                    # also means we are at the entry directory anyway, so we can just ask ls
                    # and get the correct tab completion anyway
                    try:
                        cmdTabComplete = cmdVirtual + "; " + Commands.ls(Commands.OS_LINUX)
                    except:
                        cmdTabComplete = Commands.ls(Commands.OS_LINUX)
                    requestWithCommand = self._parent.getRequestWithCommand(requestId, cmdTabComplete)
                    Thread(GetThreadForRequest(requestHttpMethod, requestWithCommand, 'tabComplete')).start()
            else:
                if Utils.shellController._tabCompletion:
                    cmdTabComplete = Commands.ls(Commands.OS_LINUX)
                    requestWithCommand = self._parent.getRequestWithCommand(requestId, cmdTabComplete)
                    Thread(GetThreadForRequest(requestHttpMethod, requestWithCommand, 'tabComplete')).start()

            #either way execute the requested command

        def startSession(self):
            #TODO when starting a session I want to test for a number of things:
            # if I can reform the request to a post request and still have it work
            # if base 64 is available
            # if bash is available
            self.setPwd(None)
            if Utils.shellController._virtualPersistence and Utils.shellController._outputIsolator:
                Utils.out("startSession > virtualPersistence enabled > Requesting pwd")
                self.sendCommand(self._parent.currentRequestId(), Commands.pwd(Commands.OS_LINUX), 'pwd')

        def appendOutput(self, text, printCommand=True):
            try:
                if printCommand:
                    self.printCommand(self._commandHistory[-1])
            except:
                pass

            self._consoleOutput.append("\n" + text)
            #auto scroll down if needed
            self._consoleOutput.setCaretPosition(self._consoleOutput.getDocument().getLength())

        def resetOutput(self):
            Utils.setConsole('')

        def printCommand(self, cmd):
            self._consoleOutput.append("\n" + self._pwd + "# " + cmd)

        def printCurrentCommand(self):
            self.printCommand(self.cmd())

        def setPwd(self, pwd):
            self._pwd = pwd
            if pwd is None:
                self._consolePwd.setText('')
            else:
                self._consolePwd.setText(pwd)
            Utils.consoleController._mainPanel.revalidate()

        def pwd(self):
            return self._pwd

        def cmdHistoryCount(self):
            return len(self._commandHistory) #TODO - 1

        def setCmd(self, cmd):
            self._consoleInput.setText(cmd)

        def cmd (self):
            return self._consoleInput.getText()

        def clearCmd(self):
            self._consoleInput.setText('')

        def resetHistoryIndex(self):
            self._historyIndex = self.cmdHistoryCount()

        def previousCommand(self):
            if self._historyIndex > 0:
                self._historyIndex -= 1
                self.setCmd(self._commandHistory[self._historyIndex])

        def nextCommand(self):
            if self._historyIndex < self.cmdHistoryCount():
                self._historyIndex += 1
                self.setCmd(self._commandHistory[self._historyIndex])
            else:
                self.clearCmd()
                self.resetHistoryIndex()

        def setTabComplete(self, text):
            self._tabComplete = text.splitlines()

        def findTabComplete(self, beginCharacters=''):
            suggestions = []
            if beginCharacters:
                for suggestion in self._tabComplete:
                    Utils.debug("suggestion", suggestion)
                    Utils.debug("text", beginCharacters)
                    if suggestion[0:len(beginCharacters)] == beginCharacters:
                        suggestions.append(suggestion)
            else:
                suggestions = self._tabComplete
            return suggestions

        def tabComplete(self):
            currentCommand = self.cmd()
            Utils.debug("currentCommand", currentCommand)
            if currentCommand:
                commandArray = currentCommand.split(' ')
                lastword = commandArray.pop()
                Utils.debug("lastword", lastword)
                suggestions = self.findTabComplete(lastword)
                if suggestions:
                    if len(suggestions) > 1:
                        self.printCurrentCommand()
                        for suggestion in suggestions:
                            self.appendOutput(suggestion, False)
                    if len(suggestions) == 1:
                        self.setCmd(' '.join(commandArray) + ' ' + suggestions.pop())
            else:
                suggestions = self.findTabComplete()
                if len(suggestions) > 1:
                    self.printCurrentCommand()
                    for suggestion in suggestions:
                        self.appendOutput(suggestion, False)

        class EnterPress(ActionListener): #TODO remove: AbstractAction
            def actionPerformed(self, e):
                Utils.consoleController.sendCommand(Utils.shellController.currentRequestId(), Utils.consoleInput.getText(), 'console')

            def keyPressed(self, e):
                Utils.out("key pressed")

        class KeyPress(KeyListener):
            def keyTyped(self, e):
                pass

            def keyReleased(self, e):
                if e.getKeyCode() == e.VK_DOWN:
                    Utils.consoleController.nextCommand()
                    Utils.out("released down")
                if e.getKeyCode() == e.VK_UP:
                    Utils.consoleController.previousCommand()
                    Utils.out("released up")

                if e.getKeyCode() == e.VK_TAB:
                    Utils.out("pressed tab")
                    Utils.consoleController.tabComplete()

            def keyPressed(self, e):
                pass
Esempio n. 18
0
class ProfelisPanel(JPanel):
    def __init__(self, frame, name):
        self.frame = frame
        self.exception = None
        self.name = name
        self.searchTerm = None
        self.searchIndex = -1

        self.searchField = JTextField("")
        self.searchField.addActionListener(SearchListener(self))

        self.newGeneFrom = JTextField("")
        self.newGeneTo = JTextField("")
        self.newGeneButton = JButton("New Gene")
        newGeneActionListener = NewGeneActionListener(self)
        self.newGeneFrom.addActionListener(newGeneActionListener)
        self.newGeneTo.addActionListener(newGeneActionListener)
        self.newGeneButton.addActionListener(newGeneActionListener)

        self.markForRemovalButton = JButton("Mark For Removal")
        self.markForRemovalButton.addActionListener(MarkForRemovalListener(self))
        
        self.inGenes = JList(DefaultListModel())
        self.inGenes.selectionMode = ListSelectionModel.SINGLE_SELECTION
        self.inGenes.cellRenderer = ProfelisCellRenderer()
        self.markButtonLabelerTimer = Timer(100, MarkButtonLabeler(self))
        self.markButtonLabelerTimer.start()
        self.loadFile()

        self.outGenes = JList(DefaultListModel())
        self.outGenes.selectionMode = ListSelectionModel.SINGLE_SELECTION
        self.outGenes.cellRenderer = ProfelisCellRenderer()
                
        constraints = GridBagConstraints()
        self.layout = GridBagLayout()
        
        constraints.gridx, constraints.gridy = 0, 0
        constraints.gridwidth, constraints.gridheight = 1, 1
        constraints.fill = GridBagConstraints.NONE
        constraints.weightx, constraints.weighty = 0, 0
        self.add(JLabel("Genes In Artemis File"), constraints)
        constraints.gridx, constraints.gridy = 0, 1
        self.add(JButton(RemoveAction(self)), constraints)
        constraints.gridx, constraints.gridy = 1, 1
        self.add(self.markForRemovalButton, constraints)
        constraints.gridx, constraints.gridy = 2, 1
        self.add(JLabel("Search"), constraints)
        constraints.gridx, constraints.gridy = 3, 1
        constraints.fill = GridBagConstraints.HORIZONTAL
        self.add(self.searchField, constraints)
        constraints.gridx, constraints.gridy = 0, 2
        constraints.gridwidth, constraints.gridheight = 4, 2
        constraints.fill = GridBagConstraints.BOTH
        constraints.weightx, constraints.weighty = 1, 1
        self.add(JScrollPane(self.inGenes), constraints)

        constraints.gridx, constraints.gridy = 4, 0
        constraints.gridwidth, constraints.gridheight = 1, 1
        constraints.fill = GridBagConstraints.NONE
        constraints.weightx, constraints.weighty = 0, 0
        self.add(JLabel("Genes To Add To Artemis File"), constraints)
        constraints.gridx, constraints.gridy = 4, 1
        self.add(self.newGeneButton, constraints)
        constraints.weightx = 1
        constraints.fill = GridBagConstraints.BOTH
        constraints.gridx, constraints.gridy = 5, 1
        self.add(self.newGeneFrom, constraints)
        constraints.weightx = 0
        constraints.fill = GridBagConstraints.NONE
        constraints.gridx, constraints.gridy = 6, 1
        self.add(JLabel("To"), constraints)
        constraints.weightx = 1
        constraints.fill = GridBagConstraints.BOTH
        constraints.gridx, constraints.gridy = 7, 1
        self.add(self.newGeneTo, constraints)

        constraints.weightx = 0
        constraints.fill = GridBagConstraints.NONE
        constraints.gridx, constraints.gridy = 4, 2
        self.add(JButton(AddGenesAction(self)), constraints)
        constraints.gridx, constraints.gridy = 4, 3
        constraints.gridwidth, constraints.gridheight = 4, 1
        constraints.fill = GridBagConstraints.BOTH
        constraints.weightx, constraints.weighty = 1, 1
        self.add(JScrollPane(self.outGenes), constraints)

    def loadFile(self):
        self.inGenes.model.clear()
        self.database, self.evalue, genes = utils.parseBlast(self.name + ".blastp.xml")
        [self.inGenes.model.addElement(gene) for gene in genes]

        artemisInput = open(self.name + ".art", "r")
        lines = artemisInput.readlines()
        artemisInput.close()
        self.restOfFile = self.genome = []
        while lines:
            if re.match("\s+CDS\s+(complement\()?\d+\.\.\d+\)?\n", lines[0]):
                lines = lines[4:]
            elif lines[0].find("ORIGIN") == 0:
                self.genome = map(lambda x: re.sub("\s+", "", x), lines[1:])
                lines = []
            else:
                if lines[0].strip():
                    self.restOfFile.append(lines[0])
                lines = lines[1:]
                
        self.genome = "".join(self.genome)
        self.restOfFile = "".join(self.restOfFile)

    def writeArtemisFile(self):
        output = open(self.name + ".art", "w")
        output.write(self.restOfFile)
        for element in self.inGenes.model.elements():
            output.write(element.toArtemis())
        output.write("\nORIGIN\n\n")
        for i in range(0, len(self.genome), 50):
            output.write(self.genome[i:min(i+50, len(self.genome))] + "\n")
        output.close()