Пример #1
0
    def initComponents(self):
        dataModel = DefaultTableModel(self.regTableData, self.regCols)
        self.regTable = JTable(dataModel)
        scrollPaneReg = JScrollPane()
        scrollPaneReg.getViewport().setView((self.regTable))
        self.regTab.add(scrollPaneReg)
        # self.logTabbedPane.addTab('Registred',self.regTab)
        self.logTabbedPane.insertTab("Registred", None, self.regTab, None, 0)

        dataModel = DefaultTableModel(self.parkTableData, self.parkCols)
        self.parkTable = JTable(dataModel)
        scrollPanePark = JScrollPane()
        scrollPanePark.getViewport().setView((self.parkTable))
        self.parkedTab.add(scrollPanePark)
        # self.logTabbedPane.addTab('Parked',self.parkedTab)
        self.logTabbedPane.insertTab("Parked", None, self.parkedTab, None, 1)

        dataModel = DefaultTableModel(self.bypassTableData, self.bypassCol)
        self.bypassTable = JTable(dataModel)
        scrollPaneBypass = JScrollPane()
        scrollPaneBypass.getViewport().setView((self.bypassTable))
        self.bypassTab.add(scrollPaneBypass)
        # self.logTabbedPane.addTab('Bypassed',self.bypassTab)
        self.logTabbedPane.insertTab("Bypassed", None, self.bypassTab, None, 2)

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

        innerBorder = BorderFactory.createTitledBorder('View Logs ')
        outerBorder = BorderFactory.createEmptyBorder(5, 5, 5, 5)
        self.setBorder(
            BorderFactory.createCompoundBorder(outerBorder, innerBorder))
