/*

 * Copyright (C) 2010 Apple Inc. All rights reserved.

 * Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies)

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions

 * are met:

 * 1. Redistributions of source code must retain the above copyright

 *    notice, this list of conditions and the following disclaimer.

 * 2. Redistributions in binary form must reproduce the above copyright

 *    notice, this list of conditions and the following disclaimer in the

 *    documentation and/or other materials provided with the distribution.

 *

 * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''

 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,

 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR

 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS

 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR

 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF

 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS

 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN

 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)

 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF

 * THE POSSIBILITY OF SUCH DAMAGE.

 */

#include "WebPage.h"

#include <WebCore/KeyboardEvent.h>

#include <WebCore/Page.h>

#include <WebCore/PlatformKeyboardEvent.h>

#include <WebCore/Settings.h>

#ifndef VK_UNKNOWN

#define VK_UNKNOWN 0

#define VK_BACK 0x08

#define VK_TAB 0x09

#define VK_CLEAR 0x0C

#define VK_RETURN 0x0D

#define VK_SHIFT 0x10

#define VK_CONTROL 0x11 // CTRL key

#define VK_MENU 0x12 // ALT key

#define VK_PAUSE 0x13 // PAUSE key

#define VK_CAPITAL 0x14 // CAPS LOCK key

#define VK_KANA 0x15 // Input Method Editor (IME) Kana mode

#define VK_HANGUL 0x15 // IME Hangul mode

#define VK_JUNJA 0x17 // IME Junja mode

#define VK_FINAL 0x18 // IME final mode

#define VK_HANJA 0x19 // IME Hanja mode 

#define VK_KANJI 0x19 // IME Kanji mode

#define VK_ESCAPE 0x1B // ESC key

#define VK_CONVERT 0x1C // IME convert

#define VK_NONCONVERT 0x1D // IME nonconvert

#define VK_ACCEPT 0x1E // IME accept

#define VK_MODECHANGE 0x1F // IME mode change request

#define VK_SPACE 0x20 // SPACE key

#define VK_PRIOR 0x21 // PAGE UP key

#define VK_NEXT 0x22 // PAGE DOWN key

#define VK_END 0x23 // END key

#define VK_HOME 0x24 // HOME key

#define VK_LEFT 0x25 // LEFT ARROW key

#define VK_UP 0x26 // UP ARROW key

#define VK_RIGHT 0x27 // RIGHT ARROW key

#define VK_DOWN 0x28 // DOWN ARROW key

#define VK_SELECT 0x29 // SELECT key

#define VK_PRINT 0x2A // PRINT key

#define VK_EXECUTE 0x2B // EXECUTE key

#define VK_SNAPSHOT 0x2C // PRINT SCREEN key

#define VK_INSERT 0x2D // INS key

#define VK_DELETE 0x2E // DEL key

#define VK_HELP 0x2F // HELP key

// Windows 2000/XP: For any country/region, the '.' key

#define VK_OEM_PERIOD 0xBE

#endif

using namespace WebCore;

namespace WebKit {

void WebPage::platformInitialize()

{

}

static const unsigned CtrlKey = 1 << 0;

static const unsigned AltKey = 1 << 1;

static const unsigned ShiftKey = 1 << 2;

struct KeyDownEntry {

    unsigned virtualKey;

    unsigned modifiers;

    const char* name;

};

struct KeyPressEntry {

    unsigned charCode;

    unsigned modifiers;

