Merge branch 'JAL-3878_ws-overhaul-3' into with_ws_overhaul-3
[jalview.git] / src / jalview / gui / UserDefinedColours.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 java.util.Locale;
24
25 import jalview.bin.Cache;
26 import jalview.io.JalviewFileChooser;
27 import jalview.io.JalviewFileView;
28 import jalview.jbgui.GUserDefinedColours;
29 import jalview.schemes.ColourSchemeI;
30 import jalview.schemes.ColourSchemeLoader;
31 import jalview.schemes.ColourSchemes;
32 import jalview.schemes.ResidueProperties;
33 import jalview.schemes.UserColourScheme;
34 import jalview.util.ColorUtils;
35 import jalview.util.Format;
36 import jalview.util.MessageManager;
37 import jalview.util.Platform;
38 import jalview.xml.binding.jalview.JalviewUserColours;
39 import jalview.xml.binding.jalview.JalviewUserColours.Colour;
40 import jalview.xml.binding.jalview.ObjectFactory;
41
42 import java.awt.Color;
43 import java.awt.Font;
44 import java.awt.Insets;
45 import java.awt.event.MouseAdapter;
46 import java.awt.event.MouseEvent;
47 import java.io.File;
48 import java.io.FileOutputStream;
49 import java.io.OutputStreamWriter;
50 import java.io.PrintWriter;
51 import java.util.ArrayList;
52 import java.util.List;
53
54 import javax.swing.JButton;
55 import javax.swing.JInternalFrame;
56 import javax.swing.event.ChangeEvent;
57 import javax.swing.event.ChangeListener;
58 import javax.xml.bind.JAXBContext;
59 import javax.xml.bind.Marshaller;
60
61 /**
62  * This panel allows the user to assign colours to Amino Acid residue codes, and
63  * save the colour scheme.
64  * 
65  * @author Andrew Waterhouse
66  * @author Mungo Carstairs
67  */
68 public class UserDefinedColours extends GUserDefinedColours
69         implements ChangeListener
70 {
71   private static final Font VERDANA_BOLD_10 = new Font("Verdana", Font.BOLD,
72           10);
73
74   public static final String USER_DEFINED_COLOURS = "USER_DEFINED_COLOURS";
75
76   private static final String LAST_DIRECTORY = "LAST_DIRECTORY";
77
78   private static final int MY_FRAME_HEIGHT = 440;
79
80   private static final int MY_FRAME_WIDTH = 810;
81
82   private static final int MY_FRAME_WIDTH_CASE_SENSITIVE = 970;
83
84   AlignmentPanel ap;
85
86   /*
87    * the colour scheme when the dialog was opened, or
88    * the scheme last saved to file
89    */
90   ColourSchemeI oldColourScheme;
91
92   /*
93    * flag is true if the colour scheme has been changed since the
94    * dialog was opened, or the changes last saved to file
95    */
96   boolean changedButNotSaved;
97
98   JInternalFrame frame;
99
100   List<JButton> upperCaseButtons;
101
102   List<JButton> lowerCaseButtons;
103
104   /**
105    * Creates and displays a new UserDefinedColours panel
106    * 
107    * @param alignPanel
108    */
109   public UserDefinedColours(AlignmentPanel alignPanel)
110   {
111     this();
112
113     lcaseColour.setEnabled(false);
114
115     this.ap = alignPanel;
116
117     oldColourScheme = alignPanel.av.getGlobalColourScheme();
118
119     if (oldColourScheme instanceof UserColourScheme)
120     {
121       schemeName.setText(oldColourScheme.getSchemeName());
122       if (((UserColourScheme) oldColourScheme)
123               .getLowerCaseColours() != null)
124       {
125         caseSensitive.setSelected(true);
126         lcaseColour.setEnabled(true);
127         resetButtonPanel(true);
128       }
129       else
130       {
131         resetButtonPanel(false);
132       }
133     }
134     else
135     {
136       resetButtonPanel(false);
137     }
138
139     showFrame();
140   }
141
142   UserDefinedColours()
143   {
144     super();
145     selectedButtons = new ArrayList<>();
146   }
147
148   void showFrame()
149   {
150     colorChooser.getSelectionModel().addChangeListener(this);
151     frame = new JInternalFrame();
152     frame.setContentPane(this);
153     Desktop.addInternalFrame(frame,
154             MessageManager.getString("label.user_defined_colours"), Desktop.FRAME_MAKE_VISIBLE,
155             MY_FRAME_WIDTH, MY_FRAME_HEIGHT, Desktop.FRAME_ALLOW_RESIZE, Desktop.FRAME_SET_MIN_SIZE_300);
156   }
157
158   /**
159    * Rebuilds the panel with coloured buttons for residues. If not case
160    * sensitive colours, show 3-letter amino acid code as button text. If case
161    * sensitive, just show the single letter code, in order to make space for the
162    * additional buttons.
163    * 
164    * @param isCaseSensitive
165    */
166   void resetButtonPanel(boolean isCaseSensitive)
167   {
168     buttonPanel.removeAll();
169
170     if (upperCaseButtons == null)
171     {
172       upperCaseButtons = new ArrayList<>();
173     }
174
175     for (int i = 0; i < 20; i++)
176     {
177       String label = isCaseSensitive ? ResidueProperties.aa[i]
178               : ResidueProperties.aa2Triplet.get(ResidueProperties.aa[i])
179                       .toString();
180       JButton button = makeButton(label, ResidueProperties.aa[i],
181               upperCaseButtons, i);
182       buttonPanel.add(button);
183     }
184
185     buttonPanel.add(makeButton("B", "B", upperCaseButtons, 20));
186     buttonPanel.add(makeButton("Z", "Z", upperCaseButtons, 21));
187     buttonPanel.add(makeButton("X", "X", upperCaseButtons, 22));
188     buttonPanel.add(makeButton("Gap", "-", upperCaseButtons, 23));
189
190     if (!isCaseSensitive)
191     {
192       gridLayout.setRows(6);
193       gridLayout.setColumns(4);
194     }
195     else
196     {
197       gridLayout.setRows(7);
198       int cols = 7;
199       gridLayout.setColumns(cols + 1);
200
201       if (lowerCaseButtons == null)
202       {
203         lowerCaseButtons = new ArrayList<>();
204       }
205
206       for (int i = 0; i < 20; i++)
207       {
208         int row = i / cols + 1;
209         int index = (row * cols) + i;
210         JButton button = makeButton(
211                 ResidueProperties.aa[i].toLowerCase(Locale.ROOT),
212                 ResidueProperties.aa[i].toLowerCase(Locale.ROOT),
213                 lowerCaseButtons, i);
214
215         buttonPanel.add(button, index);
216       }
217     }
218
219     if (isCaseSensitive)
220     {
221       buttonPanel.add(makeButton("b", "b", lowerCaseButtons, 20));
222       buttonPanel.add(makeButton("z", "z", lowerCaseButtons, 21));
223       buttonPanel.add(makeButton("x", "x", lowerCaseButtons, 22));
224     }
225
226     // JAL-1360 widen the frame dynamically to accommodate case-sensitive AA
227     // codes
228     if (this.frame != null)
229     {
230       int newWidth = isCaseSensitive ? MY_FRAME_WIDTH_CASE_SENSITIVE
231               : MY_FRAME_WIDTH;
232       this.frame.setSize(newWidth, this.frame.getHeight());
233     }
234
235     buttonPanel.validate();
236     validate();
237   }
238
239   /**
240    * ChangeListener handler for when a colour is picked in the colour chooser.
241    * The action is to apply the colour to all selected buttons as their
242    * background colour. Foreground colour (text) is set to a lighter shade in
243    * order to highlight which buttons are selected. If 'Lower Case Colour' is
244    * active, then the colour is applied to all lower case buttons (as well as
245    * the Lower Case Colour button itself).
246    * 
247    * @param evt
248    */
249   @Override
250   public void stateChanged(ChangeEvent evt)
251   {
252     JButton button = null;
253     final Color newColour = colorChooser.getColor();
254     if (lcaseColour.isSelected())
255     {
256       selectedButtons.clear();
257       for (int i = 0; i < lowerCaseButtons.size(); i++)
258       {
259         button = lowerCaseButtons.get(i);
260         button.setBackground(newColour);
261         button.setForeground(
262                 ColorUtils.brighterThan(button.getBackground()));
263       }
264     }
265     for (int i = 0; i < selectedButtons.size(); i++)
266     {
267       button = selectedButtons.get(i);
268       button.setBackground(newColour);
269       button.setForeground(ColorUtils.brighterThan(newColour));
270     }
271
272     changedButNotSaved = true;
273   }
274
275   /**
276    * Performs actions when a residue button is clicked. This manages the button
277    * selection set (highlighted by brighter foreground text).
278    * <p>
279    * On select button(s) with Ctrl/click or Shift/click: set button foreground
280    * text to brighter than background.
281    * <p>
282    * On unselect button(s) with Ctrl/click on selected, or click to release
283    * current selection: reset foreground text to darker than background.
284    * <p>
285    * Simple click: clear selection (resetting foreground to darker); set clicked
286    * button foreground to brighter
287    * <p>
288    * Finally, synchronize the colour chooser to the colour of the first button
289    * in the selected set.
290    * 
291    * @param e
292    */
293   public void colourButtonPressed(MouseEvent e)
294   {
295     JButton pressed = (JButton) e.getSource();
296
297     if (e.isShiftDown())
298     {
299       JButton start, end = (JButton) e.getSource();
300       if (selectedButtons.size() > 0)
301       {
302         start = selectedButtons.get(selectedButtons.size() - 1);
303       }
304       else
305       {
306         start = (JButton) e.getSource();
307       }
308
309       int startIndex = 0, endIndex = 0;
310       for (int b = 0; b < buttonPanel.getComponentCount(); b++)
311       {
312         if (buttonPanel.getComponent(b) == start)
313         {
314           startIndex = b;
315         }
316         if (buttonPanel.getComponent(b) == end)
317         {
318           endIndex = b;
319         }
320       }
321
322       if (startIndex > endIndex)
323       {
324         int temp = startIndex;
325         startIndex = endIndex;
326         endIndex = temp;
327       }
328
329       for (int b = startIndex; b <= endIndex; b++)
330       {
331         JButton button = (JButton) buttonPanel.getComponent(b);
332         if (!selectedButtons.contains(button))
333         {
334           button.setForeground(
335                   ColorUtils.brighterThan(button.getBackground()));
336           selectedButtons.add(button);
337         }
338       }
339     }
340     else if (!e.isControlDown())
341     {
342       for (int b = 0; b < selectedButtons.size(); b++)
343       {
344         JButton button = selectedButtons.get(b);
345         button.setForeground(ColorUtils.darkerThan(button.getBackground()));
346       }
347       selectedButtons.clear();
348       pressed.setForeground(
349               ColorUtils.brighterThan(pressed.getBackground()));
350       selectedButtons.add(pressed);
351
352     }
353     else if (e.isControlDown())
354     {
355       if (selectedButtons.contains(pressed))
356       {
357         pressed.setForeground(
358                 ColorUtils.darkerThan(pressed.getBackground()));
359         selectedButtons.remove(pressed);
360       }
361       else
362       {
363         pressed.setForeground(
364                 ColorUtils.brighterThan(pressed.getBackground()));
365         selectedButtons.add(pressed);
366       }
367     }
368
369     if (selectedButtons.size() > 0)
370     {
371       colorChooser.setColor((selectedButtons.get(0)).getBackground());
372     }
373   }
374
375   /**
376    * A helper method to update or make a colour button, whose background colour
377    * is the associated colour, and text colour a darker shade of the same. If
378    * the button is already in the list, then its text and margins are updated,
379    * if not then it is created and added. This method supports toggling between
380    * case-sensitive and case-insensitive button panels. The case-sensitive
381    * version has abbreviated button text in order to fit in more buttons.
382    * 
383    * @param label
384    * @param residue
385    * @param the
386    *          list of buttons
387    * @param buttonIndex
388    *          the button's position in the list
389    */
390   JButton makeButton(String label, String residue, List<JButton> buttons,
391           int buttonIndex)
392   {
393     final JButton button;
394     Color col;
395
396     if (buttonIndex < buttons.size())
397     {
398       button = buttons.get(buttonIndex);
399       col = button.getBackground();
400     }
401     else
402     {
403       button = new JButton();
404       button.addMouseListener(new MouseAdapter()
405       {
406         @Override
407         public void mouseClicked(MouseEvent e)
408         {
409           colourButtonPressed(e);
410         }
411       });
412
413       buttons.add(button);
414
415       /*
416        * make initial button colour that of the current colour scheme,
417        * if it is a simple per-residue colouring, else white
418        */
419       col = Color.white;
420       if (oldColourScheme != null && oldColourScheme.isSimple())
421       {
422         col = oldColourScheme.findColour(residue.charAt(0), 0, null, null,
423                 0f);
424       }
425     }
426
427     if (caseSensitive.isSelected())
428     {
429       button.setMargin(new Insets(2, 2, 2, 2));
430     }
431     else
432     {
433       button.setMargin(new Insets(2, 14, 2, 14));
434     }
435
436     button.setOpaque(true); // required for the next line to have effect
437     button.setBackground(col);
438     button.setText(label);
439     button.setForeground(ColorUtils.darkerThan(col));
440     button.setFont(VERDANA_BOLD_10);
441
442     return button;
443   }
444
445   /**
446    * On 'OK', check that at least one colour has been assigned to a residue (and
447    * if not issue a warning), and apply the chosen colour scheme and close the
448    * panel.
449    */
450   @Override
451   protected void okButton_actionPerformed()
452   {
453     if (isNoSelectionMade())
454     {
455       JvOptionPane.showMessageDialog(Desktop.getDesktopPane(),
456               MessageManager
457                       .getString("label.no_colour_selection_in_scheme"),
458               MessageManager.getString("label.no_colour_selection_warn"),
459               JvOptionPane.WARNING_MESSAGE);
460     }
461     else
462     {
463       /*
464        * OK is treated as 'apply colours and close'
465        */
466       applyButton_actionPerformed();
467
468       /*
469        * If editing a named colour scheme, warn if changes
470        * have not been saved
471        */
472       warnIfUnsavedChanges();
473
474       try
475       {
476         frame.setClosed(true);
477       } catch (Exception ex)
478       {
479       }
480     }
481   }
482
483   /**
484    * If we have made changes to an existing user defined colour scheme but not
485    * saved them, show a dialog with the option to save. If the user chooses to
486    * save, do so, else clear the colour scheme name to indicate a new colour
487    * scheme.
488    */
489   protected void warnIfUnsavedChanges()
490   {
491     // BH 2018 no warning in JavaScript TODO
492
493     if (!Platform.isJS() && changedButNotSaved)
494     /**
495      * Java only
496      * 
497      * @j2sIgnore
498      */
499     {
500       String name = schemeName.getText().trim();
501       if (oldColourScheme != null && !"".equals(name)
502               && name.equals(oldColourScheme.getSchemeName()))
503       {
504         String message = MessageManager
505                 .formatMessage("label.scheme_changed", name);
506         String title = MessageManager.getString("label.save_changes");
507         String[] options = new String[] { title,
508             MessageManager.getString("label.dont_save_changes"), };
509         final String question = JvSwingUtils.wrapTooltip(true, message);
510         int response = JvOptionPane.showOptionDialog(Desktop.getDesktopPane(),
511                 question, title, JvOptionPane.DEFAULT_OPTION,
512                 JvOptionPane.PLAIN_MESSAGE, null, options, options[0]);
513
514         if (response == 0)
515         {
516           /*
517            * prompt to save changes to file; if done,
518            * resets 'changed' flag to false
519            */
520           savebutton_actionPerformed();
521         }
522
523         /*
524          * if user chooses not to save (either in this dialog or in the
525          * save as dialogs), treat this as a new user defined colour scheme
526          */
527         if (changedButNotSaved)
528         {
529           /*
530            * clear scheme name and re-apply as an anonymous scheme
531            */
532           schemeName.setText("");
533           applyButton_actionPerformed();
534         }
535       }
536     }
537   }
538
539   /**
540    * Returns true if the user has not made any colour selection (including if
541    * 'case-sensitive' selected and no lower-case colour chosen).
542    * 
543    * @return
544    */
545   protected boolean isNoSelectionMade()
546   {
547     final boolean noUpperCaseSelected = upperCaseButtons == null
548             || upperCaseButtons.isEmpty();
549     final boolean noLowerCaseSelected = caseSensitive.isSelected()
550             && (lowerCaseButtons == null || lowerCaseButtons.isEmpty());
551     final boolean noSelectionMade = noUpperCaseSelected
552             || noLowerCaseSelected;
553     return noSelectionMade;
554   }
555
556   /**
557    * Applies the current colour scheme to the alignment or sequence group
558    */
559   @Override
560   protected void applyButton_actionPerformed()
561   {
562     if (isNoSelectionMade())
563     {
564       JvOptionPane.showMessageDialog(Desktop.getDesktopPane(),
565               MessageManager
566                       .getString("label.no_colour_selection_in_scheme"),
567               MessageManager.getString("label.no_colour_selection_warn"),
568               JvOptionPane.WARNING_MESSAGE);
569
570     }
571     UserColourScheme ucs = getSchemeFromButtons();
572
573     ap.alignFrame.changeColour(ucs);
574   }
575
576   /**
577    * Constructs an instance of UserColourScheme with the residue colours
578    * currently set on the buttons on the panel
579    * 
580    * @return
581    */
582   UserColourScheme getSchemeFromButtons()
583   {
584
585     Color[] newColours = new Color[24];
586
587     int length = upperCaseButtons.size();
588     if (length < 24)
589     {
590       int i = 0;
591       for (JButton btn : upperCaseButtons)
592       {
593         newColours[i] = btn.getBackground();
594         i++;
595       }
596     }
597     else
598     {
599       for (int i = 0; i < 24; i++)
600       {
601         JButton button = upperCaseButtons.get(i);
602         newColours[i] = button.getBackground();
603       }
604     }
605
606     UserColourScheme ucs = new UserColourScheme(newColours);
607     ucs.setName(schemeName.getText());
608
609     if (caseSensitive.isSelected())
610     {
611       newColours = new Color[23];
612       length = lowerCaseButtons.size();
613       if (length < 23)
614       {
615         int i = 0;
616         for (JButton btn : lowerCaseButtons)
617         {
618           newColours[i] = btn.getBackground();
619           i++;
620         }
621       }
622       else
623       {
624         for (int i = 0; i < 23; i++)
625         {
626           JButton button = lowerCaseButtons.get(i);
627           newColours[i] = button.getBackground();
628         }
629       }
630       ucs.setLowerCaseColours(newColours);
631     }
632
633     return ucs;
634   }
635
636   /**
637    * Action on clicking Load scheme button.
638    * <ul>
639    * <li>Open a file chooser to browse for files with extension .jc</li>
640    * <li>Load in the colour scheme and transfer it to this panel's buttons</li>
641    * <li>Register the loaded colour scheme</li>
642    * </ul>
643    */
644   @Override
645   protected void loadbutton_actionPerformed()
646   {
647     upperCaseButtons = new ArrayList<>();
648     lowerCaseButtons = new ArrayList<>();
649     JalviewFileChooser chooser = new JalviewFileChooser("jc",
650             "Jalview User Colours");
651     chooser.setFileView(new JalviewFileView());
652     chooser.setDialogTitle(
653             MessageManager.getString("label.load_colour_scheme"));
654     chooser.setToolTipText(MessageManager.getString("action.load"));
655     chooser.setResponseHandler(0, new Runnable()
656     {
657       @Override
658       public void run()
659       {
660         File choice = chooser.getSelectedFile();
661         Cache.setProperty(LAST_DIRECTORY, choice.getParent());
662
663         UserColourScheme ucs = ColourSchemeLoader
664                 .loadColourScheme(choice.getAbsolutePath());
665         Color[] colors = ucs.getColours();
666         schemeName.setText(ucs.getSchemeName());
667
668         if (ucs.getLowerCaseColours() != null)
669         {
670           caseSensitive.setSelected(true);
671           lcaseColour.setEnabled(true);
672           resetButtonPanel(true);
673           for (int i = 0; i < lowerCaseButtons.size(); i++)
674           {
675             JButton button = lowerCaseButtons.get(i);
676             button.setBackground(ucs.getLowerCaseColours()[i]);
677           }
678         }
679         else
680         {
681           caseSensitive.setSelected(false);
682           lcaseColour.setEnabled(false);
683           resetButtonPanel(false);
684         }
685
686         for (int i = 0; i < upperCaseButtons.size(); i++)
687         {
688           JButton button = upperCaseButtons.get(i);
689           button.setBackground(colors[i]);
690         }
691
692         addNewColourScheme(choice.getPath());
693       }
694     });
695
696     chooser.showOpenDialog(this);
697   }
698
699   /**
700    * Loads the user-defined colour scheme from the first file listed in property
701    * "USER_DEFINED_COLOURS". If this fails, returns an all-white colour scheme.
702    * 
703    * @return
704    */
705   public static UserColourScheme loadDefaultColours()
706   {
707     UserColourScheme ret = null;
708
709     String colours = Cache.getProperty(USER_DEFINED_COLOURS);
710     if (colours != null)
711     {
712       if (colours.indexOf("|") > -1)
713       {
714         colours = colours.substring(0, colours.indexOf("|"));
715       }
716       ret = ColourSchemeLoader.loadColourScheme(colours);
717     }
718
719     if (ret == null)
720     {
721       ret = new UserColourScheme("white");
722     }
723
724     return ret;
725   }
726
727   /**
728    * Action on pressing the Save button.
729    * <ul>
730    * <li>Check a name has been entered</li>
731    * <li>Warn if the name already exists, remove any existing scheme of the same
732    * name if overwriting</li>
733    * <li>Do the standard file chooser thing to write with extension .jc</li>
734    * <li>If saving changes (possibly not yet applied) to the currently selected
735    * colour scheme, then apply the changes, as it is too late to back out
736    * now</li>
737    * <li>Don't apply the changes if the currently selected scheme is different,
738    * to allow a new scheme to be configured and saved but not applied</li>
739    * </ul>
740    * If the scheme is saved to file, the 'changed' flag field is reset to false.
741    */
742   @Override
743   protected void savebutton_actionPerformed()
744   {
745     String name = schemeName.getText().trim();
746     if (name.length() < 1)
747     {
748       JvOptionPane.showInternalMessageDialog(Desktop.getDesktopPane(),
749               MessageManager
750                       .getString("label.user_colour_scheme_must_have_name"),
751               MessageManager.getString("label.no_name_colour_scheme"),
752               JvOptionPane.WARNING_MESSAGE);
753     }
754
755     if (!Platform.isJS() && ColourSchemes.getInstance().nameExists(name))
756     {
757       /**
758        * java only
759        * 
760        * @j2sIgnore
761        */
762       {
763         int reply = JvOptionPane.showInternalConfirmDialog(Desktop.getDesktopPane(),
764                 MessageManager.formatMessage(
765                         "label.colour_scheme_exists_overwrite", new Object[]
766                         { name, name }),
767                 MessageManager.getString("label.duplicate_scheme_name"),
768                 JvOptionPane.YES_NO_OPTION);
769         if (reply != JvOptionPane.YES_OPTION)
770         {
771           return;
772         }
773       }
774     }
775
776     JalviewFileChooser chooser = new JalviewFileChooser("jc",
777             "Jalview User Colours");
778
779     JalviewFileView fileView = new JalviewFileView();
780     chooser.setFileView(fileView);
781     chooser.setDialogTitle(
782             MessageManager.getString("label.save_colour_scheme"));
783     chooser.setToolTipText(MessageManager.getString("action.save"));
784     int option = chooser.showSaveDialog(this);
785     if (option == JalviewFileChooser.APPROVE_OPTION)
786     {
787       File file = chooser.getSelectedFile();
788       UserColourScheme updatedScheme = addNewColourScheme(file.getPath());
789       saveToFile(file);
790       changedButNotSaved = false;
791
792       /*
793        * changes saved - apply to alignment if we are changing 
794        * the currently selected colour scheme; also make the updated
795        * colours the 'backout' scheme on Cancel
796        */
797       if (oldColourScheme != null
798               && name.equals(oldColourScheme.getSchemeName()))
799       {
800         oldColourScheme = updatedScheme;
801         applyButton_actionPerformed();
802       }
803     }
804   }
805
806   /**
807    * Adds the current colour scheme to the Jalview properties file so it is
808    * loaded on next startup, and updates the Colour menu in the parent
809    * AlignFrame (if there is one). Note this action does not including applying
810    * the colour scheme.
811    * 
812    * @param filePath
813    * @return
814    */
815   protected UserColourScheme addNewColourScheme(String filePath)
816   {
817     /*
818      * update the delimited list of user defined colour files in
819      * Jalview property USER_DEFINED_COLOURS
820      */
821     String defaultColours = Cache.getDefault(USER_DEFINED_COLOURS,
822             filePath);
823     if (defaultColours.indexOf(filePath) == -1)
824     {
825       if (defaultColours.length() > 0)
826       {
827         defaultColours = defaultColours.concat("|");
828       }
829       defaultColours = defaultColours.concat(filePath);
830     }
831     Cache.setProperty(USER_DEFINED_COLOURS, defaultColours);
832
833     /*
834      * construct and register the colour scheme
835      */
836     UserColourScheme ucs = getSchemeFromButtons();
837     ColourSchemes.getInstance().registerColourScheme(ucs);
838
839     /*
840      * update the Colour menu items
841      */
842     if (ap != null)
843     {
844       ap.alignFrame.buildColourMenu();
845     }
846
847     return ucs;
848   }
849
850   /**
851    * Saves the colour scheme to file in XML format
852    * 
853    * @param path
854    */
855   protected void saveToFile(File toFile)
856   {
857     /*
858      * build a Java model of colour scheme as XML, and 
859      * marshal to file
860      */
861     JalviewUserColours ucs = new JalviewUserColours();
862     String name = schemeName.getText();
863     ucs.setSchemeName(name);
864     try
865     {
866       PrintWriter out = new PrintWriter(new OutputStreamWriter(
867               new FileOutputStream(toFile), "UTF-8"));
868
869       for (int i = 0; i < buttonPanel.getComponentCount(); i++)
870       {
871         JButton button = (JButton) buttonPanel.getComponent(i);
872         Colour col = new Colour();
873         col.setName(button.getText());
874         col.setRGB(Format.getHexString(button.getBackground()));
875         ucs.getColour().add(col);
876       }
877       JAXBContext jaxbContext = JAXBContext
878               .newInstance(JalviewUserColours.class);
879       Marshaller jaxbMarshaller = jaxbContext.createMarshaller();
880       jaxbMarshaller.marshal(
881               new ObjectFactory().createJalviewUserColours(ucs), out);
882       // ucs.marshal(out);
883       out.close();
884     } catch (Exception ex)
885     {
886       ex.printStackTrace();
887     }
888   }
889
890   /**
891    * On cancel, restores the colour scheme that was selected before the dialogue
892    * was opened
893    */
894   @Override
895   protected void cancelButton_actionPerformed()
896   {
897     ap.alignFrame.changeColour(oldColourScheme);
898     ap.paintAlignment(true, true);
899
900     try
901     {
902       frame.setClosed(true);
903     } catch (Exception ex)
904     {
905     }
906   }
907
908   /**
909    * Action on selecting or deselecting the Case Sensitive option. When
910    * selected, separate buttons are shown for lower case residues, and the panel
911    * is resized to accommodate them. Also, the checkbox for 'apply colour to all
912    * lower case' is enabled.
913    */
914   @Override
915   public void caseSensitive_actionPerformed()
916   {
917     boolean selected = caseSensitive.isSelected();
918     resetButtonPanel(selected);
919     lcaseColour.setEnabled(selected);
920   }
921 }