Пример #2
0
	def __init__(self,linac_wizard_document):
		#--- linac_wizard_document the parent document for all controllers
		self.linac_wizard_document = linac_wizard_document		
		self.main_panel = JPanel(BorderLayout())
		#----etched border
		etched_border = BorderFactory.createEtchedBorder()		
		#------tables with Seq. names and button
		tables_panel = JPanel(BorderLayout())
		tables_panel.setBorder(etched_border)
		self.first_table = JTable(WS_Records_Table_Model("First "))
		self.last_table = JTable(WS_Records_Table_Model("Last "))
		self.first_table.setSelectionMode(ListSelectionModel.SINGLE_SELECTION)
		self.last_table.setSelectionMode(ListSelectionModel.SINGLE_SELECTION)
		self.first_table.setFillsViewportHeight(true)
		self.last_table.setFillsViewportHeight(true)
		tables01_panel = JPanel(BorderLayout())
		scrl_panel0 = JScrollPane(self.first_table)
		scrl_panel1 = JScrollPane(self.last_table)
		#tables01_panel.add(JScrollPane(self.first_table),BorderLayout.WEST)
		#tables01_panel.add(JScrollPane(self.last_table),BorderLayout.EAST)
		self.first_table.getCellRenderer(0,0).setHorizontalAlignment(JLabel.CENTER)
		self.last_table.getCellRenderer(0,0).setHorizontalAlignment(JLabel.CENTER)
		self.first_table.setPreferredScrollableViewportSize(Dimension(120,300))
		self.last_table.setPreferredScrollableViewportSize(Dimension(120,300))
		tables01_panel.add(scrl_panel0,BorderLayout.WEST)
		tables01_panel.add(scrl_panel1,BorderLayout.EAST)	
		tables_button_panel = JPanel(BorderLayout())
		tables_button_panel.add(tables01_panel,BorderLayout.WEST)
		seq_button_panel = JPanel(FlowLayout(FlowLayout.CENTER,5,5))
		seq_set_button = JButton(" Set ComboSequence ")	
		seq_button_panel.add(seq_set_button)
		tables_button_panel.add(seq_button_panel,BorderLayout.SOUTH)
		tables_panel.add(tables_button_panel,BorderLayout.NORTH)
		self.main_panel.add(tables_panel,BorderLayout.WEST)
		#--------central panel-------
		cav_amp_phase_button = JButton(" Read Cavities Amp.&Phases from Ext. File ")	
		cav_info_from_scl_tuneup_button = JButton("Get SCL Cav. Amp.&Phases from SCL Long. TuneUp")	
		new_accelerator_button = JButton(" Setup a New Accelerator File ")
		center_buttons_panel0 = JPanel(FlowLayout(FlowLayout.CENTER,5,5))
		center_buttons_panel0.add(cav_amp_phase_button)
		center_buttons_panel1 = JPanel(FlowLayout(FlowLayout.CENTER,5,5))
		center_buttons_panel1.add(cav_info_from_scl_tuneup_button)			
		center_buttons_panel2 = JPanel(FlowLayout(FlowLayout.CENTER,5,5))
		center_buttons_panel2.add(new_accelerator_button)	
		center_buttons_panel = JPanel(GridLayout(3,1))
		center_buttons_panel.add(center_buttons_panel0)
		center_buttons_panel.add(center_buttons_panel1)
		center_buttons_panel.add(center_buttons_panel2)
		center_panel = JPanel(BorderLayout())		
		center_panel.add(center_buttons_panel,BorderLayout.NORTH)
		self.main_panel.add(center_panel,BorderLayout.CENTER)
		#---------add actions listeners
		seq_set_button.addActionListener(Make_Sequence_Listener(self))
		cav_amp_phase_button.addActionListener(Read_Cav_Amp_Phase_Dict_Listener(self))
		cav_info_from_scl_tuneup_button.addActionListener(Get_SCL_Cav_Amp_Phase_Listener(self))
		new_accelerator_button.addActionListener(SetUp_New_Accelerator_Listener(self))	
	def __init__(self,top_document,accl):
		#--- top_document is a parent document for all controllers
		self.top_document = top_document
		self.main_loop_controller = self.top_document.main_loop_controller
		self.main_panel = JPanel(BorderLayout())
		#----etched border
		etched_border = BorderFactory.createEtchedBorder()
		#---------------------------------------------
		#---- Cavities' Controllers - only DTLs
		self.cav_acc_scan_controllers = []
		self.cav_wrappers = self.main_loop_controller.cav_wrappers[4:10]
		self.cav_acc_scan_controllers.append(DTL_Acc_Scan_Cavity_Controller(self,self.cav_wrappers[0],"FC160"))
		self.cav_acc_scan_controllers.append(DTL_Acc_Scan_Cavity_Controller(self,self.cav_wrappers[1],"FC248"))
		self.cav_acc_scan_controllers.append(DTL_Acc_Scan_Cavity_Controller(self,self.cav_wrappers[2],"FC334"))
		self.cav_acc_scan_controllers.append(DTL_Acc_Scan_Cavity_Controller(self,self.cav_wrappers[3],"FC428"))
		self.cav_acc_scan_controllers.append(DTL_Acc_Scan_Cavity_Controller(self,self.cav_wrappers[4],"FC524"))
		self.cav_acc_scan_controllers.append(DTL_Acc_Scan_Cavity_Controller(self,self.cav_wrappers[5],"FC104"))
		#----acceptance scans loop timer
		self.acc_scan_loop_timer = Acc_Scan_Loop_Timer(self)			
		#----------------------------------------------   
		self.tabbedPane = JTabbedPane()		
		self.tabbedPane.add("Cavity",JPanel(BorderLayout()))	
		self.tabbedPane.add("Pattern",JPanel(BorderLayout()))
		#--------------------------------------------------------
		self.cav_table = JTable(Cavities_Table_Model(self))
		self.cav_table.setSelectionMode(ListSelectionModel.SINGLE_INTERVAL_SELECTION)
		self.cav_table.setFillsViewportHeight(true)
		self.cav_table.setPreferredScrollableViewportSize(Dimension(500,120))
		self.cav_table.getSelectionModel().addListSelectionListener(Cavs_Table_Selection_Listener(self))
		scrl_cav_panel = JScrollPane(self.cav_table)
		#-------------------------------------------------------
		scrl_cav_panel.setBorder(BorderFactory.createTitledBorder(etched_border,"Cavities' Parameters"))
		init_buttons_panel = JPanel(FlowLayout(FlowLayout.LEFT,5,2))
		#---- initialization buttons
		init_selected_cavs_button = JButton("Init Selected Cavs")
		init_selected_cavs_button.addActionListener(Init_Selected_Cavs_Button_Listener(self))
		fc_in_selected_cavs_button = JButton("FC In for Selected Cavs")
		fc_in_selected_cavs_button.addActionListener(FC_In_Selected_Cavs_Button_Listener(self))	
		fc_out_selected_cavs_button = JButton("FC Out for Selected Cavs")
		fc_out_selected_cavs_button.addActionListener(FC_Out_Selected_Cavs_Button_Listener(self))
		init_buttons_panel.add(init_selected_cavs_button)
		init_buttons_panel.add(fc_in_selected_cavs_button)
		init_buttons_panel.add(fc_out_selected_cavs_button)
		#---- start stop buttons panel
		self.start_stop_panel = Start_Stop_Panel(self)
		#-------------------------------------------------
		tmp0_panel = JPanel(BorderLayout())
		tmp0_panel.add(init_buttons_panel,BorderLayout.NORTH)
		tmp0_panel.add(scrl_cav_panel,BorderLayout.CENTER)
		tmp0_panel.add(self.start_stop_panel,BorderLayout.SOUTH)
		tmp1_panel = JPanel(BorderLayout())
		tmp1_panel.add(tmp0_panel,BorderLayout.NORTH)
		#-------------------------------------------------
		left_panel = JPanel(BorderLayout())
		left_panel.add(tmp1_panel,BorderLayout.WEST)
		#--------------------------------------------------
		self.main_panel.add(left_panel,BorderLayout.WEST)
		self.main_panel.add(self.tabbedPane,BorderLayout.CENTER)
		#----------- loop state
		self.loop_run_state = Acc_Scans_Loop_Run_State()	
