WebCore:
[WebKit-https.git] / WebKit / qt / WebCoreSupport / EditorClientQt.cpp
1 /*
2  * Copyright (C) 2006 Nikolas Zimmermann <zimmermann@kde.org> 
3  * Copyright (C) 2006 Zack Rusin <zack@kde.org>
4  * Copyright (C) 2006 Apple Computer, Inc.
5  *
6  * All rights reserved.
7  *
8  * Redistribution and use in source and binary forms, with or without
9  * modification, are permitted provided that the following conditions
10  * are met:
11  * 1. Redistributions of source code must retain the above copyright
12  *    notice, this list of conditions and the following disclaimer.
13  * 2. Redistributions in binary form must reproduce the above copyright
14  *    notice, this list of conditions and the following disclaimer in the
15  *    documentation and/or other materials provided with the distribution.
16  *
17  * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
18  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
20  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR
21  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
22  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
23  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
24  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
25  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
26  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
27  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28  */
29
30 #include "config.h"
31 #include "EditorClientQt.h"
32
33 #include "qwebpage.h"
34 #include "qwebpage_p.h"
35
36 #include "Document.h"
37 #include "EditCommandQt.h"
38 #include "Page.h"
39 #include "Editor.h"
40 #include "FocusController.h"
41 #include "Frame.h"
42 #include "KeyboardCodes.h"
43 #include "KeyboardEvent.h"
44 #include "Page.h"
45 #include "PlatformKeyboardEvent.h"
46 #include "NotImplemented.h"
47 #include "Node.h"
48 #include "Range.h"
49
50 #include <stdio.h>
51
52 #include <QUndoStack>
53 #define methodDebug() qDebug("EditorClientQt: %s", __FUNCTION__);
54
55 static bool dumpEditingCallbacks = false;
56 static bool drt_run = false;
57 static bool acceptsEditing = true;
58 void QWEBKIT_EXPORT qt_dump_editing_callbacks(bool b)
59 {
60     dumpEditingCallbacks = b;
61 }
62 void QWEBKIT_EXPORT qt_drt_run(bool b)
63 {
64     drt_run = b;
65 }
66
67 void QWEBKIT_EXPORT qt_dump_set_accepts_editing(bool b)
68 {
69     acceptsEditing = b;
70 }
71
72
73 static QString dumpPath(WebCore::Node *node)
74 {
75     QString str = node->nodeName();
76     
77     WebCore::Node *parent = node->parentNode();
78     while (parent) {
79         str.append(QLatin1String(" > "));
80         str.append(parent->nodeName());
81         parent = parent->parentNode();
82     }
83     return str;
84 }
85
86 static QString dumpRange(WebCore::Range *range)
87 {
88     if (!range)
89         return QLatin1String("(null)");
90     QString str;
91     WebCore::ExceptionCode code;
92     str.sprintf("range from %ld of %ls to %ld of %ls",
93                 range->startOffset(code), dumpPath(range->startContainer(code)).unicode(),
94                 range->endOffset(code), dumpPath(range->endContainer(code)).unicode());
95     return str;
96 }
97     
98
99 namespace WebCore {
100
101
102 bool EditorClientQt::shouldDeleteRange(Range* range)
103 {
104     if (dumpEditingCallbacks) 
105         printf("EDITING DELEGATE: shouldDeleteDOMRange:%s\n", dumpRange(range).toUtf8().constData());
106
107     return true;
108 }
109
110 bool EditorClientQt::shouldShowDeleteInterface(HTMLElement* element)
111 {
112     if (drt_run) 
113         return element->className() == "needsDeletionUI";
114     return false;
115 }
116
117 bool EditorClientQt::isContinuousSpellCheckingEnabled()
118 {
119     return false;
120 }
121
122 bool EditorClientQt::isGrammarCheckingEnabled()
123 {
124     return false;
125 }
126
127 int EditorClientQt::spellCheckerDocumentTag()
128 {
129     return 0;
130 }
131
132 bool EditorClientQt::shouldBeginEditing(WebCore::Range* range)
133 {
134     if (dumpEditingCallbacks)
135         printf("EDITING DELEGATE: shouldBeginEditingInDOMRange:%s\n", dumpRange(range).toUtf8().constData());
136     return true;
137 }
138
139 bool EditorClientQt::shouldEndEditing(WebCore::Range* range)
140 {
141     if (dumpEditingCallbacks)
142         printf("EDITING DELEGATE: shouldEndEditingInDOMRange:%s\n", dumpRange(range).toUtf8().constData());
143     return true;
144 }
145
146 bool EditorClientQt::shouldInsertText(String string, Range* range, EditorInsertAction action)
147 {
148     if (dumpEditingCallbacks) {
149         static const char *insertactionstring[] = {
150             "WebViewInsertActionTyped",
151             "WebViewInsertActionPasted",
152             "WebViewInsertActionDropped",
153         };
154         
155         printf("EDITING DELEGATE: shouldInsertText:%s replacingDOMRange:%s givenAction:%s\n",
156                QString(string).toUtf8().constData(), dumpRange(range).toUtf8().constData(), insertactionstring[action]);
157     }
158     return acceptsEditing;
159 }
160
161 bool EditorClientQt::shouldChangeSelectedRange(Range* currentRange, Range* proposedRange, EAffinity selectionAffinity, bool stillSelecting)
162 {
163     if (dumpEditingCallbacks) {
164         static const char *affinitystring[] = {
165             "NSSelectionAffinityUpstream",
166             "NSSelectionAffinityDownstream"
167         };
168         static const char *boolstring[] = {
169             "FALSE",
170             "TRUE"
171         };
172         
173         printf("EDITING DELEGATE: shouldChangeSelectedDOMRange:%s toDOMRange:%s affinity:%s stillSelecting:%s\n",
174                dumpRange(currentRange).toUtf8().constData(),
175                dumpRange(proposedRange).toUtf8().constData(),
176                affinitystring[selectionAffinity], boolstring[stillSelecting]);
177     }
178     return acceptsEditing;
179 }
180
181 bool EditorClientQt::shouldApplyStyle(WebCore::CSSStyleDeclaration* style,
182                                       WebCore::Range* range)
183 {
184     if (dumpEditingCallbacks)
185         printf("EDITING DELEGATE: shouldApplyStyle:%s toElementsInDOMRange:%s\n",
186                QString(style->cssText()).toUtf8().constData(), dumpRange(range).toUtf8().constData());
187     return acceptsEditing;
188 }
189
190 bool EditorClientQt::shouldMoveRangeAfterDelete(WebCore::Range*, WebCore::Range*)
191 {
192     notImplemented();
193     return true;
194 }
195
196 void EditorClientQt::didBeginEditing()
197 {
198     if (dumpEditingCallbacks)
199         printf("EDITING DELEGATE: webViewDidBeginEditing:WebViewDidBeginEditingNotification\n");
200     m_editing = true;
201 }
202
203 void EditorClientQt::respondToChangedContents()
204 {
205     if (dumpEditingCallbacks)
206         printf("EDITING DELEGATE: webViewDidChange:WebViewDidChangeNotification\n");
207     m_page->d->modified = true;
208 }
209
210 void EditorClientQt::respondToChangedSelection()
211 {
212     if (dumpEditingCallbacks)
213         printf("EDITING DELEGATE: webViewDidChangeSelection:WebViewDidChangeSelectionNotification\n");
214 //     const Selection &selection = m_page->d->page->selection();
215 //     char buffer[1024];
216 //     selection.formatForDebugger(buffer, sizeof(buffer));
217 //     printf("%s\n", buffer);
218
219     m_page->d->updateEditorActions();
220     emit m_page->selectionChanged();
221 }
222
223 void EditorClientQt::didEndEditing()
224 {
225     if (dumpEditingCallbacks)
226         printf("EDITING DELEGATE: webViewDidEndEditing:WebViewDidEndEditingNotification\n");
227     m_editing = false;
228 }
229
230 void EditorClientQt::didWriteSelectionToPasteboard()
231 {
232 }
233
234 void EditorClientQt::didSetSelectionTypesForPasteboard()
235 {
236 }
237
238 bool EditorClientQt::selectWordBeforeMenuEvent()
239 {
240     notImplemented();
241     return false;
242 }
243
244 bool EditorClientQt::isEditable()
245
246     // FIXME: should be controllable by a setting in QWebPage
247     return false;
248 }
249
250 void EditorClientQt::registerCommandForUndo(WTF::PassRefPtr<WebCore::EditCommand> cmd)
251 {
252     Frame* frame = m_page->d->page->focusController()->focusedOrMainFrame();
253     if (m_inUndoRedo || (frame && !frame->editor()->lastEditCommand() /* HACK!! Don't recreate undos */)) {
254         return;
255     }
256     m_page->undoStack()->push(new EditCommandQt(cmd));
257 }
258
259 void EditorClientQt::registerCommandForRedo(WTF::PassRefPtr<WebCore::EditCommand>)
260 {
261 }
262
263 void EditorClientQt::clearUndoRedoOperations()
264 {
265     return m_page->undoStack()->clear();
266 }
267
268 bool EditorClientQt::canUndo() const
269 {
270     return m_page->undoStack()->canUndo();
271 }
272
273 bool EditorClientQt::canRedo() const
274 {
275     return m_page->undoStack()->canRedo();
276 }
277
278 void EditorClientQt::undo()
279 {
280     m_inUndoRedo = true;
281     m_page->undoStack()->undo();
282     m_inUndoRedo = false;
283 }
284
285 void EditorClientQt::redo()
286 {
287     m_inUndoRedo = true;
288     m_page->undoStack()->redo();
289     m_inUndoRedo = false;
290 }
291
292 bool EditorClientQt::shouldInsertNode(Node* node, Range* range, EditorInsertAction action)
293 {
294     if (dumpEditingCallbacks) {
295         static const char *insertactionstring[] = {
296             "WebViewInsertActionTyped",
297             "WebViewInsertActionPasted",
298             "WebViewInsertActionDropped",
299         };
300         
301         printf("EDITING DELEGATE: shouldInsertNode:%s replacingDOMRange:%s givenAction:%s\n", dumpPath(node).toUtf8().constData(),
302                dumpRange(range).toUtf8().constData(), insertactionstring[action]);
303     }
304     return acceptsEditing;
305 }
306
307 void EditorClientQt::pageDestroyed()
308 {
309     delete this;
310 }
311
312 bool EditorClientQt::smartInsertDeleteEnabled()
313 {
314     notImplemented();
315     return false;
316 }
317
318 void EditorClientQt::toggleContinuousSpellChecking()
319 {
320     notImplemented();
321 }
322
323 void EditorClientQt::toggleGrammarChecking()
324 {
325     notImplemented();
326 }
327
328 void EditorClientQt::handleKeyboardEvent(KeyboardEvent* event)
329 {
330     Frame* frame = m_page->d->page->focusController()->focusedOrMainFrame();
331     if (!frame || !frame->document()->focusedNode())
332         return;
333
334     const PlatformKeyboardEvent* kevent = event->keyEvent();
335     if (!kevent || kevent->type() == PlatformKeyboardEvent::KeyUp)
336         return;
337
338     Node* start = frame->selectionController()->start().node();
339     if (!start)
340         return;
341
342     // FIXME: refactor all of this to use Actions or something like them
343     if (start->isContentEditable()) {
344         switch (kevent->windowsVirtualKeyCode()) {
345             case VK_RETURN:
346                 frame->editor()->command("InsertLineBreak").execute();
347                 break;
348             case VK_BACK:
349                 frame->editor()->deleteWithDirection(SelectionController::BACKWARD,
350                         CharacterGranularity, false, true);
351                 break;
352             case VK_DELETE:
353                 frame->editor()->deleteWithDirection(SelectionController::FORWARD,
354                         CharacterGranularity, false, true);
355                 break;
356             case VK_LEFT:
357                 if (kevent->shiftKey())
358                     frame->editor()->command("MoveLeftAndModifySelection").execute();
359                 else frame->editor()->command("MoveLeft").execute();
360                 break;
361             case VK_RIGHT:
362                 if (kevent->shiftKey())
363                     frame->editor()->command("MoveRightAndModifySelection").execute();
364                 else frame->editor()->command("MoveRight").execute();
365                 break;
366             case VK_UP:
367                 if (kevent->shiftKey())
368                     frame->editor()->command("MoveUpAndModifySelection").execute();
369                 else frame->editor()->command("MoveUp").execute();
370                 break;
371             case VK_DOWN:
372                 if (kevent->shiftKey())
373                     frame->editor()->command("MoveDownAndModifySelection").execute();
374                 else frame->editor()->command("MoveDown").execute();
375                 break;
376             case VK_PRIOR:  // PageUp
377                 frame->editor()->command("MovePageUp").execute();
378                 break;
379             case VK_NEXT:  // PageDown
380                 frame->editor()->command("MovePageDown").execute();
381                 break;
382             case VK_TAB:
383                 return;
384             default:
385                 if (!kevent->ctrlKey() && !kevent->altKey() && !kevent->text().isEmpty()) {
386                     frame->editor()->insertText(kevent->text(), event);
387                 } else if (kevent->ctrlKey()) {
388                     switch (kevent->windowsVirtualKeyCode()) {
389                         case VK_A:
390                             frame->editor()->command("SelectAll").execute();
391                             break;
392                         case VK_B:
393                             frame->editor()->command("ToggleBold").execute();
394                             break;
395                         case VK_C:
396                             frame->editor()->command("Copy").execute();
397                             break;
398                         case VK_I:
399                             frame->editor()->command("ToggleItalic").execute();
400                             break;
401                         case VK_V:
402                             frame->editor()->command("Paste").execute();
403                             break;
404                         case VK_X:
405                             frame->editor()->command("Cut").execute();
406                             break;
407                         case VK_Y:
408                             frame->editor()->command("Redo").execute();
409                             break;
410                         case VK_Z:
411                             frame->editor()->command("Undo").execute();
412                             break;
413                         default:
414                             return;
415                     }
416                 } else return;
417         }
418     } else {
419         switch (kevent->windowsVirtualKeyCode()) {
420             case VK_UP:
421                 frame->editor()->command("MoveUp").execute();
422                 break;
423             case VK_DOWN:
424                 frame->editor()->command("MoveDown").execute();
425                 break;
426             case VK_PRIOR:  // PageUp
427                 frame->editor()->command("MovePageUp").execute();
428                 break;
429             case VK_NEXT:  // PageDown
430                 frame->editor()->command("MovePageDown").execute();
431                 break;
432             case VK_HOME:
433                 if (kevent->ctrlKey())
434                     frame->editor()->command("MoveToBeginningOfDocument").execute();
435                 break;
436             case VK_END:
437                 if (kevent->ctrlKey())
438                     frame->editor()->command("MoveToEndOfDocument").execute();
439                 break;
440             default:
441                 if (kevent->ctrlKey()) {
442                     switch (kevent->windowsVirtualKeyCode()) {
443                         case VK_A:
444                             frame->editor()->command("SelectAll").execute();
445                             break;
446                         case VK_C: case VK_X:
447                             frame->editor()->command("Copy").execute();
448                             break;
449                         default:
450                             return;
451                     }
452                 } else return;
453         }
454     }
455     event->setDefaultHandled();
456 }
457
458 void EditorClientQt::handleInputMethodKeydown(KeyboardEvent*)
459 {
460 }
461
462 EditorClientQt::EditorClientQt(QWebPage* page)
463     : m_page(page), m_editing(false), m_inUndoRedo(false)
464 {
465 }
466
467 void EditorClientQt::textFieldDidBeginEditing(Element*)
468 {
469     m_editing = true;
470 }
471
472 void EditorClientQt::textFieldDidEndEditing(Element*)
473 {
474     m_editing = false;
475 }
476
477 void EditorClientQt::textDidChangeInTextField(Element*)
478 {
479 }
480
481 bool EditorClientQt::doTextFieldCommandFromEvent(Element*, KeyboardEvent*)
482 {
483     return false;
484 }
485
486 void EditorClientQt::textWillBeDeletedInTextField(Element*)
487 {
488 }
489
490 void EditorClientQt::textDidChangeInTextArea(Element*)
491 {
492 }
493
494 void EditorClientQt::ignoreWordInSpellDocument(const String&)
495 {
496     notImplemented();
497 }
498
499 void EditorClientQt::learnWord(const String&)
500 {
501     notImplemented();
502 }
503
504 void EditorClientQt::checkSpellingOfString(const UChar*, int, int*, int*)
505 {
506     notImplemented();
507 }
508
509 void EditorClientQt::checkGrammarOfString(const UChar*, int, Vector<GrammarDetail>&, int*, int*)
510 {
511     notImplemented();
512 }
513
514 void EditorClientQt::updateSpellingUIWithGrammarString(const String&, const GrammarDetail&)
515 {
516     notImplemented();
517 }
518
519 void EditorClientQt::updateSpellingUIWithMisspelledWord(const String&)
520 {
521     notImplemented();
522 }
523
524 void EditorClientQt::showSpellingUI(bool)
525 {
526     notImplemented();
527 }
528
529 bool EditorClientQt::spellingUIIsShowing()
530 {
531     notImplemented();
532     return false;
533 }
534
535 void EditorClientQt::getGuessesForWord(const String&, Vector<String>&)
536 {
537     notImplemented();
538 }
539
540 bool EditorClientQt::isEditing() const
541 {
542     return m_editing;
543 }
544     
545 void EditorClientQt::setInputMethodState(bool)
546 {
547 }
548
549 }
550
551 // vim: ts=4 sw=4 et