JAL-1753 statusPanel added (for ProgressBar); 'Fit to Window' menu
[jalview.git] / src / jalview / gui / ScriptWindow.java
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.gui;
22
23 import org.jmol.api.*;
24
25 import jalview.jbgui.GStructureViewer;
26
27 import java.awt.*;
28 import java.awt.event.*;
29
30 import javax.swing.*;
31 import javax.swing.text.*;
32
33 import java.util.Vector;
34
35 import org.jmol.i18n.GT;
36 import org.jmol.util.Logger;
37 import org.jmol.util.CommandHistory;
38
39 // TODO: this class is copied in from jmol 11.0.2 - upgrade to 12.0.2 ?
40 public final class ScriptWindow extends JPanel implements ActionListener,
41         EnterListener
42 {
43
44   private ConsoleTextPane console;
45
46   private JButton closeButton;
47
48   private JButton runButton;
49
50   private JButton haltButton;
51
52   private JButton clearButton;
53
54   private JButton historyButton;
55
56   private JButton stateButton;
57
58   JmolViewer viewer;
59
60   GStructureViewer appJmol;
61
62   public ScriptWindow(AppJmol appJmol)
63   {
64     this.viewer = appJmol.jmb.viewer;
65     this.appJmol = appJmol;
66
67     setLayout(new BorderLayout());
68
69     console = new ConsoleTextPane(this);
70
71     console.setPrompt();
72     add(new JScrollPane(console), BorderLayout.CENTER);
73
74     JPanel buttonPanel = new JPanel();
75     add(buttonPanel, BorderLayout.SOUTH);
76
77     runButton = new JButton(GT._("Run"));
78     haltButton = new JButton(GT._("Halt"));
79     runButton.addActionListener(this);
80     // buttonPanel.add(runButton);
81     haltButton.addActionListener(this);
82     // buttonPanel.add(haltButton);
83     haltButton.setEnabled(false);
84
85     clearButton = new JButton(GT._("Clear"));
86     clearButton.addActionListener(this);
87     buttonPanel.add(clearButton);
88
89     historyButton = new JButton(GT._("History"));
90     historyButton.addActionListener(this);
91     buttonPanel.add(historyButton);
92
93     stateButton = new JButton(GT._("State"));
94     stateButton.addActionListener(this);
95     buttonPanel.add(stateButton);
96
97     closeButton = new JButton(GT._("Close"));
98     closeButton.addActionListener(this);
99     buttonPanel.add(closeButton);
100
101     for (int i = 0; i < buttonPanel.getComponentCount(); i++)
102     {
103       // ((JButton)buttonPanel.getComponent(i))
104       // .setMargin(new Insets(0, 0, 0, 0));
105     }
106
107   }
108
109   public void sendConsoleEcho(String strEcho)
110   {
111     if (strEcho != null && !isError)
112     {
113
114       console.outputEcho(strEcho);
115
116     }
117     setError(false);
118   }
119
120   boolean isError = false;
121
122   void setError(boolean TF)
123   {
124     isError = TF;
125     // if (isError)
126     // console.recallCommand(true);
127   }
128
129   public void sendConsoleMessage(String strStatus)
130   {
131     if (strStatus == null)
132     {
133       console.clearContent();
134       console.outputStatus("");
135     }
136     else if (strStatus.indexOf("ERROR:") >= 0)
137     {
138       console.outputError(strStatus);
139       isError = true;
140     }
141     else if (!isError)
142     {
143       console.outputStatus(strStatus);
144     }
145   }
146
147   public void notifyScriptTermination(String strMsg, int msWalltime)
148   {
149     if (strMsg != null && strMsg.indexOf("ERROR") >= 0)
150     {
151       console.outputError(strMsg);
152     }
153     runButton.setEnabled(true);
154     haltButton.setEnabled(false);
155   }
156
157   public void enterPressed()
158   {
159     runButton.doClick(100);
160     // executeCommand();
161   }
162
163   class ExecuteCommandThread extends Thread
164   {
165
166     String strCommand;
167
168     ExecuteCommandThread(String command)
169     {
170       strCommand = command;
171     }
172
173     public void run()
174     {
175       try
176       {
177         executeCommand(strCommand);
178       } catch (Exception ie)
179       {
180         Logger.debug("execution command interrupted!" + ie);
181       }
182     }
183   }
184
185   ExecuteCommandThread execThread;
186
187   void executeCommandAsThread()
188   {
189     String strCommand = console.getCommandString().trim();
190     if (strCommand.length() > 0)
191     {
192       execThread = new ExecuteCommandThread(strCommand);
193       execThread.start();
194     }
195   }
196
197   void executeCommand(String strCommand)
198   {
199     boolean doWait;
200     setError(false);
201     console.appendNewline();
202     console.setPrompt();
203     if (strCommand.length() > 0)
204     {
205       String strErrorMessage = null;
206       doWait = (strCommand.indexOf("WAIT ") == 0);
207       if (doWait)
208       { // for testing, mainly
209         // demonstrates using the statusManager system.
210         runButton.setEnabled(false);
211         haltButton.setEnabled(true);
212
213         Vector info = (Vector) viewer
214                 .scriptWaitStatus(strCommand.substring(5),
215                         "+fileLoaded,+scriptStarted,+scriptStatus,+scriptEcho,+scriptTerminated");
216         runButton.setEnabled(true);
217         haltButton.setEnabled(false);
218         /*
219          * info = [ statusRecortSet0, statusRecortSet1, statusRecortSet2, ...]
220          * statusRecordSet = [ statusRecord0, statusRecord1, statusRecord2, ...]
221          * statusRecord = [int msgPtr, String statusName, int intInfo, String
222          * msg]
223          */
224         for (int i = 0; i < info.size(); i++)
225         {
226           Vector statusRecordSet = (Vector) info.get(i);
227           for (int j = 0; j < statusRecordSet.size(); j++)
228           {
229             Vector statusRecord = (Vector) statusRecordSet.get(j);
230             Logger.info("msg#=" + statusRecord.get(0) + " "
231                     + statusRecord.get(1) + " intInfo="
232                     + statusRecord.get(2) + " stringInfo="
233                     + statusRecord.get(3));
234           }
235         }
236         console.appendNewline();
237       }
238       else
239       {
240         boolean isScriptExecuting = viewer.isScriptExecuting();
241         if (viewer.checkHalt(strCommand, true))
242           strErrorMessage = (isScriptExecuting ? "string execution halted with "
243                   + strCommand
244                   : "no script was executing");
245         else
246           strErrorMessage = "";// viewer.scriptCheck(strCommand);
247         // the problem is that scriptCheck is synchronized, so these might get
248         // backed up.
249         if (strErrorMessage != null && strErrorMessage.length() > 0)
250         {
251           console.outputError(strErrorMessage);
252         }
253         else
254         {
255           // runButton.setEnabled(false);
256           haltButton.setEnabled(true);
257           viewer.script(strCommand);
258         }
259       }
260     }
261     console.grabFocus();
262   }
263
264   public void actionPerformed(ActionEvent e)
265   {
266     Object source = e.getSource();
267     if (source == closeButton)
268     {
269       // appJmol.showConsole(false);
270     }
271     else if (source == runButton)
272     {
273       executeCommandAsThread();
274     }
275     else if (source == clearButton)
276     {
277       console.clearContent();
278     }
279     else if (source == historyButton)
280     {
281       console.clearContent(viewer.getSetHistory(Integer.MAX_VALUE));
282     }
283     else if (source == stateButton)
284     {
285       console.clearContent(viewer.getStateInfo());
286     }
287     else if (source == haltButton)
288     {
289       viewer.haltScriptExecution();
290     }
291     console.grabFocus(); // always grab the focus (e.g., after clear)
292   }
293 }
294
295 class ConsoleTextPane extends JTextPane
296 {
297
298   ConsoleDocument consoleDoc;
299
300   EnterListener enterListener;
301
302   JmolViewer viewer;
303
304   ConsoleTextPane(ScriptWindow scriptWindow)
305   {
306     super(new ConsoleDocument());
307     consoleDoc = (ConsoleDocument) getDocument();
308     consoleDoc.setConsoleTextPane(this);
309     this.enterListener = (EnterListener) scriptWindow;
310     this.viewer = scriptWindow.viewer;
311   }
312
313   public String getCommandString()
314   {
315     String cmd = consoleDoc.getCommandString();
316     return cmd;
317   }
318
319   public void setPrompt()
320   {
321     consoleDoc.setPrompt();
322   }
323
324   public void appendNewline()
325   {
326     consoleDoc.appendNewline();
327   }
328
329   public void outputError(String strError)
330   {
331     consoleDoc.outputError(strError);
332   }
333
334   public void outputErrorForeground(String strError)
335   {
336     consoleDoc.outputErrorForeground(strError);
337   }
338
339   public void outputEcho(String strEcho)
340   {
341     consoleDoc.outputEcho(strEcho);
342   }
343
344   public void outputStatus(String strStatus)
345   {
346     consoleDoc.outputStatus(strStatus);
347   }
348
349   public void enterPressed()
350   {
351     if (enterListener != null)
352       enterListener.enterPressed();
353   }
354
355   public void clearContent()
356   {
357     clearContent(null);
358   }
359
360   public void clearContent(String text)
361   {
362     consoleDoc.clearContent();
363     if (text != null)
364       consoleDoc.outputEcho(text);
365     setPrompt();
366   }
367
368   /*
369    * (non-Javadoc)
370    * 
371    * @see java.awt.Component#processKeyEvent(java.awt.event.KeyEvent)
372    */
373
374   /**
375    * Custom key event processing for command 0 implementation.
376    * 
377    * Captures key up and key down strokes to call command history and redefines
378    * the same events with control down to allow caret vertical shift.
379    * 
380    * @see java.awt.Component#processKeyEvent(java.awt.event.KeyEvent)
381    */
382   protected void processKeyEvent(KeyEvent ke)
383   {
384     // Id Control key is down, captures events does command
385     // history recall and inhibits caret vertical shift.
386     if (ke.getKeyCode() == KeyEvent.VK_UP
387             && ke.getID() == KeyEvent.KEY_PRESSED && !ke.isControlDown())
388     {
389       recallCommand(true);
390     }
391     else if (ke.getKeyCode() == KeyEvent.VK_DOWN
392             && ke.getID() == KeyEvent.KEY_PRESSED && !ke.isControlDown())
393     {
394       recallCommand(false);
395     }
396     // If Control key is down, redefines the event as if it
397     // where a key up or key down stroke without modifiers.
398     // This allows to move the caret up and down
399     // with no command history recall.
400     else if ((ke.getKeyCode() == KeyEvent.VK_DOWN || ke.getKeyCode() == KeyEvent.VK_UP)
401             && ke.getID() == KeyEvent.KEY_PRESSED && ke.isControlDown())
402     {
403       super.processKeyEvent(new KeyEvent((Component) ke.getSource(), ke
404               .getID(), ke.getWhen(), 0, // No modifiers
405               ke.getKeyCode(), ke.getKeyChar(), ke.getKeyLocation()));
406     }
407     // Standard processing for other events.
408     else
409     {
410       super.processKeyEvent(ke);
411       // check command for compiler-identifyable syntax issues
412       // this may have to be taken out if people start complaining
413       // that only some of the commands are being checked
414       // that is -- that the script itself is not being fully checked
415
416       // not perfect -- help here?
417       if (ke.getID() == KeyEvent.KEY_RELEASED
418               && (ke.getKeyCode() > KeyEvent.VK_DOWN)
419               || ke.getKeyCode() == KeyEvent.VK_BACK_SPACE)
420         checkCommand();
421     }
422   }
423
424   /**
425    * Recall command history.
426    * 
427    * @param up
428    *          - history up or down
429    */
430   void recallCommand(boolean up)
431   {
432     String cmd = viewer.getSetHistory(up ? -1 : 1);
433     if (cmd == null)
434     {
435       return;
436     }
437     try
438     {
439       if (cmd.endsWith(CommandHistory.ERROR_FLAG))
440       {
441         cmd = cmd.substring(0, cmd.indexOf(CommandHistory.ERROR_FLAG));
442         consoleDoc.replaceCommand(cmd, true);
443       }
444       else
445       {
446         consoleDoc.replaceCommand(cmd, false);
447       }
448     } catch (BadLocationException e)
449     {
450       e.printStackTrace();
451     }
452   }
453
454   void checkCommand()
455   {
456     String strCommand = consoleDoc.getCommandString();
457     if (strCommand.length() == 0)
458       return;
459     consoleDoc
460             .colorCommand(viewer.scriptCheck(strCommand) == null ? consoleDoc.attUserInput
461                     : consoleDoc.attError);
462   }
463
464 }
465
466 class ConsoleDocument extends DefaultStyledDocument
467 {
468
469   ConsoleTextPane consoleTextPane;
470
471   SimpleAttributeSet attError;
472
473   SimpleAttributeSet attEcho;
474
475   SimpleAttributeSet attPrompt;
476
477   SimpleAttributeSet attUserInput;
478
479   SimpleAttributeSet attStatus;
480
481   ConsoleDocument()
482   {
483     super();
484
485     attError = new SimpleAttributeSet();
486     StyleConstants.setForeground(attError, Color.red);
487
488     attPrompt = new SimpleAttributeSet();
489     StyleConstants.setForeground(attPrompt, Color.magenta);
490
491     attUserInput = new SimpleAttributeSet();
492     StyleConstants.setForeground(attUserInput, Color.black);
493
494     attEcho = new SimpleAttributeSet();
495     StyleConstants.setForeground(attEcho, Color.blue);
496     StyleConstants.setBold(attEcho, true);
497
498     attStatus = new SimpleAttributeSet();
499     StyleConstants.setForeground(attStatus, Color.black);
500     StyleConstants.setItalic(attStatus, true);
501   }
502
503   void setConsoleTextPane(ConsoleTextPane consoleTextPane)
504   {
505     this.consoleTextPane = consoleTextPane;
506   }
507
508   Position positionBeforePrompt; // starts at 0, so first time isn't tracked
509
510   // (at least on Mac OS X)
511
512   Position positionAfterPrompt; // immediately after $, so this will track
513
514   int offsetAfterPrompt; // only still needed for the insertString override and
515
516   // replaceCommand
517
518   /**
519    * Removes all content of the script window, and add a new prompt.
520    */
521   void clearContent()
522   {
523     try
524     {
525       super.remove(0, getLength());
526     } catch (BadLocationException exception)
527     {
528       System.out.println("Could not clear script window content: "
529               + exception.getMessage());
530     }
531   }
532
533   void setPrompt()
534   {
535     try
536     {
537       super.insertString(getLength(), "$ ", attPrompt);
538       setOffsetPositions();
539       consoleTextPane.setCaretPosition(offsetAfterPrompt);
540     } catch (BadLocationException e)
541     {
542       e.printStackTrace();
543     }
544   }
545
546   void setOffsetPositions()
547   {
548     try
549     {
550       offsetAfterPrompt = getLength();
551       positionBeforePrompt = createPosition(offsetAfterPrompt - 2);
552       // after prompt should be immediately after $ otherwise tracks the end
553       // of the line (and no command will be found) at least on Mac OS X it did.
554       positionAfterPrompt = createPosition(offsetAfterPrompt - 1);
555     } catch (BadLocationException e)
556     {
557       e.printStackTrace();
558     }
559   }
560
561   void setNoPrompt()
562   {
563     try
564     {
565       offsetAfterPrompt = getLength();
566       positionAfterPrompt = positionBeforePrompt = createPosition(offsetAfterPrompt);
567       consoleTextPane.setCaretPosition(offsetAfterPrompt);
568     } catch (BadLocationException e)
569     {
570       e.printStackTrace();
571     }
572   }
573
574   // it looks like the positionBeforePrompt does not track when it started out
575   // as 0
576   // and a insertString at location 0 occurs. It may be better to track the
577   // position after the prompt in stead
578   void outputBeforePrompt(String str, SimpleAttributeSet attribute)
579   {
580     try
581     {
582       int pt = consoleTextPane.getCaretPosition();
583       Position caretPosition = createPosition(pt);
584       pt = positionBeforePrompt.getOffset();
585       super.insertString(pt, str + "\n", attribute);
586       setOffsetPositions();
587       pt = caretPosition.getOffset();
588       consoleTextPane.setCaretPosition(pt);
589     } catch (BadLocationException e)
590     {
591       e.printStackTrace();
592     }
593   }
594
595   void outputError(String strError)
596   {
597     outputBeforePrompt(strError, attError);
598   }
599
600   void outputErrorForeground(String strError)
601   {
602     try
603     {
604       super.insertString(getLength(), strError + "\n", attError);
605       consoleTextPane.setCaretPosition(getLength());
606     } catch (BadLocationException e)
607     {
608       e.printStackTrace();
609
610     }
611   }
612
613   void outputEcho(String strEcho)
614   {
615     outputBeforePrompt(strEcho, attEcho);
616   }
617
618   void outputStatus(String strStatus)
619   {
620     outputBeforePrompt(strStatus, attStatus);
621   }
622
623   void appendNewline()
624   {
625     try
626     {
627       super.insertString(getLength(), "\n", attUserInput);
628       consoleTextPane.setCaretPosition(getLength());
629     } catch (BadLocationException e)
630     {
631       e.printStackTrace();
632     }
633   }
634
635   // override the insertString to make sure everything typed ends up at the end
636   // or in the 'command line' using the proper font, and the newline is
637   // processed.
638   public void insertString(int offs, String str, AttributeSet a)
639           throws BadLocationException
640   {
641     int ichNewline = str.indexOf('\n');
642     if (ichNewline > 0)
643       str = str.substring(0, ichNewline);
644     if (ichNewline != 0)
645     {
646       if (offs < offsetAfterPrompt)
647       {
648         offs = getLength();
649       }
650       super.insertString(offs, str, a == attError ? a : attUserInput);
651       consoleTextPane.setCaretPosition(offs + str.length());
652     }
653     if (ichNewline >= 0)
654     {
655       consoleTextPane.enterPressed();
656     }
657   }
658
659   String getCommandString()
660   {
661     String strCommand = "";
662     try
663     {
664       int cmdStart = positionAfterPrompt.getOffset();
665       strCommand = getText(cmdStart, getLength() - cmdStart);
666       while (strCommand.length() > 0 && strCommand.charAt(0) == ' ')
667         strCommand = strCommand.substring(1);
668     } catch (BadLocationException e)
669     {
670       e.printStackTrace();
671     }
672     return strCommand;
673   }
674
675   public void remove(int offs, int len) throws BadLocationException
676   {
677     if (offs < offsetAfterPrompt)
678     {
679       len -= offsetAfterPrompt - offs;
680       if (len <= 0)
681         return;
682       offs = offsetAfterPrompt;
683     }
684     super.remove(offs, len);
685     // consoleTextPane.setCaretPosition(offs);
686   }
687
688   public void replace(int offs, int length, String str, AttributeSet attrs)
689           throws BadLocationException
690   {
691     if (offs < offsetAfterPrompt)
692     {
693       if (offs + length < offsetAfterPrompt)
694       {
695         offs = getLength();
696         length = 0;
697       }
698       else
699       {
700         length -= offsetAfterPrompt - offs;
701         offs = offsetAfterPrompt;
702       }
703     }
704     super.replace(offs, length, str, attrs);
705     // consoleTextPane.setCaretPosition(offs + str.length());
706   }
707
708   /**
709    * Replaces current command on script.
710    * 
711    * @param newCommand
712    *          new command value
713    * @param isError
714    *          true to set error color ends with #??
715    * 
716    * @throws BadLocationException
717    */
718   void replaceCommand(String newCommand, boolean isError)
719           throws BadLocationException
720   {
721     if (positionAfterPrompt == positionBeforePrompt)
722       return;
723     replace(offsetAfterPrompt, getLength() - offsetAfterPrompt, newCommand,
724             isError ? attError : attUserInput);
725   }
726
727   void colorCommand(SimpleAttributeSet att)
728   {
729     if (positionAfterPrompt == positionBeforePrompt)
730       return;
731     setCharacterAttributes(offsetAfterPrompt, getLength()
732             - offsetAfterPrompt, att, true);
733   }
734 }
735
736 interface EnterListener
737 {
738   public void enterPressed();
739 }