Пример #4
0
    def __init__(self):

        #super(GridLayout(0,1)) # 1 column, as many rows as necessary
        super(RoiGroupTable, self).__init__(GridLayout(
            0, 1))  # 1 column, as many rows as necessary
        #super()
        #self.setLayout(GridLayout(0,1))

        ### Table Panel ###
        # Prepare table data
        headers = ["Group number", "Name"]
        listNames = Roi.getGroupNames().split(",")  # groupNames is a list then
        dataRows = [[item[0] + 1, item[1]] for item in enumerate(listNames)
                    ]  # +1 since the group actually start at 1
        #print dataRows

        # Make the table pane
        table = JTable(dataRows, headers)
        #table.setPreferredScrollableViewportSize( Dimension(500, 70) )
        #table.setFillsViewportHeight(true)

        # Create the scroll pane and add the table to it.
        tablePane = JScrollPane(table)
        #tablePane = ScrollPane()
        #tablePane.add(table)

        # Add the scrollpane to the main panel.
        self.add(tablePane)
Пример #5
0
    def testJTableColumns(self):
        personList = [self.person]
        personList.append(Person(u'Mary', u'Mediocre', 1970))
        personList.append(Person(u'Bob', u'Mediocre', 1972))

        tableModel = ObjectTableModel(personList,
                                      (u'First name', String, 'firstName'),
                                      (u'Last name', String, 'lastName'),
                                      (u'Birth year', Integer, 'birthYear'))
        table = JTable(tableModel)
        self.group.bind(table, u'selectedColumns', self.dummy, u'value')

        table.setColumnSelectionInterval(1, 1)
        assert self.dummy.value == array('i', [1])

        table.setColumnSelectionInterval(1, 2)
        assert self.dummy.value == array('i', [1, 2])

        columnModel = DefaultTableColumnModel()
        columnModel.addColumn(TableColumn())
        columnModel.addColumn(TableColumn())
        table.setColumnModel(columnModel)

        table.setColumnSelectionInterval(0, 1)
        assert self.dummy.value == array('i', [0, 1])
Пример #6
0
    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())
Пример #7
0
    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 )
Пример #8
0
    def config():

        self.barra = JScrollPane()
        self.Tab_Caracteres_Especiales = JTable()
        nombre = ["nombre", "apeM", "apeP"]
        datos = ["victor", "esau", "cholo"]
        self.Tab_Caracteres_Especiales = JTable(datos, nombre)
        self.Tab_Caracteres_Especiales.addRow(datos)
        #  self.Tab_Caracteres_Especiales.setFont(Font("Tahoma", 0, 14)); # NOI18N
        self.barra.setViewportView(self.Tab_Caracteres_Especiales)
        #TODO: imcompleto se nesita una array y python maneja listas :(

        self.getContentPane().add(self.barra)
        self.barra.setBounds(0, 0, 929, 574)

        self.setBounds(0, 0, 939, 604)
	def __init__(self,scl_long_tuneup_controller):
		#--- scl_long_tuneup_controller the parent document for all SCL tune up controllers
		self.scl_long_tuneup_controller = 	scl_long_tuneup_controller
		self.main_panel = JPanel(BorderLayout())
		#----etched border
		etched_border = BorderFactory.createEtchedBorder()			
		#------top params panel-----------------------
		top_panel = JPanel(BorderLayout())
		self.init_amp_phases_panel = Init_New_Amps_Phases_Panel(self.scl_long_tuneup_controller)
		self.new_amp_phases_to_epics_panel = NEW_Amp_and_Phases_to_EPICS_Panel(self.scl_long_tuneup_controller)
		top_panel.add(self.init_amp_phases_panel,BorderLayout.CENTER)
		top_panel.add(self.new_amp_phases_to_epics_panel,BorderLayout.SOUTH)
		#------cavities table panel --------
		cavs_rescale_panel = JPanel(BorderLayout())
		txt = "Cavities' Prameters. New Amp and Avg. Gap Phases can be changed manually."
		rescale_table_border = BorderFactory.createTitledBorder(etched_border,txt)
		cavs_rescale_panel.setBorder(rescale_table_border)		
		self.cavs_rescale_table = JTable(Cavs_Rescale_Table_Model(self.scl_long_tuneup_controller))
		self.cavs_rescale_table.setSelectionMode(ListSelectionModel.SINGLE_INTERVAL_SELECTION)
		self.cavs_rescale_table.setFillsViewportHeight(true)
		self.cavs_rescale_table.getSelectionModel().addListSelectionListener(Cavs_Table_Selection_Listener(self.scl_long_tuneup_controller))		
		scrl_panel0 = JScrollPane(self.cavs_rescale_table)			
		cavs_rescale_panel.add(scrl_panel0,BorderLayout.CENTER)
		center_panel = JPanel(BorderLayout())
		center_panel.add(cavs_rescale_panel,BorderLayout.CENTER)
		#-------- post-rescale actions panel
		bottom_panel = JPanel(BorderLayout())
		#bottom_panel.add(self.post_rescale_panel,BorderLayout.WEST)
		#--------------------------------------------------
		self.main_panel.add(top_panel,BorderLayout.NORTH)
		self.main_panel.add(center_panel,BorderLayout.CENTER)
		self.main_panel.add(bottom_panel,BorderLayout.SOUTH)
		#----- model for tracking 	
		self.scl_tracker_model = SCL_RfGaps_Fitter_Tracker_Model(self.scl_long_tuneup_controller)
