Changeset 43265 in webkit


Ignore:
Timestamp:
May 5, 2009 5:51:02 PM (15 years ago)
Author:
kevino@webkit.org
Message:

Reviewed by Kevin Ollivier.

Full Keyboard shortcut support.
Implement wxBrowser Cut/Copy/Paste menu items.

​https://bugs.webkit.org/show_bug.cgi?id=24797

Location:
trunk
Files:
10 edited

Legend:

Unmodified
Added
Removed

  • trunk/WebCore/ChangeLog

    r43261 r43265  
     12009-04-01  miggilin  <mr.diggilin@gmail.com>
     2
     3        Reviewed by Kevin Ollivier.
     4
     5        Mouse wheel scrolling and keyboard shortcut support for wx.
     6       
     7        https://bugs.webkit.org/show_bug.cgi?id=24797
     8
     9        * platform/ScrollView.cpp:
     10        (WebCore::ScrollView::wheelEvent):
     11        * platform/wx/KeyboardEventWx.cpp:
     12        (WebCore::windowsKeyCodeForKeyEvent):
     13        (WebCore::PlatformKeyboardEvent::PlatformKeyboardEvent):
     14        * platform/wx/ScrollViewWx.cpp:
     15        (WebCore::ScrollView::platformSetScrollPosition):
     16
    1172009-05-05  Kevin Ollivier  <kevino@theolliviers.com>
    218

  • trunk/WebCore/platform/ScrollView.cpp

    r42791 r43265  
    633633{
    634634    // We don't allow mouse wheeling to happen in a ScrollView that has had its scrollbars explicitly disabled.
    635     if (!canHaveScrollbars() || platformWidget())
    636         return;
     635#if PLATFORM(WX)
     636    if (!canHaveScrollbars()) {
     637#else
     638    if (!canHaveScrollbars() || platformWidget()) {
     639#endif
     640        return;
     641    }
    637642
    638643    // Determine how much we want to scroll.  If we can move at all, we will accept the event.

  • trunk/WebCore/platform/wx/KeyboardEventWx.cpp

    r42590 r43265  
    163163        case WXK_DIVIDE:
    164164            return VK_DIVIDE; // (6F) Divide key
    165 
     165        case WXK_NUMPAD_SEPARATOR:
     166            return VK_SEPARATOR;
    166167       
    167168        case WXK_BACK:
    168169            return VK_BACK; // (08) BACKSPACE key
    169170        case WXK_TAB:
     171        case WXK_NUMPAD_TAB:
    170172            return VK_TAB; // (09) TAB key
    171173        case WXK_CLEAR:
    172174            return VK_CLEAR; // (0C) CLEAR key
     175        case WXK_NUMPAD_ENTER:
    173176        case WXK_RETURN:
    174177            return VK_RETURN; //(0D) Return key
    … …  
    204207            // VK_ACCEPT (1E) IME accept
    205208            // VK_MODECHANGE (1F) IME mode change request
     209        case WXK_NUMPAD_SPACE:
    206210        case WXK_SPACE:
    207211            return VK_SPACE; // (20) SPACEBAR
     212        case WXK_NUMPAD_PAGEUP:
    208213        case WXK_PAGEUP:
    209214            return VK_PRIOR; // (21) PAGE UP key
     215        case WXK_NUMPAD_PAGEDOWN:
    210216        case WXK_PAGEDOWN:
    211217            return VK_NEXT; // (22) PAGE DOWN key
     218        case WXK_NUMPAD_END:
    212219        case WXK_END:
    213220            return VK_END; // (23) END key
     221        case WXK_NUMPAD_HOME:
    214222        case WXK_HOME:
    215223            return VK_HOME; // (24) HOME key
     224        case WXK_NUMPAD_LEFT:
    216225        case WXK_LEFT:
    217226            return VK_LEFT; // (25) LEFT ARROW key
     227        case WXK_NUMPAD_UP:
    218228        case WXK_UP:
    219229            return VK_UP; // (26) UP ARROW key
     230        case WXK_NUMPAD_RIGHT:
    220231        case WXK_RIGHT:
    221232            return VK_RIGHT; // (27) RIGHT ARROW key
     233        case WXK_NUMPAD_DOWN:
    222234        case WXK_DOWN:
    223235            return VK_DOWN; // (28) DOWN ARROW key
    … …  
    228240        case WXK_EXECUTE:
    229241            return VK_EXECUTE;// (2B) EXECUTE key
    230             //dunno on this
    231             //case WXK_PrintScreen:
    232             //      return VK_SNAPSHOT; // (2C) PRINT SCREEN key
     242        case WXK_SNAPSHOT:
     243             return VK_SNAPSHOT; // (2C) PRINT SCREEN key
     244        case WXK_NUMPAD_INSERT:
    233245        case WXK_INSERT:
    234246            return VK_INSERT; // (2D) INS key
     247        case WXK_NUMPAD_DELETE:
    235248        case WXK_DELETE:
    236249            return VK_DELETE; // (2E) DEL key
    … …  
    336349        m_keyIdentifier = keyIdentifierForWxKeyCode(event.GetKeyCode());
    337350    else {
    338         m_text = wxString(event.GetUnicodeKey());
     351        //ENTER is an editing command processed as a char (only Enter and Tab are)
     352        //unfortunately the unicode key for numpad_enter (370) is NOT what we want here (13)
     353        //The unicode values for normal enter and tab are the same as the ASCII values, thus ok
     354        //Note that I think this a wx bug, as the Character Code is actually 13 when
     355        //numpad_enter is a CHAR event.
     356        if (event.GetKeyCode() == 13 && event.GetUnicodeKey() == wxChar(370))
     357            m_text = "\r";
     358        else
     359            m_text = wxString(event.GetUnicodeKey());
    339360        m_unmodifiedText = m_text;
    340361    }

  • trunk/WebCore/platform/wx/ScrollViewWx.cpp

    r42935 r43265  
    192192        newScrollOffset.x = 0;
    193193    else if (newScrollOffset.x + cRect.width > vRect.width)
    194         newScrollOffset.x = max(0, vRect.width - cRect.width - 1);
     194        newScrollOffset.x = max(0, vRect.width - cRect.width);
    195195
    196196    if (newScrollOffset.y < 0)
    197197        newScrollOffset.y = 0;
    198198    else if (newScrollOffset.y + cRect.height > vRect.height)
    199         newScrollOffset.y = max(0, vRect.height - cRect.height - 1);
     199        newScrollOffset.y = max(0, vRect.height - cRect.height);
    200200
    201201    if (newScrollOffset == scrollOffset)

  • trunk/WebKit/wx/ChangeLog

    r43260 r43265  
     12009-04-01  miggilin  <mr.diggilin@gmail.com>
     2
     3        Reviewed by Kevin Ollivier.
     4
     5        Full Keyboard shortcut support.
     6        Implement wxBrowser Cut/Copy/Paste menu items.
     7       
     8        https://bugs.webkit.org/show_bug.cgi?id=24797
     9
     10        * WebBrowserShell.cpp:
     11        (wxWebBrowserShell::OnSearchCtrlEnter):
     12        (wxWebBrowserShell::OnCut):
     13        (wxWebBrowserShell::OnCopy):
     14        (wxWebBrowserShell::OnPaste):
     15        * WebBrowserShell.h:
     16        * WebKitSupport/EditorClientWx.cpp:
     17        (WebCore::):
     18        (WebCore::EditorClientWx::handleEditingKeyboardEvent):
     19        (WebCore::EditorClientWx::interpretKeyEvent):
     20        (WebCore::EditorClientWx::handleKeyboardEvent):
     21        * WebKitSupport/EditorClientWx.h:
     22        * WebView.cpp:
     23        (wxWebView::CanCut):
     24        (wxWebView::CanPaste):
     25        (wxWebView::Paste):
     26        (wxWebView::OnKeyEvents):
     27
    1282009-05-05  Maclolm MacLeod  <mmacleod@webmail.co.za>
    229

  • trunk/WebKit/wx/WebBrowserShell.cpp

    r33957 r43265  
    6868
    6969BEGIN_EVENT_TABLE(wxWebBrowserShell, wxFrame)
     70    EVT_MENU(wxID_CUT, wxWebBrowserShell::OnCut)
     71    EVT_MENU(wxID_COPY, wxWebBrowserShell::OnCopy)
     72    EVT_MENU(wxID_PASTE, wxWebBrowserShell::OnPaste)
    7073    EVT_MENU(wxID_EXIT,  wxWebBrowserShell::OnQuit)
    7174    EVT_MENU(wxID_ABOUT, wxWebBrowserShell::OnAbout)
    … …  
    253256}
    254257
     258void wxWebBrowserShell::OnCut(wxCommandEvent& event)
     259{
     260    if (webview && webview->CanCut())
     261        webview->Cut();
     262}
     263
     264void wxWebBrowserShell::OnCopy(wxCommandEvent& event)
     265{
     266    if (webview && webview->CanCopy())
     267        webview->Copy();
     268}
     269
     270void wxWebBrowserShell::OnPaste(wxCommandEvent& event)
     271{
     272    if (webview && webview->CanPaste())
     273        webview->Paste();
     274}
     275
    255276void wxWebBrowserShell::OnBack(wxCommandEvent& event)
    256277{

  • trunk/WebKit/wx/WebBrowserShell.h

    r33957 r43265  
    5656
    5757    // event handlers (these functions should _not_ be virtual)
     58    void OnCut(wxCommandEvent& event);
     59    void OnCopy(wxCommandEvent& event);
     60    void OnPaste(wxCommandEvent& event);
    5861    void OnQuit(wxCommandEvent& event);
    5962    void OnAbout(wxCommandEvent& event);

  • trunk/WebKit/wx/WebKitSupport/EditorClientWx.cpp

    r42122 r43265  
    5050namespace WebCore {
    5151
     52static const unsigned CtrlKey = 1 << 0;
     53static const unsigned AltKey = 1 << 1;
     54static const unsigned ShiftKey = 1 << 2;
     55
     56struct KeyDownEntry {
     57    unsigned virtualKey;
     58    unsigned modifiers;
     59    const char* name;
     60};
     61
     62struct KeyPressEntry {
     63    unsigned charCode;
     64    unsigned modifiers;
     65    const char* name;
     66};
     67
     68static const KeyDownEntry keyDownEntries[] = {
     69    { VK_LEFT,   0,                  "MoveLeft"                                    },
     70    { VK_LEFT,   ShiftKey,           "MoveLeftAndModifySelection"                  },
     71    { VK_LEFT,   CtrlKey,            "MoveWordLeft"                                },
     72    { VK_LEFT,   CtrlKey | ShiftKey, "MoveWordLeftAndModifySelection"              },
     73    { VK_RIGHT,  0,                  "MoveRight"                                   },
     74    { VK_RIGHT,  ShiftKey,           "MoveRightAndModifySelection"                 },
     75    { VK_RIGHT,  CtrlKey,            "MoveWordRight"                               },
     76    { VK_RIGHT,  CtrlKey | ShiftKey, "MoveWordRightAndModifySelection"             },
     77    { VK_UP,     0,                  "MoveUp"                                      },
     78    { VK_UP,     ShiftKey,           "MoveUpAndModifySelection"                    },
     79    { VK_PRIOR,  ShiftKey,           "MovePageUpAndModifySelection"                },
     80    { VK_DOWN,   0,                  "MoveDown"                                    },
     81    { VK_DOWN,   ShiftKey,           "MoveDownAndModifySelection"                  },
     82    { VK_NEXT,   ShiftKey,           "MovePageDownAndModifySelection"              },
     83    { VK_PRIOR,  0,                  "MovePageUp"                                  },
     84    { VK_NEXT,   0,                  "MovePageDown"                                },
     85    { VK_HOME,   0,                  "MoveToBeginningOfLine"                       },
     86    { VK_HOME,   ShiftKey,           "MoveToBeginningOfLineAndModifySelection"     },
     87    { VK_HOME,   CtrlKey,            "MoveToBeginningOfDocument"                   },
     88    { VK_HOME,   CtrlKey | ShiftKey, "MoveToBeginningOfDocumentAndModifySelection" },
     89
     90    { VK_END,    0,                  "MoveToEndOfLine"                             },
     91    { VK_END,    ShiftKey,           "MoveToEndOfLineAndModifySelection"           },
     92    { VK_END,    CtrlKey,            "MoveToEndOfDocument"                         },
     93    { VK_END,    CtrlKey | ShiftKey, "MoveToEndOfDocumentAndModifySelection"       },
     94
     95    { VK_BACK,   0,                  "DeleteBackward"                              },
     96    { VK_BACK,   ShiftKey,           "DeleteBackward"                              },
     97    { VK_DELETE, 0,                  "DeleteForward"                               },
     98    { VK_BACK,   CtrlKey,            "DeleteWordBackward"                          },
     99    { VK_DELETE, CtrlKey,            "DeleteWordForward"                           },
     100   
     101    { 'B',       CtrlKey,            "ToggleBold"                                  },
     102    { 'I',       CtrlKey,            "ToggleItalic"                                },
     103
     104    { VK_ESCAPE, 0,                  "Cancel"                                      },
     105    //FIXME: this'll never happen. We can trash it or make it a normal period
     106    { VK_OEM_PERIOD, CtrlKey,        "Cancel"                                      },
     107    { VK_TAB,    0,                  "InsertTab"                                   },
     108    { VK_TAB,    ShiftKey,           "InsertBacktab"                               },
     109    { VK_RETURN, 0,                  "InsertNewline"                               },
     110    { VK_RETURN, CtrlKey,            "InsertNewline"                               },
     111    { VK_RETURN, AltKey,             "InsertNewline"                               },
     112    { VK_RETURN, AltKey | ShiftKey,  "InsertNewline"                               },
     113    { 'A',       CtrlKey,            "SelectAll"                                   },
     114    { 'Z',       CtrlKey,            "Undo"                                        },
     115    { 'Z',       CtrlKey | ShiftKey, "Redo"                                        },
     116};
     117
     118static const KeyPressEntry keyPressEntries[] = {
     119    { '\t',   0,                  "InsertTab"                                   },
     120    { '\t',   ShiftKey,           "InsertBacktab"                               },
     121    { '\r',   0,                  "InsertNewline"                               },
     122    { '\r',   CtrlKey,            "InsertNewline"                               },
     123    { '\r',   AltKey,             "InsertNewline"                               },
     124    { '\r',   AltKey | ShiftKey,  "InsertNewline"                               },
     125};
     126
    52127EditorClientWx::~EditorClientWx()
    53128{
    … …  
    287362}
    288363
     364bool EditorClientWx::handleEditingKeyboardEvent(KeyboardEvent* event)
     365{
     366    Node* node = event->target()->toNode();
     367    ASSERT(node);
     368    Frame* frame = node->document()->frame();
     369    ASSERT(frame);
     370
     371    const PlatformKeyboardEvent* keyEvent = event->keyEvent();
     372
     373    //NB: this is what windows does, but they also have a keypress event for Alt+Enter which clearly won't get hit with this
     374    if (!keyEvent || keyEvent->altKey())  // do not treat this as text input if Alt is down
     375        return false;
     376
     377    Editor::Command command = frame->editor()->command(interpretKeyEvent(event));
     378
     379    if (keyEvent->type() == PlatformKeyboardEvent::RawKeyDown) {
     380        // WebKit doesn't have enough information about mode to decide how commands that just insert text if executed via Editor should be treated,
     381        // so we leave it upon WebCore to either handle them immediately (e.g. Tab that changes focus) or if not to let a CHAR event be generated
     382        // (e.g. Tab that inserts a Tab character, or Enter).
     383        return !command.isTextInsertion() && command.execute(event);
     384    }
     385
     386     if (command.execute(event))
     387        return true;
     388
     389    // Don't insert null or control characters as they can result in unexpected behaviour
     390    if (event->charCode() < ' ')
     391        return false;
     392
     393    return frame->editor()->insertText(event->keyEvent()->text(), event);
     394}
     395
     396const char* EditorClientWx::interpretKeyEvent(const KeyboardEvent* evt)
     397{
     398    ASSERT(evt->keyEvent()->type() == PlatformKeyboardEvent::RawKeyDown || evt->keyEvent()->type() == PlatformKeyboardEvent::Char);
     399
     400    static HashMap<int, const char*>* keyDownCommandsMap = 0;
     401    static HashMap<int, const char*>* keyPressCommandsMap = 0;
     402
     403    if (!keyDownCommandsMap) {
     404        keyDownCommandsMap = new HashMap<int, const char*>;
     405        keyPressCommandsMap = new HashMap<int, const char*>;
     406
     407        for (unsigned i = 0; i < WXSIZEOF(keyDownEntries); i++)
     408            keyDownCommandsMap->set(keyDownEntries[i].modifiers << 16 | keyDownEntries[i].virtualKey, keyDownEntries[i].name);
     409
     410        for (unsigned i = 0; i < WXSIZEOF(keyPressEntries); i++)
     411            keyPressCommandsMap->set(keyPressEntries[i].modifiers << 16 | keyPressEntries[i].charCode, keyPressEntries[i].name);
     412    }
     413
     414    unsigned modifiers = 0;
     415    if (evt->shiftKey())
     416        modifiers |= ShiftKey;
     417    if (evt->altKey())
     418        modifiers |= AltKey;
     419    if (evt->ctrlKey())
     420        modifiers |= CtrlKey;
     421
     422    if (evt->keyEvent()->type() == PlatformKeyboardEvent::RawKeyDown) {
     423        int mapKey = modifiers << 16 | evt->keyCode();
     424        return mapKey ? keyDownCommandsMap->get(mapKey) : 0;
     425    }
     426
     427    int mapKey = modifiers << 16 | evt->charCode();
     428    return mapKey ? keyPressCommandsMap->get(mapKey) : 0;
     429}
     430
     431
    289432void EditorClientWx::handleInputMethodKeydown(KeyboardEvent* event)
    290433{
    … …  
    296439void EditorClientWx::handleKeyboardEvent(KeyboardEvent* event)
    297440{
    298     Frame* frame = m_page->focusController()->focusedOrMainFrame();
    299     if (!frame)
    300         return;
    301 
    302     const PlatformKeyboardEvent* kevent = event->keyEvent();
    303     if (kevent->type() != PlatformKeyboardEvent::KeyUp) {
    304         Node* start = frame->selection()->start().node();
    305         if (!start || !start->isContentEditable())
    306             return;
    307        
    308         if (kevent->type() == PlatformKeyboardEvent::Char && !kevent->ctrlKey() && !kevent->altKey()) {
    309             switch (kevent->windowsVirtualKeyCode()) {
    310                 // we handled these on key down, ignore them for char events
    311                 case VK_BACK:
    312                 case VK_DELETE:
    313                 case VK_LEFT:
    314                 case VK_RIGHT:
    315                 case VK_UP:
    316                 case VK_DOWN:
    317                 case VK_RETURN:
    318                     break;
    319                 default:
    320                     frame->editor()->insertText(kevent->text(), event);
    321             }
    322             event->setDefaultHandled();
    323             return;
    324         }
    325        
    326         switch (kevent->windowsVirtualKeyCode()) {
    327             case VK_BACK:
    328                 frame->editor()->deleteWithDirection(SelectionController::BACKWARD,
    329                                                      CharacterGranularity, false, true);
    330                 break;
    331             case VK_DELETE:
    332                 frame->editor()->deleteWithDirection(SelectionController::FORWARD,
    333                                                      CharacterGranularity, false, true);
    334                 break;
    335             case VK_LEFT:
    336                 frame->editor()->command("MoveLeft").execute();
    337                 break;
    338             case VK_RIGHT:
    339                 frame->editor()->command("MoveRight").execute();
    340                 break;
    341             case VK_UP:
    342                 frame->editor()->command("MoveUp").execute();
    343                 break;
    344             case VK_DOWN:
    345                 frame->editor()->command("MoveDown").execute();
    346                 break;
    347             case VK_RETURN:
    348                 frame->editor()->command("InsertLineBreak").execute();
    349             default:
    350                 break;
    351         }
    352            
     441    if (handleEditingKeyboardEvent(event))
    353442        event->setDefaultHandled();
    354     }
    355443}
    356444

  • trunk/WebKit/wx/WebKitSupport/EditorClientWx.h

    r38738 r43265  
    8888    virtual void redo();
    8989   
     90    virtual const char* interpretKeyEvent(const KeyboardEvent*);
     91    virtual bool handleEditingKeyboardEvent(KeyboardEvent*);
    9092    virtual void handleKeyboardEvent(KeyboardEvent*);
    9193    virtual void handleInputMethodKeydown(KeyboardEvent*);

  • trunk/WebKit/wx/WebView.cpp

    r42931 r43265  
    4747#include "RenderObject.h"
    4848#include "RenderView.h"
     49#include "Scrollbar.h"
    4950#include "SelectionController.h"
    5051#include "Settings.h"
    … …  
    639640{
    640641    if (m_mainFrame)
    641         m_mainFrame->CanCut();
     642        return m_mainFrame->CanCut();
    642643
    643644    return false;
    … …  
    653654{
    654655    if (m_mainFrame)
    655         m_mainFrame->CanPaste();
     656        return m_mainFrame->CanPaste();
    656657
    657658    return false;
    … …  
    662663    if (m_mainFrame)
    663664        m_mainFrame->Paste();
    664 
    665665}
    666666
    … …  
    670670    if (m_mainFrame)
    671671        frame = m_mainFrame->GetFrame();
    672        
    673     if (frame && frame->view()) {
    674         // WebCore doesn't handle these events itself, so we need to do
    675         // it and not send the event down or else CTRL+C will erase the text
    676         // and replace it with c.
    677         if (event.CmdDown() && event.GetEventType() == wxEVT_KEY_UP) {
    678             if (event.GetKeyCode() == static_cast<int>('C'))
     672
     673    if (!(frame && frame->view()))
     674        return;
     675
     676    if (event.GetKeyCode() == WXK_CAPITAL)
     677        frame->eventHandler()->capsLockStateMayHaveChanged();
     678
     679    WebCore::PlatformKeyboardEvent wkEvent(event);
     680
     681    if (frame->eventHandler()->keyEvent(wkEvent))
     682        return;
     683
     684    //Some things WebKit won't do for us... Copy/Cut/Paste and KB scrolling
     685    if (event.GetEventType() == wxEVT_KEY_DOWN) {
     686        switch (event.GetKeyCode()) {
     687        case 67: //"C"
     688            if (CanCopy() && event.GetModifiers() == wxMOD_CMD) {
    679689                Copy();
    680             else if (event.GetKeyCode() == static_cast<int>('X'))
     690                return;
     691            }
     692            break;
     693        case 86: //"V"
     694            if (CanPaste() && event.GetModifiers() == wxMOD_CMD) {
     695                Paste();
     696                return;
     697            }
     698            break;
     699        case 88: //"X"
     700            if (CanCut() && event.GetModifiers() == wxMOD_CMD) {
    681701                Cut();
    682             else if (event.GetKeyCode() == static_cast<int>('V'))
     702                return;
     703            }
     704            break;
     705        case WXK_INSERT:
     706            if (CanCopy() && event.GetModifiers() == wxMOD_CMD) {
     707                Copy();
     708                return;
     709            }
     710            if (CanPaste() && event.GetModifiers() == wxMOD_SHIFT) {
    683711                Paste();
    684             else if (event.GetKeyCode() == static_cast<int>('Z')) {
    685                 if (event.ShiftDown()) {
    686                     if (m_mainFrame->CanRedo())
    687                         m_mainFrame->Redo();
    688                 }
    689                 else {
    690                     if (m_mainFrame->CanUndo())
    691                         m_mainFrame->Undo();
    692                 }
     712                return;
    693713            }
    694         } else {   
    695             WebCore::PlatformKeyboardEvent wkEvent(event);
    696             if (wkEvent.type() == WebCore::PlatformKeyboardEvent::Char && wkEvent.altKey())
    697                 frame->eventHandler()->handleAccessKey(wkEvent);
    698             else
    699                 frame->eventHandler()->keyEvent(wkEvent);
     714            return; //Insert shall not become a char
     715        case WXK_DELETE:
     716            if (CanCut() && event.GetModifiers() == wxMOD_SHIFT) {
     717                Cut();
     718                return;
     719            }
     720            break;
     721        case WXK_LEFT:
     722        case WXK_NUMPAD_LEFT:
     723            frame->view()->scrollBy(WebCore::IntSize(-WebCore::cScrollbarPixelsPerLineStep, 0));
     724            return;
     725        case WXK_UP:
     726        case WXK_NUMPAD_UP:
     727            frame->view()->scrollBy(WebCore::IntSize(0, -WebCore::cScrollbarPixelsPerLineStep));
     728            return;
     729        case WXK_RIGHT:
     730        case WXK_NUMPAD_RIGHT:
     731            frame->view()->scrollBy(WebCore::IntSize(WebCore::cScrollbarPixelsPerLineStep, 0));
     732            return;
     733        case WXK_DOWN:
     734        case WXK_NUMPAD_DOWN:
     735            frame->view()->scrollBy(WebCore::IntSize(0, WebCore::cScrollbarPixelsPerLineStep));
     736            return;
     737        case WXK_END:
     738        case WXK_NUMPAD_END:
     739            frame->view()->setScrollPosition(WebCore::IntPoint(frame->view()->scrollX(), frame->view()->maximumScrollPosition().y()));
     740            return;
     741        case WXK_HOME:
     742        case WXK_NUMPAD_HOME:
     743            frame->view()->setScrollPosition(WebCore::IntPoint(frame->view()->scrollX(), 0));
     744            return;
     745        case WXK_PAGEUP:
     746        case WXK_NUMPAD_PAGEUP:
     747            frame->view()->scrollBy(WebCore::IntSize(0, -frame->view()->visibleHeight() + WebCore::cAmountToKeepWhenPaging));
     748            return;
     749        case WXK_PAGEDOWN:
     750        case WXK_NUMPAD_PAGEDOWN:
     751            frame->view()->scrollBy(WebCore::IntSize(0, frame->view()->visibleHeight() - WebCore::cAmountToKeepWhenPaging));
     752            return;
     753        //These we don't want turning into char events, stuff 'em
     754        case WXK_ESCAPE:
     755        case WXK_LBUTTON:
     756        case WXK_RBUTTON:
     757        case WXK_CANCEL:
     758        case WXK_MENU:
     759        case WXK_MBUTTON:
     760        case WXK_CLEAR:
     761        case WXK_PAUSE:
     762        case WXK_SELECT:
     763        case WXK_PRINT:
     764        case WXK_EXECUTE:
     765        case WXK_SNAPSHOT:
     766        case WXK_HELP:
     767        case WXK_F1:
     768        case WXK_F2:
     769        case WXK_F3:
     770        case WXK_F4:
     771        case WXK_F5:
     772        case WXK_F6:
     773        case WXK_F7:
     774        case WXK_F8:
     775        case WXK_F9:
     776        case WXK_F10:
     777        case WXK_F11:
     778        case WXK_F12:
     779        case WXK_F13:
     780        case WXK_F14:
     781        case WXK_F15:
     782        case WXK_F16:
     783        case WXK_F17:
     784        case WXK_F18:
     785        case WXK_F19:
     786        case WXK_F20:
     787        case WXK_F21:
     788        case WXK_F22:
     789        case WXK_F23:
     790        case WXK_F24:
     791        case WXK_NUMPAD_F1:
     792        case WXK_NUMPAD_F2:
     793        case WXK_NUMPAD_F3:
     794        case WXK_NUMPAD_F4:
     795        //When numlock is off Numpad 5 becomes BEGIN, or HOME on Char
     796        case WXK_NUMPAD_BEGIN:
     797        case WXK_NUMPAD_INSERT:
     798            return;
    700799        }
    701800    }
    702    
    703     // make sure we get the character event.
    704     if (event.GetEventType() != wxEVT_CHAR)
    705         event.Skip();
     801
     802    event.Skip();
    706803}
    707804
Note: See TracChangeset for help on using the changeset viewer.