Move text_field.cc and rename the class to Textfield in preparation for porti...

views/controls/textfield/textfield.h

 // Copyright (c) 2009 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.
 
-// These classes define a text field widget that can be used in the views UI
-// toolkit.
-
-#ifndef VIEWS_CONTROLS_TEXT_FIELD_H_
-#define VIEWS_CONTROLS_TEXT_FIELD_H_
+#ifndef VIEWS_CONTROLS_TEXTFIELD_TEXTFIELD_H_
+#define VIEWS_CONTROLS_TEXTFIELD_TEXTFIELD_H_
 
 #include <string>
 
 #include "app/gfx/font.h"
 #include "base/basictypes.h"
 #include "views/view.h"
 #include "third_party/skia/include/core/SkColor.h"
 
 namespace views {
 
 class HWNDView;
 
 // This class implements a ChromeView that wraps a native text (edit) field.
-class TextField : public View {
+class Textfield : public View {
  public:
   // Keystroke provides a platform-dependent way to send keystroke events.
   // Cross-platform code can use IsKeystrokeEnter/Escape to check for these
   // two common key events.
   // TODO(brettw) this should be cleaned up to be more cross-platform.
 #if defined(OS_WIN)
   struct Keystroke {
     Keystroke(unsigned int m,
               wchar_t k,
               int r,
@@ skipping 13 matching lines @@
   struct Keystroke {
     // TODO(brettw) figure out what this should be on GTK.
   };
 #endif
 
   // This defines the callback interface for other code to be notified of
   // changes in the state of a text field.
   class Controller {
    public:
     // This method is called whenever the text in the field changes.
-    virtual void ContentsChanged(TextField* sender,
+    virtual void ContentsChanged(Textfield* sender,
                                  const std::wstring& new_contents) = 0;
 
     // This method is called to get notified about keystrokes in the edit.
     // This method returns true if the message was handled and should not be
     // processed further. If it returns false the processing continues.
-    virtual bool HandleKeystroke(TextField* sender,
-                                 const TextField::Keystroke& keystroke) = 0;
+    virtual bool HandleKeystroke(Textfield* sender,
+                                 const Textfield::Keystroke& keystroke) = 0;
   };
 
   enum StyleFlags {
     STYLE_DEFAULT = 0,
     STYLE_PASSWORD = 1<<0,
     STYLE_MULTILINE = 1<<1,
     STYLE_LOWERCASE = 1<<2
   };
 
-  TextField()
+  Textfield()
       :
 #if defined(OS_WIN)
         native_view_(NULL),
 #endif
         edit_(NULL),
         controller_(NULL),
         style_(STYLE_DEFAULT),
         read_only_(false),
         default_width_in_chars_(0),
         draw_border_(true),
         use_default_background_color_(true),
         num_lines_(1) {
     SetFocusable(true);
   }
-  explicit TextField(StyleFlags style)
+  explicit Textfield(StyleFlags style)
       :
 #if defined(OS_WIN)
         native_view_(NULL),
 #endif
         edit_(NULL),
         controller_(NULL),
         style_(style),
         read_only_(false),
         default_width_in_chars_(0),
         draw_border_(true),
         use_default_background_color_(true),
         num_lines_(1) {
     SetFocusable(true);
   }
-  virtual ~TextField();
+  virtual ~Textfield();
 
   void ViewHierarchyChanged(bool is_add, View* parent, View* child);
 
   // Overridden for layout purposes
   virtual void Layout();
   virtual gfx::Size GetPreferredSize();
 
   // Controller accessors
   void SetController(Controller* controller);
   Controller* GetController() const;
@@ skipping 35 matching lines @@
   void ClearSelection() const;
 
   StyleFlags GetStyle() const { return style_; }
 
   void SetBackgroundColor(SkColor color);
   void SetDefaultBackgroundColor();
 
   // Set the font.
   void SetFont(const gfx::Font& font);
 
-  // Return the font used by this TextField.
+  // Return the font used by this Textfield.
   gfx::Font GetFont() const;
 
   // Sets the left and right margin (in pixels) within the text box. On Windows
   // this is accomplished by packing the left and right margin into a single
   // 32 bit number, so the left and right margins are effectively 16 bits.
   bool SetHorizontalMargins(int left, int right);
 
   // Should only be called on a multi-line text field. Sets how many lines of
   // text can be displayed at once by this text field.
   void SetHeightInLines(int num_lines);
@@ skipping 42 matching lines @@
   // This inherits from the native text field.
   Edit* edit_;
 
   // This is the current listener for events from this control.
   Controller* controller_;
 
   StyleFlags style_;
 
   gfx::Font font_;
 
-  // NOTE: this is temporary until we rewrite TextField to always work whether
+  // NOTE: this is temporary until we rewrite Textfield to always work whether
   // there is an HWND or not.
   // Used if the HWND hasn't been created yet.
   std::wstring text_;
 
   bool read_only_;
 
   // The default number of average characters for the width of this text field.
   // This will be reported as the "desired size". Defaults to 0.
   int default_width_in_chars_;
 
   // Whether the border is drawn.
   bool draw_border_;
 
   SkColor background_color_;
 
   bool use_default_background_color_;
 
-  // The number of lines of text this textfield displays at once.
+  // The number of lines of text this Textfield displays at once.
   int num_lines_;
 
  protected:
   // Calculates the insets for the text field.
   void CalculateInsets(gfx::Insets* insets);
 
-  DISALLOW_COPY_AND_ASSIGN(TextField);
+  DISALLOW_COPY_AND_ASSIGN(Textfield);
 };
 
 }  // namespace views
 
-#endif  // VIEWS_CONTROLS_TEXT_FIELD_H_
+#endif  // VIEWS_CONTROLS_TEXTFIELD_TEXTFIELD_H_