Пример #10
0
 def createAnyTable(self, table_model, table_number, min_size):
     _table = JTable(table_model)
     _table.setAutoResizeMode(JTable.AUTO_RESIZE_ALL_COLUMNS)
     _scrolltable = JScrollPane(_table)
     _scrolltable.setMinimumSize(min_size)
     # _table.setMinimumSize(min_size)
     return _scrolltable
Пример #11
0
    def run(self):
        frame = JFrame('Table11',
                       size=(300, 170),
                       locationRelativeTo=None,
                       defaultCloseOperation=JFrame.EXIT_ON_CLOSE)

        menuBar = JMenuBar()
        resize = JMenu('AUTO_RESIZE')

        bGroup = ButtonGroup()
        for name, value in self.info:
            rb = JRadioButtonMenuItem(name,
                                      actionPerformed=self.handler,
                                      selected=(name == 'Rest'))
            bGroup.add(rb)
            resize.add(rb)
        menuBar.add(resize)
        frame.setJMenuBar(menuBar)

        headings = 'T/F,Date,Integer,Float,Double'.split(',')
        model = myTM(self.data, headings)
        self.table = table = JTable(
            model, selectionMode=ListSelectionModel.SINGLE_SELECTION)
        table.getColumnModel().getColumn(model.getColumnCount() -
                                         1  # i.e., last column
                                         ).setCellRenderer(myRenderer())
        setColumnWidths(table)

        frame.add(JScrollPane(table))
        frame.setVisible(1)
Пример #12
0
 def __init__(self, top_document, main_loop_controller):
     #--- top_document is a parent document for all controllers
     self.top_document = top_document
     self.main_loop_controller = main_loop_controller
     self.main_panel = JPanel(BorderLayout())
     #----etched border
     etched_border = BorderFactory.createEtchedBorder()
     #----------------------------------------------
     left_panel = JPanel(BorderLayout())
     self.rf_power_table = JTable(RF_Power_Table_Model(self))
     self.rf_power_table.setSelectionMode(
         ListSelectionModel.SINGLE_INTERVAL_SELECTION)
     self.rf_power_table.setFillsViewportHeight(true)
     self.rf_power_table.setPreferredScrollableViewportSize(
         Dimension(800, 240))
     scrl_rf_power_panel = JScrollPane(self.rf_power_table)
     scrl_rf_power_panel.setBorder(
         BorderFactory.createTitledBorder(etched_border, "RF Net Power"))
     self.init_buttons_panel = Init_RF_Power_Controller_Panel(self)
     self.start_stop_panel = Start_Stop_Panel(self)
     tmp0_panel = JPanel(BorderLayout())
     tmp0_panel.add(self.init_buttons_panel, BorderLayout.NORTH)
     tmp0_panel.add(scrl_rf_power_panel, BorderLayout.CENTER)
     tmp0_panel.add(self.start_stop_panel, BorderLayout.SOUTH)
     tmp1_panel = JPanel(BorderLayout())
     tmp1_panel.add(tmp0_panel, BorderLayout.NORTH)
     left_panel.add(tmp1_panel, BorderLayout.WEST)
     #--------------------------------------------------------
     self.main_panel.add(left_panel, BorderLayout.WEST)
     #---- non GUI controllers
     self.loop_run_state = Loop_Run_State()
