source: other-projects/gs3-webservices-java-client/trunk/src/GS3DemoClient/org/greenstone/gs3client/ColourCombo.java@ 26174

package org.greenstone.gs3client;

import java.awt.Color;
import java.awt.Component;
import javax.swing.JTextField;


/** 
 * Background and selection color combinations for the Java-Client's 
 * interface. Stores Greenstone, Fedora and default colour combinations
 * and has methods for converting colours of items.
 * @author ak19 
*/
public class ColourCombo {
    /** Interface ColourChangeable defines one method, changeUIColour(),
     * which classes whose user-interface colours can change may
     * implement. They can then choose to call either of ColourCombo's 
     * changeColor() methods or changeAncestorColor() if necessary. 
     * Though it's not compulsory to implement this interface, it may
     * help in grouping the classes that are ColourChangeable. */
    public interface ColourChangeable {
        /** Subclasses define this method in order to change the
         * colour of the interface */
        public void changeUIColour();
    }
        
    /* Some fixed colours to be used in the user interface of GS3JavaClient */
    /** Greenstone transparent background colour. Useful for trees' text 
     * backgrounds which otherwise default to white even when the tree 
     * background is not white. Alpha value=0 for transparency */
    static final Color transparent = new Color(0, 0, 0, 0);
    /** Greenstone dark background colour */
    static final Color green = new Color(176, 208, 176);
    /** Greenstone light background colour */
    static final Color lightGreen = new Color(224, 240, 224);
    /** Fedora dark background colour */
    static final Color blue = new Color(128, 180, 216);
    /** Fedora light background colour */
    static final Color lightBlue = new Color(218, 237, 252);
    /** Selection colour for Fedora and Greenstone */
    static final Color yellow = new Color(240, 240, 140);
    
    /* Some default colours (system greys and selection colors) */
    /** Default background colour */
    static final Color grey = new Color(238, 238, 238);
    /** Fixed background colour for textareas, editorPanes (html) */
    static final Color background = Color.white; 
        
    /** background colours for panels, labels */
    public final Color dark; 
    /** background colours for comboboxes, lists, textfields, textareas */
    public final Color light; 
        
    /* The fixed colour combination settings for Greenstone, Fedora and default */
    /** System default greys */
    public static final ColourCombo defaultColors 
        = new ColourCombo(grey, grey);
    /** Greenstone greens */
    public static final ColourCombo greenstoneColors 
        = new ColourCombo(green, lightGreen);
    /** Fedora's colour combinations of blue */
    public static final ColourCombo fedoraColors 
        = new ColourCombo(blue, lightBlue);
    /** The colour combination currently being used in the interface */
    protected static ColourCombo current = defaultColors;
        
    /** Constructor to create a ColourCombo combination of colours
     * @param dark is the colour to set JPanels to.
     * @param light is the colour to set comboboxes, lists and non-editable 
     * textfields to.
    */
    public ColourCombo(Color dark, Color light) 
    {           
        this.dark = dark;
        this.light = light;
    }
    
    // access methods
    public static ColourCombo getCurrentCombo() { return current; }
    public static void setCurrentCombo(ColourCombo c) { current = c; }
    
    /** Sets the active colour combination based on the value of DL.
     * @param DL represents the current digital library. Values can be  
     * GS3JavaClient.GREENSTONE, GS3JavaClient.FEDORA, GS3JavaClient.SELECT.
     * Anything else and it defaults to GS3JavaClient.SELECT as well.
    */
    public static void setColour(int DL) {
        switch(DL) {
            case GS3JavaClient.GREENSTONE:
                setCurrentCombo(greenstoneColors);
                break;
                
            case GS3JavaClient.FEDORA:
                setCurrentCombo(fedoraColors);
                break;

            case GS3JavaClient.SELECT: 
            default:
                setCurrentCombo(defaultColors);
                break;  
        }
    }
    
    /** 
     * @param c is the Component for which it is to be determined whether it
     * should be a lighter or darker colour. 
     * @return true if Component c should be a lighter colour (returns true
     * for non-editable JTextFields)
    */
    protected static boolean isLightColor(Component c) {
        // JTextAreas and JEditorPane left white
        
        // Only JComboBoxes, JLists (and non-editable TextFields) are turned to
        // the light colour
        if(c.getClass().getName().equalsIgnoreCase("javax.swing.JComboBox"))  {
            return true;
        }
        if(c.getClass().getName().equalsIgnoreCase("javax.swing.JList"))  {
            return true;
        }
        // NO LONGER TRUE: Although we can set the the tree pane background to 
        // a light colour, we are unable to get the CellRenderer to do anything
        // upon selection so leave this white=the colour of selections
        // INSTEAD: since we have now set the textbackground of treenodes to
        // transparent, we can colour the background of tree displays.
        if(c.getClass().getName().toLowerCase().contains("tree")) {
            return true;
        } 
        return false;
    } 
    
    /** Given an array of components, sets their background colours to a 
     * dark or light colour setting as appropriate.
     * @param leafComponents is the array of components whose background 
     * colours are to change.
    */
    public static void changeColor(Component[] leafComponents) 
    {
        for(int i = 0; i < leafComponents.length; i++) {
            changeColor(leafComponents[i]);
        }
    }
    
    /** Given a Component, sets its background colours to a dark or 
     * light colour setting as appropriate.
     * @param c is the component whose background colours are to change.
    */
    public static void changeColor(Component c) 
    {
        // NOT NEEDED: since we made text background of treenodes transparent! 
        // skip all trees, leave them with their default (white) colouring 
        //if(c.getClass().getName().toLowerCase().contains("tree")) {
            //return;
        //}
        
        // deal with JTextFields next, based on whether they are editable
        // or not
        if(c.getClass().getName().equalsIgnoreCase("javax.swing.JTextField")) {
            JTextField field = (JTextField)c;
            if(field.isEditable()) {
                field.setBackground(background); // default white
            } else { // must be set to light (non-editable) colour
                field.setBackground(current.light); // default white
            }
        } else if(isLightColor(c)) {
            // for JLists, JComboBoxes, JTextFields need
            // to set light background color
            c.setBackground(current.light);
        } else { // need to set background color to dark
            c.setBackground(current.dark);
        }
    }
    
    /** Given a component, sets its ancestors to the dark colour setting.
     * @param c is the component whose ancestors' background colours are 
     * to be set.
    */
    public static void changeAncestorColor(Component c) {
        // assume c's background color has been changed
        do {
            c = c.getParent(); // change parent color
            // Leave tabbed panes grey, but change the colour of all other 
            // containers - all ancestor components will be containers of
            // some kind (labels or panels)
            if(!c.getClass().getName().equalsIgnoreCase("javax.swing.JTabbedPane")) 
            { 
                c.setBackground(current.dark);
            }
        } while(c.getParent() != null); // cycle through all ancestors
    }
}