1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
|
// Copyright (c) 2011 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.
#ifndef VIEWS_CONTROLS_TEXTFIELD_NATIVE_TEXTFIELD_VIEWS_H_
#define VIEWS_CONTROLS_TEXTFIELD_NATIVE_TEXTFIELD_VIEWS_H_
#pragma once
#include "app/menus/simple_menu_model.h"
#include "base/string16.h"
#include "base/task.h"
#include "gfx/font.h"
#include "views/border.h"
#include "views/controls/textfield/native_textfield_wrapper.h"
#include "views/view.h"
namespace gfx {
class Canvas;
} // namespace
namespace views {
class KeyEvent;
class Menu2;
class TextfieldViewsModel;
// A views/skia only implementation of NativeTextfieldWrapper.
// No platform specific code is used.
// Following features are not yet supported.
// * BIDI
// * IME/i18n support.
// * X selection (only if we want to support).
// * STYLE_MULTILINE, STYLE_LOWERCASE text. (These are not used in
// chromeos, so we may not need them)
// * Double click to select word, and triple click to select all.
// * Undo/Redo
class NativeTextfieldViews : public views::View,
public views::ContextMenuController,
public NativeTextfieldWrapper,
public menus::SimpleMenuModel::Delegate {
public:
explicit NativeTextfieldViews(Textfield* parent);
~NativeTextfieldViews();
// views::View overrides:
virtual bool OnMousePressed(const views::MouseEvent& e);
virtual bool OnMouseDragged(const views::MouseEvent& e);
virtual void OnMouseReleased(const views::MouseEvent& e, bool canceled);
virtual bool OnKeyPressed(const views::KeyEvent& e);
virtual bool OnKeyReleased(const views::KeyEvent& e);
virtual void Paint(gfx::Canvas* canvas);
virtual void DidChangeBounds(const gfx::Rect& previous,
const gfx::Rect& current);
virtual void WillGainFocus();
virtual void DidGainFocus();
virtual void WillLoseFocus();
// views::ContextMenuController overrides:
virtual void ShowContextMenu(View* source,
const gfx::Point& p,
bool is_mouse_gesture);
// NativeTextfieldWrapper overrides:
virtual string16 GetText() const;
virtual void UpdateText();
virtual void AppendText(const string16& text);
virtual string16 GetSelectedText() const;
virtual void SelectAll();
virtual void ClearSelection();
virtual void UpdateBorder();
virtual void UpdateTextColor();
virtual void UpdateBackgroundColor();
virtual void UpdateReadOnly();
virtual void UpdateFont();
virtual void UpdateIsPassword();
virtual void UpdateEnabled();
virtual gfx::Insets CalculateInsets();
virtual void UpdateHorizontalMargins();
virtual void UpdateVerticalMargins();
virtual bool SetFocus();
virtual View* GetView();
virtual gfx::NativeView GetTestingHandle() const;
virtual bool IsIMEComposing() const;
virtual bool HandleKeyPressed(const views::KeyEvent& e);
virtual bool HandleKeyReleased(const views::KeyEvent& e);
virtual void HandleWillGainFocus();
virtual void HandleDidGainFocus();
virtual void HandleWillLoseFocus();
// menus::SimpleMenuModel::Delegate overrides
virtual bool IsCommandIdChecked(int command_id) const;
virtual bool IsCommandIdEnabled(int command_id) const;
virtual bool GetAcceleratorForCommandId(int command_id,
menus::Accelerator* accelerator);
virtual void ExecuteCommand(int command_id);
// class name of internal
static const char kViewClassName[];
// Returns true when
// 1) built with GYP_DEFIENS="touchui=1"
// 2) enabled by SetEnableTextfieldViews(true)
// 3) enabled by the command line flag "--enable-textfield-view".
static bool IsTextfieldViewsEnabled();
// Enable/Disable TextfieldViews implementation for Textfield.
static void SetEnableTextfieldViews(bool enabled);
private:
friend class NativeTextfieldViewsTest;
// A Border class to draw focus border for the text field.
class TextfieldBorder : public Border {
public:
TextfieldBorder();
// Border implementation.
virtual void Paint(const View& view, gfx::Canvas* canvas) const;
virtual void GetInsets(gfx::Insets* insets) const;
// Sets the insets of the border.
void SetInsets(int top, int left, int bottom, int right);
// Sets the focus state.
void set_has_focus(bool has_focus) {
has_focus_ = has_focus;
}
private:
bool has_focus_;
gfx::Insets insets_;
DISALLOW_COPY_AND_ASSIGN(TextfieldBorder);
};
// Returns the Textfield's font.
const gfx::Font& GetFont() const;
// Returns the Textfield's text color.
SkColor GetTextColor() const;
// A callback function to periodically update the cursor state.
void UpdateCursor();
// Repaint the cursor.
void RepaintCursor();
// Update the cursor_bounds and text_offset.
void UpdateCursorBoundsAndTextOffset();
void PaintTextAndCursor(gfx::Canvas* canvas);
// Handle the keyevent.
bool HandleKeyEvent(const KeyEvent& key_event);
// Utility function. Gets the character corresponding to a keyevent.
// Returns 0 if the character is not printable.
char16 GetPrintableChar(const KeyEvent& key_event);
// Find a cusor position for given |point| in this views coordinates.
size_t FindCursorPosition(const gfx::Point& point) const;
// Utility function to inform the parent textfield (and its controller if any)
// that the text in the textfield has changed.
void PropagateTextChange();
// Utility function to create the context menu if one does not already exist.
void InitContextMenuIfRequired();
// The parent textfield, the owner of this object.
Textfield* textfield_;
// The text model.
scoped_ptr<TextfieldViewsModel> model_;
// The reference to the border class. The object is owned by View::border_.
TextfieldBorder* text_border_;
// The x offset for the text to be drawn, without insets;
int text_offset_;
// Cursor's bounds in the textfield's coordinates.
gfx::Rect cursor_bounds_;
// True if the textfield is in insert mode.
bool insert_;
// The drawing state of cursor. True to draw.
bool is_cursor_visible_;
// A runnable method factory for callback to update the cursor.
ScopedRunnableMethodFactory<NativeTextfieldViews> cursor_timer_;
// Context menu and its content list for the textfield.
scoped_ptr<menus::SimpleMenuModel> context_menu_contents_;
scoped_ptr<Menu2> context_menu_menu_;
DISALLOW_COPY_AND_ASSIGN(NativeTextfieldViews);
};
} // namespace views
#endif // VIEWS_CONTROLS_TEXTFIELD_NATIVE_TEXTFIELD_VIEWS_H_
|
