def p_build_ui(self, event):
"""
Adds a list of checkboxes, one for each loaded plugin
to the Selct plugins window
"""
if not self.loaded_p_list:
self.update_scroll("[!!] No plugins loaded!")
return
scroll_pane = JScrollPane()
scroll_pane.setPreferredSize(Dimension(200, 250))
check_frame = JPanel(GridBagLayout())
constraints = GridBagConstraints()
constraints.fill = GridBagConstraints.HORIZONTAL
constraints.gridy = 0
constraints.anchor = GridBagConstraints.FIRST_LINE_START
for plug in self.loaded_p_list:
check_frame.add(JCheckBox(plug.get_name(), plug.enabled,
actionPerformed=self.update_box),
constraints)
constraints.gridy += 1
vport = JViewport()
vport.setView(check_frame)
scroll_pane.setViewport(vport)
self.window.contentPane.add(scroll_pane)
self.window.pack()
self.window.setVisible(True)
def __init__(self, controller):
'''
Creates default empty text area in a panel.
It will contain the ATF file content, and allow text edition.
It should highlight reserved words and suggest autocompletion or
possible typos, a la IDEs like Eclipse.
It might need refactoring so that there is a parent panel with two modes
or contexts, depending on user choice: text view or model view.
'''
#Give reference to controller to delegate action response
self.controller = controller
#Make text area occupy all available space and resize with parent window
self.setLayout(BorderLayout())
#Create text edition area
self.editArea = JTextArea()
self.editArea.border = BorderFactory.createEmptyBorder(4,4,4,4)
self.editArea.font = Font("Monaco", Font.PLAIN, 14)
#Will need scrolling controls
scrollingText = JScrollPane(self.editArea)
scrollingText.setPreferredSize(Dimension(1,500))
#Add to parent panel
self.add(scrollingText, BorderLayout.CENTER)
def __init__(self, controller):
'''
Creates default empty console-looking panel.
It should be separated from the rest of the GUI so that users can choose
to show or hide the console. Or should it be a split panel?
This panel will display log and validation/lemmatization messages.
It might need its own toolbar for searching, etc.
It will also accept commands in later stages of development, if need be.
'''
#Give reference to controller to delegate action response
self.controller = controller
#Make text area occupy all available space and resize with parent window
self.setLayout(BorderLayout())
#Create console-looking area
self.editArea = JTextArea()
self.editArea.border = BorderFactory.createEmptyBorder(4,4,4,4)
self.editArea.font = Font("Courier New", Font.BOLD, 14)
self.editArea.background = Color.BLACK
self.editArea.foreground = Color.WHITE
self.editArea.text = "Console started. Nammu's log will appear here.\n\n"
#Will need scrolling controls
scrollingText = JScrollPane(self.editArea)
scrollingText.setPreferredSize(Dimension(1,150))
#Make text area auto scroll down to last printed line
caret = self.editArea.getCaret();
caret.setUpdatePolicy(DefaultCaret.ALWAYS_UPDATE);
#Add to parent panel
self.add(scrollingText, BorderLayout.CENTER)
def __init__(self):
# Panel for Measurements
self.setLayout(BorderLayout())
# PAGE_START
''' show group/dataset names in the list (component/variable) names '''
self.cbfilemeasOut = JComboBox([])
bfilemeasOut= JButton('Measurements', actionPerformed= self.loadMeasOut)
p3= JPanel()
p3.setLayout(GridLayout(1,2))
p3.add(self.cbfilemeasOut)
p3.add(bfilemeasOut)
self.add(p3, BorderLayout.PAGE_START)
# LINE_START
root = DefaultMutableTreeNode('VarMeasurements')
self.tree = JTree(root)
scrollPane = JScrollPane() # add a scrollbar to the viewport
scrollPane.setPreferredSize(Dimension(230,320))
scrollPane.getViewport().setView((self.tree))
p4 = JPanel()
p4.add(scrollPane)
self.add(p4, BorderLayout.LINE_START)
# CENTER
''' represent a signal with matplot lib in textarea places '''
graficMeas= JTextArea()
self.add(graficMeas, BorderLayout.CENTER)
def p_build_ui(self, event):
"""
Adds a list of checkboxes, one for each loaded plugin
to the Selct plugins window
"""
if not self.loaded_p_list:
self.update_scroll("[!!] No plugins loaded!")
return
scroll_pane = JScrollPane()
scroll_pane.setPreferredSize(Dimension(200, 250))
check_frame = JPanel(GridBagLayout())
constraints = GridBagConstraints()
constraints.fill = GridBagConstraints.HORIZONTAL
constraints.gridy = 0
constraints.anchor = GridBagConstraints.FIRST_LINE_START
for plug in self.loaded_p_list:
check_frame.add(JCheckBox(plug.get_name(), plug.enabled,
actionPerformed=self.update_box),
constraints)
constraints.gridy += 1
vport = JViewport()
vport.setView(check_frame)
scroll_pane.setViewport(vport)
self.window.contentPane.add(scroll_pane)
self.window.pack()
self.window.setVisible(True)
def __init__(self): # constructor
#origing of coordinates
self.coordx = 10
self.coordy = 10
#inintialize values
self.Canvas = None
#create panel (what is inside the GUI)
self.panel = self.getContentPane()
self.panel.setLayout(GridLayout(9, 2))
self.setTitle('Subdividing ROIs')
#define buttons here:
self.Dapi_files = DefaultListModel()
mylist = JList(self.Dapi_files, valueChanged=self.open_dapi_image)
#mylist.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
mylist.setLayoutOrientation(JList.VERTICAL)
mylist.setVisibleRowCount(-1)
listScroller1 = JScrollPane(mylist)
listScroller1.setPreferredSize(Dimension(300, 80))
self.output_files = DefaultListModel()
mylist2 = JList(self.output_files)
#mylist.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
mylist2.setLayoutOrientation(JList.VERTICAL)
mylist2.setVisibleRowCount(-1)
listScroller2 = JScrollPane(mylist2)
listScroller2.setPreferredSize(Dimension(300, 80))
quitButton = JButton("Quit", actionPerformed=self.quit)
selectInputFolderButton = JButton("Select Input",
actionPerformed=self.select_input)
cubifyROIButton = JButton("Cubify ROI",
actionPerformed=self.cubify_ROI)
saveButton = JButton("Save ROIs", actionPerformed=self.save)
summsaveButton = JButton("Save Summary",
actionPerformed=self.save_summary)
self.textfield1 = JTextField('500')
#add buttons here
self.panel.add(listScroller1)
self.panel.add(listScroller2)
self.panel.add(selectInputFolderButton)
self.panel.add(Label("Adjust the size of the ROIs"))
self.panel.add(self.textfield1)
self.panel.add(cubifyROIButton)
self.panel.add(saveButton)
self.panel.add(summsaveButton)
self.panel.add(quitButton)
#self.panel.add(saveButton)
#self.panel.add(Zslider)
#other stuff to improve the look
self.pack() # packs the frame
self.setVisible(True) # shows the JFrame
self.setLocation(self.coordx, self.coordy)
def createList(self, content):
model = DefaultListModel()
for elem in content:
model.addElement(elem)
list = JList(model)
listPane = JScrollPane(list)
listPane.setPreferredSize(Dimension(250, 400))
return listPane, list, model
def createList(self, content):
model = DefaultListModel()
for elem in content:
model.addElement(elem)
list = JList(model)
listPane = JScrollPane(list)
listPane.setPreferredSize(Dimension(250, 400))
return listPane, list, model
def __init__(self): # constructor
# origing of coordinates
self.coordx = 10
self.coordy = 10
# inintialize values
self.Canvas = None
self.default_naming = 'MouseID_ExperimentalGroup_slide-X'
# create panel (what is inside the GUI)
self.panel = self.getContentPane()
self.panel.setLayout(GridLayout(8, 2))
self.setTitle('Subdividing ROIs')
# define buttons here:
self.subimage_number = DefaultListModel()
mylist = JList(self.subimage_number, valueChanged=self.open_lowres_image)
# mylist.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
mylist.setLayoutOrientation(JList.VERTICAL)
mylist.setVisibleRowCount(1)
listScroller1 = JScrollPane(mylist)
listScroller1.setPreferredSize(Dimension(200, 90))
quitButton = JButton("Quit", actionPerformed=self.quit)
selectInputFolderButton = JButton("Select Input", actionPerformed=self.select_input)
cubifyROIButton = JButton("Cubify ROI", actionPerformed=self.cubify_ROI)
saveButton = JButton("Save ROIs", actionPerformed=self.save_ROIs)
self.textfield1 = JTextField('18')
self.textfield2 = JTextField(self.default_naming)
self.textfield3 = JTextField('R-Tail')
self.textfield4 = JTextField('6, 4, 22.619')
self.textfield5 = JTextField('0')
# add buttons here
self.panel.add(Label("Name your image, or use filename"))
self.panel.add(self.textfield2)
self.panel.add(selectInputFolderButton)
self.panel.add(listScroller1)
self.panel.add(Label("Adjust the size of the squared ROIs"))
self.panel.add(self.textfield1)
self.panel.add(Label("give a name of your hand-drawn ROI"))
self.panel.add(self.textfield3)
self.panel.add(Label("For ARA: piram, ch, res"))
# piramid number (high to low), channel number, final resolution (um/px)"))
self.panel.add(self.textfield4)
self.panel.add(Label("Piramid to check (0:none; 1:highest)"))
self.panel.add(self.textfield5)
self.panel.add(cubifyROIButton)
self.panel.add(saveButton)
self.panel.add(quitButton)
# other stuff to improve the look
self.pack() # packs the frame
self.setVisible(True) # shows the JFrame
self.setLocation(self.coordx, self.coordy)
def __init__(self, controller):
'''
Creates default empty console-looking panel.
It should be separated from the rest of the GUI so that users can
choose to show or hide the console. Or should it be a split panel?
This panel will display log and validation/lemmatization messages.
It might need its own toolbar for searching, etc.
It will also accept commands in later stages of development, if need
be.
'''
# Give reference to controller to delegate action response
self.controller = controller
# Make text area occupy all available space and resize with parent
# window
self.setLayout(BorderLayout())
# Create console-looking area
self.edit_area = JEditorPane()
# Although most of the styling is done using css, we need to set these
# properties to ensure the html is rendered properly in the console
self.edit_area.border = BorderFactory.createEmptyBorder(6, 6, 6, 6)
self.edit_area.setContentType("text/html")
# Disable writing in the console - required to render hyperlinks
self.edit_area.setEditable(False)
# Map CSS color strings to Java Color objects
self.colors = {'Gray': Color(238, 238, 238),
'Black': Color(0, 0, 0),
'Yellow': Color(255, 255, 0)}
# Initial call to refresh console to set the console style properties
self.refreshConsole()
# Set up a hyperlink listener
listener = addEventListener(self.edit_area, HyperlinkListener,
'hyperlinkUpdate', self.handleEvent)
# Will need scrolling controls
scrollingText = JScrollPane(self.edit_area)
scrollingText.setPreferredSize(Dimension(1, 150))
# Make text area auto scroll down to last printed line
caret = self.edit_area.getCaret()
caret.setUpdatePolicy(DefaultCaret.ALWAYS_UPDATE)
# Add to parent panel
self.add(scrollingText, BorderLayout.CENTER)
def getContentPane():
global contentPane
global devicesList
global devicesPanel
if not contentPane:
global devicesListLabel
devicesListLabel = JLabel("Devices")
global devicesList
devicesList = JList([])
devicesList.setSelectionMode(ListSelectionModel.MULTIPLE_INTERVAL_SELECTION)
listScroller = JScrollPane(devicesList)
listScroller.setPreferredSize(Dimension(600, 400))
global connectButton
global focusButton
allDevsButton = JButton(ALL_DEVICES, actionPerformed=handleAllDevsBtn)
connectedDevsButton = JButton(CONNECTED_DEVICES,
actionPerformed=handleConnectedDevBtn)
connectButton = JButton(CONNECT, actionPerformed=handleConnectBtn)
focusButton = JButton(FOCUS, actionPerformed=handleFocusBtn)
focusButton.setVisible(False)
goInButton = JButton("Go in device", actionPerformed=handleGoInBtn)
deviceListButtons = JPanel()
deviceListButtons.add(allDevsButton)
deviceListButtons.add(connectedDevsButton)
deviceListButtons.add(connectButton)
deviceListButtons.add(focusButton)
deviceListButtons.add(goInButton)
devicesPanel = JPanel()
devicesPanel.setLayout(BoxLayout(devicesPanel, BoxLayout.Y_AXIS))
devicesPanel.add(devicesListLabel)
devicesPanel.add(listScroller)
devicesPanel.add(deviceListButtons)
contentPane = JPanel()
contentPane.setLayout(BorderLayout())
contentPane.add(devicesPanel, BorderLayout.WEST)
contentPane.add(getControlPanel(), BorderLayout.EAST)
contentPane.add(getScreenPanel(), BorderLayout.CENTER)
getScreenPanel().setVisible(False)
return contentPane
def __init__(self, controller):
'''
Creates default empty console-looking panel.
It should be separated from the rest of the GUI so that users can
choose to show or hide the console. Or should it be a split panel?
This panel will display log and validation/lemmatization messages.
It might need its own toolbar for searching, etc.
It will also accept commands in later stages of development, if need
be.
'''
# Give reference to controller to delegate action response
self.controller = controller
# Make text area occupy all available space and resize with parent
# window
self.setLayout(BorderLayout())
# Create console-looking area
self.edit_area = JTextArea()
self.edit_area.setLineWrap(True)
self.edit_area.setWrapStyleWord(True)
self.edit_area.border = BorderFactory.createEmptyBorder(4, 4, 4, 4)
self.edit_area.font = Font("Courier New", Font.BOLD, 14)
self.edit_area.background = Color.BLACK
self.edit_area.foreground = Color.WHITE
# Disable writing in the console
self.edit_area.setEditable(False)
# Will need scrolling controls
scrollingText = JScrollPane(self.edit_area)
scrollingText.setPreferredSize(Dimension(1, 150))
# Make text area auto scroll down to last printed line
caret = self.edit_area.getCaret()
caret.setUpdatePolicy(DefaultCaret.ALWAYS_UPDATE)
# Add to parent panel
self.add(scrollingText, BorderLayout.CENTER)
def __init__(self):
frame = JFrame("Jython JTable Example")
frame.setSize(500, 250)
frame.setLayout(BorderLayout())
self.tableData = [
['Mouse 1', eventNames[0], eventScriptType[0]],
['Mouse 2', eventNames[1] , eventScriptType[1]],
['Mouse 3', eventNames[2], eventScriptType[2]],
['Mouse 1 Shift', eventNames[3], eventScriptType[3]],
['Mouse 2 Shift',eventNames[4], eventScriptType[4]],
['Mouse 3 Shift',eventNames[5], eventScriptType[5]],
['Mouse 1 Control',eventNames[6], eventScriptType[6]],
['Mouse 2 Control',eventNames[7], eventScriptType[7]],
['Mouse 3 Control',eventNames[8], eventScriptType[8]],
]
colNames = ('Script/Event','Name','Type')
dataModel = DefaultTableModel(self.tableData, colNames)
self.table = JTable(dataModel)
scrollPane = JScrollPane()
scrollPane.setPreferredSize(Dimension(400,200))
scrollPane.getViewport().setView((self.table))
panel = JPanel()
panel.add(scrollPane)
frame.add(panel, BorderLayout.CENTER)
self.label = JLabel('Hello from Jython')
frame.add(self.label, BorderLayout.NORTH)
button = JButton('Save Settings',actionPerformed=self.setText)
frame.add(button, BorderLayout.SOUTH)
exitButton = JButton('Exit',actionPerformed=self.myExit)
frame.add(exitButton, BorderLayout.EAST)
frame.setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE)
frame.setVisible(True)
def __init__(self):
frame = JFrame("Jython JTable Example")
frame.setSize(500, 250)
frame.setLayout(BorderLayout())
self.tableData = [
['Mouse 1', eventNames[0], eventScriptType[0]],
['Mouse 2', eventNames[1], eventScriptType[1]],
['Mouse 3', eventNames[2], eventScriptType[2]],
['Mouse 1 Shift', eventNames[3], eventScriptType[3]],
['Mouse 2 Shift', eventNames[4], eventScriptType[4]],
['Mouse 3 Shift', eventNames[5], eventScriptType[5]],
['Mouse 1 Control', eventNames[6], eventScriptType[6]],
['Mouse 2 Control', eventNames[7], eventScriptType[7]],
['Mouse 3 Control', eventNames[8], eventScriptType[8]],
]
colNames = ('Script/Event', 'Name', 'Type')
dataModel = DefaultTableModel(self.tableData, colNames)
self.table = JTable(dataModel)
scrollPane = JScrollPane()
scrollPane.setPreferredSize(Dimension(400, 200))
scrollPane.getViewport().setView((self.table))
panel = JPanel()
panel.add(scrollPane)
frame.add(panel, BorderLayout.CENTER)
self.label = JLabel('Hello from Jython')
frame.add(self.label, BorderLayout.NORTH)
button = JButton('Save Settings', actionPerformed=self.setText)
frame.add(button, BorderLayout.SOUTH)
exitButton = JButton('Exit', actionPerformed=self.myExit)
frame.add(exitButton, BorderLayout.EAST)
frame.setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE)
frame.setVisible(True)
def __init__(self, title=""):
JFrame.__init__(self, title)
self.size = 400, 500
self.windowClosing = self.closing
label = JLabel(text="Class Name:")
label.horizontalAlignment = JLabel.RIGHT
tpanel = JPanel(layout=awt.FlowLayout())
self.text = JTextField(20, actionPerformed=self.entered)
btn = JButton("Enter", actionPerformed=self.entered)
tpanel.add(label)
tpanel.add(self.text)
tpanel.add(btn)
bpanel = JPanel()
self.tree = JTree(default_tree())
scrollpane = JScrollPane(self.tree)
scrollpane.setMinimumSize(awt.Dimension(200, 200))
scrollpane.setPreferredSize(awt.Dimension(350, 400))
bpanel.add(scrollpane)
bag = GridBag(self.contentPane)
bag.addRow(tpanel, fill='HORIZONTAL', weightx=1.0, weighty=0.5)
bag.addRow(bpanel, fill='BOTH', weightx=0.5, weighty=1.0)
def __init__(self, title=""):
JFrame.__init__(self, title)
self.size = 400,500
self.windowClosing = self.closing
label = JLabel(text="Class Name:")
label.horizontalAlignment = JLabel.RIGHT
tpanel = JPanel(layout = awt.FlowLayout())
self.text = JTextField(20, actionPerformed = self.entered)
btn = JButton("Enter", actionPerformed = self.entered)
tpanel.add(label)
tpanel.add(self.text)
tpanel.add(btn)
bpanel = JPanel()
self.tree = JTree(default_tree())
scrollpane = JScrollPane(self.tree)
scrollpane.setMinimumSize(awt.Dimension(200,200))
scrollpane.setPreferredSize(awt.Dimension(350,400))
bpanel.add(scrollpane)
bag = GridBag(self.contentPane)
bag.addRow(tpanel, fill='HORIZONTAL', weightx=1.0, weighty=0.5)
bag.addRow(bpanel, fill='BOTH', weightx=0.5, weighty=1.0)
def __init__(self):
super(WorkHelper, self).__init__()
self.clipboard = Toolkit.getDefaultToolkit().getSystemClipboard()
#############################################################
# Layout:
layout = GroupLayout(self.getContentPane())
self.getContentPane().setLayout(layout)
layout.setAutoCreateGaps(True)
layout.setAutoCreateContainerGaps(True)
#############################################################
#############################################################
# Frame Area:
Larea1 = JLabel("InputArea:")
Sarea1 = JScrollPane()
self.area1 = JTextArea()
self.area1.setToolTipText("Input Area")
self.area1.setEditable(True)
self.area1.setBorder(BorderFactory.createLineBorder(Color.gray))
Sarea1.setPreferredSize(Dimension(300,100))
Sarea1.getViewport().setView((self.area1))
bClear = JButton("Clear", actionPerformed=self.bClear)
bClear.setToolTipText("Clears the text form both Input and Output text Areas")
bCopyToInput = JButton("Copy to Input", actionPerformed=self.bCopyToInput)
bCopyToInput.setToolTipText("Copy the text from the Output Area to the Input Area for further Operations")
self.cCtClipB = JCheckBox("Auto-Copy");
self.cCtClipB.setToolTipText("When 'Checked' after the Categories are created they will added to the clipboard")
self.cCtClipB.setSelected(1)
Larea2 = JLabel("OutputArea:")
Sarea2 = JScrollPane()
self.area2 = JTextArea()
self.area2.setToolTipText("Output Area")
self.area2.setEditable(False)
self.area2.setBorder(BorderFactory.createLineBorder(Color.gray))
Sarea2.setPreferredSize(Dimension(300,100))
Sarea2.getViewport().setView((self.area2))
#############################################################
# Tabbed Area:
tabPane = JTabbedPane(JTabbedPane.TOP)
self.getContentPane().add(tabPane)
#####################################################
# Text Edit pane
panel_TEdit = JPanel()
layout2 = GroupLayout(panel_TEdit)
layout2.setAutoCreateGaps(True)
layout2.setAutoCreateContainerGaps(True)
panel_TEdit.setLayout(layout2)
bRemoveNBSP_L = JButton("Clean LText", actionPerformed=self.bRemoveNBSP_L)
bRemoveNBSP_L.setToolTipText("Removes Spaces, Tabs from the start of every text line from the input Area")
bRemoveNBSP_R = JButton("Clean RText", actionPerformed=self.bRemoveNBSP_R)
bRemoveNBSP_R.setToolTipText("Removes Spaces, Tabs from the end of every text line from the input Area")
self.ReplaceThis = JTextField()
self.ReplaceThis = JTextField(maximumSize=Dimension(120,25))
self.ReplaceThis.setToolTipText("Text to be replaced")
self.ReplaceThat = JTextField()
self.ReplaceThat = JTextField(maximumSize=Dimension(120,25))
self.ReplaceThat.setToolTipText("Text to be placed")
bSandReplace = JButton("Replace Text", actionPerformed=self.bSandReplace)
bSandReplace.setToolTipText("Replace the text from This with Text from That in the Text from the Input Area and displays it in the Output Area")
bRemNumbers = JButton("Rem Numbers", actionPerformed=self.RemNumbers)
bRemNumbers.setToolTipText("Removes numbers from the start of every line")
#####################################################
# Dimension pane
panel_Dimensions = JPanel()
layout3 = GroupLayout(panel_Dimensions)
layout3.setAutoCreateGaps(True)
layout3.setAutoCreateContainerGaps(True)
panel_Dimensions.setLayout(layout3)
self.cCurly = JCheckBox("Curly");
self.cCurly.setToolTipText("When 'Checked' Curly Brackets will surround the Categories")
self.cCurly.setSelected(1)
self.cSemiC = JCheckBox("SemiColumn");
self.cSemiC.setToolTipText("When 'Checked' after the Categories are created at the end will be a semicolomn")
self.cSemiC.setSelected(1)
self.iStart = JTextField(maximumSize=Dimension(40,25))
self.iStart.setToolTipText("The Start Index for the Making of the Categories")
self.RThis = JTextField()
self.RThis = JTextField(maximumSize=Dimension(120,25))
self.RThis.setToolTipText("The Starting Index used in creating the Categorical")
self.RThat = JTextField()
self.RThat = JTextField(maximumSize=Dimension(120,25))
self.RThat.setToolTipText("The Finish Index used in creating the Categorical")
optioncCategories = JLabel("Options:")
bcCat = JButton("CreatCateg", actionPerformed=self.bcCat)
bcCat.setToolTipText("Create a categorical form starting C_Index to finish C_Index; Use the text boxes to define the indexes")
bM_Categories = JButton("Categories", actionPerformed=self.mCategories)
bM_Categories.setToolTipText("Make Categories using the lines from the Input Area. Use it to define Categorical questions.")
#####################################################
# ConfirmIt pane
panel_ConfirmIt = JPanel()
layout4 = GroupLayout(panel_ConfirmIt)
layout4.setAutoCreateGaps(True)
layout4.setAutoCreateContainerGaps(True)
panel_ConfirmIt.setLayout(layout4)
self.PID = JTextField()
self.PID = JTextField(maximumSize=Dimension(120,25))
self.PID.setToolTipText("The PID number used for creating links with PID and ids from every line of the Input Area")
bClinks = JButton("Create Links", actionPerformed=self.bClinks)
bClinks.setToolTipText("Create links for a project using PID and ID, ID`s are read from every line of the Input Area")
bClinksNA = JButton("Create Links NA ", actionPerformed=self.bClinksNA)
bClinksNA.setToolTipText("Create links for a project using PID and ID`s from the standard sample test for US")
bClinksCA = JButton("Create Links CA", actionPerformed=self.bClinksCA)
bClinksCA.setToolTipText("Create links for a project using PID and ID`s from the standard sample test for CA")
self.Width = JTextField()
self.Width = JTextField(maximumSize=Dimension(120,25))
self.Width.setToolTipText("The Width used in creating the DIV html tag, note the dimension used is in px")
baddDIVt = JButton("Add DIV tag", actionPerformed=self.baddDIVt)
baddDIVt.setToolTipText("Create a DIV tag for every line in the Input Area")
#####################################################
# Statistics pane
panel_Statistics = JPanel()
layout5 = GroupLayout(panel_Statistics)
layout5.setAutoCreateGaps(True)
layout5.setAutoCreateContainerGaps(True)
panel_Statistics.setLayout(layout5)
#####################################################
# TimeTraking pane
panel_TimeTraking = JPanel()
layout6 = GroupLayout(panel_TimeTraking)
layout6.setAutoCreateGaps(True)
layout6.setAutoCreateContainerGaps(True)
panel_TimeTraking.setLayout(layout6)
#####################################################
# Tabbed Area Tabs
tabPane.addTab("Text Edit", panel_TEdit)
tabPane.addTab("Dimensions", panel_Dimensions)
tabPane.addTab("ConfirmIt", panel_ConfirmIt)
tabPane.addTab("Statistics", panel_Statistics)
tabPane.addTab("TimeTraking", panel_TimeTraking)
#############################################################
#############################################################
# Aplication Layouts: 2 groups one Horizontal and one Vertical
#############################################################
# Frame Layout: 2 groups one Horizontal and one Vertical
layout.setHorizontalGroup(layout.createSequentialGroup()
.addGroup(layout.createParallelGroup()
.addComponent(Larea1)
.addComponent(Sarea1)
.addComponent(Sarea2)
.addGroup(layout.createSequentialGroup()
.addComponent(bCopyToInput)
.addComponent(bClear)
.addComponent(self.cCtClipB))
.addComponent(Larea2))
.addGroup(layout.createParallelGroup()
.addComponent(tabPane))
)
layout.setVerticalGroup(layout.createSequentialGroup()
.addGroup(layout.createParallelGroup()
.addGroup(layout.createSequentialGroup()
.addComponent(Larea1)
.addComponent(Sarea1)
.addGroup(layout.createParallelGroup()
.addComponent(bCopyToInput)
.addComponent(bClear)
.addComponent(self.cCtClipB) )
.addComponent(Larea2)
.addComponent(Sarea2))
.addGroup(layout.createSequentialGroup()
.addComponent(tabPane))
)
)
#############################################################
# TEdit Layout: 2 groups one Horizontal and one Vertical
layout2.setHorizontalGroup(layout2.createSequentialGroup()
.addGroup(layout2.createParallelGroup()
.addGroup(layout2.createSequentialGroup()
.addComponent(bRemNumbers)
.addComponent(bRemoveNBSP_L)
.addComponent(bRemoveNBSP_R))
.addGroup(layout2.createSequentialGroup()
.addComponent(bSandReplace)
.addComponent(self.ReplaceThis)
.addComponent(self.ReplaceThat))
))
layout2.setVerticalGroup(layout2.createSequentialGroup()
.addGroup(layout2.createParallelGroup()
.addComponent(bRemNumbers)
.addComponent(bRemoveNBSP_L)
.addComponent(bRemoveNBSP_R))
.addGroup(layout2.createParallelGroup()
.addComponent(bSandReplace)
.addComponent(self.ReplaceThis)
.addComponent(self.ReplaceThat))
)
#############################################################
# Dimensions Layout: 2 groups one Horizontal and one Vertical
layout3.setHorizontalGroup(layout3.createSequentialGroup()
.addGroup(layout3.createParallelGroup()
.addGroup(layout3.createSequentialGroup()
.addComponent(bM_Categories)
.addComponent(self.iStart))
.addGroup(layout3.createSequentialGroup()
.addComponent(optioncCategories)
.addComponent(self.cCurly)
.addComponent(self.cSemiC)
)
.addGroup(layout3.createSequentialGroup()
.addComponent(bcCat)
.addComponent(self.RThis)
.addComponent(self.RThat))
.addGroup(layout3.createSequentialGroup()
)
)
)
layout3.setVerticalGroup(layout3.createSequentialGroup()
.addGroup(layout3.createSequentialGroup()
.addGroup(layout3.createParallelGroup()
.addComponent(bM_Categories)
.addComponent(self.iStart))
.addGroup(layout3.createParallelGroup()
.addComponent(bcCat)
.addComponent(self.RThis)
.addComponent(self.RThat))
.addGroup(layout3.createParallelGroup()
.addGroup(layout3.createParallelGroup()
.addComponent(optioncCategories)
.addComponent(self.cCurly)
.addComponent(self.cSemiC)
)
)
)
)
#############################################################
# ConfimIT Layout: 2 groups one Horizontal and one Vertical
layout4.setHorizontalGroup(layout4.createSequentialGroup()
.addGroup(layout4.createParallelGroup()
.addGroup(layout4.createSequentialGroup()
.addComponent(bClinks)
.addComponent(self.PID)
)
.addGroup(layout4.createSequentialGroup()
.addComponent(bClinksNA)
.addComponent(bClinksCA)
)
.addGroup(layout4.createSequentialGroup()
.addComponent(baddDIVt)
.addComponent(self.Width)
)
))
layout4.setVerticalGroup(layout4.createSequentialGroup()
.addGroup(layout4.createSequentialGroup()
.addGroup(layout4.createParallelGroup()
.addComponent(bClinks)
.addComponent(self.PID))
.addGroup(layout4.createParallelGroup()
.addComponent(bClinksNA)
.addComponent(bClinksCA)
)
.addGroup(layout4.createParallelGroup()
.addComponent(baddDIVt)
.addComponent(self.Width)
)
))
#layout2.linkSize(SwingConstants.HORIZONTAL, [self.cCurly,bM_Categories])
#layout.linkSize(SwingConstants.HORIZONTAL, [ok, bCopyToInput, close, bM_Categories])
#layout3.linkSize(SwingConstants.HORIZONTAL, [self.RThis,self.RThat,bRemoveNBSP_L,bRemoveNBSP_R,bM_Categories,bSandReplace,bcCat])
#############################################################
#############################################################
# Aplication Settings
self.pack()
#self.setPreferredSize(Dimension(1000, 1000))
self.setTitle("Workhelper")
self.setSize(800, 500)
self.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE)
self.setLocationRelativeTo(None)
self.setVisible(True)
def getUiComponent(self):
#
# Button functions
#
# Apply regex and preview
def regexify(event):
withSect = re.sub(regexBox.getText(), lambda m: unichr(167) + m.group(0) + unichr(167), contentBox.getText(), flags = re.M)
resultsBox.setText(withSect)
resultsBox.requestFocusInWindow()
return
# Actually send to Intruder
def sendToIntruder(event):
# TODO Parse host, port, and SSL
offsets = ArrayList()
p = re.compile(regexBox.getText())
for m in p.finditer(contentBox.getText()):
offsets.add(array((m.start(), m.end()), 'i'))
self._callbacks.sendToIntruder("www.example.com", 80, False, contentBox.getText(), offsets)
return
# HTML body box
body = """POST /example?p1=p1val&p2=p2val HTTP/1.0
Cookie: c=cval
Content-Length: 17
p3=p3val&p4=p4val&asdf=1234&qwer=123
<b>test</b>
<xml body:something tag='asdf'>
</xml>
§"""
# HTTP request box
contentBox = JTextArea(body, 10, 80)
contentBoxScroll = JScrollPane(contentBox)
# Regex box
regexBox = JTextField("[0-9]{3}", 40)
# Buttons
btnRegexify = JButton("Regexify", actionPerformed=regexify)
btnSendToIntruder = JButton("Send to Intruder", actionPerformed=sendToIntruder)
# Results box
resultsBox = JTextArea("Results will be shown here", 10, 80)
resultsBoxScroll = JScrollPane(resultsBox)
# Main panel
mainPanel = JPanel(GridBagLayout())
gbc = GridBagConstraints()
gbc.gridx = 0
gbc.gridy = 0
gbc.weightx = 0.8
contentBoxScroll.setPreferredSize(Dimension(1000, 300))
mainPanel.add(contentBoxScroll, gbc)
gbc.gridx = 1
gbc.gridy = 0
gbc.weightx = 0.1
mainPanel.add(regexBox, gbc)
gbc.gridx = 1
gbc.gridy = 1
gbc.weightx = 0.1
mainPanel.add(btnRegexify, gbc)
gbc.gridx = 1
gbc.gridy = 3
gbc.weightx = 0.1
mainPanel.add(btnSendToIntruder, gbc)
gbc.gridx = 0
gbc.gridy = 2
gbc.weightx = 1
gbc.weighty = 1
resultsBoxScroll.setPreferredSize(Dimension(1000, 300))
mainPanel.add(resultsBoxScroll, gbc)
return mainPanel
class BurpExtender(IBurpExtender, ITab, IHttpListener, IMessageEditorController, AbstractTableModel, IContextMenuFactory, IHttpRequestResponseWithMarkers, ITextEditor):
def registerExtenderCallbacks(self, callbacks):
self._callbacks = callbacks
#Initialize callbacks to be used later
self._helpers = callbacks.getHelpers()
callbacks.setExtensionName("Trishul")
self._log = ArrayList()
#_log used to store our outputs for a URL, which is retrieved later by the tool
self._lock = Lock()
#Lock is used for locking threads while updating logs in order such that no multiple updates happen at once
self.intercept = 0
self.FOUND = "Found"
self.CHECK = "Possible! Check Manually"
self.NOT_FOUND = "Not Found"
#Static Values for output
#Initialize GUI
self.issuesTab()
self.advisoryReqResp()
self.configTab()
self.tabsInit()
self.definecallbacks()
print("Thank You for Installing Trishul")
return
#
#Initialize Issues Tab displaying the JTree
#
def issuesTab(self):
self.root = DefaultMutableTreeNode('Issues')
frame = JFrame("Issues Tree")
self.tree = JTree(self.root)
self.rowSelected = ''
self.tree.addMouseListener(mouseclick(self))
self.issuepanel = JScrollPane()
self.issuepanel.setPreferredSize(Dimension(300,450))
self.issuepanel.getViewport().setView((self.tree))
frame.add(self.issuepanel,BorderLayout.CENTER)
#
#Adding Issues to Issues TreePath
#
def addIssues(self, branch, branchData=None):
if branchData == None:
branch.add(DefaultMutableTreeNode('No valid data'))
else:
for item in branchData:
branch.add(DefaultMutableTreeNode(item))
#
#Initialize the Config Tab to modify tool settings
#
def configTab(self):
Config = JLabel("Config")
self.startButton = JToggleButton("Intercept Off", actionPerformed=self.startOrStop)
self.startButton.setBounds(40, 30, 200, 30)
self.autoScroll = JCheckBox("Auto Scroll")
self.autoScroll.setBounds(40, 80, 200, 30)
self.xsscheck = JCheckBox("Detect XSS")
self.xsscheck.setSelected(True)
self.xsscheck.setBounds(40, 110, 200, 30)
self.sqlicheck = JCheckBox("Detect SQLi")
self.sqlicheck.setSelected(True)
self.sqlicheck.setBounds(40, 140, 200, 30)
self.ssticheck = JCheckBox("Detect SSTI")
self.ssticheck.setSelected(True)
self.ssticheck.setBounds(40, 170, 200, 30)
self.blindxss = JCheckBox("Blind XSS")
self.blindxss.setBounds(40, 200, 200, 30)
self.BlindXSSText = JTextArea("", 5, 30)
scrollbxssText = JScrollPane(self.BlindXSSText)
scrollbxssText.setVerticalScrollBarPolicy(JScrollPane.VERTICAL_SCROLLBAR_AS_NEEDED)
scrollbxssText.setBounds(40, 250, 400, 110)
self.configtab = JPanel()
self.configtab.setLayout(None)
self.configtab.setBounds(0, 0, 300, 300)
self.configtab.add(Config)
self.configtab.add(self.startButton)
self.configtab.add(self.autoScroll)
self.configtab.add(self.xsscheck)
self.configtab.add(self.sqlicheck)
self.configtab.add(self.ssticheck)
self.configtab.add(self.blindxss)
self.configtab.add(scrollbxssText)
#
#Turn Intercept from Proxy on or off
#
def startOrStop(self, event):
if self.startButton.getText() == "Intercept Off":
self.startButton.setText("Intercept On")
self.startButton.setSelected(True)
self.intercept = 1
else:
self.startButton.setText("Intercept Off")
self.startButton.setSelected(False)
self.intercept = 0
#
#Intialize the Advisory, Request and Response Tabs
#
def advisoryReqResp(self):
self.textfield = JEditorPane("text/html", "")
self.kit = HTMLEditorKit()
self.textfield.setEditorKit(self.kit)
self.doc = self.textfield.getDocument()
self.textfield.setEditable(0)
self.advisorypanel = JScrollPane()
self.advisorypanel.getVerticalScrollBar()
self.advisorypanel.setPreferredSize(Dimension(300,450))
self.advisorypanel.getViewport().setView((self.textfield))
self.selectedreq = []
self._requestViewer = self._callbacks.createMessageEditor(self, False)
self._responseViewer = self._callbacks.createMessageEditor(self, False)
self._texteditor = self._callbacks.createTextEditor()
self._texteditor.setEditable(False)
#
#Initialize Trishul Tabs
#
def tabsInit(self):
self.logTable = Table(self)
tableWidth = self.logTable.getPreferredSize().width
self.logTable.getColumn("#").setPreferredWidth(Math.round(tableWidth / 50 * 0.1))
self.logTable.getColumn("Method").setPreferredWidth(Math.round(tableWidth / 50 * 3))
self.logTable.getColumn("URL").setPreferredWidth(Math.round(tableWidth / 50 * 40))
self.logTable.getColumn("Parameters").setPreferredWidth(Math.round(tableWidth / 50 * 1))
self.logTable.getColumn("XSS").setPreferredWidth(Math.round(tableWidth / 50 * 4))
self.logTable.getColumn("SQLi").setPreferredWidth(Math.round(tableWidth / 50 * 4))
self.logTable.getColumn("SSTI").setPreferredWidth(Math.round(tableWidth / 50 * 4))
self.logTable.getColumn("Request Time").setPreferredWidth(Math.round(tableWidth / 50 * 4))
self.tableSorter = TableRowSorter(self)
self.logTable.setRowSorter(self.tableSorter)
self._bottomsplit = JSplitPane(JSplitPane.HORIZONTAL_SPLIT)
self._bottomsplit.setDividerLocation(500)
self.issuetab = JTabbedPane()
self.issuetab.addTab("Config",self.configtab)
self.issuetab.addTab("Issues",self.issuepanel)
self._bottomsplit.setLeftComponent(self.issuetab)
self.tabs = JTabbedPane()
self.tabs.addTab("Advisory",self.advisorypanel)
self.tabs.addTab("Request", self._requestViewer.getComponent())
self.tabs.addTab("Response", self._responseViewer.getComponent())
self.tabs.addTab("Highlighted Response", self._texteditor.getComponent())
self._bottomsplit.setRightComponent(self.tabs)
self._splitpane = JSplitPane(JSplitPane.VERTICAL_SPLIT)
self._splitpane.setDividerLocation(450)
self._splitpane.setResizeWeight(1)
self.scrollPane = JScrollPane(self.logTable)
self._splitpane.setLeftComponent(self.scrollPane)
self.scrollPane.getVerticalScrollBar().addAdjustmentListener(autoScrollListener(self))
self._splitpane.setRightComponent(self._bottomsplit)
#
#Initialize burp callbacks
#
def definecallbacks(self):
self._callbacks.registerHttpListener(self)
self._callbacks.customizeUiComponent(self._splitpane)
self._callbacks.customizeUiComponent(self.logTable)
self._callbacks.customizeUiComponent(self.scrollPane)
self._callbacks.customizeUiComponent(self._bottomsplit)
self._callbacks.registerContextMenuFactory(self)
self._callbacks.addSuiteTab(self)
#
#Menu Item to send Request to Trishul
#
def createMenuItems(self, invocation):
responses = invocation.getSelectedMessages()
if responses > 0:
ret = LinkedList()
requestMenuItem = JMenuItem("Send request to Trishul")
for response in responses:
requestMenuItem.addActionListener(handleMenuItems(self,response, "request"))
ret.add(requestMenuItem)
return ret
return None
#
#Highlighting Response
#
def markHttpMessage( self, requestResponse, responseMarkString ):
responseMarkers = None
if responseMarkString:
response = requestResponse.getResponse()
responseMarkBytes = self._helpers.stringToBytes( responseMarkString )
start = self._helpers.indexOf( response, responseMarkBytes, False, 0, len( response ) )
if -1 < start:
responseMarkers = [ array( 'i',[ start, start + len( responseMarkBytes ) ] ) ]
requestHighlights = [array( 'i',[ 0, 5 ] )]
return self._callbacks.applyMarkers( requestResponse, requestHighlights, responseMarkers )
def getTabCaption(self):
return "Trishul"
def getUiComponent(self):
return self._splitpane
#
#Table Model to display URL's and results based on the log size
#
def getRowCount(self):
try:
return self._log.size()
except:
return 0
def getColumnCount(self):
return 8
def getColumnName(self, columnIndex):
data = ['#','Method', 'URL', 'Parameters', 'XSS', 'SQLi', "SSTI", "Request Time"]
try:
return data[columnIndex]
except IndexError:
return ""
def getColumnClass(self, columnIndex):
data = [Integer, String, String, Integer, String, String, String, String]
try:
return data[columnIndex]
except IndexError:
return ""
#Get Data stored in log and display in the respective columns
def getValueAt(self, rowIndex, columnIndex):
logEntry = self._log.get(rowIndex)
if columnIndex == 0:
return rowIndex+1
if columnIndex == 1:
return logEntry._method
if columnIndex == 2:
return logEntry._url.toString()
if columnIndex == 3:
return len(logEntry._parameter)
if columnIndex == 4:
return logEntry._XSSStatus
if columnIndex == 5:
return logEntry._SQLiStatus
if columnIndex == 6:
return logEntry._SSTIStatus
if columnIndex == 7:
return logEntry._req_time
return ""
def getHttpService(self):
return self._currentlyDisplayedItem.getHttpService()
def getRequest(self):
return self._currentlyDisplayedItem.getRequest()
def getResponse(self):
return self._currentlyDisplayedItem.getResponse()
#For Intercepted requests perform tests in scope
def processHttpMessage(self, toolFlag, messageIsRequest, messageInf):
if self.intercept == 1:
if toolFlag == self._callbacks.TOOL_PROXY:
if not messageIsRequest:
requestInfo = self._helpers.analyzeRequest(messageInf)
requeststr = requestInfo.getUrl()
parameters = requestInfo.getParameters()
param_new = [p for p in parameters if p.getType() != 2]
if len(param_new) != 0:
if self._callbacks.isInScope(URL(str(requeststr))):
start_new_thread(self.sendRequestToTrishul,(messageInf,))
return
#
#Main processing of Trishul
#
def sendRequestToTrishul(self,messageInfo):
request = messageInfo.getRequest()
req_time = datetime.datetime.today()
requestURL = self._helpers.analyzeRequest(messageInfo).getUrl()
messageInfo = self._callbacks.makeHttpRequest(self._helpers.buildHttpService(str(requestURL.getHost()), int(requestURL.getPort()), requestURL.getProtocol() == "https"), request)
resp_time = datetime.datetime.today()
time_taken = (resp_time - req_time).total_seconds()
response = messageInfo.getResponse()
#initialozations of default value
SQLiimp = self.NOT_FOUND
SSTIimp = self.NOT_FOUND
XSSimp = self.NOT_FOUND
Comp_req = messageInfo
requestInfo = self._helpers.analyzeRequest(messageInfo)
self.content_resp = self._helpers.analyzeResponse(response)
requestURL = requestInfo.getUrl()
parameters = requestInfo.getParameters()
requeststring = self._helpers.bytesToString(request)
headers = requestInfo.getHeaders()
#Used to obtain GET, POST and JSON parameters from burp api
param_new = [p for p in parameters if p.getType() == 0 or p.getType() == 1 or p.getType() == 6]
i = 0
xssflag=0
sqliflag=0
sstiflag=0
resultxss = []
resultsqli = []
resultssti = []
xssreqresp = []
sqlireqresp = []
sstireqresp = []
ssti_description = []
sqli_description = []
xss_description = []
for i in range(len(param_new)):
name = param_new[i].getName()
ptype = param_new[i].getType()
param_value = param_new[i].getValue()
#check XSS if ticked
if self.xsscheck.isSelected():
score = 0
flag1 = 0
XSSimp = self.NOT_FOUND
payload_array = ["<", ">", "\\\\'asd", "\\\\\"asd", "\\", "'\""]
json_payload_array = ["<", ">", "\\\\'asd", "\\\"asd", "\\", "\'\\\""]
payload_all = ""
json_payload = ""
rand_str = "testtest"
for payload in payload_array:
payload_all = payload_all+rand_str+payload
payload_all = URLEncoder.encode(payload_all, "UTF-8")
for payload in json_payload_array:
json_payload = json_payload+rand_str+payload
json_payload = URLEncoder.encode(json_payload, "UTF-8")
if ptype == 0 or ptype == 1:
new_paramters_value = self._helpers.buildParameter(name, payload_all, ptype)
updated_request = self._helpers.updateParameter(request, new_paramters_value)
else:
jsonreq = re.search(r"\s([{\[].*?[}\]])$", requeststring).group(1)
new = jsonreq.split(name+"\":",1)[1]
if new.startswith('\"'):
newjsonreq = jsonreq.replace(name+"\":\""+param_value,name+"\":\""+json_payload)
else:
newjsonreq = jsonreq.replace(name+"\":"+param_value,name+"\":\""+json_payload+"\"")
updated_request = self._helpers.buildHttpMessage(headers, newjsonreq)
attack = self.makeRequest(Comp_req, updated_request)
response = attack.getResponse()
response_str = self._helpers.bytesToString(response)
xssreqresp.append(attack)
if_found_payload = ""
non_encoded_symbols = ""
for check_payload in payload_array:
if_found_payload = rand_str+check_payload
if if_found_payload in response_str:
non_encoded_symbols = non_encoded_symbols+"<br>"+check_payload.replace('<', '<')
score = score+1
flag1 = 1
if score > 2: XSSimp = self.CHECK
if score > 3: XSSimp = self.FOUND
xssflag = self.checkBetterScore(score,xssflag)
if non_encoded_symbols == " \\\\'asd":
XSSimp = self.NOT_FOUND
if non_encoded_symbols != '':
xss_description.append("The Payload <b>" + payload_all.replace('<', '<') + "</b> was passed in the request for the paramater <b>" + self._helpers.urlDecode(name) + "</b>. Some Tags were observed in the output unfiltered. A payload can be generated with the observed tags.<br>Symbols not encoded for parameter <b>" + name + "</b>: " + non_encoded_symbols)
else:
xss_description.append("")
else:
XSSimp = "Disabled"
resultxss.append(XSSimp)
if self.sqlicheck.isSelected():
SQLiimp = self.NOT_FOUND
score = 0
value = "%27and%28select%2afrom%28select%28sleep%285%29%29%29a%29--"
orig_time = datetime.datetime.today()
if ptype == 0 or ptype == 1:
new_paramters_value = self._helpers.buildParameter(name, value, ptype)
updated_request = self._helpers.updateParameter(request, new_paramters_value)
else:
jsonreq = re.search(r"\s([{\[].*?[}\]])$", requeststring).group(1)
new = jsonreq.split(name+"\":",1)[1]
if new.startswith('\"'):
newjsonreq = jsonreq.replace(name+"\":\""+param_value,name+"\":\""+value)
else:
newjsonreq = jsonreq.replace(name+"\":"+param_value,name+"\":\""+value+"\"")
updated_request = self._helpers.buildHttpMessage(headers, newjsonreq)
attack1 = self.makeRequest(Comp_req, updated_request)
response1 = attack1.getResponse()
new_time = datetime.datetime.today()
response_str1 = self._helpers.bytesToString(response1)
sqlireqresp.append(attack1)
diff = (new_time - orig_time).total_seconds()
if (diff - time_taken) > 3:
score = 4
self.error_array = ["check the manual that corresponds to your", "You have an error", "syntax error", "SQL syntax", "SQL statement", "ERROR:", "Error:", "MySQL","Warning:","mysql_fetch_array()"]
found_text = ""
for error in self.error_array:
if error in response_str1:
found_text = found_text + error
score = score + 1
if score > 1: SQLiimp = self.CHECK
if score > 2: SQLiimp = self.FOUND
sqliflag = self.checkBetterScore(score,sqliflag)
if found_text != '':
sqli_description.append("The payload <b>"+self._helpers.urlDecode(value)+"</b> was passed in the request for parameter <b>"+self._helpers.urlDecode(name)+"</b>. Some errors were generated in the response which confirms that there is an Error based SQLi. Please check the request and response for this parameter")
elif (diff - time_taken) > 3:
sqli_description.append("The payload <b>"+self._helpers.urlDecode(value)+"</b> was passed in the request for parameter <b>"+self._helpers.urlDecode(name)+"</b>. The response was in a delay of <b>"+str(diff)+"</b> seconds as compared to original <b>"+str(time_taken)+"</b> seconds. This indicates that there is a time based SQLi. Please check the request and response for this parameter")
else:
sqli_description.append("")
else:
SQLiimp = "Disabled"
resultsqli.append(SQLiimp)
if self.ssticheck.isSelected():
score = 0
SSTIimp = self.NOT_FOUND
payload_array = ["${123*456}", "<%=123*567%>", "{{123*678}}"]
json_payload_array = ["$\{123*456\}", "<%=123*567%>", "\{\{123*678\}\}"]
payload_all = ""
rand_str = "jjjjjjj"
json_payload = ""
for payload in payload_array:
payload_all = payload_all+rand_str+payload
for payload in json_payload_array:
json_payload = json_payload+rand_str+payload
payload_all = URLEncoder.encode(payload_all, "UTF-8")
json_payload = URLEncoder.encode(json_payload, "UTF-8")
if ptype == 0 or ptype == 1:
new_paramters_value = self._helpers.buildParameter(name, payload_all, ptype)
updated_request = self._helpers.updateParameter(request, new_paramters_value)
else:
jsonreq = re.search(r"\s([{\[].*?[}\]])$", requeststring).group(1)
new = jsonreq.split(name+"\":",1)[1]
if new.startswith('\"'):
newjsonreq = jsonreq.replace(name+"\":\""+param_value,name+"\":\""+json_payload)
else:
newjsonreq = jsonreq.replace(name+"\":"+param_value,name+"\":\""+json_payload+"\"")
updated_request = self._helpers.buildHttpMessage(headers, newjsonreq)
attack = self.makeRequest(Comp_req, updated_request)
response = attack.getResponse()
response_str = self._helpers.bytesToString(response)
self.expected_output = ["56088","69741","83394","3885","777777777777777"]
for output in self.expected_output:
if_found_payload = rand_str+output
if if_found_payload in response_str:
if output == self.expected_output[0]:
sstireqresp.append(attack)
ssti_description.append("Parameter <b>" + self._helpers.urlDecode(name) + "</b> is using <b>Java</b> Template<br>The value <b>" + payload_new + "</b> was passed which gave result as <b>56088</b>")
score = 2
if output == self.expected_output[1]:
sstireqresp.append(attack)
ssti_description.append("Parameter <b>" + self._helpers.urlDecode(name) + "</b> is using <b>Ruby</b> Template<br>The value <b>" + payload_new + "</b> was passed which gave result as <b>69741</b>")
score = 2
if output == self.expected_output[2]:
payload_new = "{{5*'777'}}"
json_payload_ssti = "\{\{5*'777'\}\}"
payload = URLEncoder.encode("{{5*'777'}}", "UTF-8")
json_ssti = URLEncoder.encode("\{\{5*'777'\}\}", "UTF-8")
if ptype == 0 or ptype == 1:
new_paramters = self._helpers.buildParameter(name, payload, ptype)
ssti_updated_request = self._helpers.updateParameter(request, new_paramters)
else:
jsonreq = re.search(r"\s([{\[].*?[}\]])$", requeststring).group(1)
new = jsonreq.split(name+"\":",1)[1]
if new.startswith('\"'):
newjsonreq = jsonreq.replace(name+"\":\""+param_value,name+"\":\""+json_ssti)
else:
newjsonreq = jsonreq.replace(name+"\":"+param_value,name+"\":\""+json_ssti+"\"")
ssti_updated_request = self._helpers.buildHttpMessage(headers, newjsonreq)
self.ssti_attack = self.makeRequest(Comp_req, ssti_updated_request)
ssti_response = self.ssti_attack.getResponse()
ssti_response_str = self._helpers.bytesToString(ssti_response)
if self.expected_output[3] in ssti_response_str:
sstireqresp.append(self.ssti_attack)
ssti_description.append("Parameter <b>" + self._helpers.urlDecode(name) + "</b> is using <b>Twig</b> Template<br>The value <b>" + payload_new + "</b> was passed which gave result as <b>3885</b>")
score = 2
elif self.expected_output[4] in ssti_response_str:
sstireqresp.append(self.ssti_attack)
self.responseMarkString = "777777777777777"
ssti_description.append("Parameter <b>" + self._helpers.urlDecode(name) + "</b> is using <b>Jinja2</b> Template<br>The value <b>" + payload_new + "</b> was passed which gave result as <b>777777777777777</b>")
score = 2
if score > 0: SSTIimp = self.CHECK
if score > 1: SSTIimp = self.FOUND
sstiflag = self.checkBetterScore(score,sstiflag)
else:
SSTIimp = "Disabled"
resultssti.append(SSTIimp)
if self.blindxss.isSelected():
blindxss_value = self.BlindXSSText.getText()
if ptype == 0 or ptype == 1:
new_paramters_value = self._helpers.buildParameter(name, blindxss_value, ptype)
updated_request = self._helpers.updateParameter(request, new_paramters_value)
else:
jsonreq = re.search(r"\s([{\[].*?[}\]])$", requeststring).group(1)
new = jsonreq.split(name+"\":",1)[1]
if new.startswith('\"'):
newjsonreq = jsonreq.replace(name+"\":\""+param_value,name+"\":\""+blindxss_value)
else:
newjsonreq = jsonreq.replace(name+"\":"+param_value,name+"\":\""+blindxss_value+"\"")
updated_request = self._helpers.buildHttpMessage(headers, newjsonreq)
attack = self.makeRequest(Comp_req, updated_request)
if XSSimp != "Disabled":
if xssflag > 3: XSSimp = self.FOUND
elif xssflag > 2: XSSimp = self.CHECK
else: XSSimp = self.NOT_FOUND
if SSTIimp != "Disabled":
if sstiflag > 1: SSTIimp = self.FOUND
elif sstiflag > 0: SSTIimp = self.CHECK
else: SSTIimp = self.NOT_FOUND
if SQLiimp != "Disabled":
if sqliflag > 3: SQLiimp = self.FOUND
elif sqliflag > 2: SQLiimp = self.CHECK
else: SQLiimp = self.NOT_FOUND
self.addToLog(messageInfo, XSSimp, SQLiimp, SSTIimp, param_new, resultxss, resultsqli, resultssti, xssreqresp, sqlireqresp, sstireqresp , xss_description, sqli_description, ssti_description, req_time.strftime('%H:%M:%S %m/%d/%y'))
#
#Function used to check if the score originally and mentioned is better
#
def checkBetterScore(self, score, ogscore):
if score > ogscore:
ogscore = score
return ogscore
def makeRequest(self, messageInfo, message):
request = messageInfo.getRequest()
requestURL = self._helpers.analyzeRequest(messageInfo).getUrl()
return self._callbacks.makeHttpRequest(self._helpers.buildHttpService(str(requestURL.getHost()), int(requestURL.getPort()), requestURL.getProtocol() == "https"), message)
def addToLog(self, messageInfo, XSSimp, SQLiimp, SSTIimp, parameters, resultxss, resultsqli, resultssti, xssreqresp, sqlireqresp, sstireqresp, xss_description, sqli_description, ssti_description, req_time):
requestInfo = self._helpers.analyzeRequest(messageInfo)
method = requestInfo.getMethod()
self._lock.acquire()
row = self._log.size()
self._log.add(LogEntry(self._callbacks.saveBuffersToTempFiles(messageInfo), requestInfo.getUrl(),method,XSSimp,SQLiimp,SSTIimp,req_time, parameters,resultxss, resultsqli, resultssti, xssreqresp, sqlireqresp, sstireqresp, xss_description, sqli_description, ssti_description)) # same requests not include again.
SwingUtilities.invokeLater(UpdateTableEDT(self,"insert",row,row))
self._lock.release()
def __init__(self):
super(WorkHelper, self).__init__()
self.clipboard = Toolkit.getDefaultToolkit().getSystemClipboard()
#self.initUI()
#def initUI(self):
#panel = JPanel()
#self.getContentPane().add(panel)
#############################################################
# Layout
layout = GroupLayout(self.getContentPane())
self.getContentPane().setLayout(layout)
layout.setAutoCreateGaps(True)
layout.setAutoCreateContainerGaps(True)
#############################################################
#############################################################
# Scroll Area Input + Output
Larea1 = JLabel("InputArea:")
Larea2 = JLabel("OutputArea:")
Sarea1 = JScrollPane()
Sarea2 = JScrollPane()
self.area1 = JTextArea()
self.area1.setToolTipText("Input Area")
self.area1.setEditable(True)
self.area1.setBorder(BorderFactory.createLineBorder(Color.gray))
Sarea1.setPreferredSize(Dimension(300,100))
Sarea1.getViewport().setView((self.area1))
self.area2 = JTextArea()
self.area2.setToolTipText("Output Area")
self.area2.setEditable(False)
self.area2.setBorder(BorderFactory.createLineBorder(Color.gray))
Sarea2.setPreferredSize(Dimension(300,100))
Sarea2.getViewport().setView((self.area2))
#############################################################
#############################################################
# Buttons
self.cCurly = JCheckBox("Curly");
self.cCurly.setToolTipText("When 'Checked' Curly Brackets will surround the Categories")
self.cCurly.setSelected(1)
self.cCtClipB = JCheckBox("Auto-Copy");
self.cCtClipB.setToolTipText("When 'Checked' after the Categories are created they will added to the clipboard")
self.cCtClipB.setSelected(1)
self.cSemiC = JCheckBox("SemiColumn");
self.cSemiC.setToolTipText("When 'Checked' after the Categories are created at the end will be a semicolomn")
self.cSemiC.setSelected(1)
bRemoveNBSP_L = JButton("Clean LText", actionPerformed=self.bRemoveNBSP_L)
bRemoveNBSP_L.setToolTipText("Removes Spaces, Tabs from the start of every text line from the input Area")
bRemoveNBSP_R = JButton("Clean RText", actionPerformed=self.bRemoveNBSP_R)
bRemoveNBSP_R.setToolTipText("Removes Spaces, Tabs from the end of every text line from the input Area")
bCopyToInput = JButton("Copy to Input", actionPerformed=self.bCopyToInput)
bCopyToInput.setToolTipText("Copy the text from the Output Area to the Input Area for further Operations")
bClear = JButton("Clear", actionPerformed=self.bClear)
bClear.setToolTipText("Clears the text form both Input and Output text Areas")
self.iStart = JTextField(maximumSize=Dimension(40,25))
self.iStart.setToolTipText("The Start Index for the Making of the Categories")
self.RThis = JTextField()
self.RThis = JTextField(maximumSize=Dimension(120,25))
self.RThis.setToolTipText("Text to be replaced or The Starting C_Index")
self.RThat = JTextField()
self.RThat = JTextField(maximumSize=Dimension(120,25))
self.RThat.setToolTipText("Text to be placed or The Finish C_Index")
bSandReplace = JButton("Replace Text", actionPerformed=self.bSandReplace)
bSandReplace.setToolTipText("Replace the text from This with Thext from That in the Text from the Input Area and displays it in the Output Area")
bcCat = JButton("CreatCateg", actionPerformed=self.bcCat)
bcCat.setToolTipText("Create a categorical form starting C_Index to finish C_Index; Use the above text boxes to define the indexes")
bC_S = JButton("Create _Series", actionPerformed=self.bC_S)
bC_S.setToolTipText("Create a series form starting C_Index to finish C_Index; Use the above text boxes to define the indexes; It will create a series for every row in the Input Area")
bM_Categories = JButton("Categories", actionPerformed=self.mCategories)
bM_Categories.setToolTipText("Make Categories using the lines from the Input Area")
#bM_Categories = JButton(maximumSize=Dimension(40,25))
# de incercat daca merge cu ; sa grupezi in [dsa] elementele
#############################################################
#############################################################
# Aplication Layout 2 groups one Horizontal and one Vertical
layout.setHorizontalGroup(layout.createSequentialGroup()
.addGroup(layout.createParallelGroup()
.addComponent(Larea1)
.addComponent(Sarea1)
.addComponent(Sarea2)
.addComponent(bCopyToInput)
.addComponent(Larea2))
.addGroup(layout.createParallelGroup()
.addGroup(layout.createSequentialGroup()
.addComponent(bM_Categories)
.addComponent(self.iStart))
.addGroup(layout.createSequentialGroup()
.addComponent(self.cCurly)
.addComponent(self.cSemiC)
.addComponent(self.cCtClipB))
.addGroup(layout.createSequentialGroup()
.addComponent(bRemoveNBSP_L)
.addComponent(bRemoveNBSP_R))
.addGroup(layout.createSequentialGroup()
.addComponent(self.RThis)
.addComponent(self.RThat))
.addGroup(layout.createSequentialGroup()
.addComponent(bSandReplace)
.addComponent(bcCat))
.addGroup(layout.createSequentialGroup()
.addComponent(bC_S))
.addComponent(bClear))
)
layout.setVerticalGroup(layout.createSequentialGroup()
.addComponent(Larea1)
.addGroup(layout.createParallelGroup()
.addComponent(Sarea1)
.addGroup(layout.createSequentialGroup()
.addGroup(layout.createParallelGroup()
.addComponent(bM_Categories)
.addComponent(self.iStart))
.addGroup(layout.createParallelGroup()
.addComponent(self.cCurly)
.addComponent(self.cSemiC)
.addComponent(self.cCtClipB))
.addGroup(layout.createParallelGroup()
.addComponent(bRemoveNBSP_L)
.addComponent(bRemoveNBSP_R))
.addGroup(layout.createParallelGroup()
.addComponent(self.RThis)
.addComponent(self.RThat))
.addGroup(layout.createParallelGroup()
.addComponent(bSandReplace)
.addComponent(bcCat))
.addGroup(layout.createParallelGroup()
.addComponent(bC_S))
)
)
.addGroup(layout.createParallelGroup()
.addComponent(bCopyToInput)
.addComponent(bClear))
.addComponent(Larea2)
.addGroup(layout.createParallelGroup()
.addComponent(Sarea2))
)
#layout.linkSize(SwingConstants.HORIZONTAL, [ok, bCopyToInput, close, bM_Categories])
layout.linkSize(SwingConstants.HORIZONTAL, [self.RThis,self.RThat,bRemoveNBSP_L,bRemoveNBSP_R,bCopyToInput,bM_Categories,bSandReplace,bcCat,bC_S])
#layout.linkSize(SwingConstants.HORIZONTAL, [self.cCurly,bM_Categories])
#############################################################
#############################################################
# Aplication Settings
self.pack()
#self.setPreferredSize(Dimension(1000, 1000))
self.setTitle("Workhelper")
self.setSize(800, 500)
self.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE)
self.setLocationRelativeTo(None)
self.setVisible(True)
class JBrukerSubmit:
colHeads = ('block/sample #', 'Holder', 'Name', 'Experiment', 'Solvent',
'Group', 'Member', 'Sample Name')
if platform.node() == 'DM-CHEM-200':
basedir = r"W:\downloads\Eric\jython"
elif platform.node() == 'ERIC-PC':
basedir = r"C:\Users\ERIC\Dropbox\projects\programming\2020\python\autoNMRinput"
else:
# running from Bruker spectrometers
basedir = "/data/downloads/Eric"
def listSubmit(self, event):
"""Submit highlighted to csv file to automation folder of spectrometer
"""
# Ask for starting carousel position and submit experimets to topspin
# obtain file name of CSV file
selected = self.list.selectedIndex
csvName = self.data[selected]
# if no selected file and table is empty just return
if self.label.text == "Selected File":
return
# Create check dialog before submitting data to automation
self.dataTableModel.dataVector
# submitString = "submit " + csvName + " starting at carousel position " + self.carouselStartingPosition.text
submitString = "submit " + csvName + " starting at carousel position " + str(
(self.dataTableModel.dataVector)[0][1])
result = JOptionPane.showConfirmDialog(self.frame, submitString)
# if submission confirmed
if result == 0:
# submit csv file to automation
ret = readcsv243A.submitNMRexpts([
self.dataTableModel.dataVector, csvName,
self.carouselStartingPosition.text
])
# if successful or not update status string
if ret == 0:
self.statusLabel.text = "File " + csvName + " Submitted to TOPSPIN Starting at Carousel Position " + str(
(self.dataTableModel.dataVector)[0][1])
self.panelStatusLabel.setBackground(Color.GREEN)
elif ret == 1:
self.statusLabel.text = "Carousel Position not a number"
self.panelStatusLabel.setBackground(Color.RED)
elif ret == 2:
self.statusLabel.text = "Incompatible experiment chosen for spectrometer"
self.panelStatusLabel.setBackground(Color.RED)
elif ret == 3:
self.statusLabel.text = "A holder starting position is not between 1 and 60 inclusive"
self.panelStatusLabel.setBackground(Color.RED)
elif ret == 4:
self.statusLabel.text = "Too many samples for starting position chosen"
self.panelStatusLabel.setBackground(Color.RED)
# if an error occured display error message also in a warning dialog too.
if ret in [1, 2, 3, 4]:
JOptionPane.showMessageDialog(self.frame,
self.statusLabel.text)
def listSelect(self, event):
"""When a new csv file is selected from the list
read in the file and display its contents in the table.
Unordered csv files will be ordered based on the block/sample number.
A holder column will be added to the CSV data based on the carousel
starting position.
"""
# Process the events from the list box and update the label
# get the index from the list and then the filename
selected = self.list.selectedIndex
if selected >= 0:
# update file label and set background colour to normal
csvName = self.data[selected]
self.label.text = csvName
self.panelLabel.setBackground(self.standardBackgroundColor)
# reset status label
self.statusLabel.text = "Status"
self.panelStatusLabel.setBackground(self.standardBackgroundColor)
#
# update table by reading in csv file
# read in csv file and store as a list of dictionaries
# one dictionary for each line
fn = csvName
self.expt_list = []
f = open(os.path.join(JBrukerSubmit.basedir, fn), 'r')
reader = csv.DictReader(f)
for row in reader:
self.expt_list.append(row)
f.close()
# get carousel starting position, if the value cannot be converted
# to an integer reset it to 1 and reset the GUI to 1
try:
self.cnumber = int(self.carouselStartingPosition.text)
except:
self.cnumber = 1
self.self.carouselStartingPosition.text = "1"
# get the csv data into a list of lists form ready for displaying
self.tableData = returnJTableData(self.expt_list, self.cnumber)
# display csv table in table view
colNames = JBrukerSubmit.colHeads
# transfer the data over to the table model
self.dataTableModel.setDataVector(self.tableData, colNames)
# display the table in the GUI
self.scrollPaneTable.getViewport().setView((self.table))
# check to see if experiments will run on the spectometer
ok, pulseSequence = checkExperimentsWillRun(self.expt_list)
if not ok:
# display warning dialog
warningText = pulseSequence + " cannot be run on this spectrometer"
JOptionPane.showMessageDialog(self.frame, warningText)
def returnCSVlist(self, hiddenFiles):
""" read in csv files ommitting any that are created after
auto submission and return as list of strings.
Miss out any that have been hidden"""
csvlist = [
f for f in os.listdir(JBrukerSubmit.basedir)
if (f.endswith(".csv")) and (f[-6] not in ['A', 'B', 'N'])
]
csvlist = [f for f in csvlist if f not in self.hiddenFiles]
return csvlist
def listUpdate(self, event):
""" when update button clicked renew csv list """
self.data = self.returnCSVlist(self.hiddenFiles)
self.list.setListData(self.data)
def checkCarouselNumber(self, event):
""" check that carousel field is an integer change background to white
if okay, red if not."""
self.cnumber = self.carouselStartingPosition.text
try:
self.cnumber = int(self.cnumber)
self.carouselStartingPosition.background = Color.WHITE
self.listSelect(event)
except:
self.carouselStartingPosition.background = Color.RED
def tableMouseClicked(self, event):
"""Prior to editing the user will click the holder number cell
more often than not. This function saves the cell row and column and
the value in the cell prior to editing."""
tble = event.getSource()
self.rw = tble.getSelectedRow()
self.cl = tble.getSelectedColumn()
self.oldHolderValue = tble.getValueAt(self.rw, self.cl)
# print "table mouse clicked", self.rw, self.cl
def tableChangedCB(self, event):
"""Function is called when a cell is being edited. After the user
presses return the data is updated.
Should only work if Holder column is being edited"""
print "Table Changed"
tble = event.getSource()
if (event.keyChar == "\n") and (self.cl != 1):
tble.setValueAt(self.oldHolderValue, self.rw, self.cl)
elif (event.keyChar == "\n") and (self.cl == 1):
print "RETURN"
vlue = tble.getValueAt(self.rw, self.cl)
print "row", self.rw, "col", self.cl, "value", vlue
#
# check to see if new holder number is used by another sample
# get block number of sample changed
blckNumber = tble.getValueAt(self.rw, 0)
#
# get values in table
holderAlreadyOccupied = False
tableValues = self.dataTableModel.dataVector
for i, rw in enumerate(tableValues):
print i
if (int(rw[1])
== int(vlue)) and (int(blckNumber) != int(rw[0])):
tble.setValueAt(int(self.oldHolderValue), self.rw, 1)
holderAlreadyOccupied = True
warningText = "Holder " + str(
vlue) + " already used for sample " + str(rw[0])
JOptionPane.showMessageDialog(self.frame, warningText)
break
#
# check to see if any other rows with same sample number need to be updated
if not holderAlreadyOccupied:
for i, rw in enumerate(tableValues):
if int(blckNumber) == int(rw[0]):
tble.setValueAt(int(vlue), i, 1)
# def tableKeyPressedCB(self, event):
# print "tableKeyPressedCB"
# tble = event.getSource()
# if event.keyChar == "\n":
# print "RETURN"
# vlue = tble.getValueAt(self.rw, self.cl)
# print "row", self.rw, "col", self.cl, "value", vlue
# elif (event.keyChar).isdigit():
# print "event.keyChar", event.keyChar
# self.rw = tble.getSelectedRow()
# self.cl = tble.getSelectedColumn()
def listShowAllFiles(self, event):
fp = open("hiddenFiles.txt", 'w')
fp.write('zzz\n')
fp.close()
self.hiddenFiles = ['zzz']
self.listUpdate(event)
def listHideFile(self, event):
# find highlighted csv file name
selected = self.list.selectedIndex
csvName = self.data[selected]
# add csv file name to hidden csv files list
self.hiddenFiles.append(csvName)
# update label above table view
self.label.text = "Selected File"
self.panelLabel.setBackground(self.standardBackgroundColor)
# display csv table in table view
# set table to blanks
self.tableData = []
for i in range(18):
self.tableData.append([
"",
] * len(JBrukerSubmit.colHeads))
self.dataTableModel.setDataVector(self.tableData,
JBrukerSubmit.colHeads)
self.listUpdate(event)
# save hiddenFiles file
fp = open("hiddenFiles.txt", 'w')
for f in self.hiddenFiles:
fp.write(f + '\n')
fp.close()
def __init__(self):
self.rw = 0 # table row
self.cl = 0 # table column
# load hidden files list
self.hiddenFiles = ["zzz"]
if os.path.exists("hiddenFiles.txt"):
fp = open("hiddenFiles.txt", "r")
self.hiddenFiles = fp.readlines()
fp.close()
self.hiddenFiles = [f.strip() for f in self.hiddenFiles]
print self.hiddenFiles
# These lines setup the basic frame, size and layout
# the setDefaultCloseOperation so that only the window closes and not TOPSPIN
self.frame = JFrame("Submit NMR Experimets")
self.frame.setSize(1200, 440)
self.frame.setLayout(BorderLayout())
self.frame.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE)
# set up the list and the contents of the list
# the python tuple get converted to a Java vector
self.data = self.returnCSVlist(self.hiddenFiles)
self.list = JList(self.data, valueChanged=self.listSelect)
self.spane = JScrollPane()
self.spane.setPreferredSize(Dimension(145, 150))
self.spane.getViewport().setView((self.list))
panel = JPanel()
panel.add(self.spane)
# define buttons
bpanel = JPanel()
btnS = JButton('Submit File', actionPerformed=self.listSubmit)
btnU = JButton('Update List', actionPerformed=self.listUpdate)
btnHideFile = JButton('Hide File', actionPerformed=self.listHideFile)
btnShowAllFiles = JButton('Show All Files',
actionPerformed=self.listShowAllFiles)
# label displaying CSV file selected
self.label = JLabel('Selected File', JLabel.CENTER)
# label to display warnings and confirm expriments submitted
self.statusLabel = JLabel('Status', JLabel.CENTER)
# Create table to display csv file
self.tableData = []
for r in range(18):
self.tableData.append([
"",
] * len(JBrukerSubmit.colHeads))
colNames = JBrukerSubmit.colHeads
self.dataTableModel = DefaultTableModel(self.tableData, colNames)
self.table = JTable(self.dataTableModel,
keyTyped=self.tableChangedCB,
mouseClicked=self.tableMouseClicked)
# set all columns to uneditable except Holder column
# print dir(self.table)
# self.table.getColumn(0).setEditable(False)
# self.table.getColumn(2).setEditable(False)
# self.table.getColumn(3).setEditable(False)
# self.table.getColumn(4).setEditable(False)
# self.table.getColumn(5).setEditable(False)
# self.table.getColumn(6).setEditable(False)
# self.table = JTable(self.dataTableModel,
# keyPressed=self.tableKeyPressedCB)
self.scrollPaneTable = JScrollPane()
self.scrollPaneTable.setPreferredSize(Dimension(900, 300))
self.scrollPaneTable.getViewport().setView((self.table))
panelTable = JPanel()
panelTable.add(self.scrollPaneTable)
# create text field to get carousel starting position
self.carouselLabel = JLabel("Carousel Position", JLabel.CENTER)
self.carouselStartingPosition = JTextField(
'1', 13, keyPressed=self.checkCarouselNumber)
# add widgets to do with manupulating csv list in FlowLayout Mode
panelList = JPanel()
panelList.setLayout(FlowLayout())
panelList.setPreferredSize(Dimension(170, 200))
# set preferred size of buttons
btnU.setPreferredSize(Dimension(140, 20))
btnS.setPreferredSize(Dimension(140, 20))
btnHideFile.setPreferredSize(Dimension(140, 20))
btnShowAllFiles.setPreferredSize(Dimension(140, 20))
self.carouselLabel.setPreferredSize(Dimension(140, 20))
self.carouselStartingPosition.setPreferredSize(Dimension(170, 20))
panelList.add(btnU)
panelList.add(panel)
panelList.add(btnHideFile)
panelList.add(btnShowAllFiles)
panelList.add(JSeparator(JSeparator.HORIZONTAL),
BorderLayout.LINE_START)
panelList.add(self.carouselLabel)
panelList.add(self.carouselStartingPosition)
panelList.add(btnS)
self.panelLabel = JPanel()
self.panelLabel.add(self.label)
self.standardBackgroundColor = self.panelLabel.getBackground()
# put status label in a panel so that background color can be changed
self.panelStatusLabel = JPanel()
self.panelStatusLabel.add(self.statusLabel)
# add widgets to frame
self.frame.add(self.panelLabel, BorderLayout.NORTH)
self.frame.add(panelList, BorderLayout.WEST)
self.frame.add(panelTable, BorderLayout.CENTER)
self.frame.add(self.panelStatusLabel, BorderLayout.SOUTH)
self.frame.setVisible(True)
readme_fpath = os.path.join(script_path, "README.txt")
params = Parameters()
title = "Membrane Blebbing version " + Parameters._version_string
try:
f = open(readme_fpath, "rb")
text = f.readlines()
except:
raise IOError("Error reading README.txt")
finally:
f.close()
sb = StringBuilder()
for line in text:
sb.append(line)
panel = Panel()
txtArea = JTextArea(sb.toString())
txtArea.setEditable(False)
txtArea.setLineWrap(True)
txtArea.setWrapStyleWord(True)
scrollpane = JScrollPane(txtArea)
scrollpane.setPreferredSize(Dimension(500, 200))
panel.add(scrollpane)
dialog = NonBlockingGenericDialog(title)
#for line in text:
# dialog.addMessage(line);
dialog.addPanel(panel)
dialog.showDialog()
def openGUI(self, invocation):
try:
# Get values from request or response the extension is invoked from and prepopulate GUI values
invMessage = invocation.getSelectedMessages()
message = invMessage[0]
originalHttpService = message.getHttpService()
self.originalMsgProtocol = originalHttpService.getProtocol()
self.originalMsgHost = originalHttpService.getHost()
self.originalMsgPort = originalHttpService.getPort()
except:
self.originalMsgProtocol = ''
self.originalMsgHost = ''
self.originalMsgPort = ''
try:
self.cookies = self._callbacks.getCookieJarContents()
self.cookie = ''
except:
pass
self.SSL = 'http://'
self.listType = ''
self.parsedList = []
# Set up main window (JFrame)
self.window = JFrame("Directory Listing Parser for Burp Suite", preferredSize=(600, 475), windowClosing=self.closeUI)
self.window.setDefaultCloseOperation(JFrame.DO_NOTHING_ON_CLOSE)
emptyBorder = BorderFactory.createEmptyBorder(10, 10, 10, 10)
self.window.contentPane.setBorder(emptyBorder)
self.window.contentPane.layout = BorderLayout()
# Main window title placed at the top of the main window with an invisible bottom border
titlePanel = JPanel()
titleBorder = BorderFactory.createEmptyBorder(0, 0, 10, 0)
title = JLabel("Directory Listing Parser for Burp Suite", JLabel.CENTER)
title.setBorder(titleBorder)
title.setFont(Font("Default", Font.PLAIN, 18))
titlePanel.add(title)
self.window.contentPane.add("North", titlePanel)
# Left panel for user input, consisting of hostname, directory prefix, ssl, port, type of listing, and file
self.leftPanel = JPanel()
self.leftPanel.layout = GridLayout(14, 1, 3, 3)
hostnameLabel = JLabel("Hostname:")
if self.originalMsgHost:
self.hostnameTextField = JTextField(self.originalMsgHost.rstrip())
else:
self.hostnameTextField = JTextField('Hostname')
dirPrefixLabel = JLabel("Full Directory Prefix (Windows):")
self.dirPrefixField = JTextField('C:\\var\www\\')
sslLabel = JLabel("SSL:")
self.radioBtnSslEnabled = JRadioButton('Enabled (https)', actionPerformed=self.radioSsl)
self.radioBtnSslDisabled = JRadioButton('Disabled (http)', actionPerformed=self.radioSsl)
sslButtonGroup = ButtonGroup()
sslButtonGroup.add(self.radioBtnSslEnabled)
sslButtonGroup.add(self.radioBtnSslDisabled)
if self.originalMsgProtocol == "https":
self.radioBtnSslEnabled.setSelected(True)
else:
self.radioBtnSslDisabled.setSelected(True)
portLabel = JLabel("Port:")
if self.originalMsgPort:
self.portTextField = JTextField(str(self.originalMsgPort).rstrip())
else:
self.portTextField = JTextField('80')
osLabel = JLabel("Type of File Listing:")
self.types = ('Windows \'dir /s\'', 'Linux \'ls -lR\'', 'Linux \'ls -R\'')
self.comboListingType = JComboBox(self.types)
uploadLabel = JLabel("Directory Listing File:")
self.uploadTextField = JTextField('')
uploadButton = JButton('Choose File', actionPerformed=self.chooseFile)
self.leftPanel.add(hostnameLabel)
self.leftPanel.add(self.hostnameTextField)
self.leftPanel.add(dirPrefixLabel)
self.leftPanel.add(self.dirPrefixField)
self.leftPanel.add(sslLabel)
self.leftPanel.add(self.radioBtnSslEnabled)
self.leftPanel.add(self.radioBtnSslDisabled)
self.leftPanel.add(portLabel)
self.leftPanel.add(self.portTextField)
self.leftPanel.add(osLabel)
self.leftPanel.add(self.comboListingType)
self.leftPanel.add(uploadLabel)
self.leftPanel.add(self.uploadTextField)
self.leftPanel.add(uploadButton)
# Right panel consisting of a text area for the URL list
self.UrlPanelLabel = JLabel("URL List:")
self.textArea = JTextArea()
self.textArea.setEditable(True)
self.textArea.setFont(Font("Default", Font.PLAIN, 14))
if self.cookies:
self.textArea.append('Cookies Found:\n')
for cookie in self.cookies:
if cookie.getDomain() in self.originalMsgHost:
self.cookie += cookie.getName() + '=' + cookie.getValue() + '; '
self.textArea.append(cookie.getName() + '=' + cookie.getValue() + '\n')
scrollArea = JScrollPane(self.textArea)
scrollArea.setVerticalScrollBarPolicy(JScrollPane.VERTICAL_SCROLLBAR_ALWAYS)
scrollArea.setPreferredSize(Dimension(400, 200))
self.rightPanel = JPanel()
self.rightPanel.setLayout(BorderLayout(3, 3))
self.rightPanel.add(self.UrlPanelLabel, BorderLayout.NORTH)
self.rightPanel.add(scrollArea, BorderLayout.CENTER)
# Panel for the generate URL list and import URL list buttons
generatePanel = JPanel()
generatePanel.layout = BorderLayout(3, 3)
generateButton = JButton('Generate URL List', actionPerformed=self.generateUrlList)
importButton = JButton('Import URL List to Burp Site Map', actionPerformed=self.confirmImport)
generatePanel.add("North", generateButton)
generatePanel.add("South", importButton)
self.rightPanel.add("South", generatePanel)
# Add the two main panels to the left and right sides
self.window.contentPane.add("East", self.rightPanel)
self.window.contentPane.add("West", self.leftPanel)
# Create a panel to be used for the file chooser window
self.uploadPanel = JPanel()
self.window.pack()
self.window.show()
class BurpExtender(IBurpExtender, ITab, IContextMenuFactory):
EXTENSION_NAME = "H1 Report Finder"
API = 'http://h1.nobbd.de/search.php?q='
def registerExtenderCallbacks(self, callbacks):
sys.stdout = callbacks.getStdout()
self.callbacks = callbacks
self.helpers = callbacks.getHelpers()
self.callbacks.setExtensionName("H1 Report Finder")
callbacks.registerContextMenuFactory(self)
# Create the tab
self.tab = JPanel(BorderLayout())
#Create an empty Table
self.tableData = []
self.colNames = ('Vendor', 'Hunter', 'Vulnerability', 'Report', 'Date')
self.dataModel = DefaultTableModel(self.tableData, self.colNames)
self.table = Table(self.dataModel)
self.scrollPane = JScrollPane(self.table)
self.scrollPane.setPreferredSize(Dimension(500, 500))
self.tab.add(self.scrollPane, BorderLayout.NORTH)
callbacks.customizeUiComponent(self.tab)
callbacks.addSuiteTab(self)
return
def createMenuItems(self, invocation):
self.context = invocation
menuList = ArrayList()
menuItem = JMenuItem("Find Reports for Selected Host",
actionPerformed=self.populateTable)
menuList.add(menuItem)
return menuList
#Fetch Reports
def getReports(self, host):
datalist = []
minilist = []
res = requests.get(self.API + host)
if (res.status_code == 200):
soup = BeautifulSoup(res.text, 'html.parser')
reports = soup.findAll("div", {"class": "report-wrapper"})
reportDates = soup.findAll("div", {"class": "date"})
for i in range(len(reports)):
w = reports[i].find(class_='report').find(
class_='company').text #Vendor
x = reports[i].find(class_='report').find(
class_='submitter').text #Hunter
y = reports[i].find(class_='report').find(
class_='title').text #Vulnerability
z = reports[i].find(class_='report').find(
class_='title')['href'] #Report
q = reportDates[i].text
print x + '|' + y + '|' + z + '|' + q
minilist.append(w)
minilist.append(x)
minilist.append(y)
minilist.append(z)
minilist.append(q)
datalist.append(minilist)
minilist = []
for report in datalist:
self.table.getModel().addRow(report)
def populateTable(self, event):
#Clear Table Entries
self.table.getModel().setNumRows(0)
Res = self.context.getSelectedMessages()
host = tldextract.extract(Res[0].getHttpService().getHost())
baseUrl = host.domain + '.' + host.suffix
#Fetch Reports in a new thread
t = threading.Thread(target=self.getReports, args=[baseUrl])
t.daemon = True
t.start()
print baseUrl
def getTabCaption(self):
return self.EXTENSION_NAME
def getUiComponent(self):
return self.tab
t = Thread(writeAccepted)
t.setPriority(Thread.NORM_PRIORITY)
t.start()
# Create the UI: a 3-column table and a text area next to it
# to show the Motivation column of any selected row:
all = JPanel()
gb = GridBagLayout()
all.setLayout(gb)
c = GridBagConstraints()
table = JTable(TableModel())
table.setSelectionMode(ListSelectionModel.SINGLE_SELECTION)
table.setAutoCreateRowSorter(True) # to sort the view only, not the data in the underlying TableModel
jsp = JScrollPane(table)
jsp.setPreferredSize(Dimension(200, 500))
c.anchor = GridBagConstraints.NORTHWEST
c.fill = GridBagConstraints.BOTH # resize with the frame
gb.setConstraints(jsp, c)
all.add(jsp)
c.gridx = 1
c.weightx = 1.0 # take any additionally available horizontal space
c.weighty = 1.0
textarea = JTextArea()
textarea.setLineWrap(True)
textarea.setWrapStyleWord(True) # wrap text by cutting at whitespace
textarea.setEditable(False) # avoid changing the text, as any changes wouldn't be persisted to disk
font = textarea.getFont().deriveFont(20.0)
textarea.setFont(font)
textarea.setPreferredSize(Dimension(500, 500))
gb.setConstraints(textarea, c)
class ChatClient(JFrame):
## Constructor method, receives the variables from the ChatApp class as parameters
def __init__(self, name, greeting, tn):
'''Constructor, initialises base class & assigns variables
'''
# Call to the super method to take care of the base class(es)
super(ChatClient, self).__init__()
# Assign the relevent variable names
self.username=name
self.greeting=greeting
self.tn = tn
self.no_users=[]
# Initiate the Threaded function for receiving messages
t1=Thread(target=self.recvFunction)
# Set to daemon
t1.daemon=True
t1.start()
#Call the main UI
uI=self.clientUI()
## Main GUI building function
def clientUI(self):
'''ClientUI and Widget creation
'''
# Colours
foreground_colour = Color(30,57,68)
background_colour = Color(247,246,242)
window_background = Color(145,190,210)
# Borders
self.border2=BorderFactory.createLineBorder(foreground_colour,1, True)
# Fonts
self.font= Font("Ubuntu Light", Font.BOLD, 20)
self.label_font= Font("Ubuntu Light", Font.BOLD, 17)
self.label_2_font= Font( "Ubuntu Light",Font.BOLD, 12)
self.btn_font=Font("Ubuntu Light", Font.BOLD, 15)
# Set the layout parameters
self.client_layout=GroupLayout(self.getContentPane())
self.getContentPane().setLayout(self.client_layout)
self.getContentPane().setBackground(window_background)
self.client_layout.setAutoCreateGaps(True)
self.client_layout.setAutoCreateContainerGaps(True)
self.setPreferredSize(Dimension(400, 450))
# Create widgets and assemble the GUI
# Main display area
self.main_content=JTextPane()
self.main_content.setBackground(background_colour)
#self.main_content.setForeground(foreground_colour)
self.main_content.setEditable(False)
# Message entry area
self.message=JTextArea( 2,2, border=self.border2, font=self.label_font, keyPressed=self.returnKeyPress)
self.message.requestFocusInWindow()
self.message.setBackground(background_colour)
self.message.setForeground(foreground_colour)
self.message.setLineWrap(True)
self.message.setWrapStyleWord(True)
self.message.setBorder(BorderFactory.createEmptyBorder(3,3,3,3))
self.message.getInputMap().put(KeyStroke.getKeyStroke(KeyEvent.VK_ENTER,0), self.returnKeyPress)
# BUttons
quit_btn=JButton("Quit!", actionPerformed=ChatApp().closeEvent, border=self.border2, font=self.btn_font)
go_btn=JButton("Send", actionPerformed=self.grabText, border=self.border2, font=self.btn_font)
quit_btn.setBackground(background_colour)
go_btn.setBackground(background_colour)
quit_btn.setForeground(foreground_colour)
go_btn.setForeground(foreground_colour)
# Make scrollable
self.scroll_content=JScrollPane(self.main_content)
self.scroll_content.setPreferredSize(Dimension(150,275))
self.scroll_content.setHorizontalScrollBarPolicy(ScrollPaneConstants.HORIZONTAL_SCROLLBAR_NEVER)
self.scroll_content.setViewportView(self.main_content)
self.scroll_content.setBackground(Color.WHITE)
self.scroll_message=JScrollPane(self.message)
self.scroll_message.setPreferredSize(Dimension(150,20))
self.scroll_message.setVerticalScrollBarPolicy(ScrollPaneConstants.VERTICAL_SCROLLBAR_ALWAYS)
# Test user label, still not updating after first round of messages
self.user_label=JLabel(" Users online : %s "%(str(len(self.no_users))),JLabel.RIGHT, font=self.label_2_font)
# Assemble the components
# Horizontal layout
self.client_layout.setHorizontalGroup(self.client_layout.createParallelGroup()
.addComponent(self.scroll_content)
.addGroup(self.client_layout.createParallelGroup(GroupLayout.Alignment.CENTER)
.addComponent(self.scroll_message))
.addGroup(self.client_layout.createSequentialGroup()
.addComponent(quit_btn)
.addComponent(go_btn).addGap(20))
.addGroup(self.client_layout.createParallelGroup()
.addComponent(self.user_label))
)
# Vertical layout
self.client_layout.setVerticalGroup(self.client_layout.createSequentialGroup()
.addGroup(self.client_layout.createParallelGroup()
.addComponent(self.scroll_content))
.addComponent(self.scroll_message)
.addGroup(self.client_layout.createParallelGroup()
.addComponent(quit_btn)
.addComponent(go_btn))
.addGroup(self.client_layout.createParallelGroup()
.addComponent(self.user_label))
)
# Finalise the GUI
self.client_layout.linkSize(SwingConstants.HORIZONTAL, [quit_btn,go_btn, self.user_label])
self.pack()
self.message.requestFocusInWindow()
self.setTitle(">>> Client %s <<<"%self.username)
self.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE)
self.setLocationRelativeTo(None)
self.setVisible(True)
# Display the server greeting
self.appendText('\n'+self.greeting+'\n')
## Function responsible for receiving and processing new messages
def recvFunction(self):
'''A function to control the receiving of data from the connection
'''
# While the connection is available
while self.tn:
# Try to receive data using "<<<" as the delimiter
try:
message = self.tn.read_until('<<<')
# If a message is received
if message:
garb, message=message.split('>>>')
message, garb = message.split('<<<')
message = ('\n'+message+'\n')
# Call the append text function
self.appendText(message)
# Except if there is no data available
except:
#print('No message')
pass
## Event driven function to retrieve and send data to the server
def grabText(self, event):
'''Function to repeatedly grab new messages entered into the text
area and display them in the main text area. Resets the entry area
'''
# Grab the text from the text area
text=self.message.getText()
# Don't allow an empty string through
if text=='':
return
text=text.strip()
# Call the append text function
self.appendText('\nYou : '+text+'\n', self.username)
# Reset the text to be empty and grab focus so that it is ready for new text input
self.message.requestFocusInWindow()
self.message.setText('')
# Send the message to the server
data=text.encode()
self.tn.write(data+'\r\n')
## Function to handle appending of messages
def appendText(self, message, user=None):
'''This function takes care of appending any new messages to the content area
'''
message_label=JTextArea(message,2,3, font=self.label_2_font)
# If this is a message from the grab text function, create a new label, assign it's colours
if user!=None:
message_label.setBackground(Color(240,240,240))
message_label.setForeground(Color(129,129,129))
# Otherwise set the format for receive function (no user passed in)
else:
message_label.setBackground(Color(215,215,215))
message_label.setForeground(Color(40,153,153))
# Format and style options for the new message labels
message_label.setEditable(False)
message_label.setLineWrap(True)
message_label.setWrapStyleWord(True)
message_label.setBorder(BorderFactory.createLineBorder( Color(247,246,242),4))
# Sets the positioning of messages
self.main_content.setCaretPosition(self.main_content.getDocument().getLength())
doc = self.main_content.getStyledDocument()
attr=SimpleAttributeSet()
self.main_content.insertComponent(message_label)
# Essential for jtextarea to be able to stack message
doc.insertString( self.main_content.getDocument().getLength(),'\n ', attr)
# Not sure if needed
self.main_content.repaint()
### This is a late edit so it isn't included in the documentation. Basically trying to dynamically update the number
### of users label at runtime. Works for incrementing the value but not decrementing it.
print(message)
# Only split the message if there are enough values to split (greeting messages differ in format to chat messages)
try:
user, text=message.split(' : ')
except:
return
#print('Split values are %s %s'%(user, text))
user=str(user.strip())
#print(self.no_users)
#print(user+' : '+text)
# If the user already in the list, pass
if user in self.no_users:
if text == ('User %s amach sa teach !'%user):
self.no_users.remove(user)
print('User % removed'%user)
else:
#print('User %s not in list'%user)
if str(user) == 'You':
#print('User is equal to "You"')
return
self.no_users.append(user)
print('User appended')
self.number_users=len(self.no_users)
#print('Length of user list is '+str(self.number_users))
self.user_label2=JLabel(" Users online : %s "%str(len(self.no_users)),JLabel.RIGHT, font=self.label_2_font)
#print('Label created')
#print('Attempt to replace label')
self.client_layout.replace(self.user_label, self.user_label2)
self.user_label = self.user_label2
self.user_label.repaint()
self.user_label.revalidate()
print('Label updated')
## Function to control return button press in message field
def returnKeyPress(self,event):
'''This function creates an object for return key press when inside the message entry area,
creates an object of KeyAdapter and tests keycode for a match, responds with grab text callback
'''
key_object=Key()
key_value=key_object.keyPressed(event)
if key_value == 10:
self.grabText(event)
def registerExtenderCallbacks(self, callbacks):
# Set encoding to utf-8 to avoid some errors
reload(sys)
sys.setdefaultencoding('utf8')
# Keep a reference to callback object and helper object
self._callbacks = callbacks
self._helpers = callbacks.getHelpers()
# Set the extension name that shows in the burp extension menu
callbacks.setExtensionName("InjectionScanner")
# Create the log and a lock on which to synchronize when adding log entries
self._log = ArrayList()
self._logLock = Lock()
self._httpLock = Lock()
# The length of the basis used to fetch abnormal data, default to zero
self._basisLen = 0
# 1: {POST. GET}; 2: {urlencoded, json, xml}
self._postGet = 'NaN'
self._dataType = 'NaN'
# Scan list
self._simpleList = [
'\'', '\"', '/', '/*', '#', ')', '(', ')\'', '(\'', 'and 1=1',
'and 1=2', 'and 1>2', 'and 12', '+', 'and+12', '/**/and/**/1'
]
self._xmlList = ['a', 'b', 'c', 'd', 'e'] # Not setted
# Response mutex: True = is blocking; False = free to go
# self._mutexR = False
# Other classes instance
self._dataTable = Guis_DefaultTM()
self._logTable = Guis_AbstractTM(self)
self._xh = XMLHandler()
listeners = Guis_Listeners(self, self._logTable)
'''
Setting GUIs
'''
# Divide the whole pane two: one upper and one lower pane
self._mainSplitpane = JSplitPane(JSplitPane.VERTICAL_SPLIT)
self._mainSplitpane.setResizeWeight(0.4)
# Initizlize request table
dataTable = JTable(self._dataTable)
dataScrollPane = JScrollPane(dataTable)
dataScrollPane.setPreferredSize(Dimension(0, 125))
self._dataTable.addTableModelListener(listeners)
# Initialize log table
logTable = Guis_LogTable(self._logTable)
logScrollPane = JScrollPane(logTable)
logScrollPane.setPreferredSize(Dimension(0, 125))
# Split the upper pane to two panes
tableSplitpane = JSplitPane(JSplitPane.HORIZONTAL_SPLIT)
tableSplitpane.setResizeWeight(0.5)
# Set the data table to the left and log to the right
tableSplitpane.setLeftComponent(dataScrollPane)
tableSplitpane.setRightComponent(logScrollPane)
# Tabs with request/response viewers
tabs = JTabbedPane()
self._requestViewer = callbacks.createMessageEditor(self, False)
self._responseViewer = callbacks.createMessageEditor(self, False)
tabs.addTab("Request", self._requestViewer.getComponent())
tabs.addTab("Response", self._responseViewer.getComponent())
# Create buttons that do operation with the test
self._basisLabel = JLabel('Basis: ' + str(self._basisLen))
self._levelLabel = JLabel('Level:')
self._setBasisButton = JButton('Set Basis')
self._hitOnceButton = JButton('Hit Once')
self._autoScanButton = JButton('Auto Scan')
self._clearLogButton = JButton('Clear Log')
self._cancelButton = JButton('Cancel')
self._levelSelection = JComboBox()
self._levelSelection.addItem('1')
self._levelSelection.addItem('2')
self._levelSelection.addItem('3')
self._hitOnceButton.addActionListener(listeners)
self._autoScanButton.addActionListener(listeners)
self._clearLogButton.addActionListener(listeners)
self._setBasisButton.addActionListener(listeners)
self._cancelButton.addActionListener(listeners)
self._basisLabel.setPreferredSize(Dimension(100, 20))
# Create bottom pane for holding the buttons
buttonPane = JPanel()
buttonPane.setLayout(BorderLayout())
centerPane = JPanel()
leftPane = JPanel()
rightPane = JPanel()
leftPane.add(self._basisLabel)
centerPane.add(self._setBasisButton)
centerPane.add(self._hitOnceButton)
centerPane.add(self._autoScanButton)
centerPane.add(self._cancelButton)
centerPane.add(self._clearLogButton)
rightPane.add(self._levelLabel)
rightPane.add(self._levelSelection)
buttonPane.add(centerPane, BorderLayout.CENTER)
buttonPane.add(leftPane, BorderLayout.WEST)
buttonPane.add(rightPane, BorderLayout.EAST)
# Create and set the bottom panel that holds viewers and buttons
utilPane = JPanel()
utilPane.setLayout(BorderLayout())
utilPane.add(tabs, BorderLayout.CENTER)
utilPane.add(buttonPane, BorderLayout.SOUTH)
self._mainSplitpane.setLeftComponent(tableSplitpane)
self._mainSplitpane.setRightComponent(utilPane)
# Customize UI components
callbacks.customizeUiComponent(self._mainSplitpane)
callbacks.customizeUiComponent(dataTable)
callbacks.customizeUiComponent(dataScrollPane)
callbacks.customizeUiComponent(logTable)
callbacks.customizeUiComponent(logScrollPane)
callbacks.customizeUiComponent(tabs)
callbacks.customizeUiComponent(buttonPane)
callbacks.customizeUiComponent(utilPane)
callbacks.customizeUiComponent(self._basisLabel)
callbacks.customizeUiComponent(self._setBasisButton)
callbacks.customizeUiComponent(self._hitOnceButton)
callbacks.customizeUiComponent(self._autoScanButton)
callbacks.customizeUiComponent(self._clearLogButton)
callbacks.customizeUiComponent(self._levelSelection)
callbacks.customizeUiComponent(self._cancelButton)
# Add the custom tab to Burp's UI
callbacks.addSuiteTab(self)
# Register the context menu and message editor for new tabs
callbacks.registerContextMenuFactory(self)
# Register as a HTTP listener
callbacks.registerHttpListener(self)
return
class StockGlance75():
# print "StockGlance75"
import java.awt.Color as Color
import java.util.Vector as Vector
import java.util.Arrays as Arrays
import javax.swing.table.DefaultTableModel as DefaultTableModel
import javax.swing.JTable as JTable
book = None # AccountBook()
table = None # StockGlance75.SGTable()
tableModel = None # StockGlance75.SGTableModel
tablePanel = None # SGPanel()
footerTable = None # StockGlance75.SGFooterTable
footerModel = None # StockGlance75.SGFooterModel
# scrollPane = None
totalBalance = None # total of all Stock.Securities in all Accounts
# currencyTableCallback = None # currencyCallback(self)
# allAccountsCallback = None # accountCallback(self)
# refresher = None # CollapsibleRefresher()
lightLightGray = Color(0xDCDCDC)
rowCurrencies = Vector() # list of security names in the rows (like a row header)
footer = Vector() # one row of footer data
data = Vector() # the data retrieved from moneydance
# Per column metadata
names = ["Symbol", "Stock", "Price", "Change", "Balance", "Day", "7 Day", "30 Day", "365 Day", "Accounts"]
columnNames = Vector(Arrays.asList(names))
# footerNames = ["", "", "", "", "Total", "", "", "", "", ""]
# FooterNames = Vector(Arrays.asList(footerNames))
columnTypes = ["Text", "Text", "Currency2", "Currency2", "Currency0", "Percent", "Percent", "Percent", "Percent", "Text"]
# Returns a short descriptive name of this view.
def __str__(self):
""" generated source for method toString """
return "Stock Glance"
# Returns a GUI component that provides a view of the info pane for the given data file.
# w.s. must be called by Moneydance .. seems like this is how "book" gets set
# @make_synchronized
# def getGUIView(self, book): # replaced by createAndShowGUI(self):
# print("getGUIView")
# if self.tablePanel == None:
# self.book = book
# self.tableModel = self.getTableModel(book)
# print "table before",self.table
# self.table = self.SGTable(self.tableModel)
# self.scrollPane = JScrollPane(self.table)
## self.scrollPane = self.SGScrollPane(self.table)
## self.tablePanel = self.SGPanel(self.table)
## return self.tablePanel
# return self.scrollPane
# Sets the view as active or inactive. When not active, a view should not have any registered listeners
# with other parts of the program. This will be called when an view is added to the home page,
# or the home page is refreshed after not being visible for a while.
# def setActive(self, active):
# print 'setActive'
# """ generated source for method setActive """
## if self.book != None:
## self.book.getCurrencies().removeCurrencyListener(self.currencyTableCallback)
## # At most one listener
## self.book.removeAccountListener(self.allAccountsCallback)
## if active:
## self.book.getCurrencies().addCurrencyListener(self.currencyTableCallback)
## self.book.addAccountListener(self.allAccountsCallback)
# Forces a refresh of the information in the view. For example, this is called after the preferences are updated.
# Like the other home page controls, we actually do this lazily to avoid repeatedly recalculating after stock
# price updates.
# def refresh(self):
# print("refresh")
# self.refresher.enqueueRefresh()
# Actually recompute and redisplay table.
# def actuallyRefresh(self): # this function knocks out the TableRowSorter and messes with the Column Headers (i think)
# print "actuallyRefresh"
## ? synchronized (this) {
# tableModel = self.getTableModel(self.book)
# if self.table != None:
# self.table.setModel(tableModel)
# self.table.fixColumnHeaders()
# self.fixTheRowSorter()
# # ? }
# if self.tablePanel != None:
# self.tablePanel.setVisible(True)
# self.tablePanel.validate()
# Called when the view should clean up everything. For example, this is called when a file is closed and the GUI
# is reset. The view should disconnect from any resources that are associated with the currently opened data file.
# def reset(self):
# print "reset"
# self.setActive(False)
# if self.tablePanel != None:
# self.tablePanel.removeAll()
# self.tablePanel = None
# self.table = None
#
# Implementation:
# pulls the data from moneydance into data Vector , returns an SGTableModel
def getTableModel(self, book):
# print "getTableModel book",book
import java.util.Vector as Vector
import java.util.Arrays as Arrays
import java.util.Calendar as Calendar
import com.infinitekind.moneydance.model.CurrencyType as CurrencyType
import java.lang.Double as Double
ct = book.getCurrencies()
allCurrencies = ct.getAllCurrencies()
data = Vector()
today = Calendar.getInstance()
balances = self.sumBalancesByCurrency(book) # HashMap<CurrencyType, Long> contains no account info
accounts = self.getCurrencyAccounts(book) # HashMap<CurrencyType, Accounts>
self.totalBalance = 0.0
# StockGlance75.totalBalance = 0.0
for curr in allCurrencies:
if not curr.getHideInUI() and curr.getCurrencyType() == CurrencyType.Type.SECURITY:
price = self.priceOrNaN(curr, today, 0)
price1 = self.priceOrNaN(curr, today, 1)
price7 = self.priceOrNaN(curr, today, 7)
price30 = self.priceOrNaN(curr, today, 30)
price365 = self.priceOrNaN(curr, today, 365)
if not Double.isNaN(price) and (not Double.isNaN(price1) or not Double.isNaN(price7) or not Double.isNaN(price30) or not Double.isNaN(price365)):
entry = Vector(len(self.names))
bal = balances.get(curr)
balance = (0.0 if (bal == None) else curr.getDoubleValue(bal) * price)
# ? Double balance = (bal == null) ? 0.0 : curr.getDoubleValue(bal) * price;
self.totalBalance += balance
# StockGlance75.totalBalance += balance
entry.add(curr.getTickerSymbol())
entry.add(curr.getName())
entry.add(price)
entry.add(price - price1)
entry.add(balance)
entry.add((price - price1) / price1)
entry.add((price - price7) / price7)
entry.add((price - price30) / price30)
entry.add((price - price365) / price365)
entry.add(accounts.get(curr))
data.add(entry)
self.rowCurrencies.add(curr)
# StockGlance75.rowCurrencies.add(curr)
self.data = data
# StockGlance75.data = data
return self.SGTableModel(self.data, self.columnNames, self.rowCurrencies)
# return StockGlance75.SGTableModel(StockGlance75.data, self.columnNames, self.rowCurrencies)
def getFooterModel(self):
# print "getFooterModel "
import java.util.Vector as Vector
import java.util.Arrays as Arrays
entry = Vector(len(self.names)) # its 10 columns
entry.add("Total")
entry.add(None)
entry.add(None)
entry.add(None)
# entry.add(StockGlance75.totalBalance)
entry.add(self.totalBalance)
entry.add(None)
entry.add(None)
entry.add(None)
entry.add(None)
entry.add(None)
self.footer.clear()
self.footer.add(entry) # needs to be an list of lists (Vector of Vectors)
return self.SGFooterModel(self.footer,self.columnNames)
# StockGlance75.footer.clear()
# StockGlance75.footer.add(entry) # needs to be an list of lists (Vector of Vectors)
# return StockGlance75.SGFooterModel(StockGlance75.footer,StockGlance75.columnNames)
def priceOrNaN(self, curr, date, delta):
import java.lang.Double as Double
try:
backDate = self.backDays(date, delta)
if self.haveSnapshotWithinWeek(curr, backDate):
return 1.0 / curr.adjustRateForSplitsInt(backDate, curr.getUserRateByDateInt(backDate))
else:
return Double.NaN
except ZeroDivisionError as e:
return Double.NaN
except IndexError as e:
return Double.NaN
# Return the date that is delta days before startDate
def backDays(self, startDate, delta):
import java.util.Calendar as Calendar
import com.infinitekind.util.DateUtil as DateUtil
newDate = startDate.clone()
newDate.add(Calendar.DAY_OF_MONTH, -delta)
return DateUtil.convertCalToInt(newDate)
# MD function getRawRateByDateInt(int dt) returns last known value, even if wildly out of date.
# Return true if the snapshots contain a rate within a week before the date.
def haveSnapshotWithinWeek(self, curr, date):
import com.infinitekind.util.DateUtil as DateUtil
snapshots = curr.getSnapshots()
for snap in snapshots:
if DateUtil.calculateDaysBetween(snap.getDateInt(), date) <= 7:
# within a week
return True
return snapshots.isEmpty()
# If no snapshots, use fixed rate; otherwise didn't find snapshot
def sumBalancesByCurrency(self, book):
# print "sumBalancesByCurrency "
import java.util.HashMap as HashMap
import com.infinitekind.moneydance.model.AccountUtil as AccountUtil
import com.infinitekind.moneydance.model.AcctFilter as AcctFilter
import com.infinitekind.moneydance.model.Account.AccountType as AccountType
totals = HashMap() # HashMap<CurrencyType, Long>
for acct in AccountUtil.allMatchesForSearch(book.getRootAccount(), AcctFilter.ACTIVE_ACCOUNTS_FILTER ):
curr = acct.getCurrencyType()
total = totals.get(curr) # this returns None if curr doesn't exist yet
if acct.getCurrentBalance() != 0 and acct.getAccountType() == AccountType.SECURITY: # we only want Securities with holdings
pass
else:
continue # no sense slowing everything down with stuff we don't need
total = (0L if (total == None) else total) + acct.getCurrentBalance()
#? java total = ((total == null) ? 0L : total) + acct.getCurrentBalance();
totals.put(curr, total)
return totals
def getCurrencyAccounts(self, book):
# print "getCurrencyAccounts "
import java.util.HashMap as HashMap
import com.infinitekind.moneydance.model.AccountUtil as AccountUtil
import com.infinitekind.moneydance.model.AcctFilter as AcctFilter
import com.infinitekind.moneydance.model.Account.AccountType as AccountType
accounts = HashMap()
for acct in AccountUtil.allMatchesForSearch(book.getRootAccount(), AcctFilter.ACTIVE_ACCOUNTS_FILTER ):
curr = acct.getCurrencyType()
account = accounts.get(curr)# this returns None if curr doesn't exist yet
if acct.getCurrentBalance() != 0 and acct.getAccountType() == AccountType.SECURITY:
pass
else:
continue # no sense slowing everything down with stuff we don't need . only some BONDS left mixed in with the STOCK
if account == None:
account = str(acct.getParentAccount())
else:
account = account + ' : ' + str(acct.getParentAccount()) # concatinate two strings here
accounts.put(curr,account)
return accounts
#
# Private classes:
#
# CurrencyListener
## class currencyCallback(CurrencyListener):
## """ generated source for class currencyCallback """
## thisSG = self.StockGlance()
##
## def __init__(self, sg):
## """ generated source for method __init__ """
## super(currencyCallback, self).__init__()
## self.thisSG = sg
##
## def currencyTableModified(self, table):
## """ generated source for method currencyTableModified """
## self.thisSG.refresh()
# AccountListener
## class accountCallback(AccountListener):
## """ generated source for class accountCallback """
## thisSG = StockGlance()
##
## def __init__(self, sg):
## """ generated source for method __init__ """
## super(accountCallback, self).__init__()
## self.thisSG = sg
##
## def accountAdded(self, parentAccount, newAccount):
## """ generated source for method accountAdded """
## self.thisSG.refresh()
##
## def accountBalanceChanged(self, newAccount):
## """ generated source for method accountBalanceChanged """
## self.thisSG.refresh()
##
## def accountDeleted(self, parentAccount, newAccount):
## """ generated source for method accountDeleted """
## self.thisSG.refresh()
##
## def accountModified(self, newAccount):
## """ generated source for method accountModified """
## self.thisSG.refresh()
# JPanel
# class SGPanel(JPanel):
# def __init__(self, table):
# """ generated source for method __init__ """
# super(JPanel, self).__init__()
# print "SGPanel init "
# self.setLayout(BoxLayout(self, BoxLayout.PAGE_AXIS))
# self.add(table.getTableHeader())
# self.add(table)
# self.add(table.getFooterTable())
# self.setBorder(BorderFactory.createCompoundBorder(MoneydanceLAF.homePageBorder, BorderFactory.createEmptyBorder(0, 0, 0, 0)))
# SGTableModel
class SGTableModel(DefaultTableModel):
# print "SGTableModel "
import java.awt.Color as Color
import java.util.Vector as Vector
import java.util.Arrays as Arrays
import javax.swing.table.DefaultTableModel as DefaultTableModel
rowCurrencies2 = Vector()
def __init__(self, data, columnNames, rowCurrencies):
import javax.swing.table.DefaultTableModel as DefaultTableModel
super(DefaultTableModel, self).__init__(data,columnNames)
self.rowCurrencies2 = rowCurrencies
def getRowCurrencies(self):
return self.rowCurrencies2
# SGFooterModel
class SGFooterModel(DefaultTableModel):
# print "SGFooterModel "
import java.awt.Color as Color
import java.util.Vector as Vector
import java.util.Arrays as Arrays
import javax.swing.table.DefaultTableModel as DefaultTableModel
footer2 = Vector()
columnNames2 = []
def __init__(self, footer, columnNames):
import javax.swing.table.DefaultTableModel as DefaultTableModel
super(DefaultTableModel, self).__init__(footer,columnNames)
self.footer2 = footer
self.columnNames2 = columnNames
def getFooterVector(self):
return self.footer2
def isCellEditable(self, row, column):
return False
# SGFooterTable JTable
class SGFooterTable(JTable):
# print "SGFooterTable "
def __init__(self, footerModel):
import javax.swing.JTable as JTable
super(JTable, self).__init__(footerModel)
def getDataModel(self):
global AAA
return AAA.footerModel
# Rendering depends on column .. this footer only has one row
def getCellRenderer(self, row, column):
# print "footer renderer",row,column
import javax.swing.table.DefaultTableCellRenderer as DefaultTableCellRenderer
import javax.swing.JLabel as JLabel
global AAA
renderer = None
if AAA.columnTypes[column]=="Text":
renderer = DefaultTableCellRenderer()
renderer.setHorizontalAlignment(JLabel.LEFT)
elif AAA.columnTypes[column]=="Currency2" or AAA.columnTypes[column]=="Currency0":
rowCurrencies = self.getDataModel().getFooterVector() # only diff
curr = None
if 0 <= row and row < len(rowCurrencies):
curr = AAA.rowCurrencies.get(row)
else:
curr = self.book.getCurrencies().getBaseType() # Footer reports base currency
renderer = AAA.CurrencyRenderer(curr, AAA.columnTypes[column] == "Currency0")
renderer.setHorizontalAlignment(JLabel.RIGHT)
elif AAA.columnTypes[column]=="Percent":
renderer = AAA.PercentRenderer()
renderer.setHorizontalAlignment(JLabel.RIGHT)
else:
renderer = DefaultTableCellRenderer()
return renderer
class SGTable(JTable): # (JTable)
def __init__(self, tableModel):
# print "SGTable init"
import javax.swing.JTable as JTable
super(JTable, self).__init__(tableModel)
# self.fixColumnHeaders()
self.fixTheRowSorter();
def getDataModel(self):
global AAA
return AAA.tableModel
def isCellEditable(self, row, column):
return False
# Rendering depends on row (i.e. security's currency) as well as column
def getCellRenderer(self, row, column):
import javax.swing.table.DefaultTableCellRenderer as DefaultTableCellRenderer
import javax.swing.JLabel as JLabel
global AAA
renderer = None
if AAA.columnTypes[column]=="Text":
renderer = DefaultTableCellRenderer()
renderer.setHorizontalAlignment(JLabel.LEFT)
elif AAA.columnTypes[column]=="Currency2" or AAA.columnTypes[column]=="Currency0":
rowCurrencies = self.getDataModel().getRowCurrencies()
curr = None
if 0 <= row and row < len(rowCurrencies):
curr = AAA.rowCurrencies.get(row)
else:
curr = self.book.getCurrencies().getBaseType() # Footer reports base currency
renderer = AAA.CurrencyRenderer(curr, AAA.columnTypes[column] == "Currency0")
renderer.setHorizontalAlignment(JLabel.RIGHT)
elif AAA.columnTypes[column]=="Percent":
renderer = AAA.PercentRenderer()
renderer.setHorizontalAlignment(JLabel.RIGHT)
else:
renderer = DefaultTableCellRenderer()
return renderer
def columnMarginChanged(self, event):
eventModel = event.getSource()
thisModel = self.getColumnModel()
columnCount = eventModel.getColumnCount()
i = 0
while i < columnCount:
thisModel.getColumn(i).setWidth(eventModel.getColumn(i).getWidth())
i += 1
self.repaint()
import java.util.Comparator as Comparator
class myComparator (Comparator):
# print("Mycomparator") # example of jython conditional operator.works like the java ? operator
def compare( self, str1 , str2): return 1 if str1 > str2 else 0 if str1 == str2 else -1
# def fixColumnHeaders(self): # don't know what this was for
# cm = self.getColumnModel()
# i = 0
# while i < cm.getColumnCount():
# col = cm.getColumn(i);
# col.setHeaderRenderer(StockGlance75.HeaderRenderer())
# i += 1
# return
def fixTheRowSorter(self): # for some reason everthing was being coverted to strings
import javax.swing.table.TableRowSorter as TableRowSorter
sorter = TableRowSorter()
self.setRowSorter(sorter)
sorter.setModel(self.getModel())
for i in range (0 , self.getColumnCount() ) :
sorter.setComparator(i,self.myComparator())
self.getRowSorter().toggleSortOrder(0)
# @override ..JTable method . preformance pig
def prepareRenderer(self, renderer, row, column): # make Banded rows
global AAA
component = super(AAA.SGTable, self).prepareRenderer(renderer, row, column)
if not self.isRowSelected(row):
component.setBackground(self.getBackground() if row % 2 == 0 else AAA.lightLightGray)
return component
def getFooterTable(self):
return self.footerTable
# Render a currency with given number of fractional digits. NaN or null is an empty cell.
# Negative values are red.
import javax.swing.table.DefaultTableCellRenderer as DefaultTableCellRenderer
class CurrencyRenderer(DefaultTableCellRenderer):
# print "CurrencyRenderer "
noDecimals = bool()
relativeTo = None # CurrencyType()
decimalSeparator = '.'
noDecimalFormatter = None # NumberFormat()
def __init__(self, currency, noDecimals):
import java.lang.Double as Double
import java.text.NumberFormat as NumberFormat
import javax.swing.table.DefaultTableCellRenderer as DefaultTableCellRenderer
import com.infinitekind.moneydance.model.CurrencyType as CurrencyType
super(DefaultTableCellRenderer, self).__init__()
self.noDecimals = noDecimals
ct = currency.getTable()
relativeToName = currency.getParameter(CurrencyType.TAG_RELATIVE_TO_CURR)
if relativeToName != None:
self.relativeTo = ct.getCurrencyByIDString(relativeToName)
else:
self.relativeTo = ct.getBaseType()
self.noDecimalFormatter = NumberFormat.getNumberInstance()
self.noDecimalFormatter.setMinimumFractionDigits(0)
self.noDecimalFormatter.setMaximumFractionDigits(0)
def isZero(self, value):
import java.lang.Math as Math
return Math.abs(value) < 0.01
def setValue(self, value):
import java.lang.Double as Double
import java.awt.Color as Color
if value == None:
self.setText("")
elif Double.isNaN(float(value)):
self.setText("")
else:
if self.isZero(float(value)):
value = 0.0
if self.noDecimals:
# MD format functions can't print comma-separated values without a decimal point so
# we have to do it ourselves
scaledValue = float(value) * self.relativeTo.getUserRate();
self.setText(self.relativeTo.getPrefix() + " " + self.noDecimalFormatter.format(scaledValue) + self.relativeTo.getSuffix())
else:
scaledValue = self.relativeTo.convertValue(self.relativeTo.getLongValue(float(value)))
self.setText(self.relativeTo.formatFancy(scaledValue, self.decimalSeparator))
if float(value) < 0.0:
self.setForeground(Color.RED)
else:
self.setForeground(Color.BLACK)
# Render a percentage with 2 digits after the decimal point. Conventions as CurrencyRenderer
class PercentRenderer(DefaultTableCellRenderer):
# print "PercentRenderer "
# import java.lang.Double as Double
# import java.lang.Math as Math
decimalSeparator = '.'
def __init__(self):
import javax.swing.table.DefaultTableCellRenderer as DefaultTableCellRenderer
super(DefaultTableCellRenderer, self).__init__()
def isZero(self, value):
import java.lang.Math as Math
return Math.abs(value) < 0.0001
def setValue(self, value):
import java.lang.Double as Double
import com.infinitekind.util.StringUtils as StringUtils
import java.awt.Color as Color
if value == None:
self.setText("")
elif Double.isNaN(float(value)):
setText("")
else:
if self.isZero(float(value)):
value = 0.0
self.setText(StringUtils.formatPercentage(float(value), self.decimalSeparator) + "%")
if float(value) < 0.0:
self.setForeground(Color.RED)
else:
self.setForeground(Color.BLACK)
class HeaderRenderer(DefaultTableCellRenderer):
# print "HeaderRenderer "
def __init__(self):
super(DefaultTableCellRenderer, self).__init__()
self.setForeground(Color.BLACK)
self.setBackground(Color.lightGray)
self.setHorizontalAlignment(JLabel.CENTER)
# def __init__(self): # init for StockGlance class
# print "StockGlance init"
# super(StockGlance, self).__init__()
# @classmethod
def createAndShowGUI(self):
# print "creatAndShowGUI"
from javax.swing import JScrollPane as JScrollPane
import javax.swing.border.CompoundBorder as CompoundBorder
import javax.swing.border.MatteBorder as MatteBorder
import javax.swing.border.EmptyBorder as EmptyBorder
import java.awt.Color as Color
import javax.swing.JFrame as JFrame
from javax.swing import WindowConstants as WindowConstants
from java.awt import BorderLayout
import javax.swing.JTable as JTable
from java.awt import Dimension as Dimension
root = moneydance.getRootAccount()
self.book = root.getBook()
# StockGlance75.tableModel = self.getTableModel(self.book)
# StockGlance75.table = self.SGTable(StockGlance75.tableModel)
self.tableModel = self.getTableModel(self.book)
self.table = self.SGTable(self.tableModel)
self.footerModel = self.getFooterModel()
self.footerTable = self.SGFooterTable(self.footerModel)
# StockGlance75.footerModel = self.getFooterModel()
# StockGlance75.footerTable = self.SGFooterTable(StockGlance75.footerModel)
self.scrollPane = JScrollPane(self.table, JScrollPane.VERTICAL_SCROLLBAR_ALWAYS, JScrollPane.HORIZONTAL_SCROLLBAR_AS_NEEDED)
# self.scrollPane = JScrollPane(StockGlance75.table, JScrollPane.VERTICAL_SCROLLBAR_ALWAYS, JScrollPane.HORIZONTAL_SCROLLBAR_AS_NEEDED)
self.scrollPane.setBorder(CompoundBorder(MatteBorder(0, 0, 1, 0, Color.gray), EmptyBorder(0, 0, 0, 0)))
self.footerScrollPane = JScrollPane(self.footerTable, JScrollPane.VERTICAL_SCROLLBAR_ALWAYS, JScrollPane.HORIZONTAL_SCROLLBAR_AS_NEEDED)
# self.footerScrollPane = JScrollPane(StockGlance75.footerTable, JScrollPane.VERTICAL_SCROLLBAR_ALWAYS, JScrollPane.HORIZONTAL_SCROLLBAR_AS_NEEDED)
self.footerScrollPane.setBorder(CompoundBorder(MatteBorder(0, 0, 1, 0, Color.gray), EmptyBorder(0, 0, 0, 0)))
frame_ = JFrame("StockGlance")
frame_.setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE)
frame_.add(self.scrollPane, BorderLayout.CENTER)
self.table.setAutoResizeMode(JTable.AUTO_RESIZE_OFF )
# StockGlance75.table.setAutoResizeMode(JTable.AUTO_RESIZE_OFF )
self.footerTable.setColumnSelectionAllowed(False)
self.footerTable.setRowSelectionAllowed(False)
self.footerTable.setAutoResizeMode(JTable.AUTO_RESIZE_OFF )
# StockGlance75.footerTable.setColumnSelectionAllowed(False)
# StockGlance75.footerTable.setRowSelectionAllowed(False)
# StockGlance75.footerTable.setAutoResizeMode(JTable.AUTO_RESIZE_OFF )
frame_.add(self.footerScrollPane, BorderLayout.SOUTH)
frame_.setSize(1170,1000)
tcm = self.table.getColumnModel()
# tcm = StockGlance75.table.getColumnModel()
tcm.getColumn(0).setPreferredWidth(80)
tcm.getColumn(1).setPreferredWidth(250)
tcm.getColumn(2).setPreferredWidth(80)
tcm.getColumn(3).setPreferredWidth(80)
tcm.getColumn(4).setPreferredWidth(80)
tcm.getColumn(5).setPreferredWidth(80)
tcm.getColumn(6).setPreferredWidth(80)
tcm.getColumn(7).setPreferredWidth(80)
tcm.getColumn(8).setPreferredWidth(80)
tcm.getColumn(9).setPreferredWidth(260)
tcm = self.footerTable.getColumnModel()
# tcm = StockGlance75.footerTable.getColumnModel()
tcm.getColumn(0).setPreferredWidth(80)
tcm.getColumn(1).setPreferredWidth(250)
tcm.getColumn(2).setPreferredWidth(80)
tcm.getColumn(3).setPreferredWidth(80)
tcm.getColumn(4).setPreferredWidth(80)
tcm.getColumn(5).setPreferredWidth(80)
tcm.getColumn(6).setPreferredWidth(80)
tcm.getColumn(7).setPreferredWidth(80)
tcm.getColumn(8).setPreferredWidth(80)
tcm.getColumn(9).setPreferredWidth(260)
self.footerScrollPane.setPreferredSize(Dimension(10,30))# (width,height) width doesn't matter
self.footerTableHeader = self.footerTable.getTableHeader()
# self.footerTableHeader = StockGlance75.footerTable.getTableHeader()
self.footerTableHeader.setEnabled(False) # may have worked
self.footerTableHeader.setPreferredSize(Dimension(0,0)) # this worked no more footer Table header
self.tableHeader = self.table.getTableHeader()
# self.tableHeader = StockGlance75.table.getTableHeader()
self.tableHeader.setReorderingAllowed(False) # no more drag and drop columns, it didn't work
# frame_.pack()
frame_.setVisible(True)
