ColourConverter.java

Go to the documentation of this file.

/*
 * This file is part of the LibreOffice project.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
 *
 * This file incorporates work covered by the following license notice:
 *
 *   Licensed to the Apache Software Foundation (ASF) under one or more
 *   contributor license agreements. See the NOTICE file distributed
 *   with this work for additional information regarding copyright
 *   ownership. The ASF licenses this file to you under the Apache
 *   License, Version 2.0 (the "License"); you may not use this file
 *   except in compliance with the License. You may obtain a copy of
 *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
 */
 
package org.openoffice.xmerge.util;
 
import java.awt.Color;
 
public class ColourConverter {
 
    private static final short BLACK = 0;
 
    private static final short SILVER = 1;
 
    private static final short GREY = 2;
 
    private static final short WHITE = 3;
 
    private static final short RED = 4;
 
    private static final short LIME = 5;
 
    private static final short BLUE = 6;
 
    private static final short AQUA = 7;
 
    private static final short FUCHSIA = 8;
 
    private static final short YELLOW = 9;
 
    private static final short MAROON = 10;
 
    private static final short GREEN = 11;
 
    private static final short NAVY = 12;
 
    private static final short TEAL = 13;
 
    private static final short PURPLE = 14;
 
    public static final short OLIVE = 15;
 
    private short tableLookup[] = null;
 
    public ColourConverter() {
 
    }
 
    public ColourConverter(short lookup[]) {
        tableLookup = lookup;
    }
 
    private short colourLookup(short colour) {
        if(tableLookup!=null) {
            return tableLookup[colour];
        } else {
            return colour;
        }
    }
 
    private short indexLookup(short index) {
 
        short result = 0;
 
        if(tableLookup!=null) {
            for(short i = 0;i < tableLookup.length;i++) {
                if(tableLookup[i]==index)
                    result = i;
            }
        } else {
            result = index;
        }
 
        return result;
    }
    public Color convertToRGB (short colour) {
 
        short index = indexLookup(colour);
 
        int r = 0;
        int g = 0;
        int b = 0;
 
        switch (index) {
            case SILVER:
                r = g = b = 128;
                break;
 
            case GREY:
                r = g = b = 192;
                break;
 
            case WHITE:
                r = g = b = 255;
                break;
 
            case RED:
                r = 255;
                break;
 
            case LIME:
                g = 255;
                break;
 
            case BLUE:
                b = 255;
                break;
 
            case AQUA:
                g = b = 255;
                break;
 
            case FUCHSIA:
                r = b = 255;
                break;
 
            case YELLOW:
                r = g = 255;
                break;
 
            case MAROON:
                r = 128;
                break;
 
            case GREEN:
                g = 128;
                break;
 
            case NAVY:
                b = 128;
                break;
 
            case TEAL:
                b = g = 128;
                break;
 
            case PURPLE:
                r = b = 128;
                break;
 
            case OLIVE:
                r = g = 128;
                break;
 
            case BLACK:
            default:
                r = g = b = 0;
                break;
        }
 
        return new Color(r, g, b);
    }
 
