Fixes text field background when disabled/read-only to better match...

chrome/views/text_field.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.
 
 #include "chrome/views/text_field.h"
 
 #include <atlbase.h>
 #include <atlapp.h>
 #include <atlcrack.h>
 #include <atlctrls.h>
 #include <tom.h>  // For ITextDocument, a COM interface to CRichEditCtrl
 #include <vsstyle.h>
 
+#include "base/gfx/skia_utils.h"

[Finnur, 2008/11/12 22:57:39]

s is after n in the alphabet. :)

 #include "base/gfx/native_theme.h"
 #include "base/scoped_clipboard_writer.h"
 #include "base/string_util.h"
 #include "base/win_util.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/common/clipboard_service.h"
 #include "chrome/common/gfx/insets.h"
 #include "chrome/common/l10n_util.h"
 #include "chrome/common/logging_chrome.h"
 #include "chrome/common/win_util.h"
@@ skipping 30 matching lines @@
   void SelectAll();
 
   // Clears the selection within the edit field and sets the caret to the end.
   void ClearSelection();
 
   // Removes the border.
   void RemoveBorder();
 
   void SetEnabled(bool enabled);
 
+  void SetBackgroundColor(COLORREF bg_color);
+
   // CWindowImpl
   BEGIN_MSG_MAP(Edit)
     MSG_WM_CHAR(OnChar)
     MSG_WM_CONTEXTMENU(OnContextMenu)
     MSG_WM_COPY(OnCopy)
     MSG_WM_CUT(OnCut)
     MESSAGE_HANDLER_EX(WM_IME_STARTCOMPOSITION, OnImeStartComposition)
     MESSAGE_HANDLER_EX(WM_IME_COMPOSITION, OnImeComposition)
     MSG_WM_KEYDOWN(OnKeyDown)
     MSG_WM_LBUTTONDBLCLK(OnLButtonDblClk)
@@ skipping 115 matching lines @@
   // This interface is useful for accessing the CRichEditCtrl at a low level.
   mutable CComQIPtr<ITextDocument> text_object_model_;
 
   // The position and the length of the ongoing composition string.
   // These values are used for removing a composition string from a search
   // text to emulate Firefox.
   bool ime_discard_composition_;
   int ime_composition_start_;
   int ime_composition_length_;
 
+  COLORREF bg_color_;
+
   DISALLOW_EVIL_CONSTRUCTORS(Edit);

[Finnur, 2008/11/12 22:57:39]

