[chromium-reviews] Add "Enable spell check for this field" menu option in sub context menu for c...

webkit/glue/editor_client_impl.cc

 // Copyright (c) 2006-2008 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // The Mac interface forwards most of these commands to the application layer,
 // and I'm not really sure what to do about most of them.
 
 #include "config.h"
 
 #include "base/compiler_specific.h"
@@ skipping 55 matching lines @@
 
 }
 
 EditorClientImpl::EditorClientImpl(WebView* web_view)
     : web_view_(static_cast<WebViewImpl*>(web_view)),
       use_editor_delegate_(false),
       in_redo_(false),
       backspace_pressed_(false),
 // Don't complain about using "this" in initializer list.
 MSVC_PUSH_DISABLE_WARNING(4355)
-      autofill_factory_(this) {
+      autofill_factory_(this),
+      spell_check_this_field_status_(SPELLCHECK_AUTOMATIC) {
 MSVC_POP_WARNING()
 }
 
 EditorClientImpl::~EditorClientImpl() {
 }
 
 void EditorClientImpl::pageDestroyed() {
   // Called by the Page (which owns the editor client) when the page is going
   // away. This should cause us to delete ourselves, which is stupid. The page
   // should just delete us when it's going away. Oh well.
@@ skipping 19 matching lines @@
 
 bool EditorClientImpl::isSelectTrailingWhitespaceEnabled() {
   if (use_editor_delegate_) {
   WebViewDelegate* d = web_view_->delegate();
   if (d)
     return d->IsSelectTrailingWhitespaceEnabled();
   }
   return true;
 }
 
+bool EditorClientImpl::ShouldSpellcheckByDefault() {

[brettw, 2008/12/12 19:12:37]

Is it possible to make this function const? If so, do it, otherwise don't worry
about it.

+  const WebCore::Frame* frame = web_view_->GetFocusedWebCoreFrame();
+  if (!frame)
+    return false;
+  const WebCore::Editor* editor = frame->editor();
+  if (!editor)
+    return false;
+  const WebCore::Document* document = frame->document();
+  if (!document)
+    return false;
+  const WebCore::Node* node = document->focusedNode();
+  if (!node)
+    return false;
+  const WebCore::RenderObject* renderer = node->renderer();
+  if (!renderer)
+    return false;
+  // We should also retrieve the contenteditable attribute of this element to
+  // determine if this element needs spell-checking.
+  const WebCore::EUserModify user_modify = renderer->style()->userModify();
+  return (renderer->isTextArea() && editor->canEdit()) ||
+         user_modify == WebCore::READ_WRITE ||
+         user_modify == WebCore::READ_WRITE_PLAINTEXT_ONLY;
+}
+
 bool EditorClientImpl::isContinuousSpellCheckingEnabled() {
-  // Spell check everything if possible.
-  // FIXME(brettw) This should be modified to do reasonable defaults depending
-  // on input type, and probably also allow the user to turn spellchecking on
-  // for individual fields.
-  return true;
+  if (spell_check_this_field_status_ == SPELLCHECK_FORCED_OFF)
+    return false;
+  else if (spell_check_this_field_status_ == SPELLCHECK_FORCED_ON)
+    return true;
+  else 
+    return ShouldSpellcheckByDefault();
 }
 
 void EditorClientImpl::toggleContinuousSpellChecking() {
-  NOTIMPLEMENTED();
+  if (isContinuousSpellCheckingEnabled())
+    spell_check_this_field_status_ = SPELLCHECK_FORCED_OFF;
+  else
+    spell_check_this_field_status_ = SPELLCHECK_FORCED_ON;
 }
 
 bool EditorClientImpl::isGrammarCheckingEnabled() {
   return false;
 }
 
 void EditorClientImpl::toggleGrammarChecking() {
   NOTIMPLEMENTED();
 }
 
@@ skipping 575 matching lines @@
 }
 
 void EditorClientImpl::checkSpellingOfString(const UChar* str, int length,
                                              int* misspellingLocation,
                                              int* misspellingLength) {
   // SpellCheckWord will write (0, 0) into the output vars, which is what our
   // caller expects if the word is spelled correctly.
   int spell_location = -1;
   int spell_length = 0;
   WebViewDelegate* d = web_view_->delegate();
-  if (web_view_->FocusedFrameNeedsSpellchecking() && d) {
+  if (isContinuousSpellCheckingEnabled() && d) {
     std::wstring word = 
         webkit_glue::StringToStdWString(WebCore::String(str, length));
     d->SpellCheck(word, spell_location, spell_length);
   } else {
     spell_location = 0;
     spell_length = 0;
   }
 
   // Note: the Mac code checks if the pointers are NULL before writing to them,
   // so we do too.
@@ skipping 118 matching lines @@
   }
   return L"(UNKNOWN AFFINITY)";
 }
 
 std::wstring EditorClientImpl::Describe(WebCore::CSSStyleDeclaration* style) {
   // TODO(pamg): Implement me.  It's not clear what WebKit produces for this
   // (their [style description] method), and none of the layout tests provide
   // an example.  But because none of them use it, it's not yet important.
   return std::wstring();
 }