src/jalview/gui/UserDefinedColours.java

   1 /*
   2  * Jalview - A Sequence Alignment Editor and Viewer (Version 2.8.2)
   3  * Copyright (C) 2014 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 jalview.datamodel.SequenceGroup;
  24 import jalview.io.JalviewFileChooser;
  25 import jalview.jbgui.GUserDefinedColours;
  26 import jalview.schemes.ColourSchemeI;
  27 import jalview.schemes.ResidueProperties;
  28 import jalview.schemes.UserColourScheme;
  29 import jalview.util.MessageManager;
  30
  31 import java.awt.Color;
  32 import java.awt.Font;
  33 import java.awt.event.ActionEvent;
  34 import java.awt.event.MouseEvent;
  35 import java.io.File;
  36 import java.io.FileInputStream;
  37 import java.io.FileOutputStream;
  38 import java.io.InputStreamReader;
  39 import java.io.OutputStreamWriter;
  40 import java.io.PrintWriter;
  41 import java.util.Hashtable;
  42 import java.util.StringTokenizer;
  43 import java.util.Vector;
  44
  45 import javax.swing.JButton;
  46 import javax.swing.JInternalFrame;
  47 import javax.swing.JOptionPane;
  48 import javax.swing.event.ChangeEvent;
  49 import javax.swing.event.ChangeListener;
  50
  51 /**
  52  * DOCUMENT ME!
  53  *
  54  * @author $author$
  55  * @version $Revision$
  56  */
  57 public class UserDefinedColours extends GUserDefinedColours implements
  58         ChangeListener
  59 {
  60   AlignmentPanel ap;
  61
  62   SequenceGroup seqGroup;
  63
  64   Vector selectedButtons;
  65
  66   ColourSchemeI oldColourScheme;
  67
  68   JInternalFrame frame;
  69
  70   AppJmol jmol;
  71
  72   Vector upperCaseButtons;
  73
  74   Vector lowerCaseButtons;
  75
  76   /**
  77    * Creates a new UserDefinedColours object.
  78    *
  79    * @param ap
  80    *          DOCUMENT ME!
  81    * @param sg
  82    *          DOCUMENT ME!
  83    */
  84   public UserDefinedColours(AlignmentPanel ap, SequenceGroup sg)
  85   {
  86     super();
  87
  88     lcaseColour.setEnabled(false);
  89
  90     this.ap = ap;
  91     seqGroup = sg;
  92
  93     if (seqGroup != null)
  94     {
  95       oldColourScheme = seqGroup.cs;
  96     }
  97     else
  98     {
  99       oldColourScheme = ap.av.getGlobalColourScheme();
 100     }
 101
 102     if (oldColourScheme instanceof UserColourScheme)
 103     {
 104       schemeName.setText(((UserColourScheme) oldColourScheme).getName());
 105       if (((UserColourScheme) oldColourScheme).getLowerCaseColours() != null)
 106       {
 107         caseSensitive.setSelected(true);
 108         lcaseColour.setEnabled(true);
 109         resetButtonPanel(true);
 110       }
 111       else
 112       {
 113         resetButtonPanel(false);
 114       }
 115     }
 116     else
 117     {
 118       resetButtonPanel(false);
 119     }
 120
 121     showFrame();
 122   }
 123
 124   public UserDefinedColours(AppJmol jmol, ColourSchemeI oldcs)
 125   {
 126     super();
 127     this.jmol = jmol;
 128
 129     colorChooser.getSelectionModel().addChangeListener(this);
 130
 131     oldColourScheme = oldcs;
 132
 133     if (oldColourScheme instanceof UserColourScheme)
 134     {
 135       schemeName.setText(((UserColourScheme) oldColourScheme).getName());
 136     }
 137
 138     resetButtonPanel(false);
 139
 140     showFrame();
 141
 142   }
 143
 144   void showFrame()
 145   {
 146     colorChooser.getSelectionModel().addChangeListener(this);
 147     frame = new JInternalFrame();
 148     frame.setContentPane(this);
 149     Desktop.addInternalFrame(frame,
 150             MessageManager.getString("label.user_defined_colours"), 720,
 151             370, true);
 152
 153     if (seqGroup != null)
 154     {
 155       frame.setTitle(frame.getTitle() + " (" + seqGroup.getName() + ")");
 156     }
 157
 158     if (new jalview.util.Platform().isAMac())
 159     {
 160       frame.setSize(760, 370);
 161     }
 162   }
 163
 164   void resetButtonPanel(boolean caseSensitive)
 165   {
 166     buttonPanel.removeAll();
 167
 168     if (upperCaseButtons == null)
 169     {
 170       upperCaseButtons = new Vector();
 171     }
 172
 173     JButton button;
 174     String label;
 175     for (int i = 0; i < 20; i++)
 176     {
 177       if (caseSensitive)
 178       {
 179         label = ResidueProperties.aa[i];
 180       }
 181       else
 182       {
 183         label = ResidueProperties.aa2Triplet.get(ResidueProperties.aa[i])
 184                 .toString();
 185       }
 186
 187       button = makeButton(label, ResidueProperties.aa[i], upperCaseButtons,
 188               i);
 189
 190       buttonPanel.add(button);
 191     }
 192
 193     buttonPanel.add(makeButton("B", "B", upperCaseButtons, 20));
 194     buttonPanel.add(makeButton("Z", "Z", upperCaseButtons, 21));
 195     buttonPanel.add(makeButton("X", "X", upperCaseButtons, 22));
 196     buttonPanel.add(makeButton("Gap", "-", upperCaseButtons, 23));
 197
 198     if (!caseSensitive)
 199     {
 200       gridLayout.setRows(6);
 201       gridLayout.setColumns(4);
 202     }
 203     else
 204     {
 205       gridLayout.setRows(7);
 206       int cols = 7;
 207       gridLayout.setColumns(cols + 1);
 208
 209       if (lowerCaseButtons == null)
 210       {
 211         lowerCaseButtons = new Vector();
 212       }
 213
 214       for (int i = 0; i < 20; i++)
 215       {
 216         int row = i / cols + 1;
 217         int index = (row * cols) + i;
 218         button = makeButton(ResidueProperties.aa[i].toLowerCase(),
 219                 ResidueProperties.aa[i].toLowerCase(), lowerCaseButtons, i);
 220
 221         buttonPanel.add(button, index);
 222       }
 223     }
 224
 225     if (caseSensitive)
 226     {
 227       buttonPanel.add(makeButton("b", "b", lowerCaseButtons, 20));
 228       buttonPanel.add(makeButton("z", "z", lowerCaseButtons, 21));
 229       buttonPanel.add(makeButton("x", "x", lowerCaseButtons, 22));
 230     }
 231
 232     buttonPanel.validate();
 233     validate();
 234   }
 235
 236   /**
 237    * DOCUMENT ME!
 238    *
 239    * @param evt
 240    *          DOCUMENT ME!
 241    */
 242   public void stateChanged(ChangeEvent evt)
 243   {
 244     if (selectedButtons != null)
 245     {
 246       JButton button = null;
 247       for (int i = 0; i < selectedButtons.size(); i++)
 248       {
 249         button = (JButton) selectedButtons.elementAt(i);
 250         button.setBackground(colorChooser.getColor());
 251         button.setForeground(button.getBackground().brighter().brighter()
 252                 .brighter());
 253       }
 254       if (button == lcaseColour)
 255       {
 256         for (int i = 0; i < lowerCaseButtons.size(); i++)
 257         {
 258           button = (JButton) lowerCaseButtons.elementAt(i);
 259           button.setBackground(colorChooser.getColor());
 260           button.setForeground(button.getBackground().brighter().brighter()
 261                   .brighter());
 262         }
 263       }
 264     }
 265   }
 266
 267   /**
 268    * DOCUMENT ME!
 269    *
 270    * @param e
 271    *          DOCUMENT ME!
 272    */
 273   public void colourButtonPressed(MouseEvent e)
 274   {
 275     if (selectedButtons == null)
 276     {
 277       selectedButtons = new Vector();
 278     }
 279
 280     JButton pressed = (JButton) e.getSource();
 281
 282     if (e.isShiftDown())
 283     {
 284       JButton start, end = (JButton) e.getSource();
 285       if (selectedButtons.size() > 0)
 286       {
 287         start = (JButton) selectedButtons
 288                 .elementAt(selectedButtons.size() - 1);
 289       }
 290       else
 291       {
 292         start = (JButton) e.getSource();
 293       }
 294
 295       int startIndex = 0, endIndex = 0;
 296       for (int b = 0; b < buttonPanel.getComponentCount(); b++)
 297       {
 298         if (buttonPanel.getComponent(b) == start)
 299         {
 300           startIndex = b;
 301         }
 302         if (buttonPanel.getComponent(b) == end)
 303         {
 304           endIndex = b;
 305         }
 306       }
 307
 308       if (startIndex > endIndex)
 309       {
 310         int temp = startIndex;
 311         startIndex = endIndex;
 312         endIndex = temp;
 313       }
 314
 315       for (int b = startIndex; b <= endIndex; b++)
 316       {
 317         JButton button = (JButton) buttonPanel.getComponent(b);
 318         if (!selectedButtons.contains(button))
 319         {
 320           button.setForeground(button.getBackground().brighter().brighter());
 321           selectedButtons.add(button);
 322         }
 323       }
 324     }
 325     else if (!e.isControlDown())
 326     {
 327       for (int b = 0; b < selectedButtons.size(); b++)
 328       {
 329         JButton button = (JButton) selectedButtons.elementAt(b);
 330         button.setForeground(button.getBackground().darker().darker());
 331       }
 332       selectedButtons.clear();
 333       pressed.setForeground(pressed.getBackground().brighter().brighter());
 334       selectedButtons.addElement(pressed);
 335
 336     }
 337     else if (e.isControlDown())
 338     {
 339       if (selectedButtons.contains(pressed))
 340       {
 341         pressed.setForeground(pressed.getBackground().darker().darker());
 342         selectedButtons.remove(pressed);
 343       }
 344       else
 345       {
 346         pressed.setForeground(pressed.getBackground().brighter().brighter());
 347         selectedButtons.addElement(pressed);
 348       }
 349     }
 350
 351     if (selectedButtons.size() > 0)
 352     {
 353       colorChooser.setColor(((JButton) selectedButtons.elementAt(0))
 354               .getBackground());
 355     }
 356   }
 357
 358   /**
 359    * DOCUMENT ME!
 360    *
 361    * @param label
 362    *          DOCUMENT ME!
 363    * @param aa
 364    *          DOCUMENT ME!
 365    */
 366   JButton makeButton(String label, String aa, Vector caseSensitiveButtons,
 367           int buttonIndex)
 368   {
 369     final JButton button;
 370     Color col;
 371
 372     if (buttonIndex < caseSensitiveButtons.size())
 373     {
 374       button = (JButton) caseSensitiveButtons.elementAt(buttonIndex);
 375       col = button.getBackground();
 376     }
 377     else
 378     {
 379       button = new JButton();
 380       button.addMouseListener(new java.awt.event.MouseAdapter()
 381       {
 382         public void mouseClicked(MouseEvent e)
 383         {
 384           colourButtonPressed(e);
 385         }
 386       });
 387
 388       caseSensitiveButtons.addElement(button);
 389
 390       col = Color.white;
 391       if (oldColourScheme != null)
 392       {
 393         try
 394         {
 395           col = oldColourScheme.findColour(aa.charAt(0), -1, null);
 396         } catch (Exception ex)
 397         {
 398         }
 399       }
 400     }
 401
 402     if (caseSensitive.isSelected())
 403     {
 404       button.setMargin(new java.awt.Insets(2, 2, 2, 2));
 405     }
 406     else
 407     {
 408       button.setMargin(new java.awt.Insets(2, 14, 2, 14));
 409     }
 410
 411     button.setBackground(col);
 412     button.setText(label);
 413     button.setForeground(col.darker().darker().darker());
 414     button.setFont(new java.awt.Font("Verdana", Font.BOLD, 10));
 415
 416     return button;
 417   }
 418
 419   /**
 420    * DOCUMENT ME!
 421    *
 422    * @param e
 423    *          DOCUMENT ME!
 424    */
 425   protected void okButton_actionPerformed(ActionEvent e)
 426   {
 427     applyButton_actionPerformed(null);
 428
 429     try
 430     {
 431       frame.setClosed(true);
 432     } catch (Exception ex)
 433     {
 434     }
 435   }
 436
 437   /**
 438    * DOCUMENT ME!
 439    *
 440    * @param e
 441    *          DOCUMENT ME!
 442    */
 443   protected void applyButton_actionPerformed(ActionEvent e)
 444   {
 445     UserColourScheme ucs = getSchemeFromButtons();
 446     ucs.setName(schemeName.getText());
 447
 448     if (seqGroup != null)
 449     {
 450       seqGroup.cs = ucs;
 451       ap.paintAlignment(true);
 452     }
 453     else if (ap != null)
 454     {
 455       ap.alignFrame.changeColour(ucs);
 456     }
 457     else if (jmol != null)
 458     {
 459       jmol.setJalviewColourScheme(ucs);
 460     }
 461   }
 462
 463   UserColourScheme getSchemeFromButtons()
 464   {
 465
 466     Color[] newColours = new Color[24];
 467
 468     for (int i = 0; i < 24; i++)
 469     {
 470       JButton button = (JButton) upperCaseButtons.elementAt(i);
 471       newColours[i] = button.getBackground();
 472     }
 473
 474     UserColourScheme ucs = new UserColourScheme(newColours);
 475
 476     if (caseSensitive.isSelected())
 477     {
 478       newColours = new Color[23];
 479       for (int i = 0; i < 23; i++)
 480       {
 481         JButton button = (JButton) lowerCaseButtons.elementAt(i);
 482         newColours[i] = button.getBackground();
 483       }
 484       ucs.setLowerCaseColours(newColours);
 485     }
 486
 487     if (ap != null)
 488     {
 489       ucs.setThreshold(0, ap.av.getIgnoreGapsConsensus());
 490     }
 491
 492     return ucs;
 493   }
 494
 495   /**
 496    * DOCUMENT ME!
 497    *
 498    * @param e
 499    *          DOCUMENT ME!
 500    */
 501   protected void loadbutton_actionPerformed(ActionEvent e)
 502   {
 503     upperCaseButtons = new Vector();
 504     lowerCaseButtons = new Vector();
 505
 506     JalviewFileChooser chooser = new JalviewFileChooser(
 507             jalview.bin.Cache.getProperty("LAST_DIRECTORY"), new String[]
 508             { "jc" }, new String[]
 509             { "Jalview User Colours" }, "Jalview User Colours");
 510     chooser.setFileView(new jalview.io.JalviewFileView());
 511     chooser.setDialogTitle(MessageManager
 512             .getString("label.load_colour_scheme"));
 513     chooser.setToolTipText(MessageManager.getString("action.load"));
 514
 515     int value = chooser.showOpenDialog(this);
 516
 517     if (value == JalviewFileChooser.APPROVE_OPTION)
 518     {
 519       File choice = chooser.getSelectedFile();
 520       jalview.bin.Cache.setProperty("LAST_DIRECTORY", choice.getParent());
 521       String defaultColours = jalview.bin.Cache.getDefault(
 522               "USER_DEFINED_COLOURS", choice.getPath());
 523       if (defaultColours.indexOf(choice.getPath()) == -1)
 524       {
 525         defaultColours = defaultColours.concat("|")
 526                 .concat(choice.getPath());
 527       }
 528
 529       jalview.bin.Cache.setProperty("USER_DEFINED_COLOURS", defaultColours);
 530
 531       UserColourScheme ucs = loadColours(choice.getAbsolutePath());
 532       Color[] colors = ucs.getColours();
 533       schemeName.setText(ucs.getName());
 534
 535       if (ucs.getLowerCaseColours() != null)
 536       {
 537         caseSensitive.setSelected(true);
 538         lcaseColour.setEnabled(true);
 539         resetButtonPanel(true);
 540         for (int i = 0; i < lowerCaseButtons.size(); i++)
 541         {
 542           JButton button = (JButton) lowerCaseButtons.elementAt(i);
 543           button.setBackground(ucs.getLowerCaseColours()[i]);
 544         }
 545
 546       }
 547       else
 548       {
 549         caseSensitive.setSelected(false);
 550         lcaseColour.setEnabled(false);
 551         resetButtonPanel(false);
 552       }
 553
 554       for (int i = 0; i < upperCaseButtons.size(); i++)
 555       {
 556         JButton button = (JButton) upperCaseButtons.elementAt(i);
 557         button.setBackground(colors[i]);
 558       }
 559
 560     }
 561   }
 562
 563   /**
 564    * DOCUMENT ME!
 565    *
 566    * @return DOCUMENT ME!
 567    */
 568   public static UserColourScheme loadDefaultColours()
 569   {
 570     UserColourScheme ret = null;
 571
 572     String colours = jalview.bin.Cache.getProperty("USER_DEFINED_COLOURS");
 573     if (colours != null)
 574     {
 575       if (colours.indexOf("|") > -1)
 576       {
 577         colours = colours.substring(0, colours.indexOf("|"));
 578       }
 579
 580       ret = loadColours(colours);
 581     }
 582
 583     if (ret == null)
 584     {
 585       Color[] newColours = new Color[24];
 586       for (int i = 0; i < 24; i++)
 587       {
 588         newColours[i] = Color.white;
 589       }
 590       ret = new UserColourScheme(newColours);
 591     }
 592
 593     return ret;
 594   }
 595
 596   /**
 597    * DOCUMENT ME!
 598    *
 599    * @param file
 600    *          DOCUMENT ME!
 601    *
 602    * @return DOCUMENT ME!
 603    */
 604   static UserColourScheme loadColours(String file)
 605   {
 606     UserColourScheme ucs = null;
 607     Color[] newColours = null;
 608     try
 609     {
 610       InputStreamReader in = new InputStreamReader(
 611               new FileInputStream(file), "UTF-8");
 612
 613       jalview.schemabinding.version2.JalviewUserColours jucs = new jalview.schemabinding.version2.JalviewUserColours();
 614
 615       org.exolab.castor.xml.Unmarshaller unmar = new org.exolab.castor.xml.Unmarshaller(
 616               jucs);
 617       jucs = (jalview.schemabinding.version2.JalviewUserColours) unmar
 618               .unmarshal(in);
 619
 620       newColours = new Color[24];
 621
 622       Color[] lowerCase = null;
 623       boolean caseSensitive = false;
 624
 625       String name;
 626       int index;
 627       for (int i = 0; i < jucs.getColourCount(); i++)
 628       {
 629         name = jucs.getColour(i).getName();
 630         if (ResidueProperties.aa3Hash.containsKey(name))
 631         {
 632           index = ((Integer) ResidueProperties.aa3Hash.get(name))
 633                   .intValue();
 634         }
 635         else
 636         {
 637           index = ResidueProperties.aaIndex[name.charAt(0)];
 638         }
 639         if (index == -1)
 640         {
 641           continue;
 642         }
 643
 644         if (name.toLowerCase().equals(name))
 645         {
 646           if (lowerCase == null)
 647           {
 648             lowerCase = new Color[23];
 649           }
 650           caseSensitive = true;
 651           lowerCase[index] = new Color(Integer.parseInt(jucs.getColour(i)
 652                   .getRGB(), 16));
 653         }
 654         else
 655         {
 656           newColours[index] = new Color(Integer.parseInt(jucs.getColour(i)
 657                   .getRGB(), 16));
 658         }
 659       }
 660
 661       if (newColours != null)
 662       {
 663         ucs = new UserColourScheme(newColours);
 664         ucs.setName(jucs.getSchemeName());
 665         if (caseSensitive)
 666         {
 667           ucs.setLowerCaseColours(lowerCase);
 668         }
 669       }
 670
 671     } catch (Exception ex)
 672     {
 673       // Could be Archive Jalview format
 674       try
 675       {
 676         InputStreamReader in = new InputStreamReader(new FileInputStream(
 677                 file), "UTF-8");
 678
 679         jalview.binding.JalviewUserColours jucs = new jalview.binding.JalviewUserColours();
 680
 681         jucs = (jalview.binding.JalviewUserColours) jucs.unmarshal(in);
 682
 683         newColours = new Color[jucs.getColourCount()];
 684
 685         for (int i = 0; i < 24; i++)
 686         {
 687           newColours[i] = new Color(Integer.parseInt(jucs.getColour(i)
 688                   .getRGB(), 16));
 689         }
 690         if (newColours != null)
 691         {
 692           ucs = new UserColourScheme(newColours);
 693           ucs.setName(jucs.getSchemeName());
 694         }
 695       } catch (Exception ex2)
 696       {
 697         ex2.printStackTrace();
 698       }
 699
 700       if (newColours == null)
 701       {
 702         System.out.println("Error loading User ColourFile\n" + ex);
 703       }
 704     }
 705
 706     return ucs;
 707   }
 708
 709   /**
 710    * DOCUMENT ME!
 711    *
 712    * @param e
 713    *          DOCUMENT ME!
 714    */
 715   protected void savebutton_actionPerformed(ActionEvent e)
 716   {
 717     if (schemeName.getText().trim().length() < 1)
 718     {
 719       JOptionPane.showInternalMessageDialog(Desktop.desktop, MessageManager
 720               .getString("label.user_colour_scheme_must_have_name"),
 721               MessageManager.getString("label.no_name_colour_scheme"),
 722               JOptionPane.WARNING_MESSAGE);
 723       return;
 724     }
 725
 726     if (userColourSchemes != null
 727             && userColourSchemes.containsKey(schemeName.getText()))
 728     {
 729       int reply = JOptionPane.showInternalConfirmDialog(Desktop.desktop,
 730               MessageManager.formatMessage(
 731                       "label.colour_scheme_exists_overwrite", new String[]
 732                       { schemeName.getText(), schemeName.getText() }),
 733               MessageManager.getString("label.duplicate_scheme_name"),
 734               JOptionPane.YES_NO_OPTION);
 735       if (reply != JOptionPane.YES_OPTION)
 736       {
 737         return;
 738       }
 739
 740       userColourSchemes.remove(schemeName.getText());
 741     }
 742     JalviewFileChooser chooser = new JalviewFileChooser(
 743             jalview.bin.Cache.getProperty("LAST_DIRECTORY"), new String[]
 744             { "jc" }, new String[]
 745             { "Jalview User Colours" }, "Jalview User Colours");
 746
 747     chooser.setFileView(new jalview.io.JalviewFileView());
 748     chooser.setDialogTitle("Save colour scheme");
 749     chooser.setToolTipText(MessageManager.getString("action.save"));
 750
 751     int value = chooser.showSaveDialog(this);
 752
 753     if (value == JalviewFileChooser.APPROVE_OPTION)
 754     {
 755       String choice = chooser.getSelectedFile().getPath();
 756       String defaultColours = jalview.bin.Cache.getDefault(
 757               "USER_DEFINED_COLOURS", choice);
 758       if (defaultColours.indexOf(choice) == -1)
 759       {
 760         if (defaultColours.length() > 0)
 761         {
 762           defaultColours = defaultColours.concat("|");
 763         }
 764         defaultColours = defaultColours.concat(choice);
 765       }
 766
 767       userColourSchemes.put(schemeName.getText(), getSchemeFromButtons());
 768
 769       ap.alignFrame.updateUserColourMenu();
 770
 771       jalview.bin.Cache.setProperty("USER_DEFINED_COLOURS", defaultColours);
 772
 773       jalview.schemabinding.version2.JalviewUserColours ucs = new jalview.schemabinding.version2.JalviewUserColours();
 774
 775       ucs.setSchemeName(schemeName.getText());
 776       try
 777       {
 778         PrintWriter out = new PrintWriter(new OutputStreamWriter(
 779                 new FileOutputStream(choice), "UTF-8"));
 780
 781         for (int i = 0; i < buttonPanel.getComponentCount(); i++)
 782         {
 783           JButton button = (JButton) buttonPanel.getComponent(i);
 784           jalview.schemabinding.version2.Colour col = new jalview.schemabinding.version2.Colour();
 785           col.setName(button.getText());
 786           col.setRGB(jalview.util.Format.getHexString(button
 787                   .getBackground()));
 788           ucs.addColour(col);
 789         }
 790
 791         ucs.marshal(out);
 792         out.close();
 793       } catch (Exception ex)
 794       {
 795         ex.printStackTrace();
 796       }
 797     }
 798   }
 799
 800   /**
 801    * DOCUMENT ME!
 802    *
 803    * @param e
 804    *          DOCUMENT ME!
 805    */
 806   protected void cancelButton_actionPerformed(ActionEvent e)
 807   {
 808     if (ap != null)
 809     {
 810       if (seqGroup != null)
 811       {
 812         seqGroup.cs = oldColourScheme;
 813       }
 814       else if (ap != null)
 815       {
 816         ap.av.setGlobalColourScheme(oldColourScheme);
 817       }
 818       ap.paintAlignment(true);
 819     }
 820
 821     if (jmol != null)
 822     {
 823       jmol.setJalviewColourScheme(oldColourScheme);
 824     }
 825
 826     try
 827     {
 828       frame.setClosed(true);
 829     } catch (Exception ex)
 830     {
 831     }
 832   }
 833
 834   static Hashtable userColourSchemes;
 835
 836   public static Hashtable getUserColourSchemes()
 837   {
 838     return userColourSchemes;
 839   }
 840
 841   public static void initUserColourSchemes(String files)
 842   {
 843     userColourSchemes = new Hashtable();
 844
 845     if (files == null || files.length() == 0)
 846     {
 847       return;
 848     }
 849
 850     // In case colours can't be loaded, we'll remove them
 851     // from the default list here.
 852     StringBuffer coloursFound = new StringBuffer();
 853     StringTokenizer st = new StringTokenizer(files, "|");
 854     while (st.hasMoreElements())
 855     {
 856       String file = st.nextToken();
 857       try
 858       {
 859         UserColourScheme ucs = loadColours(file);
 860         if (ucs != null)
 861         {
 862           if (coloursFound.length() > 0)
 863           {
 864             coloursFound.append("|");
 865           }
 866           coloursFound.append(file);
 867           userColourSchemes.put(ucs.getName(), ucs);
 868         }
 869       } catch (Exception ex)
 870       {
 871         System.out.println("Error loading User ColourFile\n" + ex);
 872       }
 873     }
 874     if (!files.equals(coloursFound.toString()))
 875     {
 876       if (coloursFound.toString().length() > 1)
 877       {
 878         jalview.bin.Cache.setProperty("USER_DEFINED_COLOURS",
 879                 coloursFound.toString());
 880       }
 881       else
 882       {
 883         jalview.bin.Cache.applicationProperties
 884                 .remove("USER_DEFINED_COLOURS");
 885       }
 886     }
 887   }
 888
 889   public static void removeColourFromDefaults(String target)
 890   {
 891     // The only way to find colours by name is to load them in
 892     // In case colours can't be loaded, we'll remove them
 893     // from the default list here.
 894
 895     userColourSchemes = new Hashtable();
 896
 897     StringBuffer coloursFound = new StringBuffer();
 898     StringTokenizer st = new StringTokenizer(
 899             jalview.bin.Cache.getProperty("USER_DEFINED_COLOURS"), "|");
 900
 901     while (st.hasMoreElements())
 902     {
 903       String file = st.nextToken();
 904       try
 905       {
 906         UserColourScheme ucs = loadColours(file);
 907         if (ucs != null && !ucs.getName().equals(target))
 908         {
 909           if (coloursFound.length() > 0)
 910           {
 911             coloursFound.append("|");
 912           }
 913           coloursFound.append(file);
 914           userColourSchemes.put(ucs.getName(), ucs);
 915         }
 916       } catch (Exception ex)
 917       {
 918         System.out.println("Error loading User ColourFile\n" + ex);
 919       }
 920     }
 921
 922     if (coloursFound.toString().length() > 1)
 923     {
 924       jalview.bin.Cache.setProperty("USER_DEFINED_COLOURS",
 925               coloursFound.toString());
 926     }
 927     else
 928     {
 929       jalview.bin.Cache.applicationProperties
 930               .remove("USER_DEFINED_COLOURS");
 931     }
 932
 933   }
 934
 935   public void caseSensitive_actionPerformed(ActionEvent e)
 936   {
 937     resetButtonPanel(caseSensitive.isSelected());
 938     lcaseColour.setEnabled(caseSensitive.isSelected());
 939   }
 940
 941   public void lcaseColour_actionPerformed(ActionEvent e)
 942   {
 943     if (selectedButtons == null)
 944     {
 945       selectedButtons = new Vector();
 946     }
 947     else
 948     {
 949       selectedButtons.clear();
 950     }
 951     selectedButtons.add(lcaseColour);
 952   }
 953
 954 }