/*******************************************************************************
 * Copyright (c) 2005, 2006 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 * Port to the D programming language:
 *     Frank Benoit <benoit@tionex.de>
 *******************************************************************************/
module dwtx.jface.bindings.keys.SWTKeyLookup;

import dwtx.jface.bindings.keys.IKeyLookup;

import tango.util.collection.HashMap;
import tango.util.collection.model.Map;

import dwt.DWT;
import dwtx.jface.util.Util;

import dwt.dwthelper.utils;
import dwt.dwthelper.Integer;

/**
 * <p>
 * A look-up table for the formal grammar for keys, and the integer values they
 * represent. This look-up table is hard-coded to use DWT representations. By
 * replacing this class (and
 * {@link dwtx.jface.bindings.keys.SWTKeySupport}), you can remove the
 * dependency on DWT.
 * </p>
 *
 * @since 3.1
 * @see dwtx.jface.bindings.keys.KeyLookupFactory
 */
public final class SWTKeyLookup : IKeyLookup {

    /**
     * The look-up table for modifier keys. This is a map of formal name (<code>String</code>)
     * to integer value (<code>Integer</code>).
     */
    private const Map!(String,Integer) modifierKeyTable;

    /**
     * The look-up table for formal names. This is a map of integer value (<code>Integer</code>)
     * to formal name (<code>String</code>).
     */
    private const Map!(Integer,String) nameTable;

    /**
     * The look-up table for natural keys. This is a map of formal name (<code>String</code>)
     * to integer value (<code>Integer</code>).
     */
    private const Map!(String,Integer) naturalKeyTable;