    const char* name;

};

static const KeyDownEntry keyDownEntries[] = {

    { VK_LEFT,   0,                  "MoveLeft"                                    },

    { VK_LEFT,   ShiftKey,           "MoveLeftAndModifySelection"                  },

    { VK_LEFT,   CtrlKey,            "MoveWordLeft"                                },

    { VK_LEFT,   CtrlKey | ShiftKey, "MoveWordLeftAndModifySelection"              },

    { VK_RIGHT,  0,                  "MoveRight"                                   },

    { VK_RIGHT,  ShiftKey,           "MoveRightAndModifySelection"                 },

    { VK_RIGHT,  CtrlKey,            "MoveWordRight"                               },

    { VK_RIGHT,  CtrlKey | ShiftKey, "MoveWordRightAndModifySelection"             },

    { VK_UP,     0,                  "MoveUp"                                      },

    { VK_UP,     ShiftKey,           "MoveUpAndModifySelection"                    },

    { VK_PRIOR,  ShiftKey,           "MovePageUpAndModifySelection"                },

    { VK_DOWN,   0,                  "MoveDown"                                    },

    { VK_DOWN,   ShiftKey,           "MoveDownAndModifySelection"                  },

    { VK_NEXT,   ShiftKey,           "MovePageDownAndModifySelection"              },

    { VK_PRIOR,  0,                  "MovePageUp"                                  },

    { VK_NEXT,   0,                  "MovePageDown"                                },

    { VK_HOME,   0,                  "MoveToBeginningOfLine"                       },

    { VK_HOME,   ShiftKey,           "MoveToBeginningOfLineAndModifySelection"     },

    { VK_HOME,   CtrlKey,            "MoveToBeginningOfDocument"                   },

    { VK_HOME,   CtrlKey | ShiftKey, "MoveToBeginningOfDocumentAndModifySelection" },

    { VK_END,    0,                  "MoveToEndOfLine"                             },

    { VK_END,    ShiftKey,           "MoveToEndOfLineAndModifySelection"           },

    { VK_END,    CtrlKey,            "MoveToEndOfDocument"                         },

    { VK_END,    CtrlKey | ShiftKey, "MoveToEndOfDocumentAndModifySelection"       },

    { VK_BACK,   0,                  "DeleteBackward"                              },

    { VK_BACK,   ShiftKey,           "DeleteBackward"                              },

    { VK_DELETE, 0,                  "DeleteForward"                               },

    { VK_BACK,   CtrlKey,            "DeleteWordBackward"                          },

    { VK_DELETE, CtrlKey,            "DeleteWordForward"                           },

    { 'B',       CtrlKey,            "ToggleBold"                                  },

    { 'I',       CtrlKey,            "ToggleItalic"                                },

    { VK_ESCAPE, 0,                  "Cancel"                                      },

    { VK_OEM_PERIOD, CtrlKey,        "Cancel"                                      },

    { VK_TAB,    0,                  "InsertTab"                                   },

    { VK_TAB,    ShiftKey,           "InsertBacktab"                               },

    { VK_RETURN, 0,                  "InsertNewline"                               },

    { VK_RETURN, CtrlKey,            "InsertNewline"                               },

    { VK_RETURN, AltKey,             "InsertNewline"                               },

    { VK_RETURN, ShiftKey,           "InsertNewline"                               },

    { VK_RETURN, AltKey | ShiftKey,  "InsertNewline"                               },

    // It's not quite clear whether clipboard shortcuts and Undo/Redo should be handled

    // in the application or in WebKit. We chose WebKit.

    { 'C',       CtrlKey,            "Copy"                                        },

    { 'V',       CtrlKey,            "Paste"                                       },

    { 'X',       CtrlKey,            "Cut"                                         },

    { 'A',       CtrlKey,            "SelectAll"                                   },

    { VK_INSERT, CtrlKey,            "Copy"                                        },

    { VK_DELETE, ShiftKey,           "Cut"                                         },

    { VK_INSERT, ShiftKey,           "Paste"                                       },

    { 'Z',       CtrlKey,            "Undo"                                        },

    { 'Z',       CtrlKey | ShiftKey, "Redo"                                        },

};

static const KeyPressEntry keyPressEntries[] = {

    { '\t',   0,                  "InsertTab"                                   },

    { '\t',   ShiftKey,           "InsertBacktab"                               },

    { '\r',   0,                  "InsertNewline"                               },

    { '\r',   CtrlKey,            "InsertNewline"                               },

    { '\r',   AltKey,             "InsertNewline"                               },

    { '\r',   ShiftKey,           "InsertNewline"                               },

    { '\r',   AltKey | ShiftKey,  "InsertNewline"                               },

};

const char* WebPage::interpretKeyEvent(const KeyboardEvent* evt)

{

    ASSERT(evt->type() == eventNames().keydownEvent || evt->type() == eventNames().keypressEvent);

    static HashMap<int, const char*>* keyDownCommandsMap = 0;

    static HashMap<int, const char*>* keyPressCommandsMap = 0;

    if (!keyDownCommandsMap) {

        keyDownCommandsMap = new HashMap<int, const char*>;

        keyPressCommandsMap = new HashMap<int, const char*>;

        for (unsigned i = 0; i < (sizeof(keyDownEntries) / sizeof(keyDownEntries[0])); i++)

            keyDownCommandsMap->set(keyDownEntries[i].modifiers << 16 | keyDownEntries[i].virtualKey, keyDownEntries[i].name);

        for (unsigned i = 0; i < (sizeof(keyPressEntries) / sizeof(keyPressEntries[0])); i++)

            keyPressCommandsMap->set(keyPressEntries[i].modifiers << 16 | keyPressEntries[i].charCode, keyPressEntries[i].name);

    }

    unsigned modifiers = 0;

    if (evt->shiftKey())

        modifiers |= ShiftKey;

    if (evt->altKey())

        modifiers |= AltKey;

    if (evt->ctrlKey())

        modifiers |= CtrlKey;

    if (evt->type() == eventNames().keydownEvent) {

        int mapKey = modifiers << 16 | evt->keyEvent()->windowsVirtualKeyCode();

        return mapKey ? keyDownCommandsMap->get(mapKey) : 0;

    }

    int mapKey = modifiers << 16 | evt->charCode();

    return mapKey ? keyPressCommandsMap->get(mapKey) : 0;

}

} // namespace WebKit