    public short convertFromRGB (Color colour) {
        int matchedRGB = 0;
        short indexColour = 0;
        int reducedMap[] =  new int[] { 0, 0, 128 };
 
          int red = colour.getRed();
          int green = colour.getGreen();
          int blue = colour.getBlue();
 
        // We need to convert the pale colours to their base color rather than
        // white so we modify the rgb values if the colour is sufficiently white.
           if(red>0xC0 && green>0xC0 && blue>0xC0) {
 
            if(red!=0xFF)
                red = getClosest(red, reducedMap);
            if(green!=0xFF)
                green = getClosest(green, reducedMap);
            if(blue!=0xFF)
                blue = getClosest(blue, reducedMap);
        }
 
        // Need to derive an RGB value that has been rounded to match the ones
        // Pocket Word knows about.
        matchedRGB += getClosest(red)   << 16;
        matchedRGB += getClosest(green) << 8;
           matchedRGB += getClosest(blue);
 
        // The colour map used by Pocket Word doesn't have any combinations of
        // values beyond 0 and any other value.  A value of 255 in any RGB code
        // indicates a dominant colour.  Other colours are only modifiers to the
        // principal colour(s).  Thus, for this conversion, modifiers can be
        // dropped.
        if ((matchedRGB & 0xFF0000) == 0xFF0000 || (matchedRGB & 0xFF00) == 0xFF00
                || (matchedRGB & 0xFF) == 0xFF) {
                    if ((matchedRGB & 0xFF0000) == 0x800000) {
                        matchedRGB ^= 0x800000;
                    }
                    if ((matchedRGB & 0xFF00) == 0x8000) {
                        matchedRGB ^= 0x8000;
                    }
                    if ((matchedRGB & 0xFF) == 0x80) {
                        matchedRGB ^= 0x80;
                    }
        }
 
        /*
         * And now for the actual matching ...
         *
         * Colours are based on the Windows VGA 16 palette.  One difference
         * though is that Pocket Word seems to switch the RGB codes for Grey
         * and Silver.  In Pocket Word Silver is the darker colour leaving Grey
         * is closest to White.
         *
         * Shades of grey will be converted to either Silver or White, where
         * Grey may be a more appropriate colour.  This is handled specially
         * only for Silver and White matches.
         */
        switch (matchedRGB) {
            case 0x000000:
                indexColour = BLACK;
                break;
 
            case 0x808080:
                if (!isGrey(colour)) {
                    indexColour = SILVER;
                }
                else {
                    indexColour = GREY;
                }
                break;
 
            case 0xFFFFFF:
                if (!isGrey(colour)) {
                    indexColour = WHITE;
                }
                else {
                    indexColour = GREY;
                }
                break;
 
            case 0xFF0000:
                indexColour = RED;
                break;
 
            case 0x00FF00:
                indexColour = LIME;
                break;
 
            case 0x0000FF:
                indexColour = BLUE;
                break;
 
            case 0x00FFFF:
                indexColour = AQUA;
                break;
 
            case 0xFF00FF:
                indexColour = FUCHSIA;
                break;
 
            case 0xFFFF00:
                indexColour = YELLOW;
                break;
 
            case 0x800000:
                indexColour = MAROON;
                break;
 
            case 0x008000:
                indexColour = GREEN;
                break;
 
            case 0x000080:
                indexColour = NAVY;
                break;
 
            case 0x008080:
                indexColour = TEAL;
                break;
 
            case 0x800080:
                indexColour = PURPLE;
                break;
 
            case 0x808000:
                indexColour = OLIVE;
                break;
 
            default:        // Just in case!
                indexColour = BLACK;
                break;
        }
 
        return colourLookup(indexColour);
    }
 
    private int getClosest(int value) {
        int points[] = new int[] { 0, 128, 255 };
 
        return getClosest(value, points);
    }
 
    private int getClosest(int value, int[] points) {
 
        if (value == points[0] || value == points[1] || value == points[2]) {
            return value;
        }
 
        if (value < points[1]) {
            int x = value - points[0];
            return (Math.round((float)x / (points[1] - points[0])) == 1 ? points[1] : points[0]);
        }
        else {
            int x = value - points[1];
            return (Math.round((float)x / (points[2] - points[1])) >= 1 ? points[2] : points[1]);
        }
    }
 
    private boolean isGrey(Color c) {
        int matchedRGB = 0;
        int points[] = new int[] { 128, 192, 255 };
 
        matchedRGB += getClosest(c.getRed(), points) << 16;
        matchedRGB += getClosest(c.getGreen(), points) << 8;
        matchedRGB += getClosest(c.getBlue(), points);
 
        return matchedRGB == 0xC0C0C0;
    }
}