Class |
Line # |
Actions |
|||
---|---|---|---|---|---|
JalviewJmolBinding | 66 | 310 | 150 |
1 | /* | |
2 | * Jalview - A Sequence Alignment Editor and Viewer ($$Version-Rel$$) | |
3 | * Copyright (C) $$Year-Rel$$ The Jalview Authors | |
4 | * | |
5 | * This file is part of Jalview. | |
6 | * | |
7 | * Jalview is free software: you can redistribute it and/or | |
8 | * modify it under the terms of the GNU General Public License | |
9 | * as published by the Free Software Foundation, either version 3 | |
10 | * of the License, or (at your option) any later version. | |
11 | * | |
12 | * Jalview is distributed in the hope that it will be useful, but | |
13 | * WITHOUT ANY WARRANTY; without even the implied warranty | |
14 | * of MERCHANTABILITY or FITNESS FOR A PARTICULAR | |
15 | * PURPOSE. See the GNU General Public License for more details. | |
16 | * | |
17 | * You should have received a copy of the GNU General Public License | |
18 | * along with Jalview. If not, see <http://www.gnu.org/licenses/>. | |
19 | * The Jalview Authors are detailed in the 'AUTHORS' file. | |
20 | */ | |
21 | package jalview.ext.jmol; | |
22 | ||
23 | import java.awt.Container; | |
24 | import java.awt.event.ComponentEvent; | |
25 | import java.awt.event.ComponentListener; | |
26 | import java.io.File; | |
27 | import java.net.URL; | |
28 | import java.util.ArrayList; | |
29 | import java.util.Arrays; | |
30 | import java.util.HashMap; | |
31 | import java.util.List; | |
32 | import java.util.Map; | |
33 | import java.util.StringTokenizer; | |
34 | import java.util.Vector; | |
35 | ||
36 | import javax.swing.SwingUtilities; | |
37 | ||
38 | import org.jmol.adapter.smarter.SmarterJmolAdapter; | |
39 | import org.jmol.api.JmolAppConsoleInterface; | |
40 | import org.jmol.api.JmolSelectionListener; | |
41 | import org.jmol.api.JmolStatusListener; | |
42 | import org.jmol.api.JmolViewer; | |
43 | import org.jmol.c.CBK; | |
44 | import org.jmol.viewer.Viewer; | |
45 | ||
46 | import jalview.api.AlignmentViewPanel; | |
47 | import jalview.api.FeatureRenderer; | |
48 | import jalview.api.FeatureSettingsModelI; | |
49 | import jalview.api.SequenceRenderer; | |
50 | import jalview.bin.Console; | |
51 | import jalview.datamodel.PDBEntry; | |
52 | import jalview.datamodel.SequenceI; | |
53 | import jalview.gui.AppJmol; | |
54 | import jalview.gui.IProgressIndicator; | |
55 | import jalview.gui.StructureViewer.ViewerType; | |
56 | import jalview.io.DataSourceType; | |
57 | import jalview.io.StructureFile; | |
58 | import jalview.structure.AtomSpec; | |
59 | import jalview.structure.StructureCommand; | |
60 | import jalview.structure.StructureCommandI; | |
61 | import jalview.structure.StructureSelectionManager; | |
62 | import jalview.structures.models.AAStructureBindingModel; | |
63 | import jalview.ws.dbsources.Pdb; | |
64 | import javajs.util.BS; | |
65 | ||
66 | public abstract class JalviewJmolBinding extends AAStructureBindingModel | |
67 | implements JmolStatusListener, JmolSelectionListener, | |
68 | ComponentListener | |
69 | { | |
70 | private String lastMessage; | |
71 | ||
72 | /* | |
73 | * when true, try to search the associated datamodel for sequences that are | |
74 | * associated with any unknown structures in the Jmol view. | |
75 | */ | |
76 | private boolean associateNewStructs = false; | |
77 | ||
78 | private Vector<String> atomsPicked = new Vector<>(); | |
79 | ||
80 | private String lastCommand; | |
81 | ||
82 | private boolean loadedInline; | |
83 | ||
84 | private StringBuffer resetLastRes = new StringBuffer(); | |
85 | ||
86 | public Viewer jmolViewer; | |
87 | ||
88 | 45 | public JalviewJmolBinding(StructureSelectionManager ssm, |
89 | PDBEntry[] pdbentry, SequenceI[][] sequenceIs, | |
90 | DataSourceType protocol) | |
91 | { | |
92 | 45 | super(ssm, pdbentry, sequenceIs, protocol); |
93 | 45 | setStructureCommands(new JmolCommands()); |
94 | /* | |
95 | * viewer = JmolViewer.allocateViewer(renderPanel, new SmarterJmolAdapter(), | |
96 | * "jalviewJmol", ap.av.applet .getDocumentBase(), ap.av.applet.getCodeBase(), | |
97 | * "", this); | |
98 | * | |
99 | * jmolpopup = JmolPopup.newJmolPopup(viewer, true, "Jmol", true); | |
100 | */ | |
101 | } | |
102 | ||
103 | 0 | public JalviewJmolBinding(StructureSelectionManager ssm, |
104 | SequenceI[][] seqs, Viewer theViewer) | |
105 | { | |
106 | 0 | super(ssm, seqs); |
107 | ||
108 | 0 | jmolViewer = theViewer; |
109 | 0 | jmolViewer.setJmolStatusListener(this); |
110 | 0 | jmolViewer.addSelectionListener(this); |
111 | 0 | setStructureCommands(new JmolCommands()); |
112 | } | |
113 | ||
114 | /** | |
115 | * construct a title string for the viewer window based on the data jalview | |
116 | * knows about | |
117 | * | |
118 | * @return | |
119 | */ | |
120 | 45 | public String getViewerTitle() |
121 | { | |
122 | 45 | return getViewerTitle("Jmol", true); |
123 | } | |
124 | ||
125 | 39 | private String jmolScript(String script) |
126 | { | |
127 | 39 | return jmolScript(script, false); |
128 | } | |
129 | ||
130 | 1141 | private String jmolScript(String script, boolean useScriptWait) |
131 | { | |
132 | 1141 | Console.debug(">>Jmol>> " + script); |
133 | 1141 | String s; |
134 | 1141 | if (useScriptWait) |
135 | { | |
136 | 2 | s = jmolViewer.scriptWait(script); |
137 | } | |
138 | else | |
139 | { | |
140 | 1139 | s = jmolViewer.evalStringQuiet(script); // scriptWait(script); BH |
141 | } | |
142 | 1141 | Console.debug("<<Jmol<< " + s); |
143 | ||
144 | 1141 | return s; |
145 | } | |
146 | ||
147 | 445 | @Override |
148 | public List<String> executeCommand(StructureCommandI command, | |
149 | boolean getReply) | |
150 | { | |
151 | 445 | if (command == null) |
152 | { | |
153 | 0 | return null; |
154 | } | |
155 | 445 | String cmd = command.getCommand(); |
156 | 445 | jmolHistory(false); |
157 | 445 | if (lastCommand == null || !lastCommand.equals(cmd)) |
158 | { | |
159 | 212 | jmolScript(cmd + "\n", command.isWaitNeeded()); |
160 | } | |
161 | 445 | jmolHistory(true); |
162 | 445 | lastCommand = cmd; |
163 | 445 | return null; |
164 | } | |
165 | ||
166 | 0 | public void createImage(String file, String type, int quality) |
167 | { | |
168 | 0 | jalview.bin.Console.outPrintln("JMOL CREATE IMAGE"); |
169 | } | |
170 | ||
171 | 4 | @Override |
172 | public String createImage(String fileName, String type, | |
173 | Object textOrBytes, int quality) | |
174 | { | |
175 | 4 | jalview.bin.Console.outPrintln("JMOL CREATE IMAGE"); |
176 | 4 | return null; |
177 | } | |
178 | ||
179 | 0 | @Override |
180 | public String eval(String strEval) | |
181 | { | |
182 | // jalview.bin.Console.outPrintln(strEval); | |
183 | // "# 'eval' is implemented only for the applet."; | |
184 | 0 | return null; |
185 | } | |
186 | ||
187 | // End StructureListener | |
188 | // ////////////////////////// | |
189 | ||
190 | //////////////////////////// | |
191 | // HETATM get | |
192 | // | |
193 | ||
194 | 49 | @Override |
195 | public Map<String, String> getHetatmNames() | |
196 | { | |
197 | 49 | HashMap<String, String> hetlist = new HashMap(); |
198 | 99 | for (int mc = 0; mc < jmolViewer.ms.mc; mc++) |
199 | { | |
200 | 50 | Map<String, String> hets = jmolViewer.ms.getHeteroList(mc); |
201 | 50 | if (hets != null) |
202 | { | |
203 | 10 | hetlist.putAll(hets); |
204 | } | |
205 | } | |
206 | 49 | return hetlist; |
207 | } | |
208 | // | |
209 | //////////////////////////// | |
210 | ||
211 | 0 | @Override |
212 | public float[][] functionXY(String functionName, int x, int y) | |
213 | { | |
214 | 0 | return null; |
215 | } | |
216 | ||
217 | 0 | @Override |
218 | public float[][][] functionXYZ(String functionName, int nx, int ny, | |
219 | int nz) | |
220 | { | |
221 | // TODO Auto-generated method stub | |
222 | 0 | return null; |
223 | } | |
224 | ||
225 | /** | |
226 | * map between index of model filename returned from getPdbFile and the first | |
227 | * index of models from this file in the viewer. Note - this is not trimmed - | |
228 | * use getPdbFile to get number of unique models. | |
229 | */ | |
230 | private int _modelFileNameMap[]; | |
231 | ||
232 | 1111 | @Override |
233 | public synchronized String[] getStructureFiles() | |
234 | { | |
235 | 1111 | if (jmolViewer == null) |
236 | { | |
237 | 46 | return new String[0]; |
238 | } | |
239 | ||
240 | 1065 | if (modelFileNames == null) |
241 | { | |
242 | 199 | int modelCount = jmolViewer.ms.mc; |
243 | 199 | String filePath = null; |
244 | 199 | List<String> mset = new ArrayList<>(); |
245 | 399 | for (int i = 0; i < modelCount; ++i) |
246 | { | |
247 | /* | |
248 | * defensive check for null as getModelFileName can return null even when model | |
249 | * count ms.mc is > 0 | |
250 | */ | |
251 | 200 | filePath = jmolViewer.ms.getModelFileName(i); |
252 | 200 | if (filePath != null && !mset.contains(filePath)) |
253 | { | |
254 | 66 | mset.add(filePath); |
255 | } | |
256 | } | |
257 | 199 | if (!mset.isEmpty()) |
258 | { | |
259 | 65 | modelFileNames = mset.toArray(new String[mset.size()]); |
260 | } | |
261 | } | |
262 | ||
263 | 1065 | return modelFileNames; |
264 | } | |
265 | ||
266 | /** | |
267 | * map from string to applet | |
268 | */ | |
269 | 0 | @Override |
270 | public Map<String, Object> getRegistryInfo() | |
271 | { | |
272 | // TODO Auto-generated method stub | |
273 | 0 | return null; |
274 | } | |
275 | ||
276 | // /////////////////////////////// | |
277 | // JmolStatusListener | |
278 | ||
279 | 0 | public void handlePopupMenu(int x, int y) |
280 | { | |
281 | // jmolpopup.show(x, y); | |
282 | // jmolpopup.jpiShow(x, y); | |
283 | } | |
284 | ||
285 | /** | |
286 | * Highlight zero, one or more atoms on the structure | |
287 | */ | |
288 | 0 | @Override |
289 | public void highlightAtoms(List<AtomSpec> atoms) | |
290 | { | |
291 | 0 | if (atoms != null) |
292 | { | |
293 | 0 | if (resetLastRes.length() > 0) |
294 | { | |
295 | 0 | jmolScript(resetLastRes.toString()); |
296 | 0 | resetLastRes.setLength(0); |
297 | } | |
298 | 0 | StringBuilder highlightCommands = null; |
299 | 0 | for (AtomSpec atom : atoms) |
300 | { | |
301 | 0 | StringBuilder thisAtom = highlightAtom(atom.getAtomIndex(), |
302 | atom.getPdbResNum(), atom.getChain(), atom.getPdbFile()); | |
303 | 0 | if (thisAtom != null) |
304 | { | |
305 | 0 | if (highlightCommands == null) |
306 | { | |
307 | 0 | highlightCommands = thisAtom; |
308 | } | |
309 | else | |
310 | { | |
311 | 0 | highlightCommands.append(thisAtom); |
312 | } | |
313 | } | |
314 | } | |
315 | 0 | if (highlightCommands != null) |
316 | { | |
317 | 0 | jmolHistory(false); |
318 | 0 | jmolScript(highlightCommands.toString()); |
319 | 0 | jmolHistory(true); |
320 | } | |
321 | // Highlight distances between atoms with a 'measure' command - not yet | |
322 | // working | |
323 | // if (atoms.size() >= 2) | |
324 | // { | |
325 | // StringBuilder sb = new StringBuilder(); | |
326 | // for (int a = 0; a < atoms.size(); a++) | |
327 | // { | |
328 | // AtomSpec speca = atoms.get(a); | |
329 | // String a_model = getModelIdForFile(speca.getPdbFile()); | |
330 | // for (int b = a + 1; b < atoms.size(); b++) | |
331 | // { | |
332 | // AtomSpec specb = atoms.get(b); | |
333 | // String b_model = getModelIdForFile(speca.getPdbFile()); | |
334 | // sb.append("measure ALL (" + speca.getAtomIndex() + " and */" | |
335 | // + a_model + ") (" + specb.getAtomIndex() + " and */" | |
336 | // + b_model + ");"); | |
337 | // } | |
338 | // } | |
339 | // jmolHistory(false, useScriptWait); | |
340 | // jmolScript(sb.toString(), useScriptWait); | |
341 | // jmolHistory(true, useScriptWait); | |
342 | // } | |
343 | ||
344 | } | |
345 | ||
346 | } | |
347 | ||
348 | // jmol/ssm only | |
349 | 0 | private StringBuilder highlightAtom(int atomIndex, int pdbResNum, |
350 | String chain, String pdbfile) | |
351 | { | |
352 | 0 | String modelId = getModelIdForFile(pdbfile); |
353 | 0 | if (modelId.isEmpty()) |
354 | { | |
355 | 0 | return null; |
356 | } | |
357 | ||
358 | 0 | StringBuilder selection = new StringBuilder(32); |
359 | 0 | StringBuilder cmd = new StringBuilder(64); |
360 | 0 | selection.append("select ").append(String.valueOf(pdbResNum)); |
361 | 0 | selection.append(":"); |
362 | 0 | if (!chain.equals(" ")) |
363 | { | |
364 | 0 | selection.append(chain); |
365 | } | |
366 | 0 | selection.append(" /").append(modelId); |
367 | ||
368 | 0 | cmd.append(selection).append(";wireframe 100;").append(selection) |
369 | .append(" and not hetero;").append("spacefill 200;select none"); | |
370 | ||
371 | 0 | resetLastRes.append(selection).append(";wireframe 0;").append(selection) |
372 | .append(" and not hetero; spacefill 0;"); | |
373 | ||
374 | 0 | return cmd; |
375 | } | |
376 | ||
377 | private boolean debug = true; | |
378 | ||
379 | 890 | private void jmolHistory(boolean enable) |
380 | { | |
381 | 890 | jmolHistory(enable, false); |
382 | } | |
383 | ||
384 | 890 | private void jmolHistory(boolean enable, boolean useScriptWait) |
385 | { | |
386 | 890 | jmolScript("History " + ((debug || enable) ? "on" : "off"), |
387 | useScriptWait); | |
388 | } | |
389 | ||
390 | 0 | public void loadInline(String string) |
391 | { | |
392 | 0 | loadedInline = true; |
393 | // TODO: re JAL-623 | |
394 | // viewer.loadInline(strModel, isAppend); | |
395 | // could do this: | |
396 | // construct fake fullPathName and fileName so we can identify the file | |
397 | // later. | |
398 | // Then, construct pass a reader for the string to Jmol. | |
399 | // ((org.jmol.Viewer.Viewer) viewer).loadModelFromFile(fullPathName, | |
400 | // fileName, null, reader, false, null, null, 0); | |
401 | 0 | jmolViewer.openStringInline(string); |
402 | } | |
403 | ||
404 | 1 | protected void mouseOverStructure(int atomIndex, final String strInfo) |
405 | { | |
406 | 1 | int pdbResNum; |
407 | 1 | int alocsep = strInfo.indexOf("^"); |
408 | 1 | int mdlSep = strInfo.indexOf("/"); |
409 | 1 | int chainSeparator = strInfo.indexOf(":"), chainSeparator1 = -1; |
410 | ||
411 | 1 | if (chainSeparator == -1) |
412 | { | |
413 | 0 | chainSeparator = strInfo.indexOf("."); |
414 | 0 | if (mdlSep > -1 && mdlSep < chainSeparator) |
415 | { | |
416 | 0 | chainSeparator1 = chainSeparator; |
417 | 0 | chainSeparator = mdlSep; |
418 | } | |
419 | } | |
420 | // handle insertion codes | |
421 | 1 | if (alocsep != -1) |
422 | { | |
423 | 0 | pdbResNum = Integer.parseInt( |
424 | strInfo.substring(strInfo.indexOf("]") + 1, alocsep)); | |
425 | ||
426 | } | |
427 | else | |
428 | { | |
429 | 1 | pdbResNum = Integer.parseInt( |
430 | strInfo.substring(strInfo.indexOf("]") + 1, chainSeparator)); | |
431 | } | |
432 | 1 | String chainId; |
433 | ||
434 | 1 | if (strInfo.indexOf(":") > -1) |
435 | { | |
436 | 1 | chainId = strInfo.substring(strInfo.indexOf(":") + 1, |
437 | strInfo.indexOf(".")); | |
438 | } | |
439 | else | |
440 | { | |
441 | 0 | chainId = " "; |
442 | } | |
443 | ||
444 | 1 | String pdbfilename = modelFileNames[0]; // default is first model |
445 | 1 | if (mdlSep > -1) |
446 | { | |
447 | 1 | if (chainSeparator1 == -1) |
448 | { | |
449 | 1 | chainSeparator1 = strInfo.indexOf(".", mdlSep); |
450 | } | |
451 | 1 | String mdlId = (chainSeparator1 > -1) |
452 | ? strInfo.substring(mdlSep + 1, chainSeparator1) | |
453 | : strInfo.substring(mdlSep + 1); | |
454 | 1 | try |
455 | { | |
456 | // recover PDB filename for the model hovered over. | |
457 | 1 | int mnumber = Integer.valueOf(mdlId).intValue() - 1; |
458 | 1 | if (_modelFileNameMap != null) |
459 | { | |
460 | 0 | int _mp = _modelFileNameMap.length - 1; |
461 | ||
462 | 0 | while (mnumber < _modelFileNameMap[_mp]) |
463 | { | |
464 | 0 | _mp--; |
465 | } | |
466 | 0 | pdbfilename = modelFileNames[_mp]; |
467 | } | |
468 | else | |
469 | { | |
470 | 1 | if (mnumber >= 0 && mnumber < modelFileNames.length) |
471 | { | |
472 | 1 | pdbfilename = modelFileNames[mnumber]; |
473 | } | |
474 | ||
475 | 1 | if (pdbfilename == null) |
476 | { | |
477 | 0 | pdbfilename = new File(jmolViewer.ms.getModelFileName(mnumber)) |
478 | .getAbsolutePath(); | |
479 | } | |
480 | } | |
481 | } catch (Exception e) | |
482 | { | |
483 | } | |
484 | } | |
485 | ||
486 | /* | |
487 | * highlight position on alignment(s); if some text is returned, show this as a | |
488 | * second line on the structure hover tooltip | |
489 | */ | |
490 | 1 | String label = getSsm().mouseOverStructure(pdbResNum, chainId, |
491 | pdbfilename); | |
492 | 1 | if (label != null) |
493 | { | |
494 | // change comma to pipe separator (newline token for Jmol) | |
495 | 0 | label = label.replace(',', '|'); |
496 | 0 | StringTokenizer toks = new StringTokenizer(strInfo, " "); |
497 | 0 | StringBuilder sb = new StringBuilder(); |
498 | 0 | sb.append("select ").append(String.valueOf(pdbResNum)).append(":") |
499 | .append(chainId).append("/1"); | |
500 | 0 | sb.append(";set hoverLabel \"").append(toks.nextToken()).append(" ") |
501 | .append(toks.nextToken()); | |
502 | 0 | sb.append("|").append(label).append("\""); |
503 | 0 | executeCommand(new StructureCommand(sb.toString()), false); |
504 | } | |
505 | } | |
506 | ||
507 | 0 | public void notifyAtomHovered(int atomIndex, String strInfo, String data) |
508 | { | |
509 | 0 | if (strInfo.equals(lastMessage)) |
510 | { | |
511 | 0 | return; |
512 | } | |
513 | 0 | lastMessage = strInfo; |
514 | 0 | if (data != null) |
515 | { | |
516 | 0 | jalview.bin.Console.errPrintln( |
517 | "Ignoring additional hover info: " + data + " (other info: '" | |
518 | + strInfo + "' pos " + atomIndex + ")"); | |
519 | } | |
520 | 0 | mouseOverStructure(atomIndex, strInfo); |
521 | } | |
522 | ||
523 | /* | |
524 | * { if (history != null && strStatus != null && | |
525 | * !strStatus.equals("Script completed")) { history.append("\n" + strStatus); } | |
526 | * } | |
527 | */ | |
528 | ||
529 | 0 | public void notifyAtomPicked(int atomIndex, String strInfo, |
530 | String strData) | |
531 | { | |
532 | /** | |
533 | * this implements the toggle label behaviour copied from the original | |
534 | * structure viewer, mc_view | |
535 | */ | |
536 | 0 | if (strData != null) |
537 | { | |
538 | 0 | jalview.bin.Console.errPrintln( |
539 | "Ignoring additional pick data string " + strData); | |
540 | } | |
541 | 0 | int chainSeparator = strInfo.indexOf(":"); |
542 | 0 | int p = 0; |
543 | 0 | if (chainSeparator == -1) |
544 | { | |
545 | 0 | chainSeparator = strInfo.indexOf("."); |
546 | } | |
547 | ||
548 | 0 | String picked = strInfo.substring(strInfo.indexOf("]") + 1, |
549 | chainSeparator); | |
550 | 0 | String mdlString = ""; |
551 | 0 | if ((p = strInfo.indexOf(":")) > -1) |
552 | { | |
553 | 0 | picked += strInfo.substring(p, strInfo.indexOf(".")); |
554 | } | |
555 | ||
556 | 0 | if ((p = strInfo.indexOf("/")) > -1) |
557 | { | |
558 | 0 | mdlString += strInfo.substring(p, strInfo.indexOf(" #")); |
559 | } | |
560 | 0 | picked = "((" + picked + ".CA" + mdlString + ")|(" + picked + ".P" |
561 | + mdlString + "))"; | |
562 | 0 | jmolHistory(false); |
563 | ||
564 | 0 | if (!atomsPicked.contains(picked)) |
565 | { | |
566 | 0 | jmolScript("select " + picked + ";label %n %r:%c"); |
567 | 0 | atomsPicked.addElement(picked); |
568 | } | |
569 | else | |
570 | { | |
571 | 0 | jmolViewer.evalString("select " + picked + ";label off"); |
572 | 0 | atomsPicked.removeElement(picked); |
573 | } | |
574 | 0 | jmolHistory(true); |
575 | // TODO: in application this happens | |
576 | // | |
577 | // if (scriptWindow != null) | |
578 | // { | |
579 | // scriptWindow.sendConsoleMessage(strInfo); | |
580 | // scriptWindow.sendConsoleMessage("\n"); | |
581 | // } | |
582 | ||
583 | } | |
584 | ||
585 | 159 | @Override |
586 | public void notifyCallback(CBK type, Object[] data) | |
587 | { | |
588 | /* | |
589 | * ensure processed in AWT thread to avoid risk of deadlocks | |
590 | */ | |
591 | 159 | SwingUtilities.invokeLater(new Runnable() |
592 | { | |
593 | ||
594 | 159 | @Override |
595 | public void run() | |
596 | { | |
597 | 159 | processCallback(type, data); |
598 | } | |
599 | }); | |
600 | } | |
601 | ||
602 | /** | |
603 | * Processes one callback notification from Jmol | |
604 | * | |
605 | * @param type | |
606 | * @param data | |
607 | */ | |
608 | 159 | protected void processCallback(CBK type, Object[] data) |
609 | { | |
610 | 159 | try |
611 | { | |
612 | 159 | switch (type) |
613 | { | |
614 | 60 | case LOADSTRUCT: |
615 | 60 | notifyFileLoaded((String) data[1], (String) data[2], |
616 | (String) data[3], (String) data[4], | |
617 | ((Integer) data[5]).intValue()); | |
618 | ||
619 | 59 | break; |
620 | 0 | case PICK: |
621 | 0 | notifyAtomPicked(((Integer) data[2]).intValue(), (String) data[1], |
622 | (String) data[0]); | |
623 | // also highlight in alignment | |
624 | // deliberate fall through | |
625 | 0 | case HOVER: |
626 | 0 | notifyAtomHovered(((Integer) data[2]).intValue(), (String) data[1], |
627 | (String) data[0]); | |
628 | 0 | break; |
629 | 8 | case SCRIPT: |
630 | 8 | notifyScriptTermination((String) data[2], |
631 | ((Integer) data[3]).intValue()); | |
632 | 8 | break; |
633 | 32 | case ECHO: |
634 | 32 | sendConsoleEcho((String) data[1]); |
635 | 32 | break; |
636 | 0 | case MESSAGE: |
637 | 0 | sendConsoleMessage( |
638 | 0 | (data == null) ? ((String) null) : (String) data[1]); |
639 | 0 | break; |
640 | 0 | case ERROR: |
641 | // jalview.bin.Console.errPrintln("Ignoring error callback."); | |
642 | 0 | break; |
643 | 52 | case SYNC: |
644 | 0 | case RESIZE: |
645 | 52 | refreshGUI(); |
646 | 52 | break; |
647 | 7 | case MEASURE: |
648 | ||
649 | 0 | case CLICK: |
650 | 0 | default: |
651 | 7 | jalview.bin.Console.errPrintln( |
652 | "Unhandled callback " + type + " " + data[1].toString()); | |
653 | 7 | break; |
654 | } | |
655 | } catch (Exception e) | |
656 | { | |
657 | 1 | jalview.bin.Console |
658 | .errPrintln("Squashed Jmol callback handler error:"); | |
659 | 1 | e.printStackTrace(); |
660 | } | |
661 | } | |
662 | ||
663 | 360 | @Override |
664 | public boolean notifyEnabled(CBK callbackPick) | |
665 | { | |
666 | 360 | switch (callbackPick) |
667 | { | |
668 | 32 | case ECHO: |
669 | 60 | case LOADSTRUCT: |
670 | 7 | case MEASURE: |
671 | 0 | case MESSAGE: |
672 | 0 | case PICK: |
673 | 8 | case SCRIPT: |
674 | 0 | case HOVER: |
675 | 0 | case ERROR: |
676 | 107 | return true; |
677 | 253 | default: |
678 | 253 | return false; |
679 | } | |
680 | } | |
681 | ||
682 | // incremented every time a load notification is successfully handled - | |
683 | // lightweight mechanism for other threads to detect when they can start | |
684 | // referrring to new structures. | |
685 | private long loadNotifiesHandled = 0; | |
686 | ||
687 | 57 | public long getLoadNotifiesHandled() |
688 | { | |
689 | 57 | return loadNotifiesHandled; |
690 | } | |
691 | ||
692 | 60 | public void notifyFileLoaded(String fullPathName, String fileName2, |
693 | String modelName, String errorMsg, int modelParts) | |
694 | { | |
695 | 60 | if (errorMsg != null) |
696 | { | |
697 | 7 | fileLoadingError = errorMsg; |
698 | 7 | refreshGUI(); |
699 | 7 | return; |
700 | } | |
701 | // TODO: deal sensibly with models loaded inLine: | |
702 | // modelName will be null, as will fullPathName. | |
703 | ||
704 | // the rest of this routine ignores the arguments, and simply interrogates | |
705 | // the Jmol view to find out what structures it contains, and adds them to | |
706 | // the structure selection manager. | |
707 | 53 | fileLoadingError = null; |
708 | 53 | String[] oldmodels = modelFileNames; |
709 | 53 | modelFileNames = null; |
710 | 53 | boolean notifyLoaded = false; |
711 | 53 | String[] modelfilenames = getStructureFiles(); |
712 | 53 | if (modelfilenames == null) |
713 | { | |
714 | // Jmol is still loading files! | |
715 | 7 | return; |
716 | } | |
717 | // first check if we've lost any structures | |
718 | 46 | if (oldmodels != null && oldmodels.length > 0) |
719 | { | |
720 | 20 | int oldm = 0; |
721 | 40 | for (int i = 0; i < oldmodels.length; i++) |
722 | { | |
723 | 20 | for (int n = 0; n < modelfilenames.length; n++) |
724 | { | |
725 | 20 | if (modelfilenames[n] == oldmodels[i]) |
726 | { | |
727 | 20 | oldmodels[i] = null; |
728 | 20 | break; |
729 | } | |
730 | } | |
731 | 20 | if (oldmodels[i] != null) |
732 | { | |
733 | 0 | oldm++; |
734 | } | |
735 | } | |
736 | 20 | if (oldm > 0) |
737 | { | |
738 | 0 | String[] oldmfn = new String[oldm]; |
739 | 0 | oldm = 0; |
740 | 0 | for (int i = 0; i < oldmodels.length; i++) |
741 | { | |
742 | 0 | if (oldmodels[i] != null) |
743 | { | |
744 | 0 | oldmfn[oldm++] = oldmodels[i]; |
745 | } | |
746 | } | |
747 | // deregister the Jmol instance for these structures - we'll add | |
748 | // ourselves again at the end for the current structure set. | |
749 | 0 | getSsm().removeStructureViewerListener(this, oldmfn); |
750 | } | |
751 | } | |
752 | 46 | refreshPdbEntries(); |
753 | 93 | for (int modelnum = 0; modelnum < modelfilenames.length; modelnum++) |
754 | { | |
755 | 47 | String fileName = modelfilenames[modelnum]; |
756 | 47 | boolean foundEntry = false; |
757 | 47 | StructureFile pdb = null; |
758 | 47 | String pdbfile = null; |
759 | // model was probably loaded inline - so check the pdb file hashcode | |
760 | 47 | if (loadedInline) |
761 | { | |
762 | // calculate essential attributes for the pdb data imported inline. | |
763 | // prolly need to resolve modelnumber properly - for now just use our | |
764 | // 'best guess' | |
765 | 0 | pdbfile = jmolViewer.getData( |
766 | "" + (1 + _modelFileNameMap[modelnum]) + ".0", "PDB"); | |
767 | } | |
768 | // search pdbentries and sequences to find correct pdbentry for this | |
769 | // model | |
770 | 96 | for (int pe = 0; pe < getPdbCount(); pe++) |
771 | { | |
772 | 49 | boolean matches = false; |
773 | 49 | addSequence(pe, getSequence()[pe]); |
774 | 49 | if (fileName == null) |
775 | { | |
776 | 0 | if (false) |
777 | // see JAL-623 - need method of matching pasted data up | |
778 | { | |
779 | 0 | pdb = getSsm().setMapping(getSequence()[pe], getChains()[pe], |
780 | pdbfile, DataSourceType.PASTE, getIProgressIndicator()); | |
781 | 0 | getPdbEntry(modelnum).setFile("INLINE" + pdb.getId()); |
782 | 0 | matches = true; |
783 | 0 | foundEntry = true; |
784 | } | |
785 | } | |
786 | else | |
787 | { | |
788 | 49 | PDBEntry ppe = getPdbEntry(pe); |
789 | 49 | if (ppe == null) |
790 | { | |
791 | 0 | Console.warn( |
792 | "Please report under JAL-4440: Unexpected null entry for PDBEntry for a structure (for structure " | |
793 | + fileName + ")"); | |
794 | ||
795 | 0 | continue; |
796 | } | |
797 | 49 | if (ppe.getFile() == null) |
798 | { | |
799 | 0 | Console.warn( |
800 | "Please report under JAL-4440: Unexpected null entry for file that we just tried to load into Jmol: pdbEntry: " | |
801 | + ppe.toString() + "(for structure " + fileName | |
802 | + ")"); | |
803 | 0 | continue; |
804 | } | |
805 | 49 | File fl = new File(getPdbEntry(pe).getFile()); |
806 | 49 | matches = fl.equals(new File(fileName)); |
807 | 49 | if (matches) |
808 | { | |
809 | 44 | foundEntry = true; |
810 | // TODO: Jmol can in principle retrieve from CLASSLOADER but | |
811 | // this | |
812 | // needs | |
813 | // to be tested. See mantis bug | |
814 | // https://mantis.lifesci.dundee.ac.uk/view.php?id=36605 | |
815 | 44 | DataSourceType protocol = DataSourceType.URL; |
816 | 44 | try |
817 | { | |
818 | 44 | if (fl.exists()) |
819 | { | |
820 | 44 | protocol = DataSourceType.FILE; |
821 | } | |
822 | } catch (Exception e) | |
823 | { | |
824 | } catch (Error e) | |
825 | { | |
826 | } | |
827 | // Explicitly map to the filename used by Jmol ; | |
828 | 44 | pdb = getSsm().setMapping(getSequence()[pe], getChains()[pe], |
829 | fileName, protocol, getIProgressIndicator()); | |
830 | // pdbentry[pe].getFile(), protocol); | |
831 | ||
832 | } | |
833 | } | |
834 | 49 | if (matches) |
835 | { | |
836 | 44 | stashFoundChains(pdb, fileName); |
837 | 44 | notifyLoaded = true; |
838 | } | |
839 | } | |
840 | ||
841 | 47 | if (!foundEntry && associateNewStructs) |
842 | { | |
843 | // this is a foreign pdb file that jalview doesn't know about - add | |
844 | // it to the dataset and try to find a home - either on a matching | |
845 | // sequence or as a new sequence. | |
846 | 0 | String pdbcontent = jmolViewer.getData("/" + (modelnum + 1) + ".1", |
847 | "PDB"); | |
848 | // parse pdb file into a chain, etc. | |
849 | // locate best match for pdb in associated views and add mapping to | |
850 | // ssm | |
851 | // if properly registered then | |
852 | 0 | notifyLoaded = true; |
853 | ||
854 | } | |
855 | } | |
856 | // FILE LOADED OK | |
857 | // so finally, update the jmol bits and pieces | |
858 | // if (jmolpopup != null) | |
859 | // { | |
860 | // // potential for deadlock here: | |
861 | // // jmolpopup.updateComputedMenus(); | |
862 | // } | |
863 | 46 | if (!isLoadingFromArchive()) |
864 | { | |
865 | 39 | jmolScript( |
866 | "model *; select backbone;restrict;cartoon;wireframe off;spacefill off"); | |
867 | } | |
868 | // register ourselves as a listener and notify the gui that it needs to | |
869 | // update itself. | |
870 | 46 | getSsm().addStructureViewerListener(this); |
871 | 46 | if (notifyLoaded) |
872 | { | |
873 | 43 | FeatureRenderer fr = getFeatureRenderer(null); |
874 | 42 | if (fr != null) |
875 | { | |
876 | 42 | FeatureSettingsModelI colours = new Pdb().getFeatureColourScheme(); |
877 | 42 | ((AppJmol) getViewer()).getAlignmentPanel().av |
878 | .applyFeaturesStyle(colours); | |
879 | } | |
880 | 42 | refreshGUI(); |
881 | 42 | loadNotifiesHandled++; |
882 | } | |
883 | 45 | setLoadingFromArchive(false); |
884 | } | |
885 | ||
886 | 44 | protected IProgressIndicator getIProgressIndicator() |
887 | { | |
888 | 44 | return null; |
889 | } | |
890 | ||
891 | 0 | public void notifyNewPickingModeMeasurement(int iatom, String strMeasure) |
892 | { | |
893 | 0 | notifyAtomPicked(iatom, strMeasure, null); |
894 | } | |
895 | ||
896 | public abstract void notifyScriptTermination(String strStatus, | |
897 | int msWalltime); | |
898 | ||
899 | /** | |
900 | * display a message echoed from the jmol viewer | |
901 | * | |
902 | * @param strEcho | |
903 | */ | |
904 | public abstract void sendConsoleEcho(String strEcho); /* | |
905 | * { showConsole(true); | |
906 | * | |
907 | * history.append("\n" + strEcho); } | |
908 | */ | |
909 | ||
910 | // /End JmolStatusListener | |
911 | // ///////////////////////////// | |
912 | ||
913 | /** | |
914 | * @param strStatus | |
915 | * status message - usually the response received after a script | |
916 | * executed | |
917 | */ | |
918 | public abstract void sendConsoleMessage(String strStatus); | |
919 | ||
920 | 0 | @Override |
921 | public void setCallbackFunction(String callbackType, | |
922 | String callbackFunction) | |
923 | { | |
924 | 0 | jalview.bin.Console |
925 | .errPrintln("Ignoring set-callback request to associate " | |
926 | + callbackType + " with function " + callbackFunction); | |
927 | ||
928 | } | |
929 | ||
930 | 0 | public void showHelp() |
931 | { | |
932 | 0 | showUrl("http://wiki.jmol.org" |
933 | // BH 2018 "http://jmol.sourceforge.net/docs/JmolUserGuide/" | |
934 | , "jmolHelp"); | |
935 | } | |
936 | ||
937 | /** | |
938 | * open the URL somehow | |
939 | * | |
940 | * @param target | |
941 | */ | |
942 | public abstract void showUrl(String url, String target); | |
943 | ||
944 | /** | |
945 | * called to show or hide the associated console window container. | |
946 | * | |
947 | * @param show | |
948 | */ | |
949 | public abstract void showConsole(boolean show); | |
950 | ||
951 | 175 | public static Viewer getJmolData(JmolParser jmolParser) |
952 | { | |
953 | 175 | return (Viewer) JmolViewer.allocateViewer(null, null, null, null, null, |
954 | "-x -o -n", jmolParser); | |
955 | } | |
956 | ||
957 | /** | |
958 | * | |
959 | * | |
960 | * | |
961 | * @param renderPanel | |
962 | * @param jmolfileio | |
963 | * - when true will initialise jmol's file IO system (should be false | |
964 | * in applet context) | |
965 | * @param htmlName | |
966 | * @param documentBase | |
967 | * @param codeBase | |
968 | * @param commandOptions | |
969 | */ | |
970 | 0 | public void allocateViewer(Container renderPanel, boolean jmolfileio, |
971 | String htmlName, URL documentBase, URL codeBase, | |
972 | String commandOptions) | |
973 | { | |
974 | 0 | allocateViewer(renderPanel, jmolfileio, htmlName, documentBase, |
975 | codeBase, commandOptions, null, null); | |
976 | } | |
977 | ||
978 | /** | |
979 | * | |
980 | * @param renderPanel | |
981 | * @param jmolfileio | |
982 | * - when true will initialise jmol's file IO system (should be false | |
983 | * in applet context) | |
984 | * @param htmlName | |
985 | * @param documentBase | |
986 | * @param codeBase | |
987 | * @param commandOptions | |
988 | * @param consolePanel | |
989 | * - panel to contain Jmol console | |
990 | * @param buttonsToShow | |
991 | * - buttons to show on the console, in order | |
992 | */ | |
993 | 45 | public void allocateViewer(Container renderPanel, boolean jmolfileio, |
994 | String htmlName, URL documentBase, URL codeBase, | |
995 | String commandOptions, final Container consolePanel, | |
996 | String buttonsToShow) | |
997 | { | |
998 | ||
999 | 45 | jalview.bin.Console |
1000 | .errPrintln("Allocating Jmol Viewer: " + commandOptions); | |
1001 | ||
1002 | 45 | if (commandOptions == null) |
1003 | { | |
1004 | 0 | commandOptions = ""; |
1005 | } | |
1006 | 45 | jmolViewer = (Viewer) JmolViewer.allocateViewer(renderPanel, |
1007 | 45 | (jmolfileio ? new SmarterJmolAdapter() : null), |
1008 | htmlName + ((Object) this).toString(), documentBase, codeBase, | |
1009 | commandOptions, this); | |
1010 | ||
1011 | 45 | jmolViewer.setJmolStatusListener(this); // extends JmolCallbackListener |
1012 | ||
1013 | 45 | try |
1014 | { | |
1015 | 45 | console = createJmolConsole(consolePanel, buttonsToShow); |
1016 | } catch (Throwable e) | |
1017 | { | |
1018 | 0 | jalview.bin.Console |
1019 | .errPrintln("Could not create Jmol application console. " | |
1020 | + e.getMessage()); | |
1021 | 0 | e.printStackTrace(); |
1022 | } | |
1023 | 45 | if (consolePanel != null) |
1024 | { | |
1025 | 45 | consolePanel.addComponentListener(this); |
1026 | ||
1027 | } | |
1028 | ||
1029 | } | |
1030 | ||
1031 | protected abstract JmolAppConsoleInterface createJmolConsole( | |
1032 | Container consolePanel, String buttonsToShow); | |
1033 | ||
1034 | // BH 2018 -- Jmol console is not working due to problems with styled | |
1035 | // documents. | |
1036 | ||
1037 | protected org.jmol.api.JmolAppConsoleInterface console = null; | |
1038 | ||
1039 | 0 | @Override |
1040 | public int[] resizeInnerPanel(String data) | |
1041 | { | |
1042 | // Jalview doesn't honour resize panel requests | |
1043 | 0 | return null; |
1044 | } | |
1045 | ||
1046 | /** | |
1047 | * | |
1048 | */ | |
1049 | 23 | protected void closeConsole() |
1050 | { | |
1051 | 23 | if (console != null) |
1052 | { | |
1053 | 23 | try |
1054 | { | |
1055 | 23 | console.setVisible(false); |
1056 | } catch (Error e) | |
1057 | { | |
1058 | } catch (Exception x) | |
1059 | { | |
1060 | } | |
1061 | 23 | ; |
1062 | 23 | console = null; |
1063 | } | |
1064 | } | |
1065 | ||
1066 | /** | |
1067 | * ComponentListener method | |
1068 | */ | |
1069 | 0 | @Override |
1070 | public void componentMoved(ComponentEvent e) | |
1071 | { | |
1072 | } | |
1073 | ||
1074 | /** | |
1075 | * ComponentListener method | |
1076 | */ | |
1077 | 0 | @Override |
1078 | public void componentResized(ComponentEvent e) | |
1079 | { | |
1080 | } | |
1081 | ||
1082 | /** | |
1083 | * ComponentListener method | |
1084 | */ | |
1085 | 0 | @Override |
1086 | public void componentShown(ComponentEvent e) | |
1087 | { | |
1088 | 0 | showConsole(true); |
1089 | } | |
1090 | ||
1091 | /** | |
1092 | * ComponentListener method | |
1093 | */ | |
1094 | 0 | @Override |
1095 | public void componentHidden(ComponentEvent e) | |
1096 | { | |
1097 | 0 | showConsole(false); |
1098 | } | |
1099 | ||
1100 | 311 | @Override |
1101 | protected String getModelIdForFile(String pdbFile) | |
1102 | { | |
1103 | 311 | if (modelFileNames == null) |
1104 | { | |
1105 | 0 | return ""; |
1106 | } | |
1107 | 315 | for (int i = 0; i < modelFileNames.length; i++) |
1108 | { | |
1109 | 314 | if (modelFileNames[i].equalsIgnoreCase(pdbFile)) |
1110 | { | |
1111 | 310 | return String.valueOf(i + 1); |
1112 | } | |
1113 | } | |
1114 | 1 | return ""; |
1115 | } | |
1116 | ||
1117 | 2 | @Override |
1118 | protected ViewerType getViewerType() | |
1119 | { | |
1120 | 2 | return ViewerType.JMOL; |
1121 | } | |
1122 | ||
1123 | 0 | @Override |
1124 | protected String getModelId(int pdbfnum, String file) | |
1125 | { | |
1126 | 0 | return String.valueOf(pdbfnum + 1); |
1127 | } | |
1128 | ||
1129 | /** | |
1130 | * Returns ".spt" - the Jmol session file extension | |
1131 | * | |
1132 | * @return | |
1133 | * @see https://chemapps.stolaf.edu/jmol/docs/#writemodel | |
1134 | */ | |
1135 | 2 | @Override |
1136 | public String getSessionFileExtension() | |
1137 | { | |
1138 | 2 | return ".spt"; |
1139 | } | |
1140 | ||
1141 | 0 | @Override |
1142 | public void selectionChanged(BS arg0) | |
1143 | { | |
1144 | // TODO Auto-generated method stub | |
1145 | ||
1146 | } | |
1147 | ||
1148 | 0 | @Override |
1149 | public SequenceRenderer getSequenceRenderer(AlignmentViewPanel avp) | |
1150 | { | |
1151 | 0 | return new jalview.gui.SequenceRenderer(avp.getAlignViewport()); |
1152 | } | |
1153 | ||
1154 | 0 | @Override |
1155 | public String getHelpURL() | |
1156 | { | |
1157 | 0 | return "http://wiki.jmol.org"; // BH 2018 |
1158 | } | |
1159 | } |