Пример #13
0
 def gui(self):
   xnode = self.xdoc.getDocumentElement()
   tnode = self.createTree(xnode)  
   # create tree and display
   jt = JTree(tnode)
   jsp = JScrollPane(jt)
   tree_box = Box(BoxLayout.Y_AXIS)
   tree_box.add(jsp)
   tree_box.add(Box.createHorizontalStrut(10))
   headerSorter = TableSorter(DefaultTableModel())
   jtb = JTable(headerSorter)
   headerSorter.addMouseListenerToHeaderInTable(jtb)
   jtb.setAutoResizeMode(JTable.AUTO_RESIZE_OFF)
   jsp2 = JScrollPane(jtb)
   table_box = Box(BoxLayout.Y_AXIS)
   table_box.add(jsp2)
   table_box.add(Box.createHorizontalStrut(500))
   mp = JPanel()
   mp.setLayout(BoxLayout(mp,BoxLayout.X_AXIS))
   mp.add(tree_box)
   mp.add(table_box)
   # add listeners
   nsl = NodeSelectionListener(jtb,xnode)
   jt.addTreeSelectionListener(nsl)
   #
   return mp
Пример #14
0
    def registerExtenderCallbacks(self, callbacks):
        self.callbacks = callbacks
        self.helpers = callbacks.getHelpers()
        self.callbacks.setExtensionName("KkMultiProxy")
        self.PROXY_LIST = []

        self.jPanel = JPanel()
        boxVertical = Box.createVerticalBox()
        boxHorizontal = Box.createHorizontalBox()

        boxHorizontal.add(JButton("File", actionPerformed=self.getFile))
        self.FileText = JTextField("")
        boxHorizontal.add(self.FileText)
        boxVertical.add(boxHorizontal)

        TableHeader = ('IP', 'PORT')
        TableModel = DefaultTableModel(self.PROXY_LIST, TableHeader)
        self.Table = JTable(TableModel)
        boxVertical.add(self.Table)

        boxHorizontal = Box.createHorizontalBox()
        boxHorizontal.add(JButton("Add", actionPerformed=self.addIP))
        boxHorizontal.add(JButton("Delete", actionPerformed=self.deleteIP))
        boxHorizontal.add(JButton("Save", actionPerformed=self.saveIP))
        boxVertical.add(boxHorizontal)

        self.jPanel.add(boxVertical)

        self.callbacks.addSuiteTab(self)
        self.callbacks.registerHttpListener(self)
        return
Пример #15
0
    def run(self):
        frame = JFrame('Table7',
                       size=(300, 150),
                       locationRelativeTo=None,
                       defaultCloseOperation=JFrame.EXIT_ON_CLOSE)
        headings = 'T/F,Date,Integer,Float,Double'.split(',')
        model = myTM(self.data, headings)
        table = JTable(model,
                       selectionMode=ListSelectionModel.SINGLE_SELECTION)
        table.getColumnModel().getColumn(model.getColumnCount() -
                                         1  # i.e., last column
                                         ).setCellRenderer(myRenderer())

        #----------------------------------------------------------
        # Adjust the width of the columns using only header text
        #----------------------------------------------------------
        hRenderer = table.getTableHeader().getDefaultRenderer()
        for col in range(model.getColumnCount()):
            column = table.getColumnModel().getColumn(col)
            comp = hRenderer.getTableCellRendererComponent(
                None,  # Table
                column.getHeaderValue(),  # value
                0,  # isSelected = false 
                0,  # hasFocus = false
                -1,  # row #
                col  # col #
            )
            width = comp.getPreferredSize().width
            #           print 'col: %d  previous: %d  current: %d' % ( col, column.getPreferredWidth(), width )
            column.setPreferredWidth(width)

        frame.add(JScrollPane(table))
        frame.setVisible(1)
Пример #16
0
 def initTable(self, lociNames, pv, ci, locusFst):
     colNames = Vector()
     colNames.add('Locus')
     colNames.add('Het')
     colNames.add('Fst')
     colNames.add('P(simulated Fst < sample Fst)')
     colNames.add('FDR')
     data = Vector()
     self.data = data
     falses = self.calcFalsePositives(pv, ci, self.fdr)
     currentPos = 0
     for i in range(len(lociNames)):
         line = Vector()
         locus = lociNames[i]
         line.add(locus)
         if not locusFst[i]:
             line.add("NA")
             line.add("NA")
             line.add("NA")
             line.add("NA")
         else:
             line.add(str(pv[currentPos][0]))
             line.add(str(pv[currentPos][1]))
             line.add(str(self.getP(pv[currentPos])))
             line.add(str(falses[currentPos]))
             currentPos += 1
         data.add(line)
     self.table = JTable(data, colNames)
     self.table.setDefaultRenderer(
         Class.forName("java.lang.Object"),
         ColorRenderer(data, ci, self.chart.neuColor, self.chart.balColor,
                       self.chart.posColor))
