def run(self):
frame = JFrame('flexible Box',
locationRelativeTo=None,
defaultCloseOperation=JFrame.EXIT_ON_CLOSE)
print '\nscreenSize:', Toolkit.getDefaultToolkit().getScreenSize()
box = Box.createHorizontalBox()
box.add(Box.createGlue())
box.add(Box.createRigidArea(Dimension(5, 5)))
box.add(JLabel('Name:'))
box.add(Box.createRigidArea(Dimension(5, 5)))
self.tf = box.add(
JTextField(
10 # ,
# maximumSize = Dimension( 2000, 20 )
# maximumSize = Dimension( 20000, 20 )
# maximumSize = Dimension( 200000, 20 )
))
box.add(Box.createRigidArea(Dimension(5, 5)))
box.add(JButton('Submit', actionPerformed=self.buttonPress))
box.add(Box.createRigidArea(Dimension(5, 5)))
box.add(Box.createGlue())
frame.add(box)
frame.pack()
frame.setVisible(1)
def run( self ) :
frame = JFrame(
'Box1',
locationRelativeTo = None,
defaultCloseOperation = JFrame.EXIT_ON_CLOSE
)
name = 'A'
size = Dimension( 46, 26 )
vBox = Box.createVerticalBox()
for row in range( 5 ) :
hBox = Box.createHorizontalBox()
for col in range( 5 ) :
button = JButton( name )
# button = JButton(
# name,
# size = size,
# minimumSize = size,
# maximumSize = size,
# preferredSize = size
# )
hBox.add( button )
self.showSizes( name, button )
name = chr( ord( name ) + 1 )
vBox.add( hBox )
frame.add( vBox )
frame.pack()
frame.setVisible( 1 )
class VacalcFrame(object):
def __init__(self, employees, dateprovider):
self._frame = JFrame("Vacation Calculator", defaultCloseOperation=JFrame.EXIT_ON_CLOSE)
self._frame.setContentPane(self._create_ui(employees, dateprovider))
self._frame.pack()
def _create_ui(self, employees, dateprovider):
panel = JPanel(layout=FlowLayout())
self._overview = EmployeeOverview(employees, self)
self._details = EmployeeDetails(employees, dateprovider)
self._welcome = Welcome()
panel.add(self._overview)
panel.add(self._welcome)
return panel
def show(self):
self._frame.setVisible(True)
def employee_selected(self, employee):
self._ensure_details_shown()
self._details.show_employee(employee)
def edit_new_employee(self):
self._ensure_details_shown()
self._details.edit_new_employee()
def _ensure_details_shown(self):
if self._welcome:
self._frame.contentPane.remove(self._welcome)
self._frame.contentPane.add(self._details)
self._frame.pack()
self._welcome = None
class _AccountAdder:
def __init__(self, contactslist):
self.contactslist = contactslist
self.mainframe = JFrame("Add New Contact")
self.account = JComboBox(self.contactslist.clientsByName.keys())
self.contactname = JTextField()
self.buildpane()
def buildpane(self):
buttons = JPanel()
buttons.add(JButton("OK", actionPerformed=self.add))
buttons.add(JButton("Cancel", actionPerformed=self.cancel))
acct = JPanel(GridLayout(1, 2), doublebuffered)
acct.add(JLabel("Account"))
acct.add(self.account)
mainpane = self.mainframe.getContentPane()
mainpane.setLayout(BoxLayout(mainpane, BoxLayout.Y_AXIS))
mainpane.add(self.contactname)
mainpane.add(acct)
mainpane.add(buttons)
self.mainframe.pack()
self.mainframe.show()
#action listeners
def add(self, ae):
acct = self.contactslist.clientsByName[self.account.getSelectedItem()]
acct.addContact(self.contactname.getText())
self.mainframe.dispose()
def cancel(self, ae):
self.mainframe.dispose()
def makeUI(model):
table = JTable(model)
jsp = JScrollPane(table)
regex_label = JLabel("Search: ")
regex_field = JTextField(20)
top = JPanel()
top.add(regex_label)
top.add(regex_field)
top.setLayout(BoxLayout(top, BoxLayout.X_AXIS))
base_path_label = JLabel("Base path:")
base_path_field = JTextField(50)
bottom = JPanel()
bottom.add(base_path_label)
bottom.add(base_path_field)
bottom.setLayout(BoxLayout(bottom, BoxLayout.X_AXIS))
all = JPanel()
all.add(top)
all.add(jsp)
all.add(bottom)
all.setLayout(BoxLayout(all, BoxLayout.Y_AXIS))
frame = JFrame("File paths")
frame.getContentPane().add(all)
frame.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE)
frame.addWindowListener(Closing())
frame.pack()
frame.setVisible(True)
# Listeners
regex_field.addKeyListener(EnterListener(table, model, frame))
table.addMouseListener(RowClickListener(base_path_field))
#
return model, table, regex_field, frame
def run(self):
frame = JFrame('ComponentEventDemo',
locationRelativeTo=None,
defaultCloseOperation=JFrame.EXIT_ON_CLOSE)
cp = frame.getContentPane()
cp.setLayout(BorderLayout())
self.display = JTextArea(editable=0,
font=Font('Courier', Font.PLAIN, 12))
myListener = listener(self.display)
frame.addComponentListener(myListener)
scrollPane = JScrollPane(self.display,
preferredSize=Dimension(350, 210))
cp.add(scrollPane, BorderLayout.CENTER)
panel = JPanel(BorderLayout(), componentListener=myListener)
self.button = JButton('Clear',
actionPerformed=self.clear,
componentListener=myListener)
panel.add(self.button, BorderLayout.CENTER)
visible = JCheckBox('Button visible',
selected=1,
itemStateChanged=self.showHide,
componentListener=myListener)
panel.add(visible, BorderLayout.PAGE_END)
cp.add(panel, BorderLayout.PAGE_END)
frame.pack()
frame.setVisible(1)
def complex_console():
global frame
#generates frame
frame = JFrame("[BETA] Game Master\'s Bot - Console Log")
frame.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE)
frame.setResizable(False)
frame.setAlwaysOnTop(True)
frame.setBounds(8,545,600,130)
frame.contentPane.layout = FlowLayout()
#add QUIT button
quitButton = JButton("QUIT", actionPerformed = closeFrame)
quitButton.setForeground(Color.RED)
quitButton.setPreferredSize(Dimension(100,100))
frame.contentPane.add(quitButton)
#add text message
global textArea
textArea = JTextArea(6,38)
textArea.setEditable(False)
frame.contentPane.add(textArea)
scrollPane = JScrollPane(textArea, JScrollPane.VERTICAL_SCROLLBAR_ALWAYS, JScrollPane.HORIZONTAL_SCROLLBAR_AS_NEEDED)
frame.contentPane.add(scrollPane)
#show frame
frame.pack()
frame.setVisible(True)
log("Welcome to Game Master\'s Bot!")
def run(self):
frame = JFrame('Available Fonts',
defaultCloseOperation=JFrame.EXIT_ON_CLOSE)
#-----------------------------------------------------------------------
# First, we a local graphics environment (LGE) instance. Then, we call
# its getAvailableFontFamilyNames() method to obtain the list of all
# available font names.
#-----------------------------------------------------------------------
lge = GraphicsEnvironment.getLocalGraphicsEnvironment()
fontNames = lge.getAvailableFontFamilyNames()
#-----------------------------------------------------------------------
# The JTextArea will be used to hold the names of the available fonts.
# Unfortunately, we don't know, for certain, how many font names are
# present. So, we need to have the JTextArea be within a JScrollPane,
# "just in case" too many names exist for us to display at one time. ;-)
#-----------------------------------------------------------------------
frame.add(
JScrollPane(
JTextArea('\n'.join(fontNames), editable=0, rows=8,
columns=32)))
frame.pack()
frame.setVisible(1)
class myAnimFrame:
"""
Supporting class for animations.
"""
def desty(self, event):
self.display.destroy()
self.frame.dispose()
def __init__(self, display, widget, width, height, title):
from javax.swing import JFrame, JPanel
from java.awt import BorderLayout, FlowLayout
self.display = display
self.panel = JPanel(BorderLayout())
self.panel2 = JPanel(FlowLayout())
self.panel2.add(widget)
self.panel.add("North", self.panel2)
self.panel.add("Center",self.display.getComponent())
self.frame = JFrame(title, windowClosing=self.desty)
self.pane = self.frame.getContentPane()
self.pane.add(self.panel)
self.frame.setSize(width,height)
self.frame.pack()
self.frame.show()
class positionDialog(JFrame):
def __init__(self):
self.frame = JFrame("CellCropper: Experiment details", size=(400,200))
self.frame.setLocation(20,120)
self.Panel = JPanel(GridLayout(4,2))
self.frame.add(self.Panel)
self.Panel.add(JLabel("Date:"))
self.dateField = JTextField( str(date.today()), 8 )
self.Panel.add(self.dateField)
self.strainField = JTextField( "2926",4 )
self.Panel.add(self.strainField)
self.tempField = JTextField( "34",2 )
self.Panel.add(self.tempField)
self.ODField = JTextField( "0.5",3 )
self.Panel.add(self.ODField)
self.condField = JTextField( "0.5",3 )
self.Panel.add(self.condField)
self.OKButton = JButton("OK",actionPerformed=closeAndMakePos)
self.Panel.add(self.OKButton)
self.frame.pack()
WindowManager.addWindow(self.frame)
self.show()
def show(self):
self.frame.visible = True
def close(self):
return self.dateField.text, self.strainField.text, self.tempField.text, self.ODField.text, self.condField.text
WindowManager.removeWindow(self.frame)
self.frame.dispose()
def run( self ) :
frame = JFrame( 'ButtonDemo_02' )
frame.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE )
button = frame.add( JButton( 'Press me' ) )
button.addActionListener( self )
frame.pack()
frame.setVisible( 1 )
def show():
""" adapted from here: http://wiki.gephi.org/index.php/Toolkit_-_Reuse_the_Preview_Applet"""
from javax.swing import JFrame
from java.awt import BorderLayout
pc = PreviewController
pc.refreshPreview()
# New Processing target, get the PApplet
target = pc.getRenderTarget("processing")
applet = target.getApplet()
applet.init()
# Refresh the preview and reset the zoom
try:
pc.render(target)
except Exception:
# throws sun.dc.pr.PRError: sun.dc.pr.PRError: setPenT4: invalid pen transformation (singular)
pass
target.refresh()
target.resetZoom()
# Add the applet to a JFrame and display
frame = JFrame("Preview")
frame.setLayout(BorderLayout())
# frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE)
frame.add(applet, BorderLayout.CENTER)
frame.pack()
frame.setVisible(True)
def run( self ) :
frame = JFrame(
'SecConfigReport_02',
size = ( 300, 300 ),
locationRelativeTo = None,
defaultCloseOperation = JFrame.EXIT_ON_CLOSE
)
data = []
text = AdminTask.generateSecConfigReport()
for line in text.splitlines()[ 2: ] :
data.append(
[
info.strip() for info in
line[ :-2 ].split( ';' )
]
)
frame.add(
JScrollPane(
JTable( data, ';;;'.split( ';' ) )
)
)
frame.pack()
frame.setVisible( 1 )
def run( self ) :
frame = JFrame(
'BorderLayout',
layout = BorderLayout(),
defaultCloseOperation = JFrame.EXIT_ON_CLOSE
)
data = [
[ 'PAGE_START', BorderLayout.PAGE_START ],
[ 'PAGE_END' , BorderLayout.PAGE_END ],
[ 'LINE_START', BorderLayout.LINE_START ],
[ 'LINE_END' , BorderLayout.LINE_END ],
]
for name, pos in data :
frame.add( JButton( name ), pos )
big = JButton(
'CENTER',
preferredSize = Dimension( 256, 128 )
)
frame.add( big, BorderLayout.CENTER )
frame.pack()
frame.setVisible( 1 )
def run( self ) :
frame = JFrame(
'WSAShelp_01',
locationRelativeTo = None,
defaultCloseOperation = JFrame.EXIT_ON_CLOSE
)
# text = Help.help()
# tabs = text.count( '\t' )
# text = Help.help().expandtabs()
# rows = text.count( '\n' ) + 1
# cols = max( [ len( x ) for x in text.splitlines() ] )
# cols = max( [ len( x.expandtabs() ) for x in text.splitlines() ] )
# print '\nrows: %d cols: %d tabs: %d' % ( rows, cols, tabs )
frame.add(
JScrollPane(
JTextArea(
# text,
Help.help().expandtabs(),
20,
80,
font = Font( 'Courier' , Font.PLAIN, 12 )
)
)
)
frame.pack()
size = frame.getSize()
# print 'frame.getSize():', size
loc = frame.getLocation()
# print 'frame.getLocation():', loc
loc.x -= ( size.width >> 1 )
loc.y -= ( size.height >> 1 )
frame.setLocation( loc )
frame.setVisible( 1 )
class myAnimFrame:
"""
Supporting class for animations.
"""
def desty(self, event):
self.display.destroy()
self.frame.dispose()
def __init__(self, display, widget, width, height, title):
from javax.swing import JFrame, JPanel
from java.awt import BorderLayout, FlowLayout
self.display = display
self.panel = JPanel(BorderLayout())
self.panel2 = JPanel(FlowLayout())
self.panel2.add(widget)
self.panel.add("North", self.panel2)
self.panel.add("Center", self.display.getComponent())
self.frame = JFrame(title, windowClosing=self.desty)
self.pane = self.frame.getContentPane()
self.pane.add(self.panel)
self.frame.setSize(width, height)
self.frame.pack()
self.frame.show()
class UI(object):
def __init__(self, game):
self.frame = JFrame("Tic Tac Toe",
defaultCloseOperation = WindowConstants.EXIT_ON_CLOSE)
self.panel = JPanel(GridLayout(3,3))
self.buttons = []
self.game = game
for row in range(3):
for col in range(3):
self.buttons.append(TicTacButton(row,col,'',actionPerformed=self.clicked_button))
self.panel.add
self.frame.add(self.panel)
for b in self.buttons:
self.panel.add(b)
self.frame.pack()
self.show()
def show(self):
self.frame.size = 600,600
self.frame.visible = True
def clicked_button(self, event):
button = event.getSource()
print 'current_player', self.game.current_player
if self.game.current_player.level == 'human' and self.game.state=='next':
button.text = self.game.current_player.xo
self.game.update(button)
else:
pass
def run( self ) :
frame = JFrame( 'ButtonDemo_03' )
frame.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE )
button = frame.add( JButton( 'Press me' ) )
button.actionPerformed = self.buttonPressed
frame.pack()
frame.setVisible( 1 )
def tree():
"""
tree(xmlfile="dsm2.xml")
creates a tree view on a given xml file of dsm2 input data
"""
tv = TreeViewer()
mp2 = JPanel()
mp2.setLayout(BorderLayout())
tf = JTextField("dsm2.inp")
pb = JButton("parse")
mp2.add(tf,BorderLayout.CENTER)
mp2.add(pb,BorderLayout.EAST)
class ParseListener(ActionListener):
def __init__(self,tf,tv,fr):
self.tf = tf
self.tv = tv
self.fr = fr
def actionPerformed(self,evt):
dsm2file = self.tf.getText()
parser = DSM2Parser(dsm2file)
self.tv.xdoc = parser.dsm2_data.toXml()
self.fr.getContentPane().add(self.tv.gui(),BorderLayout.CENTER)
self.fr.pack()
self.fr.setVisible(1)
fr = JFrame()
fr.setTitle("DSM2Tree")
fr.setLocation(100,100)
fr.setSize(600,60)
fr.getContentPane().setLayout(BorderLayout())
fr.getContentPane().add(mp2,BorderLayout.NORTH)
al = ParseListener(tf,tv,fr)
pb.addActionListener(al)
fr.pack()
fr.setVisible(1)
def run(self):
frame = JFrame('Spinner4',
layout=FlowLayout(),
defaultCloseOperation=JFrame.EXIT_ON_CLOSE)
frame.add(JSpinner(SpinnerDateModel()))
frame.pack()
frame.setVisible(1)
def gui_open(path):
label = JLabel(ImageIcon(ImageIO.read(File(URL(path).getFile()))))
frame = JFrame()
frame.getContentPane().add(label)
frame.pack()
frame.setLocation(200, 200)
frame.setVisible(True)
class VacalcFrame(object):
def __init__(self, employees):
self._frame = JFrame('Vacation Calculator',
defaultCloseOperation=JFrame.EXIT_ON_CLOSE)
self._frame.setContentPane(self._create_ui(employees))
self._frame.pack()
def _create_ui(self, employees):
panel = JPanel(layout=FlowLayout())
self._overview = EmployeeOverview(employees, self)
self._details = EmployeeDetails(employees)
self._welcome = Welcome()
panel.add(self._overview)
panel.add(self._welcome)
return panel
def show(self):
self._frame.setVisible(True)
def employee_selected(self, employee):
self._ensure_details_shown()
self._details.show_employee(employee)
def edit_new_employee(self):
self._ensure_details_shown()
self._details.edit_new_employee()
def _ensure_details_shown(self):
if self._welcome:
self._frame.contentPane.remove(self._welcome)
self._frame.contentPane.add(self._details)
self._frame.pack()
self._welcome = None
def run(self):
frame = JFrame('horizontalBox',
locationRelativeTo=None,
defaultCloseOperation=JFrame.EXIT_ON_CLOSE)
vert = Box.createVerticalBox()
vert.add(Box.createGlue())
vert.add(JButton('<>'))
vert.add(Box.createVerticalStrut(5))
vert.add(JButton('<>'))
vert.add(Box.createVerticalStrut(5))
vert.add(JButton('<>'))
vert.add(Box.createGlue())
hor = Box.createHorizontalBox()
hor.add(Box.createGlue())
hor.add(JButton('<>'))
hor.add(Box.createHorizontalStrut(5))
hor.add(vert)
hor.add(Box.createHorizontalStrut(5))
hor.add(JButton('<>'))
hor.add(Box.createGlue())
frame.add(hor)
frame.pack()
frame.setVisible(1)
def run(self):
frame = JFrame('MethodTable2',
defaultCloseOperation=JFrame.EXIT_ON_CLOSE)
#-----------------------------------------------------------------------
# Get the text to be processed
#-----------------------------------------------------------------------
helpText = Help.help().expandtabs()
#-----------------------------------------------------------------------
# Verify our help text parsing routine
#-----------------------------------------------------------------------
headings = ['Method', 'Description / Abstract']
#-----------------------------------------------------------------------
# Let's try to highlight every instance of "help" in the table
#-----------------------------------------------------------------------
data = self.parseMethodHelp(helpText)
for r in range(len(data)):
for c in range(len(data[r])):
data[r][c] = self.hiliteText(data[r][c], 'help')
#-----------------------------------------------------------------------
# Create the JTable using the massaged data and column headings
#-----------------------------------------------------------------------
table = JTable(data, headings, font=Font('Courier', Font.PLAIN, 12))
frame.add(JScrollPane(table), 'Center')
frame.pack()
self.center(frame)
frame.setVisible(1)
def show():
""" adapted from here: http://wiki.gephi.org/index.php/Toolkit_-_Reuse_the_Preview_Applet"""
from javax.swing import JFrame
from java.awt import BorderLayout
pc = PreviewController
pc.refreshPreview();
# New Processing target, get the PApplet
target = pc.getRenderTarget("processing")
applet = target.getApplet()
applet.init()
# Refresh the preview and reset the zoom
try:
pc.render(target)
except Exception:
# throws sun.dc.pr.PRError: sun.dc.pr.PRError: setPenT4: invalid pen transformation (singular)
pass
target.refresh()
target.resetZoom()
# Add the applet to a JFrame and display
frame = JFrame("Preview")
frame.setLayout(BorderLayout())
# frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE)
frame.add(applet, BorderLayout.CENTER)
frame.pack()
frame.setVisible(True)
def run(self):
frame = JFrame('LayeredPaneDemo',
locationRelativeTo=None,
defaultCloseOperation=JFrame.EXIT_ON_CLOSE)
frame.setContentPane(self.createLayeredPane())
frame.pack()
frame.setVisible(1)
class _AccountAdder:
def __init__(self, contactslist):
self.contactslist = contactslist
self.mainframe = JFrame("Add New Contact")
self.account = JComboBox(self.contactslist.clientsByName.keys())
self.contactname = JTextField()
self.buildpane()
def buildpane(self):
buttons = JPanel()
buttons.add(JButton("OK", actionPerformed=self.add))
buttons.add(JButton("Cancel", actionPerformed=self.cancel))
acct = JPanel(GridLayout(1, 2), doublebuffered)
acct.add(JLabel("Account"))
acct.add(self.account)
mainpane = self.mainframe.getContentPane()
mainpane.setLayout(BoxLayout(mainpane, BoxLayout.Y_AXIS))
mainpane.add(self.contactname)
mainpane.add(acct)
mainpane.add(buttons)
self.mainframe.pack()
self.mainframe.show()
#action listeners
def add(self, ae):
acct = self.contactslist.clientsByName[self.account.getSelectedItem()]
acct.addContact(self.contactname.getText())
self.mainframe.dispose()
def cancel(self, ae):
self.mainframe.dispose()
def run(self):
frame = JFrame('SecConfigReport_09',
size=(500, 300),
locationRelativeTo=None,
componentResized=self.frameResized,
defaultCloseOperation=JFrame.EXIT_ON_CLOSE)
data = []
text = AdminTask.generateSecConfigReport()
#-----------------------------------------------------------------------
# The RegExp was added to replace multiple blanks with a single one
#-----------------------------------------------------------------------
for line in text.splitlines()[2:]:
data.append([
re.sub(' +', ' ', info.strip())
for info in line[:-2].split(';')
])
self.table = table = JTable(
reportTableModel(
data,
';;;'.split(';'),
),
selectionMode=ListSelectionModel.SINGLE_SELECTION)
table.setDefaultRenderer(String, reportRenderer())
self.setColumnWidths(table)
scroller = JScrollPane(table)
scroller.getViewport().addChangeListener(rowFinder(table))
frame.add(scroller)
frame.pack()
frame.setVisible(1)
frame.setMinimumSize(frame.getSize())
class ConversationWindow(Conversation):
"""A GUI window of a conversation with a specific person"""
def __init__(self, person, chatui):
"""ConversationWindow(basesupport.AbstractPerson:person)"""
Conversation.__init__(self, person, chatui)
self.mainframe = JFrame("Conversation with "+person.name)
self.display = JTextArea(columns=100,
rows=15,
editable=0,
lineWrap=1)
self.typepad = JTextField()
self.buildpane()
self.lentext = 0
def buildpane(self):
buttons = JPanel(doublebuffered)
buttons.add(JButton("Send", actionPerformed=self.send))
buttons.add(JButton("Hide", actionPerformed=self.hidewindow))
mainpane = self.mainframe.getContentPane()
mainpane.setLayout(BoxLayout(mainpane, BoxLayout.Y_AXIS))
mainpane.add(JScrollPane(self.display))
self.typepad.actionPerformed = self.send
mainpane.add(self.typepad)
mainpane.add(buttons)
def show(self):
self.mainframe.pack()
self.mainframe.show()
def hide(self):
self.mainframe.hide()
def sendText(self, text):
self.displayText("\n"+self.person.client.name+": "+text)
Conversation.sendText(self, text)
def showMessage(self, text, metadata=None):
self.displayText("\n"+self.person.name+": "+text)
def contactChangedNick(self, person, newnick):
Conversation.contactChangedNick(self, person, newnick)
self.mainframe.setTitle("Conversation with "+newnick)
#GUI code
def displayText(self, text):
self.lentext = self.lentext + len(text)
self.display.append(text)
self.display.setCaretPosition(self.lentext)
#actionlisteners
def hidewindow(self, ae):
self.hide()
def send(self, ae):
text = self.typepad.getText()
self.typepad.setText("")
if text != "" and text != None:
self.sendText(text)
def run(self):
frame = JFrame('SplitPane1',
defaultCloseOperation=JFrame.EXIT_ON_CLOSE)
frame.add(
JSplitPane(JSplitPane.HORIZONTAL_SPLIT, JButton('Left'),
JButton('Right')))
frame.pack()
frame.setVisible(1)
def run(self):
frame = JFrame('SplitPane2',
defaultCloseOperation=JFrame.EXIT_ON_CLOSE)
frame.add(
JSplitPane(JSplitPane.VERTICAL_SPLIT, JButton('Top'),
JButton('Bottom')))
frame.pack()
frame.setVisible(1)
def startGui():
frame = JFrame("MonkeyPySon")
frame.setContentPane(getContentPane())
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE)
frame.pack()
frame.setVisible(True)
frame.addWindowFocusListener(GuiWindowFocusListener())
startLookingDevices()
def run(self):
frame = JFrame('Global Security')
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE)
security = AdminConfig.list('Security')
status = AdminConfig.showAttribute(security, 'enabled')
frame.add(JLabel('Security enabled: ' + status))
frame.pack()
frame.setVisible(1)
def run(self):
frame = JFrame('Spinner1',
layout=FlowLayout(),
defaultCloseOperation=JFrame.EXIT_ON_CLOSE)
daysOfWeek = [dow for dow in DFS().getWeekdays() if dow]
frame.add(JSpinner(SpinnerListModel(daysOfWeek)))
frame.pack()
frame.setVisible(1)
def run(self):
frame = JFrame('ButtonDemo_04',
defaultCloseOperation=JFrame.EXIT_ON_CLOSE)
frame.add(JButton('Press me', actionPerformed=self.buttonPressed))
self.label = JLabel('button press pending')
frame.add(self.label, BorderLayout.SOUTH)
frame.pack()
frame.setVisible(1)
def cachedBPROM(genome, fileName, frame):
"""
genome: Genome as a string.
fileName: File to save the BPROM results in.
swing: A JFrame or None. If this is None then messages will be printed, if it isn't then
they will also be put in a dialog box.
return: Results of the BPROM prediction stored in a list of Promoter objects.
If the file Specified by fileName already exists then this function simply parses the file
already there. Also, if a request is made to BPROM and nothing is returned, no file is
created, the user is warned, and an empty list is returned.
"""
offset = 25 if ".forward.bprom" in fileName else 50
direction = "forward" if offset == 50 else "reverse"
def getPromoters():
input = open(fileName, "r")
results = parseBPROM(input.read())
input.close()
return results
if not os.path.isfile(fileName):
results = urllib.urlopen("http://linux1.softberry.com/cgi-bin/programs/gfindb/bprom.pl",
urllib.urlencode({"DATA" : genome}))
resultString = results.read()
results.close()
resultString = resultString[resultString.find("<pre>"):resultString.find("</pre>")]
resultString = re.sub("<+.+>+", "", resultString).strip()
if resultString:
output = open(fileName, "w")
output.write(resultString)
output.close()
return getPromoters()
else:
if frame:
messageFrame = JFrame("BPROM Error",
defaultCloseOperation = WindowConstants.DISPOSE_ON_CLOSE)
messageFrame.setLocation(frame.location().x + offset, frame.location().y + offset)
messageFrame.contentPane.layout = GridBagLayout()
constraints = GridBagConstraints()
constraints.gridx, constraints.gridy = 0, 0
constraints.gridwidth, constraints.gridheight = 1, 1
constraints.fill = GridBagConstraints.BOTH
constraints.weightx, constraints.weighty = 1, 1
messageFrame.contentPane.add(JLabel("<html>The pipeline will continue to run but BPROM<br/>did not process the request for promoters on the<br/>" + direction + " strand. Try again tomorrow.</html>"), constraints)
constraints.gridx, constraints.gridy = 0, 1
constraints.fill = GridBagConstraints.NONE
constraints.weightx, constraints.weighty = 1, 1
constraints.anchor = GridBagConstraints.LINE_END
messageFrame.contentPane.add(JButton("Ok", actionPerformed = lambda e: messageFrame.dispose()), constraints)
messageFrame.pack()
messageFrame.visible = True
print "BPROM Error:", "The pipeline will continue to run but BPROM did not process the request for promoters on the " + direction + " strand. Try again tomorrow"
return []
else:
return getPromoters()
def main():
from org.gjt.sp.jedit import jEdit
from javax.swing import JFrame
p = PathBrowser(jEdit.getFirstView())
f = JFrame()
f.contentPane.layout = BorderLayout()
f.contentPane.add(p.panel)
f.pack()
f.visible = 1
def run(sketch):
from javax.swing import JFrame
from processing.core import PApplet
class Main(PApplet):
def __init__(self, sketch):
self.sketch = sketch
P5_set_instance(self)
def setup(self):
self.sketch['setup']()
def draw(self):
self.sketch['draw']()
def mousePressed(self, evt):
P5_register_mouse_event(evt)
self.sketch['mousePressed']()
def mouseReleased(self, evt):
P5_register_mouse_event(evt)
def mouseClicked(self, evt):
P5_register_mouse_event(evt)
self.sketch['mouseClicked']()
def mouseEntered(self, evt):
P5_register_mouse_event(evt)
def mouseExited(self, evt):
P5_register_mouse_event(evt)
def mouseDragged(self, evt):
P5_register_mouse_event(evt)
self.sketch['mouseDragged'](evt)
def mouseMoved(self, evt):
P5_register_mouse_event(evt)
self.sketch['mouseMoved'](evt)
def getField(self, name):
# rqd due to PApplet's using frameRate and frameRate(n) etc.
return self.class.superclass.getDeclaredField(name).get(self)
if __name__ == '__main__' or True:
frame = JFrame(title="Processing",
resizable=0,
defaultCloseOperation=JFrame.EXIT_ON_CLOSE)
panel = Main(sketch)
frame.add(panel)
panel.init()
while panel.defaultSize and not panel.finished:
pass
frame.pack()
frame.visible = 1
class View(JComponent):
def __init__(self, obj, location, size=(800, 600), keys=None):
JComponent.__init__(self)
self.location = list(location)
self.buffer = FrameBuffer(
size[0], size[1], FrameBuffer.SAMPLINGMODE_NORMAL)
self.obj = obj
self.frame = JFrame(keyPressed=self.keyPressed,
keyReleased=self.keyReleased)
self.frame.add(self)
self.size = size
self.frame.pack()
self.frame.size = size
self.frame.visible = True
self.clearColor = Color(0x666666)
self.keys = keys
def paint(self, g):
x, y, z = self.location
self.obj.world.camera.setPosition(x, -y, z)
self.obj.world.camera.lookAt(SimpleVector(0, 0, 0))
self.buffer.clear(self.clearColor)
self.obj.world.renderScene(self.buffer)
self.obj.world.draw(self.buffer)
self.buffer.update()
self.buffer.display(g)
self.repaint()
def keyReleased(self, event):
if self.keys is not None and hasattr(self.keys, 'key_released'):
self.keys.key_released(KeyEvent.getKeyText(event.keyCode))
def keyPressed(self, event):
if self.keys is not None and hasattr(self.keys, 'key_pressed'):
self.keys.key_pressed(KeyEvent.getKeyText(event.keyCode))
if event.keyCode == KeyEvent.VK_ESCAPE:
self.frame.dispose()
elif event.keyCode == KeyEvent.VK_PAGE_UP:
self.obj.sch.rate *= 1.1
self.frame.title = 'rate: %1.3f' % self.obj.sch.rate
elif event.keyCode == KeyEvent.VK_PAGE_DOWN:
self.obj.sch.rate /= 1.1
self.frame.title = 'rate: %1.3f' % self.obj.sch.rate
elif event.keyCode == KeyEvent.VK_Z:
self.location[2] += 1
elif event.keyCode == KeyEvent.VK_X:
self.location[2] -= 1
elif event.keyCode == KeyEvent.VK_W:
self.location[1] += 1
elif event.keyCode == KeyEvent.VK_S:
self.location[1] -= 1
elif event.keyCode == KeyEvent.VK_A:
self.location[0] += 1
elif event.keyCode == KeyEvent.VK_D:
self.location[0] -= 1
def run(self, query, print_urls = True, pr_weight =0.4, verbose = False):
"""this function basically runs a query"""
self.query = parse_query(query, self.reader)
start_time = time.clock()
self.n_show = 10
if self.ah_flag is True:
doc_ids, score, auth_ids, auth_score, hub_ids, hub_score = self.retrieve(verbose = verbose)
elif self.pr_flag is True:
doc_ids, score, pr_ids, pr = self.retrieve(pr_weight = pr_weight, verbose = verbose)
else:
doc_ids, score = self.retrieve(verbose = verbose)
end_time = time.clock()
frame = JFrame('Ragav\'s Search Engine',
defaultCloseOperation = JFrame.EXIT_ON_CLOSE,
size = (100, 200)
)
panel = JPanel(GridLayout(0,1))
frame.add(panel)
print "in total " + str(end_time - start_time) + " seconds for retrieval"
if print_urls is True:
# panel.add ( JLabel("vector space retreival" ) )
for i in xrange(self.n_show):
d = self.reader.document(doc_ids[i])
panel.add ( JLabel (d.getFieldable("path").stringValue().replace("%%", "/") ) )
print "doc: [" + str(doc_ids[i]) + "], score: [" + str(score[doc_ids[i]]) + "], url: " + d.getFieldable("path").stringValue().replace("%%", "/")
if self.ah_flag is True:
# panel.add ( Jlabel("authorities based retreival" ) )
for i in xrange(self.n_show):
d = self.reader.document(auth_ids[i])
panel.add ( JLabel (d.getFieldable("path").stringValue().replace("%%", "/") ) )
# panel.add ( JLabel("hubs based retreival" ) )
for i in xrange(self.n_show):
d = self.reader.document(hub_ids[i])
panel.add ( JLabel ( d.getFieldable("path").stringValue().replace("%%", "/") ) )
elif self.pr_flag is True:
# panel.add ( JLabel("page rank based retreival" ) )
for i in xrange(self.n_Show):
d = self.reader.document(pr_ids[i])
panel.add ( JLabel ( d.getFieldable("path").stringValue().replace("%%", "/") ) )
print "retrieval complete. "
print "..........................................................................."
frame.pack()
frame.visible = True
return d
class ApplicationTestCase(unittest.TestCase):
def setUp(self):
Robot().mouseMove(800, 600)
self.launch_app()
self.app = ApplicationTestApp()
def tearDown(self):
self.frame.setVisible(False)
self.frame.dispose()
def launch_app(self):
self.frame = JFrame("Test Window", defaultCloseOperation=JFrame.EXIT_ON_CLOSE)
pane = self.frame.getContentPane()
layout = SpringLayout()
pane.setLayout(layout)
label = JLabel("Test Label")
pane.add(label)
layout.putConstraint(SpringLayout.WEST, label, 20, SpringLayout.WEST, pane)
layout.putConstraint(SpringLayout.NORTH, label, 20, SpringLayout.NORTH, pane)
self.frame.pack()
self.frame.setVisible(True)
self.frame.setSize(800, 600)
def test_init_window(self):
window = self.app.init_window(ApplicationTestWindow)
self.assertNotEqual(window, None)
self.assertTrue(isinstance(window, ApplicationTestWindow))
self.assertEqual((window.region.getW(), window.region.getH()), (800, 600))
def test_create_image_folders(self):
path = os.path.join('images', 'application_test_window', 'test_label')
shutil.move(os.path.join(path, 'enabled.png'), os.path.join('images', '.enabled.png.tmp'))
shutil.rmtree(os.path.join('images', 'application_test_window'))
self.app.create_image_folders()
self.assertTrue(os.path.exists(path))
shutil.move(os.path.join('images', '.enabled.png.tmp'), os.path.join(path, 'enabled.png'))
# TODO: test_capture_screenshots
# TODO: test_open
def test_find_focused_window(self):
window = self.app.find_focused_window()
self.assertNotEqual(window, None)
self.assertTrue(isinstance(window, ApplicationTestWindow))
def test_focused_window(self):
before_time = time.time()
window = self.app.focused_window(10)
after_time = time.time()
self.assertTrue(after_time >= before_time + 10)
self.assertNotEqual(window, None)
self.assertTrue(isinstance(window, ApplicationTestWindow))
def start_ashdi():
loadKeyLayout("data_2.0/ashdi_keylayout.xml")
global frame
frame = JFrame(FRAME_TITLE)
frame.setContentPane(getContentPane())
frame.windowClosing = lambda x: windowClosing()
frame.pack()
frame.setVisible(True)
frame.addWindowFocusListener(GuiWindowFocusListener())
start_android_waker()
handleConnectedDevBtn(True)
check_move_support()
def __init__(self, title, display, panel):
from java.awt import Toolkit
from javax.swing import JFrame
self.display = display
frame = JFrame(title, windowClosing=self.desty)
frame.getContentPane().add(panel)
frame.pack()
frame.invalidate()
fSize = frame.getSize()
screensize = Toolkit.getDefaultToolkit().getScreenSize()
frame.setLocation((screensize.width - fSize.width)/2,
(screensize.height - fSize.height)/2)
frame.setVisible(1)
def geom_viewer(dsm2file = "dsm2.inp"):
"""
geom_viewer(dsm2file = "dsm2.inp")
starts off a dsm2 geometry viewer for dsm2 input data
Irregular xsections are plotted if available otherwise
regular xsections are plotted.
"""
dgv = DSM2GeomViewer(dsm2file)
mp = dgv.gui()
fr = JFrame()
fr.setTitle('Geom Viewer')
fr.getContentPane().add(mp)
fr.setLocation(300,100)
fr.pack()
sz = fr.getSize()
fr.setSize(250,sz.height)
fr.setVisible(1)
def startGui(self):
frame = JFrame("Life", defaultCloseOperation=JFrame.EXIT_ON_CLOSE)
(R, C) = (self.numRows, self.numCols)
gridPanel = JPanel(GridLayout(R, C))
self.checkBoxes = [[JCheckBox() for c in range(C)] for r in range(R)]
self.grid = [[False for c in range(C)] for r in range(R)]
for r in range(R):
for c in range(C):
gridPanel.add(self.checkBoxes[r][c])
frame.add(gridPanel)
buttonPanel = JPanel(FlowLayout())
stepButton = JButton("Step", actionPerformed=self._step)
runButton = JToggleButton("Run", actionPerformed=self._run)
buttonPanel.add(stepButton)
buttonPanel.add(runButton)
frame.add(buttonPanel, SOUTH)
frame.pack()
frame.locationRelativeTo = None
frame.visible = True
def show_gui():
"""
Shows a GUI to select dss files to compare and select an input file
"""
from javax.swing import JPanel, JFrame, JButton, SpringLayout, JTextBox
from javax.swing.border import LineBorder
textBox1 = JTextBox()
textBox2 = JTextBox()
file1ChooseButton = JButton("Choose File")
file2ChooseButton = JButton("Choose File")
contentPane = JPanel(SpringLayout())
contentPane.setBorder(LineBorder(Color.blue))
contentPane.add(JLabel("Alternative DSS File"))
contentPane.add(textBox1)
contentPane.add(file1ChooseButton)
contentPane.add(JLabel("Base DSS File"))
contentPane.add(textBox2)
contentPane.add(file2ChooseButton)
fr = JFrame("Calsim Report Generator")
fr.contentPane().add(contentPane)
fr.pack();fr.show();
class StopWatch(Runnable):
def __init__(self):
self.frame = JFrame("StopWatch", defaultCloseOperation=JFrame.EXIT_ON_CLOSE)
self.start = JButton("Start", actionPerformed=self.start)
self.frame.add(self.start, BorderLayout.WEST)
self.stop = JButton("Stop", actionPerformed=self.stop)
self.frame.add(self.stop, BorderLayout.EAST)
self.label = JLabel(" " * 45)
self.frame.add(self.label, BorderLayout.SOUTH)
self.frame.pack()
def start(self, event):
self.started = Calendar.getInstance().getTimeInMillis()
self.label.setText("Running")
def stop(self, event):
elapsed = Calendar.getInstance().getTimeInMillis() - self.started
self.label.setText("Elapsed: %.2f seconds" % (float(elapsed) / 1000.0))
def run(self):
self.frame.setVisible(1)
def main(args):
_WIDTH = 300
_HEIGHT = 300
fps = 20#frames per second
bgColor = Color.white
frame = JFrame("Graphics!")
frame.setBackground(bgColor);
frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE)
drawgraphics = DrawGraphics()
content = Animator(drawgraphics, _WIDTH, _HEIGHT, fps)
content.setBackground(bgColor)
content.setSize(_WIDTH, _HEIGHT)
content.setMinimumSize(Dimension(_WIDTH, _HEIGHT))
content.setPreferredSize(Dimension(_WIDTH, _HEIGHT))
frame.setSize(_WIDTH, _HEIGHT)
frame.setContentPane(content)
frame.setResizable(True)
frame.pack()
Thread(content).start()
frame.setVisible(True)
class MandersPlugin(ImageListener, WindowAdapter):
def __init__(self):
self.imp = None
self.preview = None
self.createMainWindow()
self.cells = None
self.files = []
self.results = ResultsTable()
ImagePlus.addImageListener(self)
self.selectInputDir()
self.selectOutputDir()
self.pairs = []
self.methods = []
self.processNextFile()
def selectInputDir(self):
inputDialog = DirectoryChooser("Please select a directory contaning your images")
inputDir = inputDialog.getDirectory()
for imageFile in os.listdir(inputDir):
self.files.append(inputDir + imageFile)
def selectOutputDir(self):
outputDialog = DirectoryChooser("Please select a directory to save your results")
self.outputDir = outputDialog.getDirectory()
def closeImage(self):
if self.imp is not None:
self.imp.close()
self.imp = None
if self.preview is not None:
self.preview.close()
self.preview = None
def openImage(self, imageFile):
try:
images = BF.openImagePlus(imageFile)
self.imp = images[0]
except UnknownFormatException:
return None
if self.imp.getNChannels() < 2:
IJ.error("Bad image format", "Image must contain at lease 2 channels!")
return None
if not self.pairs or \
not self.methods:
self.getOptionsDialog(self.imp)
title = self.imp.title
self.imp.title = title[:title.rfind('.')]
return self.imp
def getOptionsDialog(self, imp):
thr_methods = ["None", "Default", "Huang", "Intermodes", "IsoData", "Li", "MaxEntropy","Mean", "MinError(I)", "Minimum", "Moments", "Otsu", "Percentile", "RenyiEntropy", "Shanbhag" , "Triangle", "Yen"]
gd = GenericDialog("Please select channels to collocalize")
for i in range(1, imp.getNChannels() + 1):
gd.addChoice("Threshold method for channel %i" % i, thr_methods, "None")
gd.showDialog()
if gd.wasCanceled():
self.exit()
channels = []
for i in range(1, imp.getNChannels() + 1):
method = gd.getNextChoice()
self.methods.append(method)
if method != "None":
channels.append(i)
for x in channels:
for y in channels:
if x < y:
self.pairs.append((x, y))
def processNextFile(self):
if self.files:
imageFile = self.files.pop(0)
return self.processFile(imageFile)
else:
return False
def processFile(self, imageFile):
imp = self.openImage(imageFile)
if imp is not None:
cell = Cell(imp.NSlices, 1)
self.cells = DelegateListModel([])
self.cells.append(cell)
self.showMainWindow(self.cells)
if self.checkbox3D.isSelected():
self.displayImage(imp)
else:
self.displayImage(imp, False)
self.preview = self.previewImage(imp)
self.displayImage(self.preview)
return True
else:
return self.processNextFile()
def displayImage(self, imp, show = True):
imp.setDisplayMode(IJ.COMPOSITE)
enhancer = ContrastEnhancer()
enhancer.setUseStackHistogram(True)
splitter = ChannelSplitter()
for c in range(1, imp.getNChannels() + 1):
imp.c = c
enhancer.stretchHistogram(imp, 0.35)
if show:
imp.show()
def previewImage(self, imp):
roi = imp.getRoi()
splitter = ChannelSplitter()
channels = []
for c in range(1, imp.getNChannels() + 1):
channel = ImagePlus("Channel %i" % c, splitter.getChannel(imp, c))
projector = ZProjector(channel)
projector.setMethod(ZProjector.MAX_METHOD)
projector.doProjection()
channels.append(projector.getProjection())
image = RGBStackMerge.mergeChannels(channels, False)
image.title = imp.title + " MAX Intensity"
image.luts = imp.luts
imp.setRoi(roi)
return image
def getCroppedChannels(self, imp, cell):
splitter = ChannelSplitter()
imp.setRoi(None)
if cell.mode3D:
cropRoi = cell.getCropRoi()
else:
cropRoi = cell.roi
if cropRoi is None:
return None
crop = cropRoi.getBounds()
channels = []
for c in range(1, imp.getNChannels() + 1):
slices = ImageStack(crop.width, crop.height)
channel = splitter.getChannel(imp, c)
for z in range(1, channel.getSize() + 1):
zslice = channel.getProcessor(z)
zslice.setRoi(cropRoi)
nslice = zslice.crop()
if cell.mode3D:
oroi = cell.slices[z - 1].roi
else:
oroi = cell.roi
if oroi is not None:
roi = oroi.clone()
bounds = roi.getBounds()
roi.setLocation(bounds.x - crop.x, bounds.y - crop.y)
nslice.setColor(Color.black)
nslice.fillOutside(roi)
slices.addSlice(nslice)
channels.append(ImagePlus("Channel %i" % c, slices))
return channels
def getThreshold(self, imp, method):
thresholder = Auto_Threshold()
duplicator = Duplicator()
tmp = duplicator.run(imp)
return thresholder.exec(tmp, method, False, False, True, False, False, True)
def getContainer(self, impA, impB):
imgA = ImagePlusAdapter.wrap(impA)
imgB = ImagePlusAdapter.wrap(impB)
return DataContainer(imgA, imgB, 1, 1, "imageA", "imageB")
def getManders(self, imp, cell):
### Crop channels according to cell mask
channels = self.getCroppedChannels(imp, cell)
if channels is None:
return None
### Calculate channel thresholds
thrs = []
thrimps = []
for c, method in enumerate(self.methods):
if method != "None":
thr, thrimp = self.getThreshold(channels[c], method)
else:
thr, thrimp = None, None
thrs.append(thr)
thrimps.append(thrimp)
### Calculate manders colocalization
manders = MandersColocalization()
raws = []
thrds = []
for chA, chB in self.pairs:
container = self.getContainer(channels[chA - 1], channels[chB - 1])
img1 = container.getSourceImage1()
img2 = container.getSourceImage2()
mask = container.getMask()
cursor = TwinCursor(img1.randomAccess(), img2.randomAccess(), Views.iterable(mask).localizingCursor())
rtype = img1.randomAccess().get().createVariable()
raw = manders.calculateMandersCorrelation(cursor, rtype)
rthr1 = rtype.copy()
rthr2 = rtype.copy()
rthr1.set(thrs[chA - 1])
rthr2.set(thrs[chB - 1])
cursor.reset()
thrd = manders.calculateMandersCorrelation(cursor, rthr1, rthr2, ThresholdMode.Above)
raws.append(raw)
thrds.append(thrd)
return (channels, thrimps, thrs, raws, thrds)
def saveMultichannelImage(self, title, channels, luts):
tmp = RGBStackMerge.mergeChannels(channels, False)
tmp.luts = luts
saver = FileSaver(tmp)
saver.saveAsTiffStack(self.outputDir + title + ".tif")
tmp.close()
def createMainWindow(self):
self.frame = JFrame('Select cells and ROIs',
defaultCloseOperation = JFrame.DISPOSE_ON_CLOSE
)
self.frame.setLayout(GridBagLayout())
self.frame.addWindowListener(self)
self.frame.add(JLabel("Cells"),
GridBagConstraints(0, 0, 1, 1, 0, 0,
GridBagConstraints.CENTER, GridBagConstraints.NONE,
Insets(5, 2, 2, 0), 0, 0
))
self.cellList = JList(DelegateListModel([]),
selectionMode = ListSelectionModel.SINGLE_SELECTION,
cellRenderer = MyRenderer(),
selectedIndex = 0,
valueChanged = self.selectCell
)
self.frame.add(JScrollPane(self.cellList),
GridBagConstraints(0, 1, 1, 5, .5, 1,
GridBagConstraints.CENTER, GridBagConstraints.BOTH,
Insets(0, 2, 2, 0), 0, 0
))
self.frame.add(JButton('Add cell', actionPerformed = self.addCell),
GridBagConstraints(1, 2, 1, 2, 0, .25,
GridBagConstraints.CENTER, GridBagConstraints.NONE,
Insets(0, 0, 0, 0), 0, 0
))
self.frame.add(JButton('Remove cell', actionPerformed = self.removeCell),
GridBagConstraints(1, 4, 1, 2, 0, .25,
GridBagConstraints.CENTER, GridBagConstraints.NONE,
Insets(0, 5, 0, 5), 0, 0
))
self.frame.add(JLabel("Slices"),
GridBagConstraints(0, 6, 1, 1, 0, 0,
GridBagConstraints.CENTER, GridBagConstraints.NONE,
Insets(5, 2, 2, 0), 0, 0
))
self.sliceList = JList(DelegateListModel([]),
selectionMode = ListSelectionModel.SINGLE_SELECTION,
cellRenderer = MyRenderer(),
selectedIndex = 0,
valueChanged = self.selectSlice
)
self.frame.add(JScrollPane(self.sliceList),
GridBagConstraints(0, 7, 1, 5, .5, 1,
GridBagConstraints.CENTER, GridBagConstraints.BOTH,
Insets(0, 2, 2, 0), 0, 0
))
self.frame.add(JButton('Update ROI', actionPerformed = self.updateSlice),
GridBagConstraints(1, 8, 1, 2, 0, .25,
GridBagConstraints.CENTER, GridBagConstraints.NONE,
Insets(0, 0, 0, 0), 0, 0
))
self.frame.add(JButton('Done', actionPerformed = self.doneSelecting),
GridBagConstraints(1, 10, 1, 2, 0, .25,
GridBagConstraints.CENTER, GridBagConstraints.NONE,
Insets(0, 0, 0, 0), 0, 0
))
self.checkbox3D = JCheckBox('3D selection mode', True, actionPerformed=self.toggle3D)
self.frame.add(self.checkbox3D,
GridBagConstraints(0, 13, 2, 1, 0, 1,
GridBagConstraints.WEST, GridBagConstraints.NONE,
Insets(0, 0, 0, 0), 0, 0
))
def showMainWindow(self, cells = None):
if cells is not None:
self.cellList.model = cells
if cells:
self.cellList.selectedIndex = 0
self.frame.pack()
self.frame.visible = True
def hideMainWindow(self):
self.frame.visible = False
def closeMainWindow(self):
self.frame.dispose()
def toggle3D(self, event):
mode3D = self.checkbox3D.isSelected()
if mode3D:
self.sliceList.enabled = True
if self.imp is not None:
self.imp.show()
if self.preview is not None:
self.preview.hide()
else:
self.sliceList.enabled = False
if self.preview is None:
self.preview = self.previewImage(self.imp)
self.displayImage(self.preview)
else:
self.preview.show()
if self.imp is not None:
self.imp.hide()
selectedCell = self.cellList.selectedIndex
if selectedCell >= 0:
cell = self.cells[selectedCell]
self.sliceList.model = cell.slices
self.sliceList.selectedIndex = 0
def addCell(self, event):
size = len(self.cells)
if (size > 0):
last = self.cells[size - 1]
n = last.n + 1
else:
n = 1
self.cells.append(Cell(self.imp.NSlices, n))
self.cellList.selectedIndex = size
def removeCell(self, event):
selected = self.cellList.selectedIndex
if selected >= 0:
self.cells.remove(self.cells[selected])
if (selected >= 1):
self.cellList.selectedIndex = selected - 1
else:
self.cellList.selectedIndex = 0
def selectCell(self, event):
selected = self.cellList.selectedIndex
if selected >= 0:
cell = self.cells[selected]
self.sliceList.model = cell.slices
self.sliceList.selectedIndex = 0
else:
self.sliceList.model = DelegateListModel([])
if self.preview is not None:
self.preview.setRoi(cell.roi)
def selectSlice(self, event):
selectedCell = self.cellList.selectedIndex
selectedSlice = self.sliceList.selectedIndex
if selectedCell >= 0 and selectedSlice >= 0:
cell = self.cells[selectedCell]
image = self.imp
mode3D = self.checkbox3D.isSelected()
if image is not None and cell is not None and mode3D:
roi = cell.slices[selectedSlice].roi
if (image.z - 1 != selectedSlice):
image.z = selectedSlice + 1
image.setRoi(roi, True)
if self.preview is not None and not mode3D:
self.preview.setRoi(cell.roi, True)
def updateSlice(self, event):
if self.checkbox3D.isSelected():
self.updateSlice3D(self.imp)
else:
self.updateSlice2D(self.preview)
def updateSlice3D(self, imp):
selectedCell = self.cellList.selectedIndex
selectedSlice = self.sliceList.selectedIndex
if selectedCell >= 0 and selectedSlice >= 0 and imp is not None:
cell = self.cells[selectedCell]
impRoi = imp.getRoi()
if cell is not None and impRoi is not None:
index = selectedSlice + 1
roi = ShapeRoi(impRoi, position = index)
cell.mode3D = True
cell.name = "Cell %i (3D)" % cell.n
cell.slices[selectedSlice].roi = roi
if (index + 1 <= len(cell.slices)):
imp.z = index + 1
self.cellList.repaint(self.cellList.getCellBounds(selectedCell, selectedCell))
self.sliceList.repaint(self.sliceList.getCellBounds(selectedSlice, selectedSlice))
def updateSlice2D(self, imp):
selectedCell = self.cellList.selectedIndex
if selectedCell >= 0 and imp is not None:
cell = self.cells[selectedCell]
impRoi = imp.getRoi()
if cell is not None and impRoi is not None:
roi = ShapeRoi(impRoi, position = 1)
cell.mode3D = False
cell.name = "Cell %i (2D)" % cell.n
cell.roi = roi
self.cellList.repaint(self.cellList.getCellBounds(selectedCell, selectedCell))
def imageOpened(self, imp):
pass
def imageClosed(self, imp):
pass
def imageUpdated(self, imp):
if self.checkbox3D.isSelected():
if imp is not None:
selectedCell = self.cellList.selectedIndex
selectedSlice = imp.z - 1
if imp == self.imp and selectedSlice != self.sliceList.selectedIndex:
self.sliceList.selectedIndex = selectedSlice
def doneSelecting(self, event):
oluts = self.imp.luts
luts = []
channels = []
for c, method in enumerate(self.methods):
if method != "None":
luts.append(oluts[c])
channels.append(c)
for cell in self.cells:
manders = self.getManders(self.imp, cell)
if manders is not None:
chimps, thrimps, thrs, raws, thrds = manders
index = self.cells.index(cell) + 1
title = "Cell_%i-" % index + self.imp.title
self.saveMultichannelImage(title, chimps, oluts)
title = "Cell_%i_thrd-" % index + self.imp.title
self.saveMultichannelImage(title, thrimps, luts)
self.results.incrementCounter()
row = self.results.getCounter() - 1
for i, thr in enumerate(thrs):
if thr is not None:
self.results.setValue("Threshold %i" % (i + 1), row, int(thr))
for i, pair in enumerate(self.pairs):
self.results.setValue("%i-%i M1 raw" % pair, row, float(raws[i].m1))
self.results.setValue("%i-%i M2 raw" % pair, row, float(raws[i].m2))
self.results.setValue("%i-%i M1 thrd" % pair, row, float(thrds[i].m1))
self.results.setValue("%i-%i M2 thrd" % pair, row, float(thrds[i].m2))
self.closeImage()
if not self.processNextFile():
print "All done - happy analysis!"
self.results.show("Manders collocalization results")
self.exit()
def windowClosing(self, e):
print "Closing plugin - BYE!!!"
self.exit()
def exit(self):
ImagePlus.removeImageListener(self)
self.closeImage()
self.closeMainWindow()
class GUI():
def __init__(self):
self.frame = JFrame('Phone status twitter')
self.frame.defaultCloseOperation = WindowConstants.EXIT_ON_CLOSE
self.asteriskLoginPanel = gui.AsteriskLoginPanel(buttonAction=self.loginToAsterisk)
self.asteriskLoginPanel.render()
self.frame.add(self.asteriskLoginPanel)
self.asteriskLoginPanel.getRootPane().setDefaultButton(self.asteriskLoginPanel.login)
self.frame.pack()
self.frame.visible = True
def renderTwitterLoginPanel(self):
'''Render on the frame the login panel with the fields needed to
authenticate with the Twitter API.'''
self.twitterLoginPanel = JPanel(GridLayout(0,2))
self.frame.add(self.twitterLoginPanel)
self.twitterLoginPanel.setBorder(BorderFactory.createTitledBorder('Twitter account information'))
self.twitterLoginField = extragui.EnhancedTextField('asterisk-jython', 15)
self.twitterLoginPanel.add(JLabel('Username:'******'password', 15)
self.twitterLoginPanel.add(JLabel('Password:'******'Log in', actionPerformed=self.loginToTwitter)
self.twitterLoginPanel.add(self.twitterLoginButton)
self.twitterLoginPanel.getRootPane().setDefaultButton(self.twitterLoginButton)
self.twitterLoginStatusLabel = JLabel('Awaiting information...')
self.twitterLoginPanel.add(self.twitterLoginStatusLabel)
def renderMainPanel(self):
'''Render on the frame the main panel with a status label'''
self.mainPanel = JPanel(GridLayout(0,2))
self.frame.add(self.mainPanel)
self.mainPanel.setBorder(BorderFactory.createTitledBorder('Application status'))
self.mainPanel.add(JLabel('Status:'))
self.statusLabel = JTextField('Running...', 15)
self.statusLabel.editable = False
self.mainPanel.add(self.statusLabel)
def loginToAsterisk(self, event):
'''Execute the login procedure to the Asterisk Manager interface'''
self.manager = PhoneStatusListener(self.asteriskLoginPanel.hostname.text, \
self.asteriskLoginPanel.username.text, \
self.asteriskLoginPanel.password.text, \
self.asteriskLoginPanel.extension.text)
try:
self.manager.addStatusUpdater(self.statusUpdater)
self.manager.start()
self.asteriskLoginPanel.visible = False
self.renderTwitterLoginPanel()
self.twitterLoginField.requestFocusInWindow()
self.frame.pack()
except:
self.asteriskLoginPanel.status.text = "Unable to authenticate"
def loginToTwitter(self, event):
'''Execute the login procedure to the Twitter platform'''
try:
self.twitter = twitter.Api(username=self.twitterLoginField.text, \
password=self.twitterPasswordField.text)
self.twitter.GetUser(self.twitterLoginField.text)
self.twitterLoginPanel.visible = False
self.renderMainPanel()
self.frame.pack()
except:
self.twitterLoginStatusLabel.text = "Unable to authenticate"
def statusUpdater(self, update):
self.statusLabel.text = update
self.twitter.PostUpdate(update)
class Menue(object):
def __init__(self, p):
self.cellCounter = 1
self.olay = Overlay()
self.position = p
print p.getRoiPath()
if p.getRoiPath() != None: # check if there is an existing overlay file and load it!
p.loadRois()
self.frame = JFrame("CellCropper", size=(200,200))
self.frame.setLocation(20,120)
self.Panel = JPanel(GridLayout(0,1))
self.frame.add(self.Panel)
#self.nameField = JTextField("p" + "_c",15)
self.nameField = JTextField("p" + str(self.position.getID()) + "_c",15)
self.Panel.add(self.nameField)
self.cutoutButton = JButton("Cut out cell",actionPerformed=cut)
self.Panel.add(self.cutoutButton)
self.delOlButton = JButton("Delete Overlay",actionPerformed=delOverlay)
self.Panel.add(self.delOlButton)
self.saveOlButton = JButton("Save Overlay",actionPerformed=saveOverlay)
self.Panel.add(self.saveOlButton)
self.quitButton = JButton("Quit script",actionPerformed=quit)
self.Panel.add(self.quitButton)
self.frame.pack()
WindowManager.addWindow(self.frame)
self.show()
#IJ.setTool("freehand")
'''def getPosition(self, path, filename):
moved to containers.position.determineID(path, filename)'''
def eventtest(self, event):
print "eventtest"
def setTextField(self, pos):
name = "p" + str(pos) + "_c"
self.nameField.setText(name)
def openOl(self, path, fileName):
print "aaaaah"
def show(self):
self.frame.visible = True
def close(self):
if self.olay != None:
yncd = YesNoCancelDialog(self.frame, "Save overlay?", "Save overlay?") #frame, title, message
if yncd.yesPressed():
self.saveOverlay()
WindowManager.removeWindow(self.frame)
self.frame.dispose()
def resetCounter(self):
self.cellCounter = 0
def increaseCounter(self):
self.cellCounter += 1
def setCounter(self):
self.cellCounter += 1
#'get' functions
def getImp(self):
return self.imp
def getCounter(self):
return self.cellCounter
def getFrame(self):
return self.frame
def getFilePath(self):
return self.filePath
def getTextField(self):
return self.nameField.text
def getPosition(self):
return self.position
# overlay functions
def addOlay(self, roi):
self.olay.add(roi)
def getOverlay(self):
return self.olay
def clearOverlay(self):
self.olay.clear()
self.cellCounter = 1
def saveOverlay(self):
self.position.saveRois()
def gui():
fr = JFrame('Calibration Compare Tool',defaultCloseOperation=JFrame.EXIT_ON_CLOSE)
fr.add(InputPanel())
fr.pack()
fr.setVisible(True)
class JyTwitter(object):
def __init__(self):
self.frame = JFrame("Jython Twitter")
self.frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE)
self.loginPanel = JPanel(GridLayout(0,2))
self.frame.add(self.loginPanel)
self.usernameField = JTextField('',15)
self.loginPanel.add(JLabel("username:"******"password:"******"Please Log in")
self.loginPanel.add(self.message)
self.frame.pack()
self.frame.visible = True
def login(self,event):
self.message.text = "Attempting to Log in..."
self.frame.show()
username = self.usernameField.text
try:
self.api = twitter.Api(username, self.passwordField.text)
self.timeline(username)
self.loginPanel.visible = False
self.message.text = "Logged in"
except:
self.message.text = "Log in failed."
raise
self.frame.size = 400,800
self.frame.show()
def timeline(self, username):
timeline = self.api.GetFriendsTimeline(username)
self.resultPanel = JPanel()
self.resultPanel.layout = BoxLayout(self.resultPanel, BoxLayout.Y_AXIS)
for s in timeline:
self.showTweet(s)
scrollpane = JScrollPane(JScrollPane.VERTICAL_SCROLLBAR_AS_NEEDED,
JScrollPane.HORIZONTAL_SCROLLBAR_NEVER)
scrollpane.preferredSize = 400, 800
scrollpane.viewport.view = self.resultPanel
self.frame.add(scrollpane)
def showTweet(self, status):
user = status.user
p = JPanel()
# image grabbing seems very expensive, good place for a callback?
p.add(JLabel(ImageIcon(URL(user.profile_image_url))))
p.add(JTextArea(text = status.text,
editable = False,
wrapStyleWord = True,
lineWrap = True,
alignmentX = Component.LEFT_ALIGNMENT,
size = (300, 1)
))
self.resultPanel.add(p)
main_panel = JPanel()
### panel 1
panel1 = JPanel()
panel1.add(lbl1)
cb1 = JComboBox(choice_list)
btn1 = JButton("Accept")
btn1.addActionListener(ButtonListener(btn1))
panel1.add(cb1)
panel1.add(btn1)
### panel 2
panel2 = JPanel()
panel2.add(lbl2)
cb2 = JComboBox(sorted(roi_ni.keys()))
cb2.addActionListener(Listener(lbl2, cb2))
panel2.add(cb2)
### panel 3
pnl3 = JPanel()
lst1 = JList(listmodel)
pnl3.add(lst1)
frame = JFrame("Swing GUI Test Frame")
frame.getContentPane().add(main_panel)
main_panel.add(panel1)
main_panel.add(panel2)
main_panel.add(pnl3)
frame.pack()
frame.setVisible(True)
class Pipeline():
def __init__(self):
#If a swing interface is asked for this will be the JFrame.
self.frame = None
#Keeps track of the number of queries processed.
self.jobCount = 0
#Keeps track of the query currently being processed.
self.currentJob = ""
#Keeps track of the massage to be displayed.
self.message = 0
#Messages to be displayed at each stage in the processing of a single query.
self.messages = ["Searching for genes via genemark",
"Extending genes found via genemark",
"Searching for intergenic genes",
"Removing overlapping genes",
"Searching for promoters",
"Using transterm to find terminators",
"Removing transcription signals which conflict with genes",
"Using tRNAscan to find transfer RNAs",
"Writing Artemis file",
"Writing summary .xml, .html, and .xls files"]
self.exception = None
def initializeDisplay(self, queries, swing):
"""
queries: A list of the fasts files to be processed.
swing: If true then updates about progress will be displayed in a swing window, otherwise they will be written to stdout.
Initializes the interface for telling the user about progress in the pipeline. Queries is used to count the
number of queries the pipeline will process and to size the swing display(if it is used) so that text
isn't cutoff at the edge of the window. The swing display is setup if swing is true.
"""
self.numJobs = len(queries)
if swing:
self.frame = JFrame("Neofelis")
self.frame.addWindowListener(PipelineWindowAdapter(self))
contentPane = JPanel(GridBagLayout())
self.frame.setContentPane(contentPane)
self.globalLabel = JLabel(max(queries, key = len))
self.globalProgress = JProgressBar(0, self.numJobs)
self.currentLabel = JLabel(max(self.messages, key = len))
self.currentProgress = JProgressBar(0, len(self.messages))
self.doneButton = JButton(DoneAction(self.frame))
self.doneButton.setEnabled(False)
constraints = GridBagConstraints()
constraints.gridx, constraints.gridy = 0, 0
constraints.gridwidth, constraints.gridheight = 1, 1
constraints.weightx = 1
constraints.fill = GridBagConstraints.HORIZONTAL
contentPane.add(self.globalLabel, constraints)
constraints.gridy = 1
contentPane.add(self.globalProgress, constraints)
constraints.gridy = 2
contentPane.add(self.currentLabel, constraints)
constraints.gridy = 3
contentPane.add(self.currentProgress, constraints)
constraints.gridy = 4
constraints.weightx = 0
constraints.fill = GridBagConstraints.NONE
constraints.anchor = GridBagConstraints.LINE_END
contentPane.add(self.doneButton, constraints)
self.frame.pack()
self.frame.setResizable(False)
self.globalLabel.setText(" ")
self.currentLabel.setText(" ")
self.frame.setLocationRelativeTo(None)
self.frame.setVisible(True)
def updateProgress(self, job):
"""
query: Name of the query currently being processed.
This function use used for updating the progress shown in the interface. If job is not equal to currentJob then
global progress is incremented and shown and the currentProgress is reset and shown. If job is equal to currentJob
then the globalProgress does not change and currentProgress is increased.
"""
if self.exception:
raise self.exception
if self.frame:
if job != self.currentJob:
self.currentProgress.setValue(self.currentProgress.getMaximum())
self.globalLabel.setText(job)
self.globalProgress.setValue(self.jobCount)
print "Processing %s, %.2f%% done" % (job, 100.0*self.jobCount/self.numJobs)
self.jobCount += 1
self.currentJob = job
self.message = -1
self.message += 1
print " %s, %.2f%% done" % (self.messages[self.message], 100.0*self.message/len(self.messages))
self.currentProgress.setValue(self.message)
self.currentLabel.setText(self.messages[self.message])
else:
if job != self.currentJob:
print "Processing %s, %.2f%% done" % (job, 100.0*self.jobCount/self.numJobs)
self.jobCount += 1
self.currentJob = job
self.message = -1
self.message += 1
print " %s, %.2f%% done" % (self.messages[self.message], 100.0*self.message/len(self.messages))
def finished(self):
"""
This function is to be called at the end of the pipeline. Informs the user that the pipeline is finished
and if a swing interface is being used the Done button is enabled.
"""
print "Processing 100.00% done"
if self.frame:
self.globalLabel.setText("Finished")
self.globalProgress.setValue(self.globalProgress.getMaximum())
self.currentLabel.setText(" ")
self.currentProgress.setValue(self.currentProgress.getMaximum())
self.doneButton.setEnabled(True)
while self.frame.isVisible():
pass
def run(self, blastLocation, genemarkLocation, transtermLocation, tRNAscanLocation, database, eValue, matrix, minLength, scaffoldingDistance, promoterScoreCutoff, queries, swing = False, email = ""):
"""
blastLocation: Directory blast was installed in.
genemarkLocation: Directory genemark was installed in.
transtermLocation: Directory transterm was installed in.
tRNAscanLocation: Directory tRNAscan was installed in.
database: Name of the blast database to use.
eValue: The e value used whenever a blast search is done.
matrix: The matrix to use when running genemark. If None then genemark is run heuristically.
minLength: Minimum length of any genes included in the resulting annotation.
scaffoldingDistance: The maximum length allowed between genes when contiguous regions of genes are being identified
promoterScoreCutoff: Minimum score allowed for any promoters included in the resulting annotation
queries: A list of faster files to process.
swing: If true a swing window will be used to updated the user about the pipeline's progress.
email: If this is a non-empty string an email will be sent to the address in the string when the pipeline is done. This will be attempted with the sendmail command on the local computer.
The main pipeline function. For every query genemark is used to predict genes, these genes are then extended to any preferable starts. Then the pipeline searches
for any intergenic genes(genes between those found by genemark) and these are combined with the extended genemark genes. Then the genes are pruned to remove
any undesirable genes found in the intergenic stage. BPROM and Transterm are used to find promoters and terminators, which are then pruned to remove any
signals which are inside or too far away from any genes. Next, tRNAscan is used to find any transfer RNAs in the genome. Finally, all the remaining genes,
promoters, and terminators are written to an artemis file in the directory of the query with the same name but with a .art extension, and .xml, .html, and
.xls files will be generating describing the blast results of the final genes.
"""
self.initializeDisplay(queries, swing)
try:
for query in queries:
name = os.path.splitext(query)[0]
queryDirectory, name = os.path.split(name)
genome = utils.loadGenome(query)
swapFileName = "query" + str(id(self)) + ".fas"
queryFile = open(swapFileName, "w")
queryFile.write(">" + name + "\n")
for i in range(0, len(genome), 50):
queryFile.write(genome[i:min(i+50, len(genome))] + "\n")
queryFile.close()
self.updateProgress(query)
initialGenes = genemark.findGenes(swapFileName, name, blastLocation, database, eValue, genemarkLocation, matrix, self)
self.updateProgress(query)
extendedGenes = extend.extendGenes(swapFileName, initialGenes, name, blastLocation, database, eValue, self)
self.updateProgress(query)
intergenicGenes = intergenic.findIntergenics(swapFileName, extendedGenes, name, minLength, blastLocation, database, eValue, self)
genes = {}
for k, v in extendedGenes.items() + intergenicGenes.items():
genes[k] = v
self.updateProgress(query)
scaffolded = scaffolds.refineScaffolds(genes, scaffoldingDistance)
self.updateProgress(query)
initialPromoters = promoters.findPromoters(swapFileName, name, promoterScoreCutoff, self.frame)
self.updateProgress(query)
initialTerminators = terminators.findTerminators(swapFileName, name, genes.values(), transtermLocation)
self.updateProgress(query)
filteredSignals = signals.filterSignals(scaffolded.values(), initialPromoters + initialTerminators)
filteredPromoters = filter(lambda x: isinstance(x, promoters.Promoter), filteredSignals)
filteredTerminators = filter(lambda x: isinstance(x, terminators.Terminator), filteredSignals)
self.updateProgress(query)
transferRNAs = rna.findtRNAs(tRNAscanLocation, swapFileName)
os.remove(swapFileName)
self.updateProgress(query)
artemis.writeArtemisFile(os.path.splitext(query)[0] + ".art", genome, scaffolded.values(), filteredPromoters, filteredTerminators, transferRNAs)
self.updateProgress(query)
report.report(name, scaffolded, os.path.splitext(query)[0])
if email:
if not os.path.isfile("EMAIL_MESSAGE"):
message = open("EMAIL_MESSAGE", "w")
message.write("Subject: Annotation Complete\nYour genome has been annotated.\n")
message.close()
sent = False
while not sent:
message = open("EMAIL_MESSAGE", "r")
sendmailProcess = subprocess.Popen(["/usr/sbin/sendmail", "-F", "Neofelis", "-f", "*****@*****.**", email],
stdin = message,
stdout = subprocess.PIPE)
result = ""
nextRead = sendmailProcess.stdout.read()
while nextRead:
result += nextRead
nextRead = sendmailProcess.stdout.read()
sent = not result.strip()
message.close()
self.finished()
except PipelineException:
return
class FilamentGame_ModelEditor(EditorExtension, JPanel, MouseListener, MouseMotionListener):
def getExtensionName(self):
return "Filament Model Tool"
def initializeExtension(self, manager):
self.manager = manager
self.frame = JFrame(self.getExtensionName())
self.frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE)
# instance setup
self.state = State.NOTHING
self.entity = Entity()
# Setupgui
self.setupGui()
self.addMouseListener(self)
self.addMouseMotionListener(self)
self.setPreferredSize(Dimension(500, 500))
self.frame.pack()
self.frame.setResizable(False)
self.frame.setVisible(True)
self.cameraPos = [0, 0]
def setupGui(self):
cPanel = JPanel()
# Draw Shape Button
self.drawShapeButton = JButton("Draw", actionPerformed=self.drawShapeButtonAction)
cPanel.add(self.drawShapeButton)
drawShapeButton = JButton("Clear", actionPerformed=self.clearShapeButtonAction)
cPanel.add(drawShapeButton)
# Label
self.infoLabel = JLabel("Shape Editor")
cPanel.add(self.infoLabel)
self.frame.add(BorderLayout.NORTH, cPanel)
self.frame.add(BorderLayout.CENTER, self)
def entitySelected(self, entity):
self.entity = entity
self.repaint()
def sceneChanged(self, scene):
self.scene = scene
self.entity = Entity()
self.repaint()
# BUTTONS
def drawShapeButtonAction(self, e):
if self.state == State.NOTHING:
self.state = State.DRAW_SHAPE
self.infoLabel.setText("Click to Draw Shape")
self.drawShapeButton.setText("Stop Drawing")
elif self.state != State.NOTHING:
self.state = State.NOTHING
self.infoLabel.setText("")
self.drawShapeButton.setText("Draw")
self.revalidate()
def clearShapeButtonAction(self, e):
if self.state != State.NOTHING:
self.drawShapeButtonAction(e)
self.state = State.NOTHING
polygon = self.entity.getModel().pol
polygon.reset()
self.repaint()
# DRAWING
def paintComponent(self, g):
self.super__paintComponent(g)
g.scale(1, -1)
g.translate(-self.cameraPos[0] + self.getWidth() / 2, -self.cameraPos[1] - self.getHeight() / 2)
self.drawGrid(g)
polygon = self.entity.getModel().pol
x = []
y = []
g.setColor(Color.BLACK)
for i in range(polygon.npoints):
x = x + [int(polygon.xpoints[i])]
y = y + [int(polygon.ypoints[i])]
g.drawRect(int(polygon.xpoints[i]) - 2, int(polygon.ypoints[i]) - 2, 4, 4)
g.fillPolygon(x, y, polygon.npoints)
def drawGrid(self, g):
g.setColor(Color.RED)
g.drawLine(50, 0, -50, 0)
g.drawLine(0, 50, 0, -50)
# MOUSE LISTENER
def mouseCicked(self, e):
return
def mouseEntered(self, e):
return
def mouseExited(self, e):
return
def mousePressed(self, e):
self.anchor = e.getPoint()
self.oldCamPos = self.cameraPos
def findMousePos(self, p):
w = self.getWidth()
h = self.getHeight()
cX = self.cameraPos[0]
cY = self.cameraPos[1]
y = h - p.y
x = p.x - w / 2 + cX
y = y - h / 2 + cY
return [x, y]
def mouseReleased(self, e):
if self.state == State.DRAW_SHAPE:
try:
p = self.findMousePos(e.getPoint())
self.entity.getModel().pol.addPoint(p[0], p[1])
except IllegalPathStateException:
print "Error Building Polygon path!"
self.repaint()
def mouseMoved(self, e):
return
def mouseDragged(self, e):
if self.state == State.NOTHING:
self.cameraPos = [
self.oldCamPos[0] + self.anchor.x - e.getX(),
self.oldCamPos[1] - self.anchor.y + e.getY(),
]
print str(self.cameraPos)
self.repaint()
def update(self, delta):
return
