JAL-3563 Bamboo testing
[jalview.git] / unused / JalviewJS.java
1 package jalview.bin;
2
3 import jalview.analysis.AlignmentUtils;
4 import jalview.datamodel.AlignmentI;
5 import jalview.gui.AlignFrame;
6 import jalview.gui.SplitFrame;
7 import jalview.io.DataSourceType;
8 import jalview.io.FileFormatException;
9 import jalview.io.FileFormatI;
10 import jalview.io.FileLoader;
11 import jalview.io.IdentifyFile;
12 import jalview.structure.StructureSelectionManager;
13
14 import java.util.ArrayList;
15 import java.util.HashMap;
16 import java.util.List;
17 import java.util.Map;
18
19 import javax.swing.JFrame;
20 import javax.swing.JInternalFrame;
21
22 /**
23  * 
24  * early work -- deprecated
25  * 
26  * Entry point for Jalview as Javascript. Expects parameter names as for the
27  * JalviewLite applet, formatted as for the Jalview application, for example
28  * 
29  * <pre>
30  *   JalviewJS file /examples/uniref50.fa features /examples/exampleFeatures.txt \
31  *       PDBFile "/examples/pdb1.txt seq1"
32  * </pre>
33  * 
34  * Note that (unlike the applet) parameter names are case sensitive
35  */
36 // TODO or format as file=/examples/uniref50.fa (etc)?
37 public class JalviewJS
38 {
39
40   static
41   {
42     /**
43      * @j2sNative
44      * 
45      *            thisApplet.__Info.args =
46      *            ["file","examples/uniref50.fa","features",
47      *            "examples/exampleFeatures.txt",
48      *            "props","/Users/gmcarstairs/.jalview_properties"];
49      */
50
51   }
52
53   private static final String PARAM_FILE = "file";
54
55   private static final String PARAM_FILE2 = "file2";
56
57   private static final String PARAM_TREE = "tree";
58
59   private static final String PARAM_FEATURES = "features";
60
61   private static final String PARAM_ANNOTATIONS = "annotations";
62
63   private static final String PARAM_SHOW_ANNOTATION = "showAnnotation";
64
65   private static final String PARAM_PDBFILE = "PDBFile";
66
67   private static final String PARAM_PROPS = "props";
68
69   private Map<String, String> params;
70
71   private List<String> pdbFileParams;
72
73   public static void main(String[] args) throws Exception
74   {
75     new JalviewJS().doMain(args);
76   }
77
78   /**
79    * Parses parameters and shows the frame and any loaded panels
80    * 
81    * @throws FileFormatException
82    */
83   void doMain(String[] args) throws FileFormatException
84   {
85     loadParameters(args);
86     if (getParameter(PARAM_FILE) == null)
87     {
88       usage();
89     }
90     else
91     {
92       showFrame();
93     }
94   }
95
96   /**
97    * Answers the value of the given runtime parameter, or null if not provided
98    * 
99    * @param paramName
100    * @return
101    */
102   private String getParameter(String paramName)
103   {
104     return params.get(paramName);
105   }
106
107   /**
108    * Prints a chastising, yet helpful, error message on syserr
109    */
110   private void usage()
111   {
112     System.err.println(
113             "Usage: JalviewJS file <alignmentFile> [features <featuresFile>]");
114     System.err.println("See documentation for full parameter list");
115   }
116
117   /**
118    * Parses any supplied parameters. Note that (unlike for the applet),
119    * parameter names are case sensitive.
120    * 
121    * @param args
122    * 
123    * @see http://www.jalview.org/examples/index.html#appletParameters
124    */
125   void loadParameters(String[] args)
126   {
127     ArgsParser parser = new ArgsParser(args);
128     params = new HashMap<>();
129
130     // TODO javascript-friendly source of properties
131     Cache.loadProperties(parser.getValue(PARAM_PROPS));
132     loadParameter(parser, PARAM_FILE);
133     loadParameter(parser, PARAM_FILE2);
134     loadParameter(parser, PARAM_TREE);
135     loadParameter(parser, PARAM_FEATURES);
136     loadParameter(parser, PARAM_ANNOTATIONS);
137     loadParameter(parser, PARAM_SHOW_ANNOTATION);
138     pdbFileParams = loadPdbParameters(parser);
139   }
140
141   /**
142    * Reads one command line parameter value and saves it against the parameter
143    * name. Note the saved value is null if the parameter is not present.
144    * 
145    * @param parser
146    * @param param
147    */
148   protected void loadParameter(ArgsParser parser, String param)
149   {
150     params.put(param, parser.getValue(param));
151   }
152
153   /**
154    * Reads parameter PDBFile, PDBFile1, PDFile2, ... and saves the value(s) (if
155    * any)
156    * 
157    * @param parser
158    * @return
159    */
160   List<String> loadPdbParameters(ArgsParser parser)
161   {
162     List<String> values = new ArrayList<>();
163     String value = parser.getValue(PARAM_PDBFILE);
164     if (value != null)
165     {
166       values.add(value);
167     }
168     int i = 1;
169     while (true)
170     {
171       value = parser.getValue(PARAM_PDBFILE + String.valueOf(i));
172       if (value != null)
173       {
174         values.add(value);
175       }
176       else
177       {
178         break;
179       }
180     }
181     return values;
182   }
183
184   /**
185    * Constructs and displays a JFrame containing an alignment panel (and any
186    * additional panels depending on parameters supplied)
187    * 
188    * @throws FileFormatException
189    */
190   void showFrame() throws FileFormatException
191   {
192     JFrame frame = new JFrame(getParameter(PARAM_FILE));
193     frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
194
195     /*
196      * construct an AlignFrame (optionally with features)
197      */
198     AlignFrame alignFrame = createAlignFrame(PARAM_FILE);
199     loadFeatures(alignFrame, getParameter(PARAM_FEATURES));
200
201     JInternalFrame internalFrame = alignFrame;
202
203     /*
204      * convert to SplitFrame if a valid file2 is supplied
205      */
206     AlignFrame alignFrame2 = createAlignFrame(PARAM_FILE2);
207     if (alignFrame2 != null)
208     {
209       SplitFrame splitFrame = loadSplitFrame(alignFrame, alignFrame2);
210       if (splitFrame != null)
211       {
212         internalFrame = splitFrame;
213       }
214     }
215
216     /*
217      * move AlignFrame (or SplitFrame) menu bar and content pane to our frame
218      * TODO there may be a less obscure way to do this
219      */
220     frame.setContentPane(internalFrame.getContentPane());
221     frame.setJMenuBar(internalFrame.getJMenuBar());
222
223     // fudge so that dialogs can be opened with this frame as parent
224     // todo JAL-3031 also override Desktop.addInternalFrame etc
225     // Desktop.parent = frame.getContentPane();
226
227     frame.pack();
228     frame.setSize(AlignFrame.DEFAULT_WIDTH, AlignFrame.DEFAULT_HEIGHT);
229     frame.setVisible(true);
230   }
231
232   /**
233    * Constructs a SplitFrame if cdna-protein mappings can be made between the
234    * given alignment frames, else returns null. Any mappings made are registered
235    * with StructureSelectionManager to enable broadcast to listeners.
236    * 
237    * @param alignFrame
238    * @param alignFrame2
239    * @return
240    */
241   protected SplitFrame loadSplitFrame(AlignFrame alignFrame,
242           AlignFrame alignFrame2)
243   {
244     // code borrowed from AlignViewport.openLinkedAlignment
245     AlignmentI al1 = alignFrame.getViewport().getAlignment();
246     AlignmentI al2 = alignFrame2.getViewport().getAlignment();
247     boolean al1Nuc = al1.isNucleotide();
248     if (al1Nuc == al2.isNucleotide())
249     {
250       System.err.println("Can't make split frame as alignments are both "
251               + (al1Nuc ? "nucleotide" : "protein"));
252       return null;
253     }
254     AlignmentI protein = al1Nuc ? al2 : al1;
255     AlignmentI cdna = al1Nuc ? al1 : al2;
256     boolean mapped = AlignmentUtils.mapProteinAlignmentToCdna(protein,
257             cdna);
258     if (!mapped)
259     {
260       System.err.println("Can't make any mappings for split frame");
261       return null;
262     }
263
264     /*
265      * register sequence mappings
266      */
267     StructureSelectionManager ssm = StructureSelectionManager
268             .getStructureSelectionManager(null);
269     ssm.registerMappings(protein.getCodonFrames());
270
271     cdna.alignAs(protein);
272
273     SplitFrame splitFrame = new SplitFrame(
274             al1Nuc ? alignFrame : alignFrame2,
275             al1Nuc ? alignFrame2 : alignFrame);
276
277     return splitFrame;
278   }
279
280   /**
281    * Loads on a features file if one was specified as a parameter
282    * 
283    * @param alignFrame
284    * @param featureFile
285    */
286   protected void loadFeatures(AlignFrame alignFrame, String featureFile)
287   {
288     if (featureFile != null)
289     {
290       // todo extract helper for protocol resolution from JalviewLite
291       DataSourceType sourceType = featureFile.startsWith("http")
292               ? DataSourceType.URL
293               : DataSourceType.RELATIVE_URL;
294       alignFrame.parseFeaturesFile(featureFile, sourceType);
295     }
296   }
297
298   /**
299    * Constructs and returns the frame containing the alignment and its
300    * annotations. Returns null if the specified parameter value is not set.
301    * 
302    * @param fileParam
303    * 
304    * @return
305    * @throws FileFormatException
306    */
307   AlignFrame createAlignFrame(String fileParam) throws FileFormatException
308   {
309     AlignFrame af = null;
310     String file = getParameter(fileParam);
311     if (file != null)
312     {
313       DataSourceType protocol = file.startsWith("http") ? DataSourceType.URL
314               : DataSourceType.RELATIVE_URL;
315       // DataSourceType protocol = AppletFormatAdapter.checkProtocol(file);
316       FileFormatI format = new IdentifyFile().identify(file, protocol);
317       FileLoader fileLoader = new FileLoader(false);
318       af = fileLoader.LoadFileWaitTillLoaded(file, protocol, format);
319     }
320
321     return af;
322   }
323
324 }