| /** |
| * Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. See the NOTICE file distributed with |
| * this work for additional information regarding copyright ownership. |
| * The ASF licenses this file to You under the Apache License, Version 2.0 |
| * (the "License"); you may not use this file except in compliance with |
| * the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| package org.apache.oodt.cas.workflow.gui.perspective.view.impl; |
| |
| //JDK imports |
| import java.awt.BorderLayout; |
| import java.awt.Checkbox; |
| import java.awt.Color; |
| import java.awt.Component; |
| import java.awt.Dimension; |
| import java.awt.Font; |
| import java.awt.GridLayout; |
| import java.awt.event.ActionEvent; |
| import java.awt.event.ActionListener; |
| import java.awt.event.ItemEvent; |
| import java.awt.event.ItemListener; |
| import java.awt.event.MouseEvent; |
| import java.awt.event.MouseListener; |
| import java.text.DecimalFormat; |
| import java.text.Format; |
| import java.util.Arrays; |
| import java.util.Collections; |
| import java.util.HashMap; |
| import java.util.Hashtable; |
| import java.util.List; |
| import java.util.Vector; |
| import javax.swing.BoxLayout; |
| import javax.swing.DefaultListModel; |
| import javax.swing.JButton; |
| import javax.swing.JComboBox; |
| import javax.swing.JComponent; |
| import javax.swing.JLabel; |
| import javax.swing.JList; |
| import javax.swing.JMenuItem; |
| import javax.swing.JPanel; |
| import javax.swing.JPopupMenu; |
| import javax.swing.JScrollPane; |
| import javax.swing.JSlider; |
| import javax.swing.JTable; |
| import javax.swing.JTextField; |
| import javax.swing.ListSelectionModel; |
| import javax.swing.border.EtchedBorder; |
| import javax.swing.event.ChangeEvent; |
| import javax.swing.event.ChangeListener; |
| import javax.swing.event.ListSelectionEvent; |
| import javax.swing.event.ListSelectionListener; |
| import javax.swing.event.TableModelEvent; |
| import javax.swing.event.TableModelListener; |
| import javax.swing.table.AbstractTableModel; |
| import javax.swing.table.TableCellRenderer; |
| import javax.swing.table.TableColumn; |
| |
| //Apache imports |
| import org.apache.commons.lang.StringUtils; |
| |
| //OODT imports |
| import org.apache.oodt.cas.metadata.Metadata; |
| import org.apache.oodt.cas.workflow.gui.model.ModelGraph; |
| import org.apache.oodt.cas.workflow.gui.perspective.view.View; |
| import org.apache.oodt.cas.workflow.gui.perspective.view.ViewState; |
| import org.apache.oodt.cas.workflow.gui.util.GuiUtils; |
| |
| /** |
| * |
| * |
| * The default view displaying a workflow property (for a task, or a condition, |
| * or set of workflows). |
| * |
| * @author bfoster |
| * @author mattmann |
| * |
| */ |
| public class DefaultPropView extends View { |
| |
| private static final long serialVersionUID = -5521047300551974898L; |
| |
| private JTable table; |
| private JPopupMenu tableMenu; |
| private JMenuItem override; |
| private JMenuItem delete; |
| private static final String OVERRIDE = "Override"; |
| private static final String DELETE = "Delete"; |
| private int DEFAULT_PRIORITY = 5; |
| |
| public DefaultPropView(String name) { |
| super(name); |
| this.setLayout(new BorderLayout()); |
| } |
| |
| private JTable createTable(final ViewState state) { |
| JTable table = null; |
| final ModelGraph selected = state.getSelected(); |
| if (selected != null) { |
| final Vector<Vector<String>> rows = new Vector<Vector<String>>(); |
| HashMap<String, String> keyToGroupMap = new HashMap<String, String>(); |
| Metadata staticMet = selected.getModel().getStaticMetadata(); |
| Metadata inheritedMet = selected.getInheritedStaticMetadata(state); |
| Metadata completeMet = new Metadata(); |
| if (staticMet != null) { |
| completeMet.replaceMetadata(staticMet.getSubMetadata(state |
| .getCurrentMetGroup())); |
| } |
| if (selected.getModel().getExtendsConfig() != null) { |
| for (String configGroup : selected.getModel().getExtendsConfig()) { |
| Metadata extendsMetadata = state.getGlobalConfigGroups() |
| .get(configGroup).getMetadata() |
| .getSubMetadata(state.getCurrentMetGroup()); |
| for (String key : extendsMetadata.getAllKeys()) { |
| if (!completeMet.containsKey(key)) { |
| keyToGroupMap.put(key, configGroup); |
| completeMet.replaceMetadata(key, |
| extendsMetadata.getAllMetadata(key)); |
| } |
| } |
| } |
| } |
| if (inheritedMet != null) { |
| Metadata inheritedMetadata = inheritedMet.getSubMetadata(state |
| .getCurrentMetGroup()); |
| for (String key : inheritedMetadata.getAllKeys()) { |
| if (!completeMet.containsKey(key)) { |
| keyToGroupMap.put(key, "__inherited__"); |
| completeMet.replaceMetadata(key, |
| inheritedMetadata.getAllMetadata(key)); |
| } |
| } |
| } |
| List<String> keys = completeMet.getAllKeys(); |
| Collections.sort(keys); |
| for (String key : keys) { |
| if (key.endsWith("/envReplace")) |
| continue; |
| String values = StringUtils.join(completeMet.getAllMetadata(key), ","); |
| Vector<String> row = new Vector<String>(); |
| row.add(keyToGroupMap.get(key)); |
| row.add(key); |
| row.add(values); |
| row.add(Boolean.toString(Boolean.parseBoolean(completeMet |
| .getMetadata(key + "/envReplace")))); |
| rows.add(row); |
| } |
| table = new JTable();// rows, new Vector<String>(Arrays.asList(new |
| // String[] { "key", "values", "envReplace" }))); |
| table.setModel(new AbstractTableModel() { |
| public String getColumnName(int col) { |
| switch (col) { |
| case 0: |
| return "group"; |
| case 1: |
| return "key"; |
| case 2: |
| return "values"; |
| case 3: |
| return "envReplace"; |
| default: |
| return null; |
| } |
| } |
| |
| public int getRowCount() { |
| return rows.size() + 1; |
| } |
| |
| public int getColumnCount() { |
| return 4; |
| } |
| |
| public Object getValueAt(int row, int col) { |
| if (row >= rows.size()) |
| return null; |
| String value = rows.get(row).get(col); |
| if (value == null && col == 3) |
| return "false"; |
| if (value == null && col == 0) |
| return "__local__"; |
| return value; |
| } |
| |
| public boolean isCellEditable(int row, int col) { |
| if (row >= rows.size()) { |
| if (selected.getModel().getStaticMetadata() |
| .containsGroup(state.getCurrentMetGroup())) |
| return true; |
| else |
| return false; |
| } |
| if (col == 0) |
| return false; |
| String key = rows.get(row).get(1); |
| if (key == null |
| || (selected.getModel().getStaticMetadata() != null && selected |
| .getModel().getStaticMetadata() |
| .containsKey(getKey(key, state)))) |
| return true; |
| return false; |
| } |
| |
| public void setValueAt(Object value, int row, int col) { |
| if (row >= rows.size()) { |
| Vector<String> newRow = new Vector<String>(Arrays |
| .asList(new String[] { null, null, null, null })); |
| newRow.add(col, (String) value); |
| rows.add(newRow); |
| } else { |
| Vector<String> rowValues = rows.get(row); |
| rowValues.add(col, (String) value); |
| rowValues.remove(col + 1); |
| } |
| this.fireTableCellUpdated(row, col); |
| } |
| |
| }); |
| MyTableListener tableListener = new MyTableListener(state); |
| table.getModel().addTableModelListener(tableListener); |
| table.getSelectionModel().addListSelectionListener(tableListener); |
| } else { |
| table = new JTable(new Vector<Vector<String>>(), new Vector<String>( |
| Arrays.asList(new String[] { "key", "values", "envReplace" }))); |
| } |
| |
| // table.setFillsViewportHeight(true); |
| table.setSelectionBackground(Color.cyan); |
| table.setAutoResizeMode(JTable.AUTO_RESIZE_OFF); |
| TableCellRenderer cellRenderer = new TableCellRenderer() { |
| |
| public Component getTableCellRendererComponent(JTable table, |
| Object value, boolean isSelected, boolean hasFocus, int row, |
| int column) { |
| JLabel field = new JLabel((String) value); |
| if (column == 0) { |
| field.setForeground(Color.gray); |
| } else { |
| if (isSelected) |
| field.setBorder(new EtchedBorder(1)); |
| if (table.isCellEditable(row, 1)) |
| field.setForeground(Color.black); |
| else |
| field.setForeground(Color.gray); |
| } |
| return field; |
| } |
| |
| }; |
| TableColumn groupCol = table.getColumnModel().getColumn(0); |
| groupCol.setPreferredWidth(75); |
| groupCol.setCellRenderer(cellRenderer); |
| TableColumn keyCol = table.getColumnModel().getColumn(1); |
| keyCol.setPreferredWidth(200); |
| keyCol.setCellRenderer(cellRenderer); |
| TableColumn valuesCol = table.getColumnModel().getColumn(2); |
| valuesCol.setPreferredWidth(300); |
| valuesCol.setCellRenderer(cellRenderer); |
| TableColumn envReplaceCol = table.getColumnModel().getColumn(3); |
| envReplaceCol.setPreferredWidth(75); |
| envReplaceCol.setCellRenderer(cellRenderer); |
| |
| table.addMouseListener(new MouseListener() { |
| public void mouseClicked(MouseEvent e) { |
| if (e.getButton() == MouseEvent.BUTTON3 |
| && DefaultPropView.this.table.getSelectedRow() != -1) { |
| int row = DefaultPropView.this.table.getSelectedRow();// rowAtPoint(DefaultPropView.this.table.getMousePosition()); |
| String key = getKey( |
| (String) DefaultPropView.this.table.getValueAt(row, 1), state); |
| Metadata staticMet = state.getSelected().getModel() |
| .getStaticMetadata(); |
| override.setVisible(staticMet == null || !staticMet.containsKey(key)); |
| delete.setVisible(staticMet != null && staticMet.containsKey(key)); |
| tableMenu.show(DefaultPropView.this.table, e.getX(), e.getY()); |
| } |
| } |
| |
| public void mouseEntered(MouseEvent e) { |
| } |
| |
| public void mouseExited(MouseEvent e) { |
| } |
| |
| public void mousePressed(MouseEvent e) { |
| } |
| |
| public void mouseReleased(MouseEvent e) { |
| } |
| }); |
| |
| return table; |
| } |
| |
| @Override |
| public void refreshView(final ViewState state) { |
| this.removeAll(); |
| |
| tableMenu = new JPopupMenu("TableMenu"); |
| this.add(tableMenu); |
| override = new JMenuItem(OVERRIDE); |
| override.addActionListener(new ActionListener() { |
| public void actionPerformed(ActionEvent e) { |
| int row = DefaultPropView.this.table.getSelectedRow();// rowAtPoint(DefaultPropView.this.table.getMousePosition()); |
| String key = getKey( |
| (String) DefaultPropView.this.table.getValueAt(row, 1), state); |
| Metadata staticMet = state.getSelected().getModel().getStaticMetadata(); |
| if (staticMet == null) |
| staticMet = new Metadata(); |
| if (e.getActionCommand().equals(OVERRIDE)) { |
| if (!staticMet.containsKey(key)) { |
| staticMet.addMetadata(key, |
| (String) DefaultPropView.this.table.getValueAt(row, 2)); |
| String envReplace = (String) DefaultPropView.this.table.getValueAt( |
| row, 3); |
| if (Boolean.valueOf(envReplace)) |
| staticMet.addMetadata(key + "/envReplace", envReplace); |
| state.getSelected().getModel().setStaticMetadata(staticMet); |
| DefaultPropView.this.notifyListeners(); |
| } |
| } |
| } |
| }); |
| delete = new JMenuItem(DELETE); |
| delete.addActionListener(new ActionListener() { |
| |
| public void actionPerformed(ActionEvent e) { |
| int row = DefaultPropView.this.table.getSelectedRow();// rowAtPoint(DefaultPropView.this.table.getMousePosition()); |
| String key = getKey( |
| (String) DefaultPropView.this.table.getValueAt(row, 1), state); |
| Metadata staticMet = state.getSelected().getModel().getStaticMetadata(); |
| if (staticMet == null) |
| staticMet = new Metadata(); |
| staticMet.removeMetadata(key); |
| staticMet.removeMetadata(key + "/envReplace"); |
| state.getSelected().getModel().setStaticMetadata(staticMet); |
| DefaultPropView.this.notifyListeners(); |
| } |
| |
| }); |
| tableMenu.add(override); |
| tableMenu.add(delete); |
| |
| if (state.getSelected() != null) { |
| JPanel masterPanel = new JPanel(); |
| masterPanel.setLayout(new BoxLayout(masterPanel, BoxLayout.Y_AXIS)); |
| masterPanel.add(this.getModelIdPanel(state.getSelected(), state)); |
| masterPanel.add(this.getModelNamePanel(state.getSelected(), state)); |
| if (!state.getSelected().getModel().isParentType()) |
| masterPanel.add(this.getInstanceClassPanel(state.getSelected(), state)); |
| masterPanel.add(this.getExecutionTypePanel(state.getSelected(), state)); |
| masterPanel.add(this.getPriorityPanel(state)); |
| masterPanel.add(this.getExecusedIds(state.getSelected())); |
| if (state.getSelected().getModel().getExecutionType().equals("condition")) { |
| masterPanel.add(this.getTimeout(state.getSelected(), state)); |
| masterPanel.add(this.getOptional(state.getSelected(), state)); |
| } |
| JScrollPane scrollPane = new JScrollPane(table = this.createTable(state), |
| JScrollPane.VERTICAL_SCROLLBAR_ALWAYS, |
| JScrollPane.HORIZONTAL_SCROLLBAR_ALWAYS); |
| scrollPane.getHorizontalScrollBar().setUnitIncrement(10); |
| scrollPane.getVerticalScrollBar().setUnitIncrement(10); |
| JPanel panel = new JPanel(); |
| panel.setLayout(new BorderLayout()); |
| panel.setBorder(new EtchedBorder()); |
| final JLabel metLabel = new JLabel("Static Metadata"); |
| metLabel.setAlignmentX(Component.CENTER_ALIGNMENT); |
| final JLabel extendsLabel = new JLabel("<extends>"); |
| extendsLabel.setFont(new Font("Serif", Font.PLAIN, 10)); |
| extendsLabel.setAlignmentX(Component.CENTER_ALIGNMENT); |
| extendsLabel.addMouseListener(new MouseListener() { |
| |
| private JScrollPane availableScroller; |
| private JScrollPane mineScroller; |
| private JList mineList; |
| private JList availableList; |
| private DefaultListModel mineModel; |
| private DefaultListModel availableModel; |
| |
| public void mouseClicked(MouseEvent e) { |
| final JPopupMenu popup = new JPopupMenu(); |
| popup.setLayout(new BorderLayout()); |
| |
| JPanel main = new JPanel(); |
| main.setLayout(new BoxLayout(main, BoxLayout.X_AXIS)); |
| |
| JPanel mine = new JPanel(); |
| mine.setBorder(new EtchedBorder()); |
| mine.setLayout(new BorderLayout()); |
| JLabel mineLabel = new JLabel("Mine"); |
| mineScroller = new JScrollPane(mineList = createJList( |
| mineModel = new DefaultListModel(), state.getSelected() |
| .getModel().getExtendsConfig())); |
| mineScroller.setPreferredSize(new Dimension(250, 80)); |
| mine.add(mineLabel, BorderLayout.NORTH); |
| mine.add(mineScroller, BorderLayout.CENTER); |
| |
| JPanel available = new JPanel(); |
| available.setBorder(new EtchedBorder()); |
| available.setLayout(new BorderLayout()); |
| JLabel availableLabel = new JLabel("Available"); |
| Vector<String> availableGroups = new Vector<String>(state |
| .getGlobalConfigGroups().keySet()); |
| availableGroups.removeAll(state.getSelected().getModel() |
| .getExtendsConfig()); |
| availableScroller = new JScrollPane(availableList = this.createJList( |
| availableModel = new DefaultListModel(), availableGroups)); |
| availableScroller.setPreferredSize(new Dimension(250, 80)); |
| available.add(availableLabel, BorderLayout.NORTH); |
| available.add(availableScroller, BorderLayout.CENTER); |
| |
| JPanel buttons = new JPanel(); |
| buttons.setLayout(new BoxLayout(buttons, BoxLayout.Y_AXIS)); |
| JButton addButton = new JButton("<---"); |
| addButton.addMouseListener(new MouseListener() { |
| |
| public void mouseClicked(MouseEvent e) { |
| String selected = availableList.getSelectedValue().toString(); |
| Vector<String> extendsConfig = new Vector<String>(state |
| .getSelected().getModel().getExtendsConfig()); |
| extendsConfig.add(selected); |
| state.getSelected().getModel().setExtendsConfig(extendsConfig); |
| availableModel.remove(availableList.getSelectedIndex()); |
| mineModel.addElement(selected); |
| popup.revalidate(); |
| DefaultPropView.this.notifyListeners(); |
| } |
| |
| public void mouseEntered(MouseEvent e) { |
| } |
| |
| public void mouseExited(MouseEvent e) { |
| } |
| |
| public void mousePressed(MouseEvent e) { |
| } |
| |
| public void mouseReleased(MouseEvent e) { |
| } |
| |
| }); |
| JButton removeButton = new JButton("--->"); |
| removeButton.addMouseListener(new MouseListener() { |
| |
| public void mouseClicked(MouseEvent e) { |
| String selected = mineList.getSelectedValue().toString(); |
| Vector<String> extendsConfig = new Vector<String>(state |
| .getSelected().getModel().getExtendsConfig()); |
| extendsConfig.remove(selected); |
| state.getSelected().getModel().setExtendsConfig(extendsConfig); |
| mineModel.remove(mineList.getSelectedIndex()); |
| availableModel.addElement(selected); |
| popup.revalidate(); |
| DefaultPropView.this.notifyListeners(); |
| } |
| |
| public void mouseEntered(MouseEvent e) { |
| } |
| |
| public void mouseExited(MouseEvent e) { |
| } |
| |
| public void mousePressed(MouseEvent e) { |
| } |
| |
| public void mouseReleased(MouseEvent e) { |
| } |
| |
| }); |
| buttons.add(addButton); |
| buttons.add(removeButton); |
| |
| main.add(mine); |
| main.add(buttons); |
| main.add(available); |
| popup.add(main, BorderLayout.CENTER); |
| popup.show(extendsLabel, e.getX(), e.getY()); |
| } |
| |
| public void mouseEntered(MouseEvent e) { |
| extendsLabel.setForeground(Color.blue); |
| } |
| |
| public void mouseExited(MouseEvent e) { |
| extendsLabel.setForeground(Color.black); |
| } |
| |
| public void mousePressed(MouseEvent e) { |
| } |
| |
| public void mouseReleased(MouseEvent e) { |
| } |
| |
| private JList createJList(DefaultListModel model, |
| final List<String> list) { |
| for (String value : list) |
| model.addElement(value); |
| JList jList = new JList(model); |
| jList.setSelectionMode(ListSelectionModel.SINGLE_INTERVAL_SELECTION); |
| jList.setLayoutOrientation(JList.VERTICAL); |
| return jList; |
| } |
| }); |
| JLabel metGroupLabel = new JLabel("(Sub-Group: " |
| + (state.getCurrentMetGroup() != null ? state.getCurrentMetGroup() |
| : "<base>") + ")"); |
| metGroupLabel.setAlignmentX(Component.CENTER_ALIGNMENT); |
| JPanel labelPanel = new JPanel(); |
| labelPanel.setLayout(new BoxLayout(labelPanel, BoxLayout.Y_AXIS)); |
| JPanel top = new JPanel(); |
| top.setLayout(new BoxLayout(top, BoxLayout.Y_AXIS)); |
| top.add(extendsLabel); |
| top.add(metLabel); |
| labelPanel.add(top); |
| labelPanel.add(metGroupLabel); |
| panel.add(labelPanel, BorderLayout.NORTH); |
| panel.add(scrollPane, BorderLayout.CENTER); |
| masterPanel.add(panel); |
| this.add(masterPanel); |
| } else { |
| this.add(new JPanel()); |
| } |
| this.revalidate(); |
| } |
| |
| private JPanel getTimeout(final ModelGraph graph, final ViewState state) { |
| JPanel panel = new JPanel(); |
| panel.setLayout(new BorderLayout()); |
| panel.setBorder(new EtchedBorder()); |
| panel.add(new JLabel("Timeout:"), BorderLayout.NORTH); |
| JTextField field = new JTextField(String.valueOf(graph.getModel() |
| .getTimeout()), 50); |
| field.addActionListener(new ActionListener() { |
| |
| public void actionPerformed(ActionEvent e) { |
| if (!graph.getModel().getModelId().equals(e.getActionCommand())) { |
| graph.getModel().setTimeout(Long.valueOf( |
| e.getActionCommand() != null && |
| !e.getActionCommand().equals("") ? |
| e.getActionCommand():"-1")); |
| DefaultPropView.this.notifyListeners(); |
| DefaultPropView.this.refreshView(state); |
| } |
| } |
| |
| }); |
| panel.add(field, BorderLayout.CENTER); |
| return panel; |
| } |
| |
| private JPanel getModelIdPanel(final ModelGraph graph, final ViewState state) { |
| JPanel panel = new JPanel(); |
| panel.setLayout(new BorderLayout()); |
| panel.setBorder(new EtchedBorder()); |
| panel.add(new JLabel("ModelId:"), BorderLayout.NORTH); |
| JTextField field = new JTextField(graph.getModel().getModelId(), 50); |
| field.addActionListener(new ActionListener() { |
| |
| public void actionPerformed(ActionEvent e) { |
| if (!graph.getModel().getModelId().equals(e.getActionCommand())) { |
| GuiUtils.updateGraphModelId(state, graph.getModel().getId(), |
| e.getActionCommand()); |
| DefaultPropView.this.notifyListeners(); |
| DefaultPropView.this.refreshView(state); |
| } |
| } |
| |
| }); |
| panel.add(field, BorderLayout.CENTER); |
| return panel; |
| } |
| |
| private JPanel getModelNamePanel(final ModelGraph graph, final ViewState state) { |
| JPanel panel = new JPanel(); |
| panel.setLayout(new BorderLayout()); |
| panel.setBorder(new EtchedBorder()); |
| panel.add(new JLabel("ModelName:"), BorderLayout.NORTH); |
| JTextField field = new JTextField(graph.getModel().getModelName(), 50); |
| field.addActionListener(new ActionListener() { |
| |
| public void actionPerformed(ActionEvent e) { |
| if (!graph.getModel().getModelName().equals(e.getActionCommand())) { |
| // GuiUtils.updateGraphModelName(getState(), |
| // graph.getModel().getModelId(), e.getActionCommand()); |
| graph.getModel().setModelName(e.getActionCommand()); |
| DefaultPropView.this.notifyListeners(); |
| DefaultPropView.this.refreshView(state); |
| } |
| } |
| |
| }); |
| panel.add(field, BorderLayout.CENTER); |
| return panel; |
| } |
| |
| private JPanel getInstanceClassPanel(final ModelGraph graph, |
| final ViewState state) { |
| JPanel panel = new JPanel(); |
| panel.setLayout(new BorderLayout()); |
| panel.setBorder(new EtchedBorder()); |
| panel.add(new JLabel("InstanceClass:"), BorderLayout.NORTH); |
| JTextField field = new JTextField(graph.getModel().getInstanceClass(), 50); |
| field.addActionListener(new ActionListener() { |
| |
| public void actionPerformed(ActionEvent e) { |
| if (graph.getModel().getInstanceClass() == null |
| || !graph.getModel().getInstanceClass() |
| .equals(e.getActionCommand())) { |
| graph.getModel().setInstanceClass(e.getActionCommand()); |
| DefaultPropView.this.notifyListeners(); |
| DefaultPropView.this.refreshView(state); |
| } |
| } |
| |
| }); |
| panel.add(field, BorderLayout.CENTER); |
| return panel; |
| } |
| |
| private JPanel getPriorityPanel(final ViewState state) { |
| JPanel panel = new JPanel(); |
| panel.setBorder(new EtchedBorder()); |
| panel.setLayout(new BorderLayout()); |
| panel.add(new JLabel("Priority: "), BorderLayout.WEST); |
| final JLabel priorityLabel = new JLabel(String.valueOf(DEFAULT_PRIORITY)); |
| panel.add(priorityLabel, BorderLayout.CENTER); |
| JSlider slider = new JSlider(0, 100, (int) 5 * 10); |
| slider.setMajorTickSpacing(10); |
| slider.setMinorTickSpacing(1); |
| slider.setPaintLabels(true); |
| slider.setPaintTicks(true); |
| slider.setSnapToTicks(false); |
| Format f = new DecimalFormat("0.0"); |
| Hashtable<Integer, JComponent> labels = new Hashtable<Integer, JComponent>(); |
| for (int i = 0; i <= 10; i += 2) { |
| JLabel label = new JLabel(f.format(i)); |
| label.setFont(label.getFont().deriveFont(Font.PLAIN)); |
| labels.put(i * 10, label); |
| } |
| slider.setLabelTable(labels); |
| slider.addChangeListener(new ChangeListener() { |
| |
| public void stateChanged(ChangeEvent e) { |
| double value = ((JSlider) e.getSource()).getValue() / 10.0; |
| priorityLabel.setText(value + ""); |
| priorityLabel.revalidate(); |
| if (!((JSlider) e.getSource()).getValueIsAdjusting()) { |
| // FIXME: deal with priorities |
| DefaultPropView.this.notifyListeners(); |
| } |
| } |
| |
| }); |
| |
| panel.add(slider, BorderLayout.SOUTH); |
| return panel; |
| } |
| |
| private JPanel getExecutionTypePanel(final ModelGraph graph, |
| final ViewState state) { |
| JPanel panel = new JPanel(); |
| panel.setBorder(new EtchedBorder()); |
| panel.setLayout(new BorderLayout()); |
| panel.add(new JLabel("ExecutionType:"), BorderLayout.WEST); |
| JComboBox comboBox = new JComboBox(); |
| if (graph.hasChildren()) { |
| comboBox.addItem("parallel"); |
| comboBox.addItem("sequential"); |
| } else if (graph.getModel().getExecutionType().equals("task")) { |
| comboBox.addItem("parallel"); |
| comboBox.addItem("sequential"); |
| comboBox.addItem("task"); |
| } else if (graph.isCondition() |
| || graph.getModel().getExecutionType().equals("condition")) { |
| comboBox.addItem("parallel"); |
| comboBox.addItem("sequential"); |
| comboBox.addItem("condition"); |
| } else { |
| comboBox.addItem("parallel"); |
| comboBox.addItem("sequential"); |
| comboBox.addItem("task"); |
| } |
| comboBox.setSelectedItem(graph.getModel().getExecutionType()); |
| comboBox.addItemListener(new ItemListener() { |
| public void itemStateChanged(ItemEvent e) { |
| if (!graph.getModel().getExecutionType().equals(e.getItem())) { |
| graph.getModel().setExecutionType((String) e.getItem()); |
| DefaultPropView.this.notifyListeners(); |
| DefaultPropView.this.refreshView(state); |
| } |
| } |
| }); |
| panel.add(comboBox, BorderLayout.CENTER); |
| return panel; |
| } |
| |
| private JPanel getOptional(final ModelGraph graph, final ViewState state) { |
| JPanel panel = new JPanel(); |
| panel.setLayout(new BorderLayout()); |
| panel.setBorder(new EtchedBorder()); |
| panel.add(new JLabel("Optional:"), BorderLayout.NORTH); |
| JPanel checkBoxes = new JPanel(); |
| checkBoxes.setLayout(new GridLayout(1, 1)); |
| Checkbox checkbox = new Checkbox("ignore", graph.getModel().isOptional()); |
| checkBoxes.add(checkbox); |
| checkbox.addItemListener(new ItemListener() { |
| |
| public void itemStateChanged(ItemEvent e) { |
| if (e.getStateChange() == ItemEvent.DESELECTED) |
| graph.getModel().setOptional(false); |
| else if (e.getStateChange() == ItemEvent.SELECTED) |
| graph.getModel().setOptional(true); |
| else |
| return; |
| DefaultPropView.this.notifyListeners(); |
| DefaultPropView.this.refreshView(state); |
| } |
| |
| }); |
| panel.add(checkBoxes, BorderLayout.CENTER); |
| return panel; |
| } |
| |
| |
| private JPanel getExecusedIds(final ModelGraph graph) { |
| JPanel panel = new JPanel(); |
| panel.setLayout(new BorderLayout()); |
| panel.setBorder(new EtchedBorder()); |
| panel.add(new JLabel("ExcusedSubProcessorIds:"), BorderLayout.NORTH); |
| JPanel checkBoxes = new JPanel(); |
| checkBoxes.setLayout(new GridLayout(graph.getChildren().size(), 1)); |
| if (graph.hasChildren()) { |
| for (ModelGraph childGraph : graph.getChildren()) { |
| final String modelId = childGraph.getModel().getModelId(); |
| Checkbox checkbox = new Checkbox(modelId, graph.getModel() |
| .getExcusedSubProcessorIds().contains(modelId)); |
| checkBoxes.add(checkbox); |
| checkbox.addItemListener(new ItemListener() { |
| |
| public void itemStateChanged(ItemEvent e) { |
| if (e.getStateChange() == ItemEvent.DESELECTED) |
| graph.getModel().getExcusedSubProcessorIds().remove(modelId); |
| else if (e.getStateChange() == ItemEvent.SELECTED) |
| graph.getModel().getExcusedSubProcessorIds().add(modelId); |
| else |
| return; |
| DefaultPropView.this.notifyListeners(); |
| } |
| |
| }); |
| } |
| } |
| panel.add(checkBoxes, BorderLayout.CENTER); |
| return panel; |
| } |
| |
| public class MyTableListener implements TableModelListener, |
| ListSelectionListener { |
| |
| String oldKey, oldValue, oldEnvReplace; |
| |
| private ViewState state; |
| |
| public MyTableListener(ViewState state) { |
| this.state = state; |
| } |
| |
| public void tableChanged(TableModelEvent e) { |
| System.out.println(oldKey + " " + oldValue + " " + oldEnvReplace); |
| if (e.getType() == TableModelEvent.UPDATE) { |
| Metadata staticMet = state.getSelected().getModel().getStaticMetadata(); |
| if (staticMet == null) |
| staticMet = new Metadata(); |
| if (e.getColumn() == 1) { |
| String newGrouplessKey = (String) table.getValueAt(e.getFirstRow(), |
| e.getColumn()); |
| if (newGrouplessKey.equals("") |
| || (newGrouplessKey.equals("envReplace") && !state.getSelected() |
| .getModel().getStaticMetadata() |
| .containsGroup(state.getCurrentMetGroup()))) { |
| notifyListeners(); |
| return; |
| } |
| String newKey = getKey(newGrouplessKey, state); |
| System.out.println("newKey: " + newKey); |
| if (oldKey != null) { |
| staticMet.replaceMetadata(newKey, staticMet.getAllMetadata(oldKey)); |
| if (staticMet.containsKey(oldKey + "/envReplace")) |
| staticMet.replaceMetadata(newKey, |
| staticMet.getAllMetadata(oldKey + "/envReplace")); |
| if (!newKey.equals(oldKey)) |
| staticMet.removeMetadata(oldKey); |
| notifyListeners(); |
| } else { |
| staticMet.replaceMetadata(oldKey = newKey, (String) null); |
| } |
| } else if (e.getColumn() == 2) { |
| if (oldKey != null) { |
| String newValue = (String) table.getValueAt(e.getFirstRow(), |
| e.getColumn()); |
| if (oldKey.endsWith("/envReplace")) { |
| newValue = newValue.toLowerCase(); |
| if (newValue.equals("false")) |
| staticMet.removeMetadata(oldKey); |
| else |
| staticMet.replaceMetadata(oldKey, |
| Arrays.asList(newValue.split(","))); |
| } else { |
| staticMet.replaceMetadata(oldKey, |
| Arrays.asList(newValue.split(","))); |
| } |
| notifyListeners(); |
| } |
| } else if (e.getColumn() == 3) { |
| if (oldKey != null) { |
| String newEnvReplace = ((String) table.getValueAt(e.getFirstRow(), |
| e.getColumn())).toLowerCase(); |
| if (newEnvReplace.equals("true")) |
| staticMet.replaceMetadata(oldKey + "/envReplace", newEnvReplace); |
| else |
| staticMet.removeMetadata(oldKey + "/envReplace"); |
| notifyListeners(); |
| } |
| } |
| state.getSelected().getModel().setStaticMetadata(staticMet); |
| } |
| |
| } |
| |
| public void valueChanged(ListSelectionEvent e) { |
| oldKey = getKey((String) table.getValueAt(e.getFirstIndex(), 1), state); |
| oldValue = (String) table.getValueAt(e.getFirstIndex(), 2); |
| oldEnvReplace = (String) table.getValueAt(e.getFirstIndex(), 3); |
| } |
| |
| } |
| |
| private String getKey(String key, ViewState state) { |
| if (key != null && state.getCurrentMetGroup() != null) |
| return state.getCurrentMetGroup() + "/" + key; |
| else |
| return key; |
| } |
| |
| } |