    /**
     * Constructs a new look-up class. This should only be done by the look-up
     * factory.
     *
     * @see KeyLookupFactory
     */
    this() {
        modifierKeyTable = new HashMap!(String,Integer);
        nameTable = new HashMap!(Integer,String);
        naturalKeyTable = new HashMap!(String,Integer);
        Integer alt = new Integer(DWT.ALT);
        Integer command = new Integer(DWT.COMMAND);
        Integer ctrl = new Integer(DWT.CTRL);
        Integer shift = new Integer(DWT.SHIFT);
        modifierKeyTable.add(ALT_NAME, alt);
        nameTable.add(alt, ALT_NAME);
        modifierKeyTable.add(COMMAND_NAME, command);
        nameTable.add(command, COMMAND_NAME);
        modifierKeyTable.add(CTRL_NAME, ctrl);
        nameTable.add(ctrl, CTRL_NAME);
        modifierKeyTable.add(SHIFT_NAME, shift);
        nameTable.add(shift, SHIFT_NAME);
        modifierKeyTable.add(M1_NAME,
                "carbon".equals(DWT.getPlatform()) ? command : ctrl); //$NON-NLS-1$
        modifierKeyTable.add(M2_NAME, shift);
        modifierKeyTable.add(M3_NAME, alt);
        modifierKeyTable.add(M4_NAME, "carbon".equals(DWT.getPlatform()) ? ctrl //$NON-NLS-1$
                : command);

        Integer arrowDown = new Integer(DWT.ARROW_DOWN);
        naturalKeyTable.add(ARROW_DOWN_NAME, arrowDown);
        nameTable.add(arrowDown, ARROW_DOWN_NAME);
        Integer arrowLeft = new Integer(DWT.ARROW_LEFT);
        naturalKeyTable.add(ARROW_LEFT_NAME, arrowLeft);
        nameTable.add(arrowLeft, ARROW_LEFT_NAME);
        Integer arrowRight = new Integer(DWT.ARROW_RIGHT);
        naturalKeyTable.add(ARROW_RIGHT_NAME, arrowRight);
        nameTable.add(arrowRight, ARROW_RIGHT_NAME);
        Integer arrowUp = new Integer(DWT.ARROW_UP);
        naturalKeyTable.add(ARROW_UP_NAME, arrowUp);
        nameTable.add(arrowUp, ARROW_UP_NAME);
        Integer breakKey = new Integer(DWT.BREAK);
        naturalKeyTable.add(BREAK_NAME, breakKey);
        nameTable.add(breakKey, BREAK_NAME);
        Integer bs = new Integer(DWT.BS);
        naturalKeyTable.add(BS_NAME, bs);
        nameTable.add(bs, BS_NAME);
        naturalKeyTable.add(BACKSPACE_NAME, bs);
        Integer capsLock = new Integer(DWT.CAPS_LOCK);
        naturalKeyTable.add(CAPS_LOCK_NAME, capsLock);
        nameTable.add(capsLock, CAPS_LOCK_NAME);
        Integer cr = new Integer(DWT.CR);
        naturalKeyTable.add(CR_NAME, cr);
        nameTable.add(cr, CR_NAME);
        naturalKeyTable.add(ENTER_NAME, cr);
        naturalKeyTable.add(RETURN_NAME, cr);
        Integer del = new Integer(DWT.DEL);
        naturalKeyTable.add(DEL_NAME, del);
        nameTable.add(del, DEL_NAME);
        naturalKeyTable.add(DELETE_NAME, del);
        Integer end = new Integer(DWT.END);
        naturalKeyTable.add(END_NAME, end);
        nameTable.add(end, END_NAME);
        Integer esc = new Integer(DWT.ESC);
        naturalKeyTable.add(ESC_NAME, esc);
        nameTable.add(esc, ESC_NAME);
        naturalKeyTable.add(ESCAPE_NAME, esc);
        Integer f1 = new Integer(DWT.F1);
        naturalKeyTable.add(F1_NAME, f1);
        nameTable.add(f1, F1_NAME);
        Integer f2 = new Integer(DWT.F2);
        naturalKeyTable.add(F2_NAME, new Integer(DWT.F2));
        nameTable.add(f2, F2_NAME);
        Integer f3 = new Integer(DWT.F3);
        naturalKeyTable.add(F3_NAME, new Integer(DWT.F3));
        nameTable.add(f3, F3_NAME);
        Integer f4 = new Integer(DWT.F4);
        naturalKeyTable.add(F4_NAME, new Integer(DWT.F4));
        nameTable.add(f4, F4_NAME);
        Integer f5 = new Integer(DWT.F5);
        naturalKeyTable.add(F5_NAME, new Integer(DWT.F5));
        nameTable.add(f5, F5_NAME);
        Integer f6 = new Integer(DWT.F6);
        naturalKeyTable.add(F6_NAME, new Integer(DWT.F6));
        nameTable.add(f6, F6_NAME);
        Integer f7 = new Integer(DWT.F7);
        naturalKeyTable.add(F7_NAME, new Integer(DWT.F7));
        nameTable.add(f7, F7_NAME);
        Integer f8 = new Integer(DWT.F8);
        naturalKeyTable.add(F8_NAME, new Integer(DWT.F8));
        nameTable.add(f8, F8_NAME);
        Integer f9 = new Integer(DWT.F9);
        naturalKeyTable.add(F9_NAME, new Integer(DWT.F9));
        nameTable.add(f9, F9_NAME);
        Integer f10 = new Integer(DWT.F10);
        naturalKeyTable.add(F10_NAME, new Integer(DWT.F10));
        nameTable.add(f10, F10_NAME);
        Integer f11 = new Integer(DWT.F11);
        naturalKeyTable.add(F11_NAME, new Integer(DWT.F11));
        nameTable.add(f11, F11_NAME);
        Integer f12 = new Integer(DWT.F12);
        naturalKeyTable.add(F12_NAME, new Integer(DWT.F12));
        nameTable.add(f12, F12_NAME);
        Integer f13 = new Integer(DWT.F13);
        naturalKeyTable.add(F13_NAME, new Integer(DWT.F13));
        nameTable.add(f13, F13_NAME);
        Integer f14 = new Integer(DWT.F14);
        naturalKeyTable.add(F14_NAME, new Integer(DWT.F14));
        nameTable.add(f14, F14_NAME);
        Integer f15 = new Integer(DWT.F15);
        naturalKeyTable.add(F15_NAME, new Integer(DWT.F15));
        nameTable.add(f15, F15_NAME);
        Integer ff = new Integer(12); // ASCII 0x0C
        naturalKeyTable.add(FF_NAME, ff);
        nameTable.add(ff, FF_NAME);
        Integer home = new Integer(DWT.HOME);
        naturalKeyTable.add(HOME_NAME, home);
        nameTable.add(home, HOME_NAME);
        Integer insert = new Integer(DWT.INSERT);
        naturalKeyTable.add(INSERT_NAME, insert);
        nameTable.add(insert, INSERT_NAME);
        Integer lf = new Integer(DWT.LF);
        naturalKeyTable.add(LF_NAME, lf);
        nameTable.add(lf, LF_NAME);
        Integer nul = new Integer(DWT.NULL);
        naturalKeyTable.add(NUL_NAME, nul);
        nameTable.add(nul, NUL_NAME);
        Integer numLock = new Integer(DWT.NUM_LOCK);
        naturalKeyTable.add(NUM_LOCK_NAME, numLock);
        nameTable.add(numLock, NUM_LOCK_NAME);
        Integer keypad0 = new Integer(DWT.KEYPAD_0);
        naturalKeyTable.add(NUMPAD_0_NAME, keypad0);
        nameTable.add(keypad0, NUMPAD_0_NAME);
        Integer keypad1 = new Integer(DWT.KEYPAD_1);
        naturalKeyTable.add(NUMPAD_1_NAME, keypad1);
        nameTable.add(keypad1, NUMPAD_1_NAME);
        Integer keypad2 = new Integer(DWT.KEYPAD_2);
        naturalKeyTable.add(NUMPAD_2_NAME, keypad2);
        nameTable.add(keypad2, NUMPAD_2_NAME);
        Integer keypad3 = new Integer(DWT.KEYPAD_3);
        naturalKeyTable.add(NUMPAD_3_NAME, keypad3);
        nameTable.add(keypad3, NUMPAD_3_NAME);
        Integer keypad4 = new Integer(DWT.KEYPAD_4);
        naturalKeyTable.add(NUMPAD_4_NAME, keypad4);
        nameTable.add(keypad4, NUMPAD_4_NAME);
        Integer keypad5 = new Integer(DWT.KEYPAD_5);
        naturalKeyTable.add(NUMPAD_5_NAME, keypad5);
        nameTable.add(keypad5, NUMPAD_5_NAME);
        Integer keypad6 = new Integer(DWT.KEYPAD_6);
        naturalKeyTable.add(NUMPAD_6_NAME, keypad6);
        nameTable.add(keypad6, NUMPAD_6_NAME);
        Integer keypad7 = new Integer(DWT.KEYPAD_7);
        naturalKeyTable.add(NUMPAD_7_NAME, keypad7);
        nameTable.add(keypad7, NUMPAD_7_NAME);
        Integer keypad8 = new Integer(DWT.KEYPAD_8);
        naturalKeyTable.add(NUMPAD_8_NAME, keypad8);
        nameTable.add(keypad8, NUMPAD_8_NAME);
        Integer keypad9 = new Integer(DWT.KEYPAD_9);
        naturalKeyTable.add(NUMPAD_9_NAME, keypad9);
        nameTable.add(keypad9, NUMPAD_9_NAME);
        Integer keypadAdd = new Integer(DWT.KEYPAD_ADD);
        naturalKeyTable.add(NUMPAD_ADD_NAME, keypadAdd);
        nameTable.add(keypadAdd, NUMPAD_ADD_NAME);
        Integer keypadDecimal = new Integer(DWT.KEYPAD_DECIMAL);
        naturalKeyTable.add(NUMPAD_DECIMAL_NAME, keypadDecimal);
        nameTable.add(keypadDecimal, NUMPAD_DECIMAL_NAME);
        Integer keypadDivide = new Integer(DWT.KEYPAD_DIVIDE);
        naturalKeyTable.add(NUMPAD_DIVIDE_NAME, keypadDivide);
        nameTable.add(keypadDivide, NUMPAD_DIVIDE_NAME);
        Integer keypadCr = new Integer(DWT.KEYPAD_CR);
        naturalKeyTable.add(NUMPAD_ENTER_NAME, keypadCr);
        nameTable.add(keypadCr, NUMPAD_ENTER_NAME);
        Integer keypadEqual = new Integer(DWT.KEYPAD_EQUAL);
        naturalKeyTable.add(NUMPAD_EQUAL_NAME, keypadEqual);
        nameTable.add(keypadEqual, NUMPAD_EQUAL_NAME);
        Integer keypadMultiply = new Integer(DWT.KEYPAD_MULTIPLY);
        naturalKeyTable.add(NUMPAD_MULTIPLY_NAME, keypadMultiply);
        nameTable.add(keypadMultiply, NUMPAD_MULTIPLY_NAME);
        Integer keypadSubtract = new Integer(DWT.KEYPAD_SUBTRACT);
        naturalKeyTable.add(NUMPAD_SUBTRACT_NAME, keypadSubtract);
        nameTable.add(keypadSubtract, NUMPAD_SUBTRACT_NAME);
        Integer pageDown = new Integer(DWT.PAGE_DOWN);
        naturalKeyTable.add(PAGE_DOWN_NAME, pageDown);
        nameTable.add(pageDown, PAGE_DOWN_NAME);
        Integer pageUp = new Integer(DWT.PAGE_UP);
        naturalKeyTable.add(PAGE_UP_NAME, pageUp);
        nameTable.add(pageUp, PAGE_UP_NAME);
        Integer pause = new Integer(DWT.PAUSE);
        naturalKeyTable.add(PAUSE_NAME, pause);
        nameTable.add(pause, PAUSE_NAME);
        Integer printScreen = new Integer(DWT.PRINT_SCREEN);
        naturalKeyTable.add(PRINT_SCREEN_NAME, printScreen);
        nameTable.add(printScreen, PRINT_SCREEN_NAME);
        Integer scrollLock = new Integer(DWT.SCROLL_LOCK);
        naturalKeyTable.add(SCROLL_LOCK_NAME, scrollLock);
        nameTable.add(scrollLock, SCROLL_LOCK_NAME);
        Integer space = new Integer(' ');
        naturalKeyTable.add(SPACE_NAME, space);
        nameTable.add(space, SPACE_NAME);
        Integer tab = new Integer(DWT.TAB);
        naturalKeyTable.add(TAB_NAME, tab);
        nameTable.add(tab, TAB_NAME);
        Integer vt = new Integer(11); // ASCII 0x0B
        naturalKeyTable.add(VT_NAME, vt);
        nameTable.add(vt, VT_NAME);
    }

