Merge branch 'patch/JAL-4345_pae_epas1_doubleclick' into develop
[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.awt.Color;
24 import java.awt.Font;
25 import java.awt.Insets;
26 import java.awt.event.MouseAdapter;
27 import java.awt.event.MouseEvent;
28 import java.io.File;
29 import java.io.FileOutputStream;
30 import java.io.OutputStreamWriter;
31 import java.io.PrintWriter;
32 import java.util.ArrayList;
33 import java.util.List;
34 import java.util.Locale;
35
36 import javax.swing.JButton;
37 import javax.swing.JInternalFrame;
38 import javax.swing.event.ChangeEvent;
39 import javax.swing.event.ChangeListener;
40 import javax.xml.bind.JAXBContext;
41 import javax.xml.bind.Marshaller;
42
43 import jalview.bin.Cache;
44 import jalview.io.JalviewFileChooser;
45 import jalview.io.JalviewFileView;
46 import jalview.jbgui.GUserDefinedColours;
47 import jalview.schemes.ColourSchemeI;
48 import jalview.schemes.ColourSchemeLoader;
49 import jalview.schemes.ColourSchemes;
50 import jalview.schemes.ResidueProperties;
51 import jalview.schemes.UserColourScheme;
52 import jalview.util.ColorUtils;
53 import jalview.util.Format;
54 import jalview.util.MessageManager;
55 import jalview.util.Platform;
56 import jalview.xml.binding.jalview.JalviewUserColours;
57 import jalview.xml.binding.jalview.JalviewUserColours.Colour;
58 import jalview.xml.binding.jalview.ObjectFactory;
59
60 /**
61  * This panel allows the user to assign colours to Amino Acid residue codes, and
62  * save the colour scheme.
63  * 
64  * @author Andrew Waterhouse
65  * @author Mungo Carstairs
66  */
67 public class UserDefinedColours extends GUserDefinedColours
68         implements ChangeListener
69 {
70   private static final Font VERDANA_BOLD_10 = new Font("Verdana", Font.BOLD,
71           10);
72
73   public static final String USER_DEFINED_COLOURS = "USER_DEFINED_COLOURS";
74
75   private static final String LAST_DIRECTORY = "LAST_DIRECTORY";
76
77   private static final int MY_FRAME_HEIGHT = 440;
78
79   private static final int MY_FRAME_WIDTH = 810;
80
81   private static final int MY_FRAME_WIDTH_CASE_SENSITIVE = 970;
82
83   AlignmentPanel ap;
84
85   /*
86    * the colour scheme when the dialog was opened, or
87    * the scheme last saved to file
88    */
89   ColourSchemeI oldColourScheme;
90
91   /*
92    * flag is true if the colour scheme has been changed since the
93    * dialog was opened, or the changes last saved to file
94    */
95   boolean changedButNotSaved;
96
97   JInternalFrame frame;
98
99   List<JButton> upperCaseButtons;
100
101   List<JButton> lowerCaseButtons;
102
103   /**
104    * Creates and displays a new UserDefinedColours panel
105    * 
106    * @param alignPanel
107    */
108   public UserDefinedColours(AlignmentPanel alignPanel)
109   {
110     this();
111
112     lcaseColour.setEnabled(false);
113
114     this.ap = alignPanel;
115
116     oldColourScheme = alignPanel.av.getGlobalColourScheme();
117
118     if (oldColourScheme instanceof UserColourScheme)
119     {
120       schemeName.setText(oldColourScheme.getSchemeName());
121       if (((UserColourScheme) oldColourScheme)
122               .getLowerCaseColours() != null)
123       {
124         caseSensitive.setSelected(true);
125         lcaseColour.setEnabled(true);
126         resetButtonPanel(true);
127       }
128       else
129       {
130         resetButtonPanel(false);
131       }
132     }
133     else
134     {
135       resetButtonPanel(false);
136     }
137
138     showFrame();
139   }
140
141   UserDefinedColours()
142   {
143     super();
144     selectedButtons = new ArrayList<>();
145   }
146
147   void showFrame()
148   {
149     colorChooser.getSelectionModel().addChangeListener(this);
150     frame = new JInternalFrame();
151     frame.setFrameIcon(null);
152     frame.setContentPane(this);
153     Desktop.addInternalFrame(frame,
154             MessageManager.getString("label.user_defined_colours"),
155             MY_FRAME_WIDTH, MY_FRAME_HEIGHT, true);
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.desktop,
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.desktop,
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.desktop,
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, () -> {
656       File choice = chooser.getSelectedFile();
657       Cache.setProperty(LAST_DIRECTORY, choice.getParent());
658
659       UserColourScheme ucs = ColourSchemeLoader
660               .loadColourScheme(choice.getAbsolutePath());
661       Color[] colors = ucs.getColours();
662       schemeName.setText(ucs.getSchemeName());
663
664       if (ucs.getLowerCaseColours() != null)
665       {
666         caseSensitive.setSelected(true);
667         lcaseColour.setEnabled(true);
668         resetButtonPanel(true);
669         for (int i = 0; i < lowerCaseButtons.size(); i++)
670         {
671           JButton button = lowerCaseButtons.get(i);
672           button.setBackground(ucs.getLowerCaseColours()[i]);
673         }
674       }
675       else
676       {
677         caseSensitive.setSelected(false);
678         lcaseColour.setEnabled(false);
679         resetButtonPanel(false);
680       }
681
682       for (int i = 0; i < upperCaseButtons.size(); i++)
683       {
684         JButton button = upperCaseButtons.get(i);
685         button.setBackground(colors[i]);
686       }
687
688       addNewColourScheme(choice.getPath());
689     });
690
691     chooser.showOpenDialog(this);
692   }
693
694   /**
695    * Loads the user-defined colour scheme from the first file listed in property
696    * "USER_DEFINED_COLOURS". If this fails, returns an all-white colour scheme.
697    * 
698    * @return
699    */
700   public static UserColourScheme loadDefaultColours()
701   {
702     UserColourScheme ret = null;
703
704     String colours = Cache.getProperty(USER_DEFINED_COLOURS);
705     if (colours != null)
706     {
707       if (colours.indexOf("|") > -1)
708       {
709         colours = colours.substring(0, colours.indexOf("|"));
710       }
711       ret = ColourSchemeLoader.loadColourScheme(colours);
712     }
713
714     if (ret == null)
715     {
716       ret = new UserColourScheme("white");
717     }
718
719     return ret;
720   }
721
722   /**
723    * Action on pressing the Save button.
724    * <ul>
725    * <li>Check a name has been entered</li>
726    * <li>Warn if the name already exists, remove any existing scheme of the same
727    * name if overwriting</li>
728    * <li>Do the standard file chooser thing to write with extension .jc</li>
729    * <li>If saving changes (possibly not yet applied) to the currently selected
730    * colour scheme, then apply the changes, as it is too late to back out
731    * now</li>
732    * <li>Don't apply the changes if the currently selected scheme is different,
733    * to allow a new scheme to be configured and saved but not applied</li>
734    * </ul>
735    * If the scheme is saved to file, the 'changed' flag field is reset to false.
736    */
737   @Override
738   protected void savebutton_actionPerformed()
739   {
740     String name = schemeName.getText().trim();
741     if (name.length() < 1)
742     {
743       JvOptionPane.showInternalMessageDialog(Desktop.desktop,
744               MessageManager
745                       .getString("label.user_colour_scheme_must_have_name"),
746               MessageManager.getString("label.no_name_colour_scheme"),
747               JvOptionPane.WARNING_MESSAGE);
748     }
749
750     if (!Platform.isJS() && ColourSchemes.getInstance().nameExists(name))
751     {
752       /**
753        * java only
754        * 
755        * @j2sIgnore
756        */
757       {
758         int reply = JvOptionPane.showInternalConfirmDialog(Desktop.desktop,
759                 MessageManager.formatMessage(
760                         "label.colour_scheme_exists_overwrite", new Object[]
761                         { name, name }),
762                 MessageManager.getString("label.duplicate_scheme_name"),
763                 JvOptionPane.YES_NO_OPTION);
764         if (reply != JvOptionPane.YES_OPTION)
765         {
766           return;
767         }
768       }
769     }
770
771     JalviewFileChooser chooser = new JalviewFileChooser("jc",
772             "Jalview User Colours");
773
774     JalviewFileView fileView = new JalviewFileView();
775     chooser.setFileView(fileView);
776     chooser.setDialogTitle(
777             MessageManager.getString("label.save_colour_scheme"));
778     chooser.setToolTipText(MessageManager.getString("action.save"));
779     int option = chooser.showSaveDialog(this);
780     if (option == JalviewFileChooser.APPROVE_OPTION)
781     {
782       File file = chooser.getSelectedFile();
783       UserColourScheme updatedScheme = addNewColourScheme(file.getPath());
784       saveToFile(file);
785       changedButNotSaved = false;
786
787       /*
788        * changes saved - apply to alignment if we are changing 
789        * the currently selected colour scheme; also make the updated
790        * colours the 'backout' scheme on Cancel
791        */
792       if (oldColourScheme != null
793               && name.equals(oldColourScheme.getSchemeName()))
794       {
795         oldColourScheme = updatedScheme;
796         applyButton_actionPerformed();
797       }
798     }
799   }
800
801   /**
802    * Adds the current colour scheme to the Jalview properties file so it is
803    * loaded on next startup, and updates the Colour menu in the parent
804    * AlignFrame (if there is one). Note this action does not including applying
805    * the colour scheme.
806    * 
807    * @param filePath
808    * @return
809    */
810   protected UserColourScheme addNewColourScheme(String filePath)
811   {
812     /*
813      * update the delimited list of user defined colour files in
814      * Jalview property USER_DEFINED_COLOURS
815      */
816     String defaultColours = Cache.getDefault(USER_DEFINED_COLOURS,
817             filePath);
818     if (defaultColours.indexOf(filePath) == -1)
819     {
820       if (defaultColours.length() > 0)
821       {
822         defaultColours = defaultColours.concat("|");
823       }
824       defaultColours = defaultColours.concat(filePath);
825     }
826     Cache.setProperty(USER_DEFINED_COLOURS, defaultColours);
827
828     /*
829      * construct and register the colour scheme
830      */
831     UserColourScheme ucs = getSchemeFromButtons();
832     ColourSchemes.getInstance().registerColourScheme(ucs);
833
834     /*
835      * update the Colour menu items
836      */
837     if (ap != null)
838     {
839       ap.alignFrame.buildColourMenu();
840     }
841
842     return ucs;
843   }
844
845   /**
846    * Saves the colour scheme to file in XML format
847    * 
848    * @param path
849    */
850   protected void saveToFile(File toFile)
851   {
852     /*
853      * build a Java model of colour scheme as XML, and 
854      * marshal to file
855      */
856     JalviewUserColours ucs = new JalviewUserColours();
857     String name = schemeName.getText();
858     ucs.setSchemeName(name);
859     try
860     {
861       PrintWriter out = new PrintWriter(new OutputStreamWriter(
862               new FileOutputStream(toFile), "UTF-8"));
863
864       for (int i = 0; i < buttonPanel.getComponentCount(); i++)
865       {
866         JButton button = (JButton) buttonPanel.getComponent(i);
867         Colour col = new Colour();
868         col.setName(button.getText());
869         col.setRGB(Format.getHexString(button.getBackground()));
870         ucs.getColour().add(col);
871       }
872       JAXBContext jaxbContext = JAXBContext
873               .newInstance(JalviewUserColours.class);
874       Marshaller jaxbMarshaller = jaxbContext.createMarshaller();
875       jaxbMarshaller.marshal(
876               new ObjectFactory().createJalviewUserColours(ucs), out);
877       // ucs.marshal(out);
878       out.close();
879     } catch (Exception ex)
880     {
881       ex.printStackTrace();
882     }
883   }
884
885   /**
886    * On cancel, restores the colour scheme that was selected before the dialogue
887    * was opened
888    */
889   @Override
890   protected void cancelButton_actionPerformed()
891   {
892     ap.alignFrame.changeColour(oldColourScheme);
893     ap.paintAlignment(true, true);
894
895     try
896     {
897       frame.setClosed(true);
898     } catch (Exception ex)
899     {
900     }
901   }
902
903   /**
904    * Action on selecting or deselecting the Case Sensitive option. When
905    * selected, separate buttons are shown for lower case residues, and the panel
906    * is resized to accommodate them. Also, the checkbox for 'apply colour to all
907    * lower case' is enabled.
908    */
909   @Override
910   public void caseSensitive_actionPerformed()
911   {
912     boolean selected = caseSensitive.isSelected();
913     resetButtonPanel(selected);
914     lcaseColour.setEnabled(selected);
915   }
916 }