Пример #17
0
 def __init__(self):
     self.setName('Jython Properties')
     self.setLayout(BorderLayout())
     self.add(JScrollPane(JTable([['x', 42],
                                  ['y', 'Bibo']],
                                 ['Name', 'Value'])),
              BorderLayout.CENTER)
	def __init__(self,scl_long_tuneup_controller):
		#--- scl_long_tuneup_controller the parent document for all SCL tune up controllers
		self.scl_long_tuneup_controller = 	scl_long_tuneup_controller	
		self.main_panel = JPanel(BorderLayout())
		#----etched border
		etched_border = BorderFactory.createEtchedBorder()			
		#------top panels = offsets analysis ----------------------------
		top_panel = JPanel(BorderLayout())
		self.bpms_offsets_from_ccl4_panel = BPMs_Offsets_from_CCL4_Panel(self.scl_long_tuneup_controller)
		self.bpms_offsets_from_hebt1_panel = BPMs_Offsets_from_HEBT1_Panel(self.scl_long_tuneup_controller)
		self.bpms_offsets_from_ext_file_panel = BPMs_Offsets_from_ExtFile_Panel(self.scl_long_tuneup_controller)
		top_panel0 = JPanel(BorderLayout())
		top_panel0.add(self.bpms_offsets_from_ccl4_panel,BorderLayout.NORTH)
		top_panel0.add(self.bpms_offsets_from_hebt1_panel,BorderLayout.SOUTH)
		top_panel1 = JPanel(BorderLayout())
		top_panel1.add(top_panel0,BorderLayout.NORTH)
		top_panel1.add(self.bpms_offsets_from_ext_file_panel,BorderLayout.SOUTH)
		top_panel.add(top_panel1,BorderLayout.NORTH)
		#--------center panel = table------------
		center_panel = JPanel(BorderLayout())		
		self.bpm_offsets_table_model = PhaseOffsets_BPMs_Table_Model(self.scl_long_tuneup_controller)
		self.bpm_offsets_table = JTable(self.bpm_offsets_table_model)
		self.bpm_offsets_table.setSelectionMode(ListSelectionModel.SINGLE_INTERVAL_SELECTION)
		self.bpm_offsets_table.setFillsViewportHeight(true)	
		scrl_panel = JScrollPane(self.bpm_offsets_table)
		scrl_panel.setBorder(etched_border)
		center_panel.add(scrl_panel,BorderLayout.CENTER)
		#-------- bottom panel = post analysis ---------------
		bottom_panel = JPanel(BorderLayout())
		self.set_bpms_as_bad_panel = Set_BPMs_as_Bad_Panel(self.scl_long_tuneup_controller)
		bottom_panel.add(self.set_bpms_as_bad_panel,BorderLayout.SOUTH)
		#--------------------------------------------------
		self.main_panel.add(top_panel,BorderLayout.NORTH)
		self.main_panel.add(center_panel,BorderLayout.CENTER)
		self.main_panel.add(bottom_panel,BorderLayout.SOUTH)		
Пример #19
0
    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)
Пример #20
0
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 __init__(self,scl_long_tuneup_controller):
		self.scl_long_tuneup_controller = scl_long_tuneup_controller
		self.setLayout(BorderLayout())
		#----etched border
		etched_border = BorderFactory.createEtchedBorder()
		titled_border = BorderFactory.createTitledBorder(etched_border,"BPM Table and Plots")
		self.setBorder(titled_border)	
		#----------------------------------------
		self.bpm_table = JTable(Energy_Meter_BPMs_Table_Model(self.scl_long_tuneup_controller))
		self.bpm_table.setSelectionMode(ListSelectionModel.SINGLE_SELECTION)
		self.bpm_table.setFillsViewportHeight(true)
		self.bpm_table.setPreferredScrollableViewportSize(Dimension(400,300))	
		scrl_panel = JScrollPane(self.bpm_table)
		scrl_panel.setBorder(etched_border)
		bpm_table_panel = JPanel(BorderLayout())
		bpm_table_panel.add(scrl_panel,BorderLayout.WEST)
		#-----------------------------------------
		self.gp_bpm_phase_err = FunctionGraphsJPanel()
		self.gp_bpm_phase_err.setLegendButtonVisible(true)
		self.gp_bpm_phase_err.setChooseModeButtonVisible(true)	
		self.gp_bpm_phase_err.setName("BPM Phase Errors")
		self.gp_bpm_phase_err.setAxisNames("position, [m]","BPM Phase Error, [deg]")	
		self.gp_bpm_phase_err.setBorder(etched_border)
		bpm_graph_panel = JPanel(BorderLayout())
		bpm_graph_panel.add(self.gp_bpm_phase_err)
		#------graph data 
		self.bpm_phase_err_gd = BasicGraphData()
		self.bpm_phase_err_gd.setGraphPointSize(8)
		self.bpm_phase_err_gd.setDrawLinesOn(false)
		self.bpm_phase_err_gd.setGraphColor(Color.BLUE)	
		self.gp_bpm_phase_err.addGraphData(self.bpm_phase_err_gd)
		#-----------------------------------------
		self.add(bpm_table_panel,BorderLayout.WEST)	
		self.add(bpm_graph_panel,BorderLayout.CENTER)	
