VertexViewPanel.java

Go to the documentation of this file.

/*
 *   DENOPTIM
 *   Copyright (C) 2020 Marco Foscato <marco.foscato@uib.no>
 *
 *   This program is free software: you can redistribute it and/or modify
 *   it under the terms of the GNU Affero General Public License as published
 *   by the Free Software Foundation, either version 3 of the License, or
 *   (at your option) any later version.
 *
 *   This program is distributed in the hope that it will be useful,
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *   GNU Affero General Public License for more details.
 *
 *   You should have received a copy of the GNU Affero General Public License
 *   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
package denoptim.gui;
 
 
import java.awt.BorderLayout;
import java.awt.CardLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.beans.PropertyChangeEvent;
import java.beans.PropertyChangeListener;
import java.util.ArrayList;
import java.util.Map;
 
import javax.swing.JButton;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.table.DefaultTableModel;
 
import org.openscience.cdk.interfaces.IAtom;
import org.openscience.cdk.interfaces.IAtomContainer;
 
import denoptim.exception.DENOPTIMException;
import denoptim.graph.AttachmentPoint;
import denoptim.graph.EmptyVertex;
import denoptim.graph.Fragment;
import denoptim.graph.Template;
import denoptim.graph.Vertex;
 
 
public class VertexViewPanel extends JPanel
{
    private static final long serialVersionUID = 1L;
    
    private Vertex vertex;
    
    public boolean alteredAPData = false;
    
    private JPanel titlePanel;
    
    private JLabel labTitle;
    private JButton btnSwitchToNodeViewer;
    private JButton btnSwitchToMolViewer;
    private JButton btnSwitchTo2DViewer;
    
    private JPanel centralPanel;
    
    private JPanel emptyViewerCard;
    private FragmentViewPanel fragViewer;
    private VertexAsGraphViewPanel graphNodeViewer;
    private VertexAsTwoDimStructureViewPanel twoDimViewer;
    private IVertexAPSelection activeViewer;
    protected final String EMPTYCARDNAME = "emptyCard";
    protected final String GRAPHVIEWERCARDNAME = "emptyVertesCard";
    protected final String MOLVIEWERCARDNAME = "fragViewerCard";
    protected final String TWODVIEWERCARDNAME = "twoDimViewerCard";
        
    private boolean editableAPTable = false;
    
    private boolean switchbleByVertexType = true;
    
//-----------------------------------------------------------------------------
 
    public VertexViewPanel(boolean editableTable)
    {
        super(new BorderLayout());
        this.editableAPTable = editableTable;
        initialize();
    }
    
//-----------------------------------------------------------------------------
 
    private void initialize()
    {
        centralPanel = new JPanel(new CardLayout());
        this.add(centralPanel, BorderLayout.CENTER);
        
        titlePanel = new JPanel();
                
        labTitle = new JLabel("");
        titlePanel.add(labTitle);
        
        btnSwitchToNodeViewer = new JButton("Node View");
        btnSwitchToNodeViewer.setToolTipText("Switch to graph node depiction "
                + "of this vertex.");
        btnSwitchToNodeViewer.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent e) {
                switchToGraphNodeViewer();
            }
        });
        btnSwitchToNodeViewer.setEnabled(false);
        titlePanel.add(btnSwitchToNodeViewer);
        
        btnSwitchToMolViewer = new JButton("3D Molecule View");
        btnSwitchToMolViewer.setToolTipText("Switch to 3D molecular depiction "
                + "of this vertex.");
        btnSwitchToMolViewer.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent e) {
                switchToMolecularViewer();
            }
        });
        btnSwitchToMolViewer.setEnabled(false);
        titlePanel.add(btnSwitchToMolViewer);
        
        btnSwitchTo2DViewer = new JButton("2D Molecular Structure");
        btnSwitchTo2DViewer.setToolTipText("Switch to 2D molecular depiction "
                + "of this vertex.");
        btnSwitchTo2DViewer.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent e) {
                switchTo2DViewer();
            }
        });
        btnSwitchTo2DViewer.setEnabled(false);
        titlePanel.add(btnSwitchTo2DViewer);
        
        this.add(titlePanel, BorderLayout.NORTH);
        
        emptyViewerCard = new JPanel();
        emptyViewerCard.setToolTipText("Vertices are displayed here.");
        centralPanel.add(emptyViewerCard, EMPTYCARDNAME);
        
        graphNodeViewer = new VertexAsGraphViewPanel(editableAPTable,300);
        graphNodeViewer.addPropertyChangeListener(
                IVertexAPSelection.APDATACHANGEEVENT, 
                new PropertyChangeListener() {
            @Override
            public void propertyChange(PropertyChangeEvent evt) {
                alteredAPData = true;
                firePropertyChange(IVertexAPSelection.APDATACHANGEEVENT, false, 
                        true);          
            }
        });
        centralPanel.add(graphNodeViewer, GRAPHVIEWERCARDNAME);
            
        fragViewer = new FragmentViewPanel(editableAPTable);
        fragViewer.addPropertyChangeListener(
                IVertexAPSelection.APDATACHANGEEVENT, 
                new PropertyChangeListener() {
            @Override
            public void propertyChange(PropertyChangeEvent evt) {
                alteredAPData = true;
                firePropertyChange(IVertexAPSelection.APDATACHANGEEVENT, false, 
                        true);          
            }
        });
        centralPanel.add(fragViewer, MOLVIEWERCARDNAME);
        
        twoDimViewer = new VertexAsTwoDimStructureViewPanel(editableAPTable);
        twoDimViewer.addPropertyChangeListener(
                IVertexAPSelection.APDATACHANGEEVENT, 
                new PropertyChangeListener() {
            @Override
            public void propertyChange(PropertyChangeEvent evt) {
                alteredAPData = true;
                firePropertyChange(IVertexAPSelection.APDATACHANGEEVENT, false, 
                        true);          
            }
        });
        centralPanel.add(twoDimViewer, TWODVIEWERCARDNAME);
        
        
        switchToEmptyCard();
    }
    
//-----------------------------------------------------------------------------
    
    public boolean hasUnsavedAPEdits()
    {
        return alteredAPData;
    }
    
//-----------------------------------------------------------------------------
    
    public void deprotectEdits()
    {
        fragViewer.deprotectEdits();
        graphNodeViewer.deprotectEdits();
        alteredAPData = false;
    }
    
//-----------------------------------------------------------------------------
    
    public void setSwitchable(boolean switchable)
    {
        if (switchbleByVertexType)
        {
            if (switchable)
            {
                btnSwitchToMolViewer.setEnabled(true);
                btnSwitchToNodeViewer.setEnabled(true);
                btnSwitchTo2DViewer.setEnabled(true);
            } else {
                btnSwitchToMolViewer.setEnabled(false);
                btnSwitchToNodeViewer.setEnabled(false);
                btnSwitchTo2DViewer.setEnabled(false);
            }
        }
    }
    
//-----------------------------------------------------------------------------
    
    private void switchToEmptyCard()
    {
        btnSwitchToMolViewer.setEnabled(false);
        btnSwitchToNodeViewer.setEnabled(false);
        btnSwitchTo2DViewer.setEnabled(false);
        ((CardLayout) centralPanel.getLayout()).show(centralPanel, 
                EMPTYCARDNAME);
        activeViewer = null;
    }
    
//-----------------------------------------------------------------------------
    
    private void switchToGraphNodeViewer()
    {
        ((CardLayout) centralPanel.getLayout()).show(centralPanel, 
                GRAPHVIEWERCARDNAME);
        activeViewer = graphNodeViewer;
    }
    
//-----------------------------------------------------------------------------
    
    private void switchToMolecularViewer()
    {
        ((CardLayout) centralPanel.getLayout()).show(centralPanel, 
                MOLVIEWERCARDNAME);
        activeViewer = fragViewer;
    }
    
//-----------------------------------------------------------------------------
    
    private void switchTo2DViewer()
    {
        ((CardLayout) centralPanel.getLayout()).show(centralPanel, 
                TWODVIEWERCARDNAME);
        activeViewer = twoDimViewer;
    }
    
//-----------------------------------------------------------------------------
    
    public boolean loadSMILES(String smiles)
    {   
        switchToMolecularViewer();
        return fragViewer.loadSMILES(smiles);
    }
 
//-----------------------------------------------------------------------------
    
    public Vertex getLoadedStructure()
    {
        Vertex v = null;
        if (vertex == null || vertex instanceof Fragment)
        {
            v = fragViewer.getLoadedStructure();
            switchToMolecularViewer();
        } else {
            v = vertex;
        }
        return v;
    }
 
//-----------------------------------------------------------------------------
    
    public void loadPlainStructure(IAtomContainer mol)
    {
        fragViewer.loadPlainStructure(mol);
        switchToMolecularViewer();
    }
 
//-----------------------------------------------------------------------------
    
    public void loadVertexToViewer(Vertex v)
    {
        vertex = v;
        if (v instanceof Fragment) {
            labTitle.setText("Fragment");
            Fragment frag = (Fragment) v;
            loadFragmentToViewer(frag);
        } else if (v instanceof EmptyVertex) {
            labTitle.setText("EmptyVertex");
            EmptyVertex ev = (EmptyVertex) v;
            loadEmptyVertexToViewer(ev);
        } else if (v instanceof Template) {
            labTitle.setText("Template");
            Template tmpl = (Template) v;
            loadTemplateToViewer(tmpl);
        } else {
            System.err.println("Loading empty card as a result of vertex with " 
                    + "type " + v.getClass().getName());
            switchToEmptyCard();
        }
    }
 
//-----------------------------------------------------------------------------
    
    private void loadEmptyVertexToViewer(EmptyVertex ev)
    {
        btnSwitchToMolViewer.setEnabled(false);
        btnSwitchToNodeViewer.setEnabled(false);
        btnSwitchTo2DViewer.setEnabled(false);
        graphNodeViewer.loadVertexToViewer(ev);
        switchToGraphNodeViewer();
        switchbleByVertexType = false;
    }
    
//-----------------------------------------------------------------------------
    
    private void loadFragmentToViewer(Fragment frag)
    {
        btnSwitchToMolViewer.setEnabled(true);
        btnSwitchToNodeViewer.setEnabled(true);
        btnSwitchTo2DViewer.setEnabled(true);
        fragViewer.loadFragmentToViewer(frag);
        graphNodeViewer.loadVertexToViewer(frag);
        twoDimViewer.loadVertexToViewer(frag);
        switchbleByVertexType = true;
        if (frag.is3D())
        {
            switchToMolecularViewer();
        } else {
            switchTo2DViewer();
        }
    }
 
//-----------------------------------------------------------------------------
    
    private void loadTemplateToViewer(Template tmpl)
    {       
        if (tmpl.containsAtoms())
        {
            Fragment frag;
            try
            {
                frag = new Fragment(tmpl.getVertexId(), 
                        tmpl.getIAtomContainer(), tmpl.getBuildingBlockType());
 
                loadFragmentToViewer(frag);
                btnSwitchToMolViewer.setEnabled(true);
                btnSwitchToNodeViewer.setEnabled(true);
                //TODO: maybe one day we'll enable looking at the 2D of the whole template
                btnSwitchTo2DViewer.setEnabled(false);
                switchbleByVertexType = true;
            } catch (DENOPTIMException e)
            {
                // We lease data in the viewer to increase speed of execution, but the
                // leftover is outdated! This is the meaning of 'true'
                fragViewer.clearAll(true);
                switchbleByVertexType = false;
            }
        } else {
            // We lease data in the viewer to increase speed of execution, but the
            // leftover is outdated! This is the meaning of 'true'
            fragViewer.clearAll(true);
            switchbleByVertexType = false;
        }
        graphNodeViewer.loadVertexToViewer(tmpl);
        switchToGraphNodeViewer();
        graphNodeViewer.setVertexSpecificEditableAPTable(false);
    }
    
//-----------------------------------------------------------------------------
 
    public void clearCurrentSystem()
    {
        vertex = null;
        graphNodeViewer.mapAPs = null;
        graphNodeViewer.clearAPTable();
        fragViewer.mapAPs = null;
        fragViewer.clearAPTable();
        switchToEmptyCard();
        // NB: avoid it very slow! Mol viewer gets update upon loading a new mol
        // clearMolecularViewer();
    }
    
//-----------------------------------------------------------------------------
    
    public void clearMolecularViewer(boolean dataIsComing)
    {
        fragViewer.clearMolecularViewer(dataIsComing);
    }
    
//-----------------------------------------------------------------------------
    
    public Map<Integer,AttachmentPoint> getActiveMapAPs()
    {
        return activeViewer.getMapOfAPsInTable();
    }
    
//-----------------------------------------------------------------------------
 
    public DefaultTableModel getAPTableModel()
    {
        return activeViewer.getAPTableModel();
    }
    
//-----------------------------------------------------------------------------
 
    public ArrayList<Integer> getSelectedAPIDs()
    {
        return activeViewer.getSelectedAPIDs();
    }
    
//-----------------------------------------------------------------------------
    
    protected ArrayList<IAtom> getAtomsSelectedFromJMol()
    {
        return fragViewer.getAtomsSelectedFromJMol();
    }
    
//-----------------------------------------------------------------------------
 
    protected void activateTabEditsListener(boolean var)
    {
        fragViewer.activateTabEditsListener(var);
    }
 
//-----------------------------------------------------------------------------
    
    /*
     * This is needed to stop Jmol threads
     */
    protected void dispose() 
    {
        fragViewer.dispose();
    }
    
//-----------------------------------------------------------------------------
 
}