DISALLOW_COPY_AND_ASSIGN. Sorry, didn't mean to shout at you. :)

 };
 
 ///////////////////////////////////////////////////////////////////////////////
 // Helper classes
 
 TextField::Edit::ScopedFreeze::ScopedFreeze(TextField::Edit* edit,
                                             ITextDocument* text_object_model)
     : edit_(edit),
       text_object_model_(text_object_model) {
   // Freeze the screen.
@@ skipping 25 matching lines @@
 
 TextField::Edit::Edit(TextField* parent, bool draw_border)
     : parent_(parent),
       tracking_double_click_(false),
       double_click_time_(0),
       can_discard_mousemove_(false),
       contains_mouse_(false),
       draw_border_(draw_border),
       ime_discard_composition_(false),
       ime_composition_start_(0),
-      ime_composition_length_(0) {
+      ime_composition_length_(0),
+      bg_color_(0) {
   if (!did_load_library_)
     did_load_library_ = !!LoadLibrary(L"riched20.dll");
 
   DWORD style = kDefaultEditStyle;
   if (parent->GetStyle() & TextField::STYLE_PASSWORD)
     style |= ES_PASSWORD;
 
   if (parent->read_only_)
     style |= ES_READONLY;
 
@@ skipping 78 matching lines @@
   SetWindowPos(NULL, 0, 0, 0, 0,
                SWP_NOMOVE | SWP_FRAMECHANGED | SWP_NOACTIVATE |
                SWP_NOOWNERZORDER | SWP_NOSIZE);
 }
 
 void TextField::Edit::SetEnabled(bool enabled) {
   SendMessage(parent_->GetNativeComponent(), WM_ENABLE,
               static_cast<WPARAM>(enabled), 0);
 }
 
+void TextField::Edit::SetBackgroundColor(COLORREF bg_color) {
+  CRichEditCtrl::SetBackgroundColor(bg_color);
+  bg_color_ = bg_color;
+}
+
 bool TextField::Edit::IsCommandEnabled(int id) const {
   switch (id) {
     case IDS_UNDO:      return !parent_->IsReadOnly() && !!CanUndo();
     case IDS_CUT:       return !parent_->IsReadOnly() && !!CanCut();
     case IDS_COPY:      return !!CanCopy();
     case IDS_PASTE:     return !parent_->IsReadOnly() && !!CanPaste();
     case IDS_SELECTALL: return !!CanSelectAll();
     default:            NOTREACHED();
                         return false;
   }
@@ skipping 302 matching lines @@
   GetWindowRect(&window_rect);
   // Convert to be relative to 0x0.
   window_rect.MoveToXY(0, 0);
 
   ExcludeClipRect(hdc,
                   window_rect.left + content_insets_.left(),
                   window_rect.top + content_insets_.top(),
                   window_rect.right - content_insets_.right(),
                   window_rect.bottom - content_insets_.bottom());
 
-  FillRect(hdc, &window_rect, (HBRUSH) (COLOR_WINDOW+1));
+  HBRUSH brush = CreateSolidBrush(bg_color_);
+  FillRect(hdc, &window_rect, brush);
+  DeleteObject(brush);
 
   int part;
   int state;
 
   if (win_util::GetWinVersion() < win_util::WINVERSION_VISTA) {
     part = EP_EDITTEXT;
 
     if (!parent_->IsEnabled())
       state = ETS_DISABLED;
     else if (parent_->IsReadOnly())
@@ skipping 13 matching lines @@
       state = EPSHV_HOT;
     else
       state = EPSHV_NORMAL;
     // Vista doesn't appear to have a unique state for readonly.
   }
 
   int classic_state =
       (!parent_->IsEnabled() || parent_->IsReadOnly()) ? DFCS_INACTIVE : 0;
 
   NativeTheme::instance()->PaintTextField(hdc, part, state, classic_state,
-                                          &window_rect, NULL, false, true);
+                                          &window_rect, bg_color_, false,
+                                          true);
 
   // NOTE: I tried checking the transparent property of the theme and invoking
   // drawParentBackground, but it didn't seem to make a difference.
 
   ReleaseDC(hdc);
 }
 
 void TextField::Edit::OnNonLButtonDown(UINT keys, const CPoint& point) {
   // Interestingly, the edit doesn't seem to cancel triple clicking when the
   // x-buttons (which usually means "thumb buttons") are pressed, so we only
@@ skipping 180 matching lines @@
       delete edit_;
       edit_ = NULL;
     }
 
     if (!edit_) {
       edit_ = new Edit(this, draw_border_);
       edit_->SetFont(font_.hfont());
       native_view_->Attach(*edit_);
       if (!text_.empty())
         edit_->SetText(text_);
-      if (!use_default_background_color_)
-        SetBackgroundColor(background_color_);
+      UpdateEditBackgroundColor();
       Layout();
     }
   } else if (!is_add && edit_ && IsWindow(edit_->m_hWnd)) {
     edit_->SetParent(NULL);
   }
 }
 
 void TextField::Layout() {
   if (native_view_) {
     native_view_->SetBounds(GetLocalBounds(true));
@@ skipping 48 matching lines @@
 
 bool TextField::IsReadOnly() const {
   return edit_ ? ((edit_->GetStyle() & ES_READONLY) != 0) : read_only_;
 }
 
 bool TextField::IsMultiLine() const {
   return (style_ & STYLE_MULTILINE) != 0;
 }
 
 void TextField::SetReadOnly(bool read_only) {
-  if (edit_)
+  read_only_ = read_only;
+  if (edit_) {
     edit_->SetReadOnly(read_only);
-  else
-    read_only_ = read_only;
+    UpdateEditBackgroundColor();
+  }
 }
 
-
 void TextField::Focus() {
   ::SetFocus(native_view_->GetHWND());
 }
 
 void TextField::SelectAll() {
   if (edit_)
     edit_->SelectAll();
 }
 
 void TextField::ClearSelection() const {
   if (edit_)
     edit_->ClearSelection();
 }
 
 HWND TextField::GetNativeComponent() {
   return native_view_->GetHWND();
 }
 
 void TextField::SetBackgroundColor(SkColor color) {
   background_color_ = color;
   use_default_background_color_ = false;
-  if (edit_) {
-    edit_->SetBackgroundColor(RGB(SkColorGetR(color),
-                                  SkColorGetG(color),
-                                  SkColorGetB(color)));
-  }
+  UpdateEditBackgroundColor();
 }
 
 void TextField::SetDefaultBackgroundColor() {
   use_default_background_color_ = true;
-  if (edit_)
-    edit_->SetBackgroundColor();
+  UpdateEditBackgroundColor();
 }
 
 void TextField::SetFont(const ChromeFont& font) {
   font_ = font;
   if (edit_)
     edit_->SetFont(font.hfont());
 }
 
 ChromeFont TextField::GetFont() const {
   return font_;
@@ skipping 18 matching lines @@
   if (!draw_border_)
     return;
 
   draw_border_ = false;
   if (edit_)
     edit_->RemoveBorder();
 }
 
 void TextField::SetEnabled(bool enabled) {
   View::SetEnabled(enabled);
-  SetReadOnly(!enabled);
   edit_->SetEnabled(enabled);
 }
 
 bool TextField::IsFocusable() const {
   return IsEnabled() && !IsReadOnly();
 }
 
 void TextField::AboutToRequestFocusFromTabTraversal(bool reverse) {
   SelectAll();
 }
 
 // We don't translate accelerators for ALT + numpad digit, they are used for
 // entering special characters.
 bool TextField::ShouldLookupAccelerators(const KeyEvent& e) {
   if (!e.IsAltDown())
     return true;
 
   return !win_util::IsNumPadDigit(e.GetCharacter(), e.IsExtendedKey());
 }
 
+void TextField::UpdateEditBackgroundColor() {
+  if (!edit_)
+    return;
+
+  COLORREF bg_color;
+  if (!use_default_background_color_)
+    bg_color = gfx::SkColorToCOLORREF(background_color_);
+  else
+    bg_color = GetSysColor(read_only_ ? COLOR_3DFACE : COLOR_WINDOW);
+  edit_->SetBackgroundColor(bg_color);
+}
+
 }  // namespace views
-