Пример #22
0
 def run(self):
     frame = JFrame('NumbEdit',
                    size=(500, 100),
                    locationRelativeTo=None,
                    defaultCloseOperation=JFrame.EXIT_ON_CLOSE)
     table = JTable(tm())
     frame.add(JScrollPane(table))
     frame.setVisible(1)
Пример #23
0
 def __initTable(self):
     table = JTable(HitListModel())
     scrollpane = JScrollPane(table)
     table.setAutoResizeMode(JTable.AUTO_RESIZE_OFF)
     table.addMouseListener(HitListMouseListener())
     self.add(scrollpane, self.__createTableConstraints())
     scrollpane.addComponentListener(PanelSizeChangeListener(table))
     return table
Пример #24
0
 def display(self):
     colnames = ['file', 'line']
     table = JTable(self.results, colnames)
     frame = JFrame("%i Results" % len(self.results))
     frame.getContentPane().add(table)
     frame.size = 400, 300
     frame.defaultCloseOperation = WindowConstants.EXIT_ON_CLOSE
     frame.visible = True
Пример #25
0
 def run(self):
     frame = JFrame('Table1',
                    size=(300, 200),
                    locationRelativeTo=None,
                    defaultCloseOperation=JFrame.EXIT_ON_CLOSE)
     headings = 'Date,size,Location'.split(',')
     frame.add(JScrollPane(JTable(self.data, headings)))
     #       frame.pack()
     frame.setVisible(1)
Пример #26
0
 def run(self):
     frame = JFrame('cbEdit1',
                    size=(200, 100),
                    locationRelativeTo=None,
                    defaultCloseOperation=JFrame.EXIT_ON_CLOSE)
     table = JTable(tm())
     table.setDefaultEditor(String, cbEditor())
     frame.add(JScrollPane(table))
     frame.setVisible(1)
Пример #27
0
 def run(self):
     frame = JFrame('SpinEdit',
                    size=(200, 106),
                    locationRelativeTo=None,
                    defaultCloseOperation=JFrame.EXIT_ON_CLOSE)
     table = JTable(tm(), rowHeight=20)
     table.setDefaultEditor(String, editor())
     frame.add(JScrollPane(table))
     frame.setVisible(1)
