| /** |
| * 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.build; |
| |
| //JDK imports |
| import java.awt.BorderLayout; |
| import java.awt.Dimension; |
| import java.awt.event.ActionEvent; |
| import java.awt.event.ActionListener; |
| import java.awt.event.MouseEvent; |
| import java.awt.event.MouseListener; |
| import java.util.Collections; |
| import java.util.HashMap; |
| import java.util.Map; |
| import java.util.Map.Entry; |
| import javax.swing.JMenuItem; |
| import javax.swing.JPanel; |
| import javax.swing.JPopupMenu; |
| import javax.swing.JSplitPane; |
| import javax.swing.JTabbedPane; |
| import javax.swing.event.ChangeEvent; |
| import javax.swing.event.ChangeListener; |
| |
| //OODT imports |
| import org.apache.oodt.cas.workflow.gui.model.ModelGraph; |
| import org.apache.oodt.cas.workflow.gui.perspective.MultiStatePerspective; |
| import org.apache.oodt.cas.workflow.gui.perspective.view.MultiStateView; |
| import org.apache.oodt.cas.workflow.gui.perspective.view.View; |
| import org.apache.oodt.cas.workflow.gui.perspective.view.ViewChange; |
| import org.apache.oodt.cas.workflow.gui.perspective.view.ViewListener; |
| import org.apache.oodt.cas.workflow.gui.perspective.view.ViewState; |
| import org.apache.oodt.cas.workflow.gui.perspective.view.impl.DefaultPropView; |
| import org.apache.oodt.cas.workflow.gui.perspective.view.impl.DefaultTreeView; |
| import org.apache.oodt.cas.workflow.gui.perspective.view.impl.GlobalConfigView; |
| import org.apache.oodt.cas.workflow.gui.perspective.view.impl.GraphView; |
| import org.apache.oodt.cas.workflow.gui.perspective.view.impl.TreeProjectView; |
| import org.apache.oodt.cas.workflow.gui.util.GuiUtils; |
| |
| /** |
| * |
| * The default build perspective. |
| * |
| * @author bfoster |
| * @author mattmann |
| * |
| */ |
| public class BuildPerspective extends MultiStatePerspective { |
| |
| private static final long serialVersionUID = 3387632819576057527L; |
| |
| private View projectView; |
| private View globalConfigView; |
| private Class<? extends View> projectViewClass; |
| private Class<? extends View> mainViewClass; |
| private Class<? extends View> treeViewClass; |
| private Class<? extends View> propViewClass; |
| private Class<? extends View> globalViewClass; |
| |
| private HashMap<ViewState, BuildPanel> stateViews; |
| private ViewState activeState; |
| |
| public static final int MAIN_VIEW = 1; |
| |
| private static final int WIDTH = 1000; |
| private static final int HEIGHT = 700; |
| |
| private JSplitPane projectSplitPane; |
| |
| private boolean findSelectedInTab = false; |
| |
| public BuildPerspective() throws InstantiationException, |
| IllegalAccessException { |
| this(TreeProjectView.class, GraphView.class, DefaultTreeView.class, |
| DefaultPropView.class, GlobalConfigView.class); |
| } |
| |
| public BuildPerspective(Class<? extends View> projectViewClass, |
| Class<? extends View> mainViewClass, Class<? extends View> treeViewClass, |
| Class<? extends View> propViewClass, Class<? extends View> globalViewClass) |
| throws InstantiationException, IllegalAccessException { |
| super("Build"); |
| this.projectViewClass = projectViewClass; |
| this.mainViewClass = mainViewClass; |
| this.treeViewClass = treeViewClass; |
| this.propViewClass = propViewClass; |
| this.globalViewClass = globalViewClass; |
| this.stateViews = new HashMap<ViewState, BuildPanel>(); |
| this.projectView = this.createProjectView(); |
| this.projectView.setPreferredSize(new Dimension(WIDTH / 10, HEIGHT / 2)); |
| this.globalConfigView = this.createGlobalConfigView(); |
| this.globalConfigView |
| .setPreferredSize(new Dimension(WIDTH / 10, HEIGHT / 2)); |
| } |
| |
| public void reset() { |
| super.reset(); |
| this.activeState = null; |
| this.stateViews.clear(); |
| this.projectView = this.createProjectView(); |
| this.globalConfigView = this.createGlobalConfigView(); |
| } |
| |
| public void stateChangeNotify(ViewChange<?> change) { |
| if (change instanceof ViewChange.NEW_ACTIVE_STATE) { |
| this.activeState = ((ViewChange.NEW_ACTIVE_STATE) change).getObject(); |
| this.refresh(); |
| } else if (change instanceof ViewChange.REFRESH_VIEW) { |
| this.refresh(); |
| } else if (change instanceof ViewChange.STATE_NAME_CHANGE) { |
| ViewState state = ((ViewChange.STATE_NAME_CHANGE) change).getObject(); |
| this.refresh(); |
| } else if (change instanceof ViewChange.VIEW_MODEL) { |
| String modelId = ((ViewChange.VIEW_MODEL) change).getObject(); |
| for (ViewState state : this.stateViews.keySet()) { |
| for (ModelGraph graph : state.getGraphs()) { |
| ModelGraph found = graph.recursiveFindByModelId(modelId); |
| if (found != null && !found.getModel().isRef()) { |
| this.activeState = state; |
| this.activeState.setSelected(found); |
| break; |
| } |
| } |
| } |
| this.findSelectedInTab = true; |
| this.refresh(); |
| this.findSelectedInTab = false; |
| } |
| } |
| |
| @Override |
| public ViewState getActiveState() { |
| return this.activeState; |
| } |
| |
| public View getActiveView() { |
| if (this.getActiveState() != null) |
| return this.stateViews.get(this.getActiveState()).getActiveView(); |
| else |
| return null; |
| } |
| |
| @Override |
| public void handleAddState(final ViewState state) { |
| this.activeState = state; |
| BuildPanel buildPanel = new BuildPanel(state); |
| this.stateViews.put(state, buildPanel); |
| this.refresh(); |
| } |
| |
| @Override |
| public void handleRemoveState(ViewState state) { |
| this.stateViews.remove(state); |
| if (this.stateViews.size() > 0) |
| this.activeState = this.stateViews.keySet().iterator().next(); |
| else |
| this.activeState = null; |
| this.refresh(); |
| } |
| |
| @Override |
| public void refresh() { |
| this.save(); |
| this.removeAll(); |
| this.setLayout(new BorderLayout()); |
| JPanel panel = null; |
| if (this.activeState != null) { |
| BuildPanel buildPanel = this.stateViews.get(this.activeState); |
| buildPanel.refresh(); |
| panel = buildPanel; |
| } else { |
| panel = new JPanel(); |
| } |
| |
| if (this.projectView instanceof MultiStateView) |
| ((MultiStateView) this.projectView).refreshView(this.activeState, |
| this.getStates()); |
| else |
| this.projectView.refreshView(this.activeState); |
| |
| this.globalConfigView.refreshView(this.activeState); |
| |
| JPanel globalPanel = new JPanel(); |
| globalPanel.setLayout(new BorderLayout()); |
| globalPanel.add(this.projectView, BorderLayout.CENTER); |
| globalPanel.add(this.globalConfigView, BorderLayout.SOUTH); |
| |
| int dividerLocation = -1; |
| if (projectSplitPane != null) |
| dividerLocation = projectSplitPane.getDividerLocation(); |
| projectSplitPane = new JSplitPane(JSplitPane.HORIZONTAL_SPLIT, globalPanel, |
| panel); |
| if (dividerLocation != -1) |
| projectSplitPane.setDividerLocation(dividerLocation); |
| this.add(projectSplitPane, BorderLayout.CENTER); |
| |
| this.revalidate(); |
| |
| } |
| |
| private View createMainView(String name) { |
| try { |
| return this.mainViewClass.getConstructor(String.class).newInstance(name); |
| } catch (Exception e) { |
| e.printStackTrace(); |
| return null; |
| } |
| } |
| |
| private View createTreeView() { |
| try { |
| return this.treeViewClass.getConstructor(String.class).newInstance( |
| this.treeViewClass.getSimpleName()); |
| } catch (Exception e) { |
| e.printStackTrace(); |
| return null; |
| } |
| } |
| |
| private View createGlobalConfigView() { |
| try { |
| return this.globalViewClass.getConstructor(String.class).newInstance( |
| this.globalViewClass.getSimpleName()); |
| } catch (Exception e) { |
| e.printStackTrace(); |
| return null; |
| } |
| } |
| |
| private View createProjectView() { |
| try { |
| View view = this.projectViewClass.getConstructor(String.class) |
| .newInstance(this.projectViewClass.getSimpleName()); |
| view.registerListener(this); |
| return view; |
| } catch (Exception e) { |
| e.printStackTrace(); |
| return null; |
| } |
| } |
| |
| private View createPropView() { |
| try { |
| return this.propViewClass.getConstructor(String.class).newInstance( |
| this.propViewClass.getSimpleName()); |
| } catch (Exception e) { |
| e.printStackTrace(); |
| return null; |
| } |
| } |
| |
| private class BuildPanel extends JPanel implements ViewListener { |
| |
| private static final long serialVersionUID = -6120047959962567963L; |
| |
| private JTabbedPane tabbedPane; |
| private Map<View, ViewState> mainViews; |
| private View propView; |
| private View treeView; |
| |
| private View primaryMainView; |
| |
| private JPopupMenu closeTabPopup; |
| |
| private ViewState state; |
| |
| public BuildPanel(ViewState state) { |
| this.state = state; |
| |
| mainViews = new HashMap<View, ViewState>(); |
| |
| propView = createPropView(); |
| propView.registerListener(this); |
| |
| treeView = createTreeView(); |
| treeView.registerListener(this); |
| |
| tabbedPane = new JTabbedPane(); |
| |
| this.addMainView(createMainView(state.getFile().getName()), state); |
| |
| closeTabPopup = new JPopupMenu(); |
| JMenuItem closeItem = new JMenuItem("Close"); |
| closeItem.addActionListener(new ActionListener() { |
| |
| public void actionPerformed(ActionEvent e) { |
| View mainView = (View) BuildPanel.this.tabbedPane |
| .getSelectedComponent(); |
| BuildPanel.this.removeMainView(mainView); |
| } |
| |
| }); |
| closeTabPopup.add(closeItem); |
| |
| this.tabbedPane.addMouseListener(new MouseListener() { |
| |
| public void mouseClicked(MouseEvent e) { |
| if (e.getButton() == MouseEvent.BUTTON3 |
| && !BuildPanel.this.tabbedPane.getSelectedComponent().equals( |
| BuildPanel.this.primaryMainView)) { |
| closeTabPopup.show(BuildPanel.this.tabbedPane, e.getX(), e.getY()); |
| } |
| } |
| |
| public void mouseEntered(MouseEvent e) { |
| } |
| |
| public void mouseExited(MouseEvent e) { |
| } |
| |
| public void mousePressed(MouseEvent e) { |
| } |
| |
| public void mouseReleased(MouseEvent e) { |
| } |
| |
| }); |
| |
| this.tabbedPane.addChangeListener(new ChangeListener() { |
| |
| public void stateChanged(ChangeEvent e) { |
| View activeView = (View) BuildPanel.this.tabbedPane |
| .getSelectedComponent(); |
| activeView.notifyListeners(); |
| } |
| |
| }); |
| |
| treeView.setPreferredSize(new Dimension(WIDTH / 10, HEIGHT / 2)); |
| propView.setPreferredSize(new Dimension(WIDTH / 10, HEIGHT / 2)); |
| JSplitPane treePropPane = new JSplitPane(JSplitPane.VERTICAL_SPLIT, |
| treeView, propView); |
| treePropPane.setResizeWeight(.25); |
| tabbedPane.setPreferredSize(new Dimension(WIDTH, HEIGHT)); |
| JSplitPane mainSplitPane = new JSplitPane(JSplitPane.HORIZONTAL_SPLIT, |
| tabbedPane, treePropPane); |
| mainSplitPane.setResizeWeight(.75); |
| this.setLayout(new BorderLayout()); |
| this.add(mainSplitPane, BorderLayout.CENTER); |
| } |
| |
| public void addMainView(View mainView, ViewState state) { |
| if (this.mainViews.size() == 0) { |
| this.primaryMainView = mainView; |
| mainView.setPrimary(true); |
| } |
| this.mainViews.put(mainView, state); |
| this.tabbedPane.addTab(mainView.getName(), mainView); |
| this.tabbedPane.setSelectedComponent(mainView); |
| mainView.registerListener(this); |
| } |
| |
| public void removeMainView(View mainView) { |
| if (!this.primaryMainView.equals(mainView)) { |
| for (int i = 0; i < this.tabbedPane.getTabCount(); i++) { |
| if (mainView.getName().equals(this.tabbedPane.getTitleAt(i))) { |
| this.tabbedPane.removeTabAt(i); |
| this.mainViews.remove(mainView); |
| return; |
| } |
| } |
| } |
| } |
| |
| public View getActiveView() { |
| return (View) this.tabbedPane.getSelectedComponent(); |
| } |
| |
| public void refresh() { |
| if (this.getActiveView() != null) { |
| ViewState viewState = null; |
| if (this.state.getSelected() != null && findSelectedInTab) { |
| TOP: for (Entry<View, ViewState> entry : this.mainViews.entrySet()) { |
| for (ModelGraph graph : entry.getValue().getGraphs()) { |
| ModelGraph found = graph.recursiveFindByModelId(this.state |
| .getSelected().getModel().getModelId()); |
| if (found != null && !found.getModel().isRef()) { |
| viewState = entry.getValue(); |
| viewState.setSelected(found); |
| this.tabbedPane.setSelectedComponent(entry.getKey()); |
| break TOP; |
| } |
| } |
| } |
| } else { |
| viewState = this.mainViews.get(this.getActiveView()); |
| } |
| this.getActiveView().refreshView(viewState); |
| this.propView.refreshView(viewState); |
| this.treeView.refreshView(viewState); |
| } |
| this.revalidate(); |
| } |
| |
| public void stateChangeNotify(ViewChange<?> change) { |
| if (change instanceof ViewChange.NEW_VIEW) { |
| this.addMainView( |
| createMainView(((ViewChange.NEW_VIEW) change).getObject() |
| .getModel().getModelId()), |
| new ViewState(this.state.getFile(), null, Collections |
| .singletonList(GuiUtils.find(this.state.getGraphs(), |
| ((ViewChange.NEW_VIEW) change).getObject().getModel() |
| .getId())), this.state.getGlobalConfigGroups())); |
| this.refresh(); |
| } |
| BuildPerspective.this.stateChangeNotify(change); |
| } |
| |
| } |
| |
| } |