BioInfWeb - JPhyloIO / Source code / Show File - Application.java

JPhyloIO subversion repository

sventon subversion web client - http://www.sventon.org
[show recent changes]
 
  Help
Rev: HEAD (1550) - https://secure.bioinfweb.info/Code/svn/JPhyloIO / trunk / demo / info.bioinfweb.jphyloio.demo.tree / src / info / bioinfweb / jphyloio / demo / tree / Application.java
Show File - Application.java  [show properties]
spinner
/*
 * JPhyloIO - Event based parsing and stream writing of multiple sequence alignment and tree formats. 
 * Copyright (C) 2015-2016  Ben Stöver, Sarah Wiechers
 * <http://bioinfweb.info/JPhyloIO>
 * 
 * This file is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
10   * 
11   * This file is distributed in the hope that it will be useful,
12   * but WITHOUT ANY WARRANTY; without even the implied warranty of
13   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14   * GNU Lesser General Public License for more details.
15   * 
16   * You should have received a copy of the GNU Lesser General Public License
17   * along with this program. If not, see <http://www.gnu.org/licenses/>.
18   */
19  package info.bioinfweb.jphyloio.demo.tree;
20 
21 
22  import info.bioinfweb.commons.appversion.ApplicationType;
23  import info.bioinfweb.commons.appversion.ApplicationVersion;
24  import info.bioinfweb.commons.io.ContentExtensionFileFilter;
25  import info.bioinfweb.commons.io.ContentExtensionFileFilter.TestStrategy;
26  import info.bioinfweb.commons.io.ExtensionFileFilter;
27  import info.bioinfweb.jphyloio.JPhyloIOEventReader;
28  import info.bioinfweb.jphyloio.JPhyloIOEventWriter;
29  import info.bioinfweb.jphyloio.JPhyloIOFormatSpecificObject;
30  import info.bioinfweb.jphyloio.ReadWriteParameterMap;
31  import info.bioinfweb.jphyloio.ReadWriteParameterNames;
32  import info.bioinfweb.jphyloio.dataadapters.implementations.ListBasedDocumentDataAdapter;
33  import info.bioinfweb.jphyloio.dataadapters.implementations.store.StoreTreeNetworkGroupDataAdapter;
34  import info.bioinfweb.jphyloio.events.LinkedLabeledIDEvent;
35  import info.bioinfweb.jphyloio.events.type.EventContentType;
36  import info.bioinfweb.jphyloio.factory.JPhyloIOContentExtensionFileFilter;
37  import info.bioinfweb.jphyloio.factory.JPhyloIOReaderWriterFactory;
38  import info.bioinfweb.jphyloio.formatinfo.JPhyloIOFormatInfo;
39 
40  import java.awt.BorderLayout;
41  import java.awt.Desktop;
42  import java.awt.EventQueue;
43  import java.awt.event.ActionEvent;
44  import java.awt.event.ActionListener;
45  import java.io.File;
46  import java.io.IOException;
47  import java.net.URI;
48  import java.util.ArrayList;
49  import java.util.List;
50 
51  import javax.swing.JFileChooser;
52  import javax.swing.JFrame;
53  import javax.swing.JMenu;
54  import javax.swing.JMenuBar;
55  import javax.swing.JMenuItem;
56  import javax.swing.JOptionPane;
57  import javax.swing.JScrollPane;
58  import javax.swing.JTree;
59  import javax.swing.UIManager;
60  import javax.swing.filechooser.FileFilter;
61  import javax.swing.tree.DefaultTreeModel;
62 
63  import org.apache.commons.collections4.set.ListOrderedSet;
64 
65 
66 
67  public class Application {
68      protected JFrame mainFrame;
69      protected JTree tree;
70      private JFileChooser fileChooser;
71      private List<FileFilter> readingFilters = new ArrayList<FileFilter>();
72      private List<FileFilter> writingFilters = new ArrayList<FileFilter>();
73      
74      protected JPhyloIOReaderWriterFactory factory = new JPhyloIOReaderWriterFactory();
75 
76      
77      /**
78       * Launch the application.
79       */
80      public static void main(String[] args) {
81          try {
82              UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
83          }
84          catch (Exception e) {
85              e.printStackTrace();
86          }
87          
88          EventQueue.invokeLater(new Runnable() {
89              public void run() {
90                  try {
91                      Application window = new Application();
92                      window.mainFrame.setVisible(true);
93                  } 
94                  catch (Exception e) {
95                      e.printStackTrace();
96                  }
97              }
98          });
99      }
100      
101      
102      /**
103       * Create the application.
104       */
105      public Application() {
106          initialize();  // Create GUI components.
107      }
108      
109      
110      public String getName() {
111          return "JPhyloIO tree demo application";
112      }
113      
114      
115      public ApplicationVersion getVersion() {
116          return new ApplicationVersion(1, 1, 0, 1368, ApplicationType.BETA);
117      }
118      
119      
120      public String getApplicationURL() {
121          return "http://r.bioinfweb.info/JPhyloIODemoTree";
122      }
123      
124      
125      protected void readTree(String formatID, File file) throws Exception {
126          ReadWriteParameterMap parameters = new ReadWriteParameterMap();
127          parameters.put(ReadWriteParameterNames.KEY_USE_OTU_LABEL, true);  
128                  // Use OTU labels as node labels if no node label is present.
129          parameters.put(ReadWriteParameterNames.KEY_PHYLOXML_CONSIDER_PHYLOGENY_AS_TREE, true);
130                  // This parameter defines if cross links between nodes (defined by the clade_relation tag of PhyloXML) should be
131                  // modeled as metadata attached to a node or if the whole phylogeny shall be interpreted as a phylogenetic network.
132                  // Since the network interpretation is the default, we need to set this parameter in order to receive tree events
133                  // and not network events.
134          
135          JPhyloIOEventReader eventReader = factory.getReader(formatID, file, parameters);  // Create JPhyloIO reader instance for the determined format.
136          try {
137              new TreeReader().read(eventReader, getTreeModel());  // Read tree into the data model of this application.
138          }
139          finally {
140              eventReader.close();
141          }
142      }
143      
144      
145      protected void writeTree(String formatID, File file) {
146          // Create data adapters:
147          ListBasedDocumentDataAdapter document = new ListBasedDocumentDataAdapter();
148          StoreTreeNetworkGroupDataAdapter treeGroup = new StoreTreeNetworkGroupDataAdapter(
149                  new LinkedLabeledIDEvent(EventContentType.TREE_NETWORK_GROUP, "treeGroup", null, null), null);
150          document.getTreeNetworkGroups().add(treeGroup);
151          treeGroup.getTreesAndNetworks().add(new TreeNetworkDataAdapterImpl(getTreeModel()));
152          
153          // Define writer parameters:
154          ReadWriteParameterMap parameters = new ReadWriteParameterMap();
155          parameters.put(ReadWriteParameterNames.KEY_APPLICATION_NAME, getName());
156          parameters.put(ReadWriteParameterNames.KEY_APPLICATION_VERSION, getVersion());
157          parameters.put(ReadWriteParameterNames.KEY_APPLICATION_URL, getApplicationURL());
158          
159          // Write document:
160          JPhyloIOEventWriter writer = factory.getWriter(formatID);
161          try {
162              writer.writeDocument(document, file, parameters);
163          }
164          catch (IOException ex) {
165              ex.printStackTrace();
166              JOptionPane.showMessageDialog(mainFrame, "The error \"" + ex.getLocalizedMessage() + "\" occurred.", 
167                      "Error", JOptionPane.ERROR_MESSAGE);
168          }
169      }
170      
171      
172      /**
173       * Initialize the contents of the frame.
174       */
175      protected void initialize() {
176          mainFrame = new JFrame();
177          mainFrame.setTitle(getName());
178          mainFrame.setBounds(100, 100, 600, 400);
179          mainFrame.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
180          
181          tree = new JTree(new DefaultTreeModel(null));
182          JScrollPane scrollPane = new JScrollPane(tree);
183          mainFrame.getContentPane().add(scrollPane, BorderLayout.CENTER);
184          mainFrame.setJMenuBar(createMenuBar());
185      }
186      
187      
188      private void setFileFilters(List<FileFilter> filters) {
189          getFileChooser().resetChoosableFileFilters();
190          for (FileFilter filter : filters) {
191              getFileChooser().addChoosableFileFilter(filter);
192          }
193      }
194      
195      
196      private JMenuBar createMenuBar() {
197          JMenuBar menuBar = new JMenuBar();
198          
199          JMenu mnFile = new JMenu("File");
200          menuBar.add(mnFile);
201          
202          JMenuItem mntmOpen = new JMenuItem("Open...");
203          mntmOpen.addActionListener(new ActionListener() {
204              public void actionPerformed(ActionEvent e) {
205                  try {
206                      setFileFilters(readingFilters);
207                      if (getFileChooser().showOpenDialog(mainFrame) == JFileChooser.APPROVE_OPTION) {
208                          String formatID;
209                          if (getFileChooser().getFileFilter() instanceof JPhyloIOFormatSpecificObject) {
210                              formatID = ((JPhyloIOFormatSpecificObject)getFileChooser().getFileFilter()).getFormatID();  // Use the user defined format.
211                          }
212                          else {  // In this case the "All supported formats" filter was used and the format needs to be guessed.
213                              formatID = factory.guessFormat(getFileChooser().getSelectedFile());  // Guess the format, since the user did not explicitly specify one.
214                          }
215                          
216                          if (formatID != null) {
217                              readTree(formatID, getFileChooser().getSelectedFile());
218                          }
219                          else {  // If the format had to be guessed and none was found.
220                              JOptionPane.showMessageDialog(mainFrame, "The format of the file \"" + getFileChooser().getSelectedFile() + 
221                                      "\" is not supported.", "Unsupported format", JOptionPane.ERROR_MESSAGE);
222                          }
223                      }
224                  }
225                  catch (Exception ex) {  // If an error occurred while trying to load a tree.
226                      ex.printStackTrace();
227                      JOptionPane.showMessageDialog(mainFrame, "The error \"" + ex.getLocalizedMessage() + "\" occurred.", 
228                              "Error", JOptionPane.ERROR_MESSAGE);
229                  }
230              }
231          });
232          mnFile.add(mntmOpen);
233          
234          JMenuItem mntmSaveAs = new JMenuItem("Save as...");
235          mntmSaveAs.addActionListener(new ActionListener() {
236              public void actionPerformed(ActionEvent e) {
237                  setFileFilters(writingFilters);
238                  if (getFileChooser().showSaveDialog(mainFrame) == JFileChooser.APPROVE_OPTION) {
239                      writeTree(((JPhyloIOFormatSpecificObject)getFileChooser().getFileFilter()).getFormatID(), getFileChooser().getSelectedFile());
240                  }
241              }
242          });
243          mnFile.add(mntmSaveAs);
244          
245          JMenuItem mntmExit = new JMenuItem("Exit");
246          mntmExit.addActionListener(new ActionListener() {
247              public void actionPerformed(ActionEvent e) {
248                  mainFrame.setVisible(false);
249                  System.exit(0);
250              }
251          });
252          mnFile.add(mntmExit);
253          
254          JMenu mnHelp = new JMenu("Help");
255          menuBar.add(mnHelp);
256          
257          JMenuItem mntmAbout = new JMenuItem("About");
258          mntmAbout.addActionListener(new ActionListener() {
259              public void actionPerformed(ActionEvent e) {
260                  try {
261                      Desktop.getDesktop().browse(new URI(getApplicationURL()));
262                  }
263                  catch (Exception ex) {
264                      ex.printStackTrace();
265                  }
266              }
267          });
268          mnHelp.add(mntmAbout);
269          
270          return menuBar;
271      }
272      
273      
274      private JTree getTree() {
275          return tree;
276      }
277      
278      
279      protected DefaultTreeModel getTreeModel() {
280          return (DefaultTreeModel)getTree().getModel();
281      }
282      
283      
284      /**
285       * Returns a file chooser with file filters for all tree formats supported by <i>JPhyloIO</i> and a filter filter
286       * accepting valid extensions of all tree formats.
287       * <p>
288       * The goal of this dialog is on the one hand to filter all supported tree files using the "All supported formats" 
289       * filter. {@link JPhyloIOReaderWriterFactory#guessReader(File, ReadWriteParameterMap)} will be used to determine
290       * an appropriate reader for files selected this way later. On the other hand, single filters for all supported
291       * formats are offered, so the user can manually define the format of a file. In that case the format will not be
292       * guessed but directly determined using {@link JPhyloIOContentExtensionFileFilter#getFormatID()}.
293       * 
294       * @return the file chooser instance for opening files in this application
295       */
296      private JFileChooser getFileChooser() {
297          if (fileChooser == null) {  // if fileChooser was not initialized yet
298              // Create file chooser:
299              fileChooser = new JFileChooser();
300              fileChooser.setMultiSelectionEnabled(false);  // Do not allow to select more than one file.
301              fileChooser.setAcceptAllFileFilterUsed(false);  // Do not include predefined "All files (*.*)" filter, since we will create a special filter later.
302              
303              // Add file filters for supported formats and collect extensions for "All supported formats" filter:
304              ListOrderedSet<String> validExtensions = new ListOrderedSet<String>();  // This set is used to collect valid extensions of all formats to create the "All supported formats" filter later.
305              for (String formatID : factory.getFormatIDsSet()) {
306                  JPhyloIOFormatInfo info = factory.getFormatInfo(formatID);
307                  ContentExtensionFileFilter filter = info.createFileFilter(TestStrategy.CONTENT);  // Create a filter filter instance for the current format.
308                  if (info.isElementModeled(EventContentType.TREE, true)) {  // Check if the current format can contain trees and can be read.
309                      validExtensions.addAll(filter.getExtensions());  // Add the file extensions of this filter to the set of all supported extensions.
310                      readingFilters.add(filter);
311                  }
312                  if (info.isElementModeled(EventContentType.TREE, false)) {  // The same for writing. (Not all formats in JPhyloIO can be read and written.)
313                      writingFilters.add(filter);
314                  }
315              }
316              
317              // Add "All supported formats" filter:
318              readingFilters.add(0, new ExtensionFileFilter("All supported formats", false, validExtensions.asList()));
319                      // Create a file filter accepting extensions of all supported formats at the same time. 
320          }
321          return fileChooser;
322      }
323  }


feed icon

sventon 2.5.1

Valid XHTML 1.0 Strict   CSS ist valide!
JPhyloIO icon
bioinfweb RSS feed JPhyloIO on ResearchGate bioinfweb on twitter JPhyloIO on GitHub

JPhyloIO poster ECCB 2016 Conference poster at ECCB Sep 2016

bioinfweb - Biology & Informatics Website