2008-07-24 Tor Arne Vestbø <tavestbo@trolltech.com>
[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(const 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     emit m_page->microFocusChanged();
222 }
223
224 void EditorClientQt::didEndEditing()
225 {
226     if (dumpEditingCallbacks)
227         printf("EDITING DELEGATE: webViewDidEndEditing:WebViewDidEndEditingNotification\n");
228     m_editing = false;
229 }
230
231 void EditorClientQt::didWriteSelectionToPasteboard()
232 {
233 }
234
235 void EditorClientQt::didSetSelectionTypesForPasteboard()
236 {
237 }
238
239 bool EditorClientQt::selectWordBeforeMenuEvent()
240 {
241     notImplemented();
242     return false;
243 }
244
245 bool EditorClientQt::isEditable()
246
247     return m_page->isEditable();
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->selection()->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->type() != PlatformKeyboardEvent::KeyDown
386                         && !kevent->ctrlKey() && !kevent->altKey() && !kevent->text().isEmpty()) {
387                     frame->editor()->insertText(kevent->text(), event);
388                 } else if (kevent->ctrlKey()) {
389                     switch (kevent->windowsVirtualKeyCode()) {
390                         case VK_A:
391                             frame->editor()->command("SelectAll").execute();
392                             break;
393                         case VK_B:
394                             frame->editor()->command("ToggleBold").execute();
395                             break;
396                         case VK_C:
397                             frame->editor()->command("Copy").execute();
398                             break;
399                         case VK_I:
400                             frame->editor()->command("ToggleItalic").execute();
401                             break;
402                         case VK_V:
403                             frame->editor()->command("Paste").execute();
404                             break;
405                         case VK_X:
406                             frame->editor()->command("Cut").execute();
407                             break;
408                         case VK_Y:
409                             frame->editor()->command("Redo").execute();
410                             break;
411                         case VK_Z:
412                             frame->editor()->command("Undo").execute();
413                             break;
414                         default:
415                             // catch combination AltGr+key or Ctrl+Alt+key
416                             if (kevent->type() != PlatformKeyboardEvent::KeyDown && !kevent->text().isEmpty()) {
417                                 frame->editor()->insertText(kevent->text(), event);
418                                 break;
419                             }
420                             return;
421                     }
422                 } else return;
423         }
424     } else {
425         switch (kevent->windowsVirtualKeyCode()) {
426             case VK_UP:
427                 frame->editor()->command("MoveUp").execute();
428                 break;
429             case VK_DOWN:
430                 frame->editor()->command("MoveDown").execute();
431                 break;
432             case VK_PRIOR:  // PageUp
433                 frame->editor()->command("MovePageUp").execute();
434                 break;
435             case VK_NEXT:  // PageDown
436                 frame->editor()->command("MovePageDown").execute();
437                 break;
438             case VK_HOME:
439                 if (kevent->ctrlKey())
440                     frame->editor()->command("MoveToBeginningOfDocument").execute();
441                 break;
442             case VK_END:
443                 if (kevent->ctrlKey())
444                     frame->editor()->command("MoveToEndOfDocument").execute();
445                 break;
446             default:
447                 if (kevent->ctrlKey()) {
448                     switch (kevent->windowsVirtualKeyCode()) {
449                         case VK_A:
450                             frame->editor()->command("SelectAll").execute();
451                             break;
452                         case VK_C: case VK_X:
453                             frame->editor()->command("Copy").execute();
454                             break;
455                         default:
456                             return;
457                     }
458                 } else return;
459         }
460     }
461     event->setDefaultHandled();
462 }
463
464 void EditorClientQt::handleInputMethodKeydown(KeyboardEvent*)
465 {
466 }
467
468 EditorClientQt::EditorClientQt(QWebPage* page)
469     : m_page(page), m_editing(false), m_inUndoRedo(false)
470 {
471 }
472
473 void EditorClientQt::textFieldDidBeginEditing(Element*)
474 {
475     m_editing = true;
476 }
477
478 void EditorClientQt::textFieldDidEndEditing(Element*)
479 {
480     m_editing = false;
481 }
482
483 void EditorClientQt::textDidChangeInTextField(Element*)
484 {
485 }
486
487 bool EditorClientQt::doTextFieldCommandFromEvent(Element*, KeyboardEvent*)
488 {
489     return false;
490 }
491
492 void EditorClientQt::textWillBeDeletedInTextField(Element*)
493 {
494 }
495
496 void EditorClientQt::textDidChangeInTextArea(Element*)
497 {
498 }
499
500 void EditorClientQt::ignoreWordInSpellDocument(const String&)
501 {
502     notImplemented();
503 }
504
505 void EditorClientQt::learnWord(const String&)
506 {
507     notImplemented();
508 }
509
510 void EditorClientQt::checkSpellingOfString(const UChar*, int, int*, int*)
511 {
512     notImplemented();
513 }
514
515 void EditorClientQt::checkGrammarOfString(const UChar*, int, Vector<GrammarDetail>&, int*, int*)
516 {
517     notImplemented();
518 }
519
520 void EditorClientQt::updateSpellingUIWithGrammarString(const String&, const GrammarDetail&)
521 {
522     notImplemented();
523 }
524
525 void EditorClientQt::updateSpellingUIWithMisspelledWord(const String&)
526 {
527     notImplemented();
528 }
529
530 void EditorClientQt::showSpellingUI(bool)
531 {
532     notImplemented();
533 }
534
535 bool EditorClientQt::spellingUIIsShowing()
536 {
537     notImplemented();
538     return false;
539 }
540
541 void EditorClientQt::getGuessesForWord(const String&, Vector<String>&)
542 {
543     notImplemented();
544 }
545
546 bool EditorClientQt::isEditing() const
547 {
548     return m_editing;
549 }
550
551 void EditorClientQt::setInputMethodState(bool active)
552 {
553     QWidget *view = m_page->view();
554     if (view) {
555         view->setAttribute(Qt::WA_InputMethodEnabled, active);
556         emit m_page->microFocusChanged();
557     }
558 }
559
560 }
561
562 // vim: ts=4 sw=4 et