    /*
     * (non-Javadoc)
     *
     * @see dwtx.jface.bindings.keys.IKeyLookup#formalKeyLookup(java.lang.String)
     *
     */
    public final int formalKeyLookup(String name) {
        Object value = naturalKeyTable.get(name);
        if (cast(Integer)value ) {
            return (cast(Integer) value).intValue();
        }

        if (name.length > 0) {
            throw new IllegalArgumentException("Unrecognized formal key name: " //$NON-NLS-1$
                    ~ name);
        }

        return name.charAt(0);
    }

    /*
     * (non-Javadoc)
     *
     * @see dwtx.jface.bindings.keys.IKeyLookup#formalKeyLookupInteger(java.lang.String)
     *
     */
    public final Integer formalKeyLookupInteger(String name) {
        Object value = naturalKeyTable.get(name);
        if (cast(Integer)value ) {
            return cast(Integer) value;
        }

        return new Integer(name.charAt(0));
    }

    /*
     * (non-Javadoc)
     *
     * @see dwtx.jface.bindings.keys.IKeyLookup#formalModifierLookup(java.lang.String)
     *
     */
    public final int formalModifierLookup(String name) {
        Object value = modifierKeyTable.get(name);
        if (cast(Integer)value ) {
            return (cast(Integer) value).intValue();
        }

        return 0;
    }

