Allow to retrieve the request data from abstract TextCheckingRequest to be accessible...
[WebKit-https.git] / Source / WebKit / chromium / src / EditorClientImpl.cpp
1 /*
2  * Copyright (C) 2006, 2007 Apple, Inc.  All rights reserved.
3  * Copyright (C) 2012 Google, Inc.  All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  * 1. Redistributions of source code must retain the above copyright
9  *    notice, this list of conditions and the following disclaimer.
10  * 2. Redistributions in binary form must reproduce the above copyright
11  *    notice, this list of conditions and the following disclaimer in the
12  *    documentation and/or other materials provided with the distribution.
13  *
14  * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
15  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
17  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR
18  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
19  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
20  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
21  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
22  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
23  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
24  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
25  */
26
27 #include "config.h"
28 #include "EditorClientImpl.h"
29
30 #include "Document.h"
31 #include "Editor.h"
32 #include "EventHandler.h"
33 #include "EventNames.h"
34 #include "Frame.h"
35 #include "HTMLInputElement.h"
36 #include "HTMLNames.h"
37 #include "KeyboardCodes.h"
38 #include "KeyboardEvent.h"
39 #include "PlatformKeyboardEvent.h"
40 #include "RenderObject.h"
41 #include "Settings.h"
42 #include "SpellChecker.h"
43 #include "UndoStep.h"
44
45 #include "DOMUtilitiesPrivate.h"
46 #include "WebAutofillClient.h"
47 #include "WebEditingAction.h"
48 #include "WebElement.h"
49 #include "WebFrameClient.h"
50 #include "WebFrameImpl.h"
51 #include "WebInputElement.h"
52 #include "WebInputEventConversion.h"
53 #include "WebKit.h"
54 #include "WebNode.h"
55 #include "WebPermissionClient.h"
56 #include "WebRange.h"
57 #include "WebSpellCheckClient.h"
58 #include "WebTextAffinity.h"
59 #include "WebTextCheckingCompletionImpl.h"
60 #include "WebTextCheckingResult.h"
61 #include "WebViewClient.h"
62 #include "WebViewImpl.h"
63 #include <wtf/text/WTFString.h>
64
65 using namespace WebCore;
66
67 namespace WebKit {
68
69 // Arbitrary depth limit for the undo stack, to keep it from using
70 // unbounded memory.  This is the maximum number of distinct undoable
71 // actions -- unbroken stretches of typed characters are coalesced
72 // into a single action.
73 static const size_t maximumUndoStackDepth = 1000;
74
75 EditorClientImpl::EditorClientImpl(WebViewImpl* webview)
76     : m_webView(webview)
77     , m_inRedo(false)
78     , m_spellCheckThisFieldStatus(SpellCheckAutomatic)
79 {
80 }
81
82 EditorClientImpl::~EditorClientImpl()
83 {
84 }
85
86 void EditorClientImpl::pageDestroyed()
87 {
88     // Our lifetime is bound to the WebViewImpl.
89 }
90
91 void EditorClientImpl::frameWillDetachPage(WebCore::Frame* frame)
92 {
93 }
94
95 bool EditorClientImpl::smartInsertDeleteEnabled()
96 {
97     if (m_webView->client())
98         return m_webView->client()->isSmartInsertDeleteEnabled();
99     return true;
100 }
101
102 bool EditorClientImpl::isSelectTrailingWhitespaceEnabled()
103 {
104     if (m_webView->client())
105         return m_webView->client()->isSelectTrailingWhitespaceEnabled();
106 #if OS(WINDOWS)
107     return true;
108 #else
109     return false;
110 #endif
111 }
112
113 bool EditorClientImpl::shouldSpellcheckByDefault()
114 {
115     // Spellcheck should be enabled for all editable areas (such as textareas,
116     // contentEditable regions, and designMode docs), except text inputs.
117     const Frame* frame = m_webView->focusedWebCoreFrame();
118     if (!frame)
119         return false;
120     const Editor* editor = frame->editor();
121     if (!editor)
122         return false;
123     if (editor->isSpellCheckingEnabledInFocusedNode())
124         return true;
125     const Document* document = frame->document();
126     if (!document)
127         return false;
128     const Node* node = document->focusedNode();
129     // If |node| is null, we default to allowing spellchecking. This is done in
130     // order to mitigate the issue when the user clicks outside the textbox, as a
131     // result of which |node| becomes null, resulting in all the spell check
132     // markers being deleted. Also, the Frame will decide not to do spellchecking
133     // if the user can't edit - so returning true here will not cause any problems
134     // to the Frame's behavior.
135     if (!node)
136         return true;
137     const RenderObject* renderer = node->renderer();
138     if (!renderer)
139         return false;
140
141     return !renderer->isTextField();
142 }
143
144 bool EditorClientImpl::isContinuousSpellCheckingEnabled()
145 {
146     if (m_spellCheckThisFieldStatus == SpellCheckForcedOff)
147         return false;
148     if (m_spellCheckThisFieldStatus == SpellCheckForcedOn)
149         return true;
150     return shouldSpellcheckByDefault();
151 }
152
153 void EditorClientImpl::toggleContinuousSpellChecking()
154 {
155     if (isContinuousSpellCheckingEnabled())
156         m_spellCheckThisFieldStatus = SpellCheckForcedOff;
157     else
158         m_spellCheckThisFieldStatus = SpellCheckForcedOn;
159 }
160
161 bool EditorClientImpl::isGrammarCheckingEnabled()
162 {
163     const Frame* frame = m_webView->focusedWebCoreFrame();
164     return frame && frame->settings() && (frame->settings()->asynchronousSpellCheckingEnabled() || frame->settings()->unifiedTextCheckerEnabled());
165 }
166
167 void EditorClientImpl::toggleGrammarChecking()
168 {
169     notImplemented();
170 }
171
172 int EditorClientImpl::spellCheckerDocumentTag()
173 {
174     ASSERT_NOT_REACHED();
175     return 0;
176 }
177
178 bool EditorClientImpl::shouldBeginEditing(Range* range)
179 {
180     if (m_webView->client())
181         return m_webView->client()->shouldBeginEditing(WebRange(range));
182     return true;
183 }
184
185 bool EditorClientImpl::shouldEndEditing(Range* range)
186 {
187     if (m_webView->client())
188         return m_webView->client()->shouldEndEditing(WebRange(range));
189     return true;
190 }
191
192 bool EditorClientImpl::shouldInsertNode(Node* node,
193                                         Range* range,
194                                         EditorInsertAction action)
195 {
196     if (m_webView->client()) {
197         return m_webView->client()->shouldInsertNode(WebNode(node),
198                                                      WebRange(range),
199                                                      static_cast<WebEditingAction>(action));
200     }
201     return true;
202 }
203
204 bool EditorClientImpl::shouldInsertText(const String& text,
205                                         Range* range,
206                                         EditorInsertAction action)
207 {
208     if (m_webView->client()) {
209         return m_webView->client()->shouldInsertText(WebString(text),
210                                                      WebRange(range),
211                                                      static_cast<WebEditingAction>(action));
212     }
213     return true;
214 }
215
216
217 bool EditorClientImpl::shouldDeleteRange(Range* range)
218 {
219     if (m_webView->client())
220         return m_webView->client()->shouldDeleteRange(WebRange(range));
221     return true;
222 }
223
224 bool EditorClientImpl::shouldChangeSelectedRange(Range* fromRange,
225                                                  Range* toRange,
226                                                  EAffinity affinity,
227                                                  bool stillSelecting)
228 {
229     if (m_webView->client()) {
230         return m_webView->client()->shouldChangeSelectedRange(WebRange(fromRange),
231                                                               WebRange(toRange),
232                                                               static_cast<WebTextAffinity>(affinity),
233                                                               stillSelecting);
234     }
235     return true;
236 }
237
238 bool EditorClientImpl::shouldApplyStyle(StylePropertySet* style, Range* range)
239 {
240     if (m_webView->client()) {
241         // FIXME: Pass a reference to the CSSStyleDeclaration somehow.
242         return m_webView->client()->shouldApplyStyle(WebString(), WebRange(range));
243     }
244     return true;
245 }
246
247 bool EditorClientImpl::shouldMoveRangeAfterDelete(Range* range,
248                                                   Range* rangeToBeReplaced)
249 {
250     return true;
251 }
252
253 void EditorClientImpl::didBeginEditing()
254 {
255     if (m_webView->client())
256         m_webView->client()->didBeginEditing();
257 }
258
259 void EditorClientImpl::respondToChangedSelection(Frame* frame)
260 {
261     if (m_webView->client()) {
262         if (frame) {
263             m_webView->client()->didChangeSelection(!frame->selection()->isRange());
264             if (frame->editor()->cancelCompositionIfSelectionIsInvalid())
265                 m_webView->client()->didCancelCompositionOnSelectionChange();
266         }
267     }
268 }
269
270 void EditorClientImpl::respondToChangedContents()
271 {
272     if (m_webView->client())
273         m_webView->client()->didChangeContents();
274 }
275
276 void EditorClientImpl::didEndEditing()
277 {
278     if (m_webView->client())
279         m_webView->client()->didEndEditing();
280 }
281
282 void EditorClientImpl::didWriteSelectionToPasteboard()
283 {
284 }
285
286 void EditorClientImpl::willWriteSelectionToPasteboard(WebCore::Range*)
287 {
288 }
289
290 void EditorClientImpl::getClientPasteboardDataForRange(WebCore::Range*, Vector<String>&, Vector<RefPtr<WebCore::SharedBuffer> >&)
291 {
292 }
293
294 void EditorClientImpl::didSetSelectionTypesForPasteboard()
295 {
296 }
297
298 void EditorClientImpl::registerUndoStep(PassRefPtr<UndoStep> step)
299 {
300     if (m_undoStack.size() == maximumUndoStackDepth)
301         m_undoStack.removeFirst(); // drop oldest item off the far end
302     if (!m_inRedo)
303         m_redoStack.clear();
304     m_undoStack.append(step);
305 }
306
307 void EditorClientImpl::registerRedoStep(PassRefPtr<UndoStep> step)
308 {
309     m_redoStack.append(step);
310 }
311
312 void EditorClientImpl::clearUndoRedoOperations()
313 {
314     m_undoStack.clear();
315     m_redoStack.clear();
316 }
317
318 bool EditorClientImpl::canCopyCut(Frame* frame, bool defaultValue) const
319 {
320     if (!m_webView->permissionClient())
321         return defaultValue;
322     return m_webView->permissionClient()->allowWriteToClipboard(WebFrameImpl::fromFrame(frame), defaultValue);
323 }
324
325 bool EditorClientImpl::canPaste(Frame* frame, bool defaultValue) const
326 {
327     if (!m_webView->permissionClient())
328         return defaultValue;
329     return m_webView->permissionClient()->allowReadFromClipboard(WebFrameImpl::fromFrame(frame), defaultValue);
330 }
331
332 bool EditorClientImpl::canUndo() const
333 {
334     return !m_undoStack.isEmpty();
335 }
336
337 bool EditorClientImpl::canRedo() const
338 {
339     return !m_redoStack.isEmpty();
340 }
341
342 void EditorClientImpl::undo()
343 {
344     if (canUndo()) {
345         UndoManagerStack::iterator back = --m_undoStack.end();
346         RefPtr<UndoStep> step(*back);
347         m_undoStack.remove(back);
348         step->unapply();
349         // unapply will call us back to push this command onto the redo stack.
350     }
351 }
352
353 void EditorClientImpl::redo()
354 {
355     if (canRedo()) {
356         UndoManagerStack::iterator back = --m_redoStack.end();
357         RefPtr<UndoStep> step(*back);
358         m_redoStack.remove(back);
359
360         ASSERT(!m_inRedo);
361         m_inRedo = true;
362         step->reapply();
363         // reapply will call us back to push this command onto the undo stack.
364         m_inRedo = false;
365     }
366 }
367
368 //
369 // The below code was adapted from the WebKit file webview.cpp
370 //
371
372 static const unsigned CtrlKey = 1 << 0;
373 static const unsigned AltKey = 1 << 1;
374 static const unsigned ShiftKey = 1 << 2;
375 static const unsigned MetaKey = 1 << 3;
376 #if OS(DARWIN)
377 // Aliases for the generic key defintions to make kbd shortcuts definitions more
378 // readable on OS X.
379 static const unsigned OptionKey  = AltKey;
380
381 // Do not use this constant for anything but cursor movement commands. Keys
382 // with cmd set have their |isSystemKey| bit set, so chances are the shortcut
383 // will not be executed. Another, less important, reason is that shortcuts
384 // defined in the renderer do not blink the menu item that they triggered.  See
385 // http://crbug.com/25856 and the bugs linked from there for details.
386 static const unsigned CommandKey = MetaKey;
387 #endif
388
389 // Keys with special meaning. These will be delegated to the editor using
390 // the execCommand() method
391 struct KeyDownEntry {
392     unsigned virtualKey;
393     unsigned modifiers;
394     const char* name;
395 };
396
397 struct KeyPressEntry {
398     unsigned charCode;
399     unsigned modifiers;
400     const char* name;
401 };
402
403 static const KeyDownEntry keyDownEntries[] = {
404     { VKEY_LEFT,   0,                  "MoveLeft"                             },
405     { VKEY_LEFT,   ShiftKey,           "MoveLeftAndModifySelection"           },
406 #if OS(DARWIN)
407     { VKEY_LEFT,   OptionKey,          "MoveWordLeft"                         },
408     { VKEY_LEFT,   OptionKey | ShiftKey,
409         "MoveWordLeftAndModifySelection"                                      },
410 #else
411     { VKEY_LEFT,   CtrlKey,            "MoveWordLeft"                         },
412     { VKEY_LEFT,   CtrlKey | ShiftKey,
413         "MoveWordLeftAndModifySelection"                                      },
414 #endif
415     { VKEY_RIGHT,  0,                  "MoveRight"                            },
416     { VKEY_RIGHT,  ShiftKey,           "MoveRightAndModifySelection"          },
417 #if OS(DARWIN)
418     { VKEY_RIGHT,  OptionKey,          "MoveWordRight"                        },
419     { VKEY_RIGHT,  OptionKey | ShiftKey,
420       "MoveWordRightAndModifySelection"                                       },
421 #else
422     { VKEY_RIGHT,  CtrlKey,            "MoveWordRight"                        },
423     { VKEY_RIGHT,  CtrlKey | ShiftKey,
424       "MoveWordRightAndModifySelection"                                       },
425 #endif
426     { VKEY_UP,     0,                  "MoveUp"                               },
427     { VKEY_UP,     ShiftKey,           "MoveUpAndModifySelection"             },
428     { VKEY_PRIOR,  ShiftKey,           "MovePageUpAndModifySelection"         },
429     { VKEY_DOWN,   0,                  "MoveDown"                             },
430     { VKEY_DOWN,   ShiftKey,           "MoveDownAndModifySelection"           },
431     { VKEY_NEXT,   ShiftKey,           "MovePageDownAndModifySelection"       },
432 #if !OS(DARWIN)
433     { VKEY_PRIOR,  0,                  "MovePageUp"                           },
434     { VKEY_NEXT,   0,                  "MovePageDown"                         },
435 #endif
436     { VKEY_HOME,   0,                  "MoveToBeginningOfLine"                },
437     { VKEY_HOME,   ShiftKey,
438         "MoveToBeginningOfLineAndModifySelection"                             },
439 #if OS(DARWIN)
440     { VKEY_LEFT,   CommandKey,         "MoveToBeginningOfLine"                },
441     { VKEY_LEFT,   CommandKey | ShiftKey,
442       "MoveToBeginningOfLineAndModifySelection"                               },
443     { VKEY_PRIOR,  OptionKey,          "MovePageUp"                           },
444     { VKEY_NEXT,   OptionKey,          "MovePageDown"                         },
445 #endif
446 #if OS(DARWIN)
447     { VKEY_UP,     CommandKey,         "MoveToBeginningOfDocument"            },
448     { VKEY_UP,     CommandKey | ShiftKey,
449         "MoveToBeginningOfDocumentAndModifySelection"                         },
450 #else
451     { VKEY_HOME,   CtrlKey,            "MoveToBeginningOfDocument"            },
452     { VKEY_HOME,   CtrlKey | ShiftKey,
453         "MoveToBeginningOfDocumentAndModifySelection"                         },
454 #endif
455     { VKEY_END,    0,                  "MoveToEndOfLine"                      },
456     { VKEY_END,    ShiftKey,           "MoveToEndOfLineAndModifySelection"    },
457 #if OS(DARWIN)
458     { VKEY_DOWN,   CommandKey,         "MoveToEndOfDocument"                  },
459     { VKEY_DOWN,   CommandKey | ShiftKey,
460         "MoveToEndOfDocumentAndModifySelection"                               },
461 #else
462     { VKEY_END,    CtrlKey,            "MoveToEndOfDocument"                  },
463     { VKEY_END,    CtrlKey | ShiftKey,
464         "MoveToEndOfDocumentAndModifySelection"                               },
465 #endif
466 #if OS(DARWIN)
467     { VKEY_RIGHT,  CommandKey,         "MoveToEndOfLine"                      },
468     { VKEY_RIGHT,  CommandKey | ShiftKey,
469         "MoveToEndOfLineAndModifySelection"                                   },
470 #endif
471     { VKEY_BACK,   0,                  "DeleteBackward"                       },
472     { VKEY_BACK,   ShiftKey,           "DeleteBackward"                       },
473     { VKEY_DELETE, 0,                  "DeleteForward"                        },
474 #if OS(DARWIN)
475     { VKEY_BACK,   OptionKey,          "DeleteWordBackward"                   },
476     { VKEY_DELETE, OptionKey,          "DeleteWordForward"                    },
477 #else
478     { VKEY_BACK,   CtrlKey,            "DeleteWordBackward"                   },
479     { VKEY_DELETE, CtrlKey,            "DeleteWordForward"                    },
480 #endif
481     { 'B',         CtrlKey,            "ToggleBold"                           },
482     { 'I',         CtrlKey,            "ToggleItalic"                         },
483     { 'U',         CtrlKey,            "ToggleUnderline"                      },
484     { VKEY_ESCAPE, 0,                  "Cancel"                               },
485     { VKEY_OEM_PERIOD, CtrlKey,        "Cancel"                               },
486     { VKEY_TAB,    0,                  "InsertTab"                            },
487     { VKEY_TAB,    ShiftKey,           "InsertBacktab"                        },
488     { VKEY_RETURN, 0,                  "InsertNewline"                        },
489     { VKEY_RETURN, CtrlKey,            "InsertNewline"                        },
490     { VKEY_RETURN, AltKey,             "InsertNewline"                        },
491     { VKEY_RETURN, AltKey | ShiftKey,  "InsertNewline"                        },
492     { VKEY_RETURN, ShiftKey,           "InsertLineBreak"                      },
493     { VKEY_INSERT, CtrlKey,            "Copy"                                 },
494     { VKEY_INSERT, ShiftKey,           "Paste"                                },
495     { VKEY_DELETE, ShiftKey,           "Cut"                                  },
496 #if !OS(DARWIN)
497     // On OS X, we pipe these back to the browser, so that it can do menu item
498     // blinking.
499     { 'C',         CtrlKey,            "Copy"                                 },
500     { 'V',         CtrlKey,            "Paste"                                },
501     { 'V',         CtrlKey | ShiftKey, "PasteAndMatchStyle"                   },
502     { 'X',         CtrlKey,            "Cut"                                  },
503     { 'A',         CtrlKey,            "SelectAll"                            },
504     { 'Z',         CtrlKey,            "Undo"                                 },
505     { 'Z',         CtrlKey | ShiftKey, "Redo"                                 },
506     { 'Y',         CtrlKey,            "Redo"                                 },
507 #endif
508 };
509
510 static const KeyPressEntry keyPressEntries[] = {
511     { '\t',   0,                  "InsertTab"                                 },
512     { '\t',   ShiftKey,           "InsertBacktab"                             },
513     { '\r',   0,                  "InsertNewline"                             },
514     { '\r',   CtrlKey,            "InsertNewline"                             },
515     { '\r',   ShiftKey,           "InsertLineBreak"                           },
516     { '\r',   AltKey,             "InsertNewline"                             },
517     { '\r',   AltKey | ShiftKey,  "InsertNewline"                             },
518 };
519
520 const char* EditorClientImpl::interpretKeyEvent(const KeyboardEvent* evt)
521 {
522     const PlatformKeyboardEvent* keyEvent = evt->keyEvent();
523     if (!keyEvent)
524         return "";
525
526     static HashMap<int, const char*>* keyDownCommandsMap = 0;
527     static HashMap<int, const char*>* keyPressCommandsMap = 0;
528
529     if (!keyDownCommandsMap) {
530         keyDownCommandsMap = new HashMap<int, const char*>;
531         keyPressCommandsMap = new HashMap<int, const char*>;
532
533         for (unsigned i = 0; i < arraysize(keyDownEntries); i++) {
534             keyDownCommandsMap->set(keyDownEntries[i].modifiers << 16 | keyDownEntries[i].virtualKey,
535                                     keyDownEntries[i].name);
536         }
537
538         for (unsigned i = 0; i < arraysize(keyPressEntries); i++) {
539             keyPressCommandsMap->set(keyPressEntries[i].modifiers << 16 | keyPressEntries[i].charCode,
540                                      keyPressEntries[i].name);
541         }
542     }
543
544     unsigned modifiers = 0;
545     if (keyEvent->shiftKey())
546         modifiers |= ShiftKey;
547     if (keyEvent->altKey())
548         modifiers |= AltKey;
549     if (keyEvent->ctrlKey())
550         modifiers |= CtrlKey;
551     if (keyEvent->metaKey())
552         modifiers |= MetaKey;
553
554     if (keyEvent->type() == PlatformEvent::RawKeyDown) {
555         int mapKey = modifiers << 16 | evt->keyCode();
556         return mapKey ? keyDownCommandsMap->get(mapKey) : 0;
557     }
558
559     int mapKey = modifiers << 16 | evt->charCode();
560     return mapKey ? keyPressCommandsMap->get(mapKey) : 0;
561 }
562
563 bool EditorClientImpl::handleEditingKeyboardEvent(KeyboardEvent* evt)
564 {
565     const PlatformKeyboardEvent* keyEvent = evt->keyEvent();
566     // do not treat this as text input if it's a system key event
567     if (!keyEvent || keyEvent->isSystemKey())
568         return false;
569
570     Frame* frame = evt->target()->toNode()->document()->frame();
571     if (!frame)
572         return false;
573
574     String commandName = interpretKeyEvent(evt);
575     Editor::Command command = frame->editor()->command(commandName);
576
577     if (keyEvent->type() == PlatformEvent::RawKeyDown) {
578         // WebKit doesn't have enough information about mode to decide how
579         // commands that just insert text if executed via Editor should be treated,
580         // so we leave it upon WebCore to either handle them immediately
581         // (e.g. Tab that changes focus) or let a keypress event be generated
582         // (e.g. Tab that inserts a Tab character, or Enter).
583         if (command.isTextInsertion() || commandName.isEmpty())
584             return false;
585         if (command.execute(evt)) {
586             if (m_webView->client())
587                 m_webView->client()->didExecuteCommand(WebString(commandName));
588             return true;
589         }
590         return false;
591     }
592
593     if (command.execute(evt)) {
594         if (m_webView->client())
595             m_webView->client()->didExecuteCommand(WebString(commandName));
596         return true;
597     }
598
599     // Here we need to filter key events.
600     // On Gtk/Linux, it emits key events with ASCII text and ctrl on for ctrl-<x>.
601     // In Webkit, EditorClient::handleKeyboardEvent in
602     // WebKit/gtk/WebCoreSupport/EditorClientGtk.cpp drop such events.
603     // On Mac, it emits key events with ASCII text and meta on for Command-<x>.
604     // These key events should not emit text insert event.
605     // Alt key would be used to insert alternative character, so we should let
606     // through. Also note that Ctrl-Alt combination equals to AltGr key which is
607     // also used to insert alternative character.
608     // http://code.google.com/p/chromium/issues/detail?id=10846
609     // Windows sets both alt and meta are on when "Alt" key pressed.
610     // http://code.google.com/p/chromium/issues/detail?id=2215
611     // Also, we should not rely on an assumption that keyboards don't
612     // send ASCII characters when pressing a control key on Windows,
613     // which may be configured to do it so by user.
614     // See also http://en.wikipedia.org/wiki/Keyboard_Layout
615     // FIXME(ukai): investigate more detail for various keyboard layout.
616     if (evt->keyEvent()->text().length() == 1) {
617         UChar ch = evt->keyEvent()->text()[0U];
618
619         // Don't insert null or control characters as they can result in
620         // unexpected behaviour
621         if (ch < ' ')
622             return false;
623 #if !OS(WINDOWS)
624         // Don't insert ASCII character if ctrl w/o alt or meta is on.
625         // On Mac, we should ignore events when meta is on (Command-<x>).
626         if (ch < 0x80) {
627             if (evt->keyEvent()->ctrlKey() && !evt->keyEvent()->altKey())
628                 return false;
629 #if OS(DARWIN)
630             if (evt->keyEvent()->metaKey())
631             return false;
632 #endif
633         }
634 #endif
635     }
636
637     if (!frame->editor()->canEdit())
638         return false;
639
640     return frame->editor()->insertText(evt->keyEvent()->text(), evt);
641 }
642
643 void EditorClientImpl::handleKeyboardEvent(KeyboardEvent* evt)
644 {
645     // Give the embedder a chance to handle the keyboard event.
646     if ((m_webView->client()
647          && m_webView->client()->handleCurrentKeyboardEvent())
648         || handleEditingKeyboardEvent(evt))
649         evt->setDefaultHandled();
650 }
651
652 void EditorClientImpl::handleInputMethodKeydown(KeyboardEvent* keyEvent)
653 {
654     // We handle IME within chrome.
655 }
656
657 void EditorClientImpl::textFieldDidBeginEditing(Element* element)
658 {
659 }
660
661 void EditorClientImpl::textFieldDidEndEditing(Element* element)
662 {
663     HTMLInputElement* inputElement = toHTMLInputElement(element);
664     if (m_webView->autofillClient() && inputElement)
665         m_webView->autofillClient()->textFieldDidEndEditing(WebInputElement(inputElement));
666
667     // Notification that focus was lost.  Be careful with this, it's also sent
668     // when the page is being closed.
669
670     // Hide any showing popup.
671     m_webView->hideAutofillPopup();
672 }
673
674 void EditorClientImpl::textDidChangeInTextField(Element* element)
675 {
676     ASSERT(element->hasLocalName(HTMLNames::inputTag));
677     HTMLInputElement* inputElement = static_cast<HTMLInputElement*>(element);
678     if (m_webView->autofillClient())
679         m_webView->autofillClient()->textFieldDidChange(WebInputElement(inputElement));
680 }
681
682 bool EditorClientImpl::doTextFieldCommandFromEvent(Element* element,
683                                                    KeyboardEvent* event)
684 {
685     HTMLInputElement* inputElement = toHTMLInputElement(element);
686     if (m_webView->autofillClient() && inputElement) {
687         m_webView->autofillClient()->textFieldDidReceiveKeyDown(WebInputElement(inputElement),
688                                                                 WebKeyboardEventBuilder(*event));
689     }
690
691     // The Mac code appears to use this method as a hook to implement special
692     // keyboard commands specific to Safari's auto-fill implementation.  We
693     // just return false to allow the default action.
694     return false;
695 }
696
697 void EditorClientImpl::textWillBeDeletedInTextField(Element*)
698 {
699 }
700
701 void EditorClientImpl::textDidChangeInTextArea(Element*)
702 {
703 }
704
705 bool EditorClientImpl::shouldEraseMarkersAfterChangeSelection(TextCheckingType type) const
706 {
707     const Frame* frame = m_webView->focusedWebCoreFrame();
708     return !frame || !frame->settings() || (!frame->settings()->asynchronousSpellCheckingEnabled() && !frame->settings()->unifiedTextCheckerEnabled());
709 }
710
711 void EditorClientImpl::ignoreWordInSpellDocument(const String&)
712 {
713     notImplemented();
714 }
715
716 void EditorClientImpl::learnWord(const String&)
717 {
718     notImplemented();
719 }
720
721 void EditorClientImpl::checkSpellingOfString(const UChar* text, int length,
722                                              int* misspellingLocation,
723                                              int* misspellingLength)
724 {
725     // SpellCheckWord will write (0, 0) into the output vars, which is what our
726     // caller expects if the word is spelled correctly.
727     int spellLocation = -1;
728     int spellLength = 0;
729
730     // Check to see if the provided text is spelled correctly.
731     if (m_webView->spellCheckClient())
732         m_webView->spellCheckClient()->spellCheck(WebString(text, length), spellLocation, spellLength, 0);
733     else {
734         spellLocation = 0;
735         spellLength = 0;
736     }
737
738     // Note: the Mac code checks if the pointers are null before writing to them,
739     // so we do too.
740     if (misspellingLocation)
741         *misspellingLocation = spellLocation;
742     if (misspellingLength)
743         *misspellingLength = spellLength;
744 }
745
746 void EditorClientImpl::requestCheckingOfString(WTF::PassRefPtr<WebCore::TextCheckingRequest> request)
747 {
748     if (m_webView->spellCheckClient()) {
749         String text = request->data().text();
750         m_webView->spellCheckClient()->requestCheckingOfText(text, new WebTextCheckingCompletionImpl(request));
751     }
752 }
753
754 String EditorClientImpl::getAutoCorrectSuggestionForMisspelledWord(const String& misspelledWord)
755 {
756     if (!(isContinuousSpellCheckingEnabled() && m_webView->client()))
757         return String();
758
759     // Do not autocorrect words with capital letters in it except the
760     // first letter. This will remove cases changing "IMB" to "IBM".
761     for (size_t i = 1; i < misspelledWord.length(); i++) {
762         if (u_isupper(static_cast<UChar32>(misspelledWord[i])))
763             return String();
764     }
765
766     if (m_webView->spellCheckClient())
767         return m_webView->spellCheckClient()->autoCorrectWord(WebString(misspelledWord));
768     return String();
769 }
770
771 void EditorClientImpl::checkGrammarOfString(const UChar* text, int length, WTF::Vector<GrammarDetail>& details, int* badGrammarLocation, int* badGrammarLength)
772 {
773     if (badGrammarLocation)
774         *badGrammarLocation = -1;
775     if (badGrammarLength)
776         *badGrammarLength = 0;
777
778     if (!m_webView->spellCheckClient())
779         return;
780     WebVector<WebTextCheckingResult> webResults;
781     m_webView->spellCheckClient()->checkTextOfParagraph(WebString(text, length), WebTextCheckingTypeGrammar, &webResults);
782     if (!webResults.size())
783         return;
784
785     // Convert a list of WebTextCheckingResults to a list of GrammarDetails. If
786     // the converted vector of GrammarDetails has grammar errors, we set
787     // badGrammarLocation and badGrammarLength to tell WebKit that the input
788     // text has grammar errors.
789     for (size_t i = 0; i < webResults.size(); ++i) {
790         if (webResults[i].type == WebTextCheckingTypeGrammar) {
791             GrammarDetail detail;
792             detail.location = webResults[i].location;
793             detail.length = webResults[i].length;
794             detail.userDescription = webResults[i].replacement;
795             details.append(detail);
796         }
797     }
798     if (!details.size())
799         return;
800     if (badGrammarLocation)
801         *badGrammarLocation = 0;
802     if (badGrammarLength)
803         *badGrammarLength = length;
804 }
805
806 void EditorClientImpl::checkTextOfParagraph(const UChar* text, int length,
807                                             TextCheckingTypeMask mask,
808                                             WTF::Vector<TextCheckingResult>& results)
809 {
810     if (!m_webView->spellCheckClient())
811         return;
812
813     WebTextCheckingTypeMask webMask = static_cast<WebTextCheckingTypeMask>(mask);
814     WebVector<WebTextCheckingResult> webResults;
815     m_webView->spellCheckClient()->checkTextOfParagraph(WebString(text, length), webMask, &webResults);
816
817     results.resize(webResults.size());
818     for (size_t i = 0; i < webResults.size(); ++i)
819         results[i] = webResults[i];
820 }
821
822 void EditorClientImpl::updateSpellingUIWithGrammarString(const String&,
823                                                          const GrammarDetail& detail)
824 {
825     notImplemented();
826 }
827
828 void EditorClientImpl::updateSpellingUIWithMisspelledWord(const String& misspelledWord)
829 {
830     if (m_webView->spellCheckClient())
831         m_webView->spellCheckClient()->updateSpellingUIWithMisspelledWord(WebString(misspelledWord));
832 }
833
834 void EditorClientImpl::showSpellingUI(bool show)
835 {
836     if (m_webView->spellCheckClient())
837         m_webView->spellCheckClient()->showSpellingUI(show);
838 }
839
840 bool EditorClientImpl::spellingUIIsShowing()
841 {
842     if (m_webView->spellCheckClient())
843         return m_webView->spellCheckClient()->isShowingSpellingUI();
844     return false;
845 }
846
847 void EditorClientImpl::getGuessesForWord(const String& word,
848                                          const String& context,
849                                          WTF::Vector<String>& guesses)
850 {
851     notImplemented();
852 }
853
854 bool EditorClientImpl::supportsGlobalSelection()
855 {
856 #if OS(UNIX) && !OS(DARWIN)
857     return true;
858 #else
859     return false;
860 #endif
861 }
862
863 void EditorClientImpl::willSetInputMethodState()
864 {
865     if (m_webView->client())
866         m_webView->client()->resetInputMethod();
867 }
868
869 void EditorClientImpl::setInputMethodState(bool)
870 {
871 }
872
873 } // namesace WebKit