src/jalview/gui/UserDefinedColours.java

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