    /*
     * (non-Javadoc)
     *
     * @see dwtx.jface.bindings.keys.IKeyLookup#formalNameLookup(int)
     *
     */
    public final String formalNameLookup(int key) {
        Integer keyObject = new Integer(key);
        if (nameTable.containsKey(keyObject) ) {
            return nameTable.get(keyObject);
        }

        return dcharToString( cast(dchar) key );
    }

    /*
     * (non-Javadoc)
     *
     * @see dwtx.jface.bindings.keys.IKeyLookup#getAlt()
     *
     */
    public final int getAlt() {
        return DWT.ALT;
    }

    /*
     * (non-Javadoc)
     *
     * @see dwtx.jface.bindings.keys.IKeyLookup#getCommand()
     *
     */
    public final int getCommand() {
        return DWT.COMMAND;
    }

    /*
     * (non-Javadoc)
     *
     * @see dwtx.jface.bindings.keys.IKeyLookup#getCtrl()
     *
     */
    public final int getCtrl() {
        return DWT.CTRL;
    }

    /*
     * (non-Javadoc)
     *
     * @see dwtx.jface.bindings.keys.IKeyLookup#getShift()
     *
     */
    public final int getShift() {
        return DWT.SHIFT;
    }

    /*
     * (non-Javadoc)
     *
     * @see dwtx.jface.bindings.keys.IKeyLookup#isModifierKey(int)
     *
     */
    public final bool isModifierKey(int key) {
        return ((key & DWT.MODIFIER_MASK) !is 0);
    }
}