Пример #28
0
	def __init__(self,transverse_twiss_analysis_Controller):
		self.transverse_twiss_analysis_Controller = transverse_twiss_analysis_Controller
		self.setLayout(BorderLayout())
		#-----------dict table panel
		etched_border = BorderFactory.createEtchedBorder()
		border = BorderFactory.createTitledBorder(etched_border,"Quad and Cavities Amp.&Phases Sets")
		self.setBorder(border)		
		self.quad_cav_dict_table_model = QuadCavDict_Table_Model(self.transverse_twiss_analysis_Controller.accStatesKeeper)
		self.dict_table = JTable(self.quad_cav_dict_table_model)
		self.dict_table.setSelectionMode(ListSelectionModel.SINGLE_SELECTION)
		self.dict_table.setFillsViewportHeight(true)
		self.dict_table.setPreferredScrollableViewportSize(Dimension(120,100))
		self.dict_table.getSelectionModel().addListSelectionListener(QuadCavDict_Table_Selection_Listener(self.transverse_twiss_analysis_Controller))
		#--------buttons panel
		button_panel = JPanel(BorderLayout())
		self.gaussButton = JRadioButton("Use Ext. Gauss Fit")
		self.custom_gaussButton = JRadioButton("Use Gauss Fit")
		self.custom_rmsButton = JRadioButton("Use RMS")
		button_group = ButtonGroup()
		button_group.add(self.gaussButton)
		button_group.add(self.custom_gaussButton)
		button_group.add(self.custom_rmsButton)
		button_group.clearSelection()
		self.gaussButton.setSelected(true)
		button_panel0 = JPanel(FlowLayout(FlowLayout.LEFT,2,2))
		button_panel0.add(self.gaussButton)
		button_panel1 = JPanel(FlowLayout(FlowLayout.LEFT,2,2))
		button_panel1.add(self.custom_gaussButton)
		button_panel2 = JPanel(FlowLayout(FlowLayout.LEFT,2,2))
		button_panel2.add(self.custom_rmsButton)
		button_panel012 = JPanel(GridLayout(3,1))
		button_panel012.add(button_panel0)
		button_panel012.add(button_panel1)
		button_panel012.add(button_panel2)
		#-------new buttons-----
		button_bottom_panel = JPanel(FlowLayout(FlowLayout.LEFT,2,2))
		button_bottom_panel0 = JPanel(GridLayout(3,1,2,2))
		dump_quad_fields_button = JButton("Dump Quad Fields to ASCII")
		dump_quad_fields_button.addActionListener(Dump_Quad_Fields_Button_Listener(self.transverse_twiss_analysis_Controller))
		button_bottom_panel0.add(dump_quad_fields_button)
		dump_cav_amps_phases_button = JButton("Dump. Cav Amps. Phases to ASCII")
		dump_cav_amps_phases_button.addActionListener(Dump_Cav_Amps_Phases_Button_Listener(self.transverse_twiss_analysis_Controller))
		button_bottom_panel0.add(dump_cav_amps_phases_button)	
		read_cav_amps_phases_button = JButton("Read Cav Amps. Phases from ASCII")
		read_cav_amps_phases_button.addActionListener(Read_Cav_Amps_Phases_Button_Listener(self.transverse_twiss_analysis_Controller))
		button_bottom_panel0.add(read_cav_amps_phases_button)
		button_bottom_panel.add(button_bottom_panel0)
		#----- final knobs panel 
		button_panel.add(button_panel012,BorderLayout.NORTH)
		button_panel.add(button_bottom_panel,BorderLayout.SOUTH)
		self.gaussButton.addActionListener(FitParam_Buttons_Listener(self.transverse_twiss_analysis_Controller,0))
		self.custom_gaussButton.addActionListener(FitParam_Buttons_Listener(self.transverse_twiss_analysis_Controller,1))
		self.custom_rmsButton.addActionListener(FitParam_Buttons_Listener(self.transverse_twiss_analysis_Controller,2))
		#----------------------------------------------------------
		self.add(JScrollPane(self.dict_table), BorderLayout.WEST)
		self.add(button_panel, BorderLayout.CENTER)
Пример #29
0
def studentLogined(stObj):
    global panel
    global table
    global heading
    global frame

    frame = JFrame("Student  Page ")
    frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE)
    frame.setSize(500, 600)
    frame.setLocation(200, 200)
    frame.setLayout(None)

    panel = JPanel()
    panel.setSize(500, 580)
    panel.setLocation(0, 20)
    panel.setLayout(None)
    panel.setVisible(True)
    panel.setBackground(Color.WHITE)

    heading = JLabel()
    heading.setBounds(210, 10, 200, 30)

    table = JTable()
    table.setBounds(0, 50, 500, 470)
    sp = JScrollPane(table, ScrollPaneConstants.VERTICAL_SCROLLBAR_ALWAYS,
                     ScrollPaneConstants.HORIZONTAL_SCROLLBAR_ALWAYS)

    bar = JMenuBar()

    profile = JMenu("Profile")
    showProfile = JMenuItem("Show Profile",
                            actionPerformed=clickShowStudentProfile)
    changePassword = JMenuItem("Change Password",
                               actionPerformed=changeStudentPassword)
    profile.add(showProfile)
    profile.add(changePassword)
    bar.add(profile)

    attendence = JMenu("Attendence")
    showAllAttendence = JMenuItem("Show All Attendence",
                                  actionPerformed=clickAllAttendence)
    showAttendenceInMonth = JMenuItem("show attendence in month",
                                      actionPerformed=clickAttendenceInMonth)
    attendence.add(showAllAttendence)
    attendence.add(showAttendenceInMonth)
    bar.add(attendence)

    logout = JMenuItem("logout", actionPerformed=clickLogout)
    bar.add(logout)

    panel.add(table)

    frame.setJMenuBar(bar)
    frame.add(panel)

    frame.setVisible(True)
Пример #30
0
 def run(self):
     frame = JFrame('cbEdit3',
                    size=(200, 125),
                    locationRelativeTo=None,
                    defaultCloseOperation=JFrame.EXIT_ON_CLOSE)
     table = JTable(tm(), rowHeight=20)
     table.setDefaultRenderer(JComboBox, cbRenderer())
     table.setDefaultEditor(JComboBox, cbEditor())
     frame.add(JScrollPane(table))
     frame.setVisible(1)