| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright 2014 The Chromium Authors. All rights reserved. | |
| 2 // Use of this source code is governed by a BSD-style license that can be | |
| 3 // found in the LICENSE file. | |
| 4 | |
| 5 #include "mojo/examples/keyboard/keyboard_view.h" | |
| 6 | |
| 7 #include <algorithm> | |
| 8 | |
| 9 #include "base/strings/string16.h" | |
| 10 #include "base/strings/utf_string_conversions.h" | |
| 11 #include "mojo/examples/keyboard/keyboard_delegate.h" | |
| 12 #include "mojo/examples/keyboard/keys.h" | |
| 13 #include "ui/events/keycodes/keyboard_code_conversion.h" | |
| 14 #include "ui/events/keycodes/keyboard_codes.h" | |
| 15 #include "ui/gfx/canvas.h" | |
| 16 #include "ui/views/background.h" | |
| 17 #include "ui/views/controls/button/label_button.h" | |
| 18 #include "ui/views/controls/button/label_button_border.h" | |
| 19 | |
| 20 namespace mojo { | |
| 21 namespace examples { | |
| 22 | |
| 23 namespace { | |
| 24 | |
| 25 const int kHorizontalPadding = 6; | |
| 26 const int kVerticalPadding = 8; | |
| 27 | |
| 28 base::string16 GetDisplayString(int key_code, int flags) { | |
| 29 return base::string16(1, ui::GetCharacterFromKeyCode( | |
| 30 static_cast<ui::KeyboardCode>(key_code), flags)); | |
| 31 } | |
| 32 | |
| 33 // Returns a font that fits in the space provided. |text| is used as a basis | |
| 34 // for determing the size. | |
| 35 gfx::FontList CalculateFont(int width, int height, const base::string16& text) { | |
| 36 gfx::FontList font; | |
| 37 gfx::FontList last_font; | |
| 38 while (gfx::Canvas::GetStringWidth(text, font) < width && | |
| 39 font.GetHeight() < height) { | |
| 40 last_font = font; | |
| 41 font = font.DeriveWithSizeDelta(2); | |
| 42 } | |
| 43 return last_font; | |
| 44 } | |
| 45 | |
| 46 // Returns the total number of keys in |rows|. | |
| 47 int NumKeys(const std::vector<const Row*>& rows) { | |
| 48 int result = 0; | |
| 49 for (size_t i = 0; i < rows.size(); ++i) | |
| 50 result += static_cast<int>(rows[i]->num_keys); | |
| 51 return result; | |
| 52 } | |
| 53 | |
| 54 } // namespace | |
| 55 | |
| 56 KeyboardView::KeyboardView(KeyboardDelegate* delegate) | |
| 57 : delegate_(delegate), | |
| 58 max_keys_in_row_(0), | |
| 59 keyboard_layout_(KEYBOARD_LAYOUT_ALPHA) { | |
| 60 set_background(views::Background::CreateSolidBackground(SK_ColorBLACK)); | |
| 61 SetRows(GetQWERTYRows()); | |
| 62 } | |
| 63 | |
| 64 KeyboardView::~KeyboardView() { | |
| 65 } | |
| 66 | |
| 67 void KeyboardView::Layout() { | |
| 68 if (width() == 0 || height() == 0 || rows_.empty() || | |
| 69 last_layout_size_ == bounds().size()) | |
| 70 return; | |
| 71 | |
| 72 last_layout_size_ = bounds().size(); | |
| 73 | |
| 74 const int button_width = | |
| 75 (width() - (max_keys_in_row_ - 1) * kHorizontalPadding) / | |
| 76 max_keys_in_row_; | |
| 77 const int button_height = | |
| 78 (height() - (static_cast<int>(rows_.size() - 1) * kVerticalPadding)) / | |
| 79 static_cast<int>(rows_.size()); | |
| 80 const int initial_x = (width() - button_width * max_keys_in_row_ - | |
| 81 kHorizontalPadding * (max_keys_in_row_ - 1)) / 2; | |
| 82 for (size_t i = 0; i < rows_.size(); ++i) { | |
| 83 LayoutRow(*(rows_[i]), static_cast<int>(i), initial_x, button_width, | |
| 84 button_height); | |
| 85 } | |
| 86 | |
| 87 views::LabelButtonBorder border(views::Button::STYLE_TEXTBUTTON); | |
| 88 gfx::Insets insets(border.GetInsets()); | |
| 89 gfx::FontList font = CalculateFont(button_width - insets.width(), | |
| 90 button_height - insets.height(), | |
| 91 base::ASCIIToUTF16("W")); | |
| 92 gfx::FontList special_font = CalculateFont(button_width - insets.width(), | |
| 93 button_height - insets.height(), | |
| 94 base::ASCIIToUTF16("?123")); | |
| 95 button_font_ = font; | |
| 96 ResetFonts(font, special_font); | |
| 97 } | |
| 98 | |
| 99 void KeyboardView::SetLayout(KeyboardLayout keyboard_layout) { | |
| 100 if (keyboard_layout_ == keyboard_layout) | |
| 101 return; | |
| 102 | |
| 103 keyboard_layout_ = keyboard_layout; | |
| 104 last_layout_size_ = gfx::Size(); | |
| 105 if (keyboard_layout_ == KEYBOARD_LAYOUT_NUMERIC) | |
| 106 SetRows(GetNumericRows()); | |
| 107 else | |
| 108 SetRows(GetQWERTYRows()); | |
| 109 Layout(); | |
| 110 SchedulePaint(); | |
| 111 } | |
| 112 | |
| 113 void KeyboardView::LayoutRow(const Row& row, | |
| 114 int row_index, | |
| 115 int initial_x, | |
| 116 int button_width, | |
| 117 int button_height) { | |
| 118 int x = initial_x + row.padding * (button_width + kHorizontalPadding); | |
| 119 const int y = row_index * (button_height + kVerticalPadding); | |
| 120 for (size_t i = 0; i < row.num_keys; ++i) { | |
| 121 views::View* button = GetButton(row_index, static_cast<int>(i)); | |
| 122 int actual_width = button_width; | |
| 123 if (row.keys[i].size > 1) { | |
| 124 actual_width = (button_width + kHorizontalPadding) * | |
| 125 row.keys[i].size - kHorizontalPadding; | |
| 126 } | |
| 127 button->SetBounds(x, y, actual_width, button_height); | |
| 128 x += actual_width + kHorizontalPadding; | |
| 129 } | |
| 130 } | |
| 131 | |
| 132 void KeyboardView::SetRows(const std::vector<const Row*>& rows) { | |
| 133 const int num_keys = NumKeys(rows); | |
| 134 while (child_count() > num_keys) | |
| 135 delete child_at(child_count() - 1); | |
| 136 for (int i = child_count(); i < num_keys; ++i) | |
| 137 AddChildView(CreateButton()); | |
| 138 | |
| 139 last_layout_size_ = gfx::Size(); | |
| 140 | |
| 141 rows_ = rows; | |
| 142 | |
| 143 max_keys_in_row_ = 0; | |
| 144 for (size_t i = 0; i < rows_.size(); ++i) { | |
| 145 max_keys_in_row_ = std::max(max_keys_in_row_, | |
| 146 static_cast<int>(rows_[i]->num_keys)); | |
| 147 ConfigureButtonsInRow(static_cast<int>(i), *rows_[i]); | |
| 148 } | |
| 149 } | |
| 150 | |
| 151 void KeyboardView::ConfigureButtonsInRow(int row_index, const Row& row) { | |
| 152 for (size_t i = 0; i < row.num_keys; ++i) { | |
| 153 views::LabelButton* button = GetButton(row_index, static_cast<int>(i)); | |
| 154 const Key& key(row.keys[i]); | |
| 155 switch (key.display_code) { | |
| 156 case SPECIAL_KEY_SHIFT: | |
| 157 // TODO: need image. | |
| 158 button->SetText(base::string16()); | |
| 159 break; | |
| 160 case SPECIAL_KEY_NUMERIC: | |
| 161 button->SetText(base::ASCIIToUTF16("?123")); | |
| 162 break; | |
| 163 case SPECIAL_KEY_ALPHA: | |
| 164 button->SetText(base::ASCIIToUTF16("ABC")); | |
| 165 break; | |
| 166 default: | |
| 167 button->SetText(GetDisplayString(key.display_code, | |
| 168 key.event_flags | event_flags())); | |
| 169 break; | |
| 170 } | |
| 171 button->SetState(views::Button::STATE_NORMAL); | |
| 172 } | |
| 173 } | |
| 174 | |
| 175 views::View* KeyboardView::CreateButton() { | |
| 176 views::LabelButton* button = new views::LabelButton(this, base::string16()); | |
| 177 button->SetTextColor(views::Button::STATE_NORMAL, SK_ColorWHITE); | |
| 178 button->SetHorizontalAlignment(gfx::ALIGN_CENTER); | |
| 179 button->set_background(views::Background::CreateSolidBackground(78, 78, 78)); | |
| 180 button->SetFontList(button_font_); | |
| 181 // button->SetHaloColor(SK_ColorBLACK); | |
| 182 // Turn off animations as we reuse buttons in different layouts. If we didn't | |
| 183 // do this and you click a button to change the layout then the button you | |
| 184 // clicked on would animate the transition even though it may now represent a | |
| 185 // different key. | |
| 186 button->SetAnimationDuration(0); | |
| 187 return button; | |
| 188 } | |
| 189 | |
| 190 views::LabelButton* KeyboardView::GetButton(int row, int column) { | |
| 191 int offset = column; | |
| 192 for (int i = 0; i < row; ++i) | |
| 193 offset += static_cast<int>(rows_[i]->num_keys); | |
| 194 return static_cast<views::LabelButton*>(child_at(offset)); | |
| 195 } | |
| 196 | |
| 197 const Key& KeyboardView::GetKeyForButton(views::Button* button) const { | |
| 198 int index = GetIndexOf(button); | |
| 199 DCHECK_NE(-1, index); | |
| 200 int row = 0; | |
| 201 while (index >= static_cast<int>(rows_[row]->num_keys)) { | |
| 202 index -= static_cast<int>(rows_[row]->num_keys); | |
| 203 row++; | |
| 204 } | |
| 205 return rows_[row]->keys[index]; | |
| 206 } | |
| 207 | |
| 208 void KeyboardView::ResetFonts(const gfx::FontList& button_font, | |
| 209 const gfx::FontList& special_font) { | |
| 210 for (size_t i = 0; i < rows_.size(); ++i) { | |
| 211 for (size_t j = 0; j < rows_[i]->num_keys; ++j) { | |
| 212 views::LabelButton* button = GetButton(static_cast<int>(i), | |
| 213 static_cast<int>(j)); | |
| 214 const Key& key(GetKeyForButton(button)); | |
| 215 switch (key.display_code) { | |
| 216 case SPECIAL_KEY_ALPHA: | |
| 217 case SPECIAL_KEY_NUMERIC: | |
| 218 button->SetFontList(special_font); | |
| 219 break; | |
| 220 default: | |
| 221 button->SetFontList(button_font); | |
| 222 break; | |
| 223 } | |
| 224 } | |
| 225 } | |
| 226 } | |
| 227 | |
| 228 void KeyboardView::ButtonPressed(views::Button* sender, | |
| 229 const ui::Event& event) { | |
| 230 const Key& key(GetKeyForButton(sender)); | |
| 231 switch (key.display_code) { | |
| 232 case SPECIAL_KEY_SHIFT: | |
| 233 SetLayout((keyboard_layout_ == KEYBOARD_LAYOUT_SHIFT) ? | |
| 234 KEYBOARD_LAYOUT_ALPHA : KEYBOARD_LAYOUT_SHIFT); | |
| 235 return; | |
| 236 case SPECIAL_KEY_ALPHA: | |
| 237 SetLayout(KEYBOARD_LAYOUT_ALPHA); | |
| 238 return; | |
| 239 case SPECIAL_KEY_NUMERIC: | |
| 240 SetLayout(KEYBOARD_LAYOUT_NUMERIC); | |
| 241 return; | |
| 242 default: | |
| 243 break; | |
| 244 } | |
| 245 | |
| 246 // Windows isn't happy if we pass in the flags used to get the display string. | |
| 247 #if defined(OS_WIN) | |
| 248 int key_event_flags = 0; | |
| 249 #else | |
| 250 int key_event_flags = key.event_flags; | |
| 251 #endif | |
| 252 delegate_->OnKeyPressed(key.keyboard_code(), key_event_flags | event_flags()); | |
| 253 } | |
| 254 | |
| 255 } // namespace examples | |
| 256 } // namespace mojo | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 684543003:
Move //mojo/examples to //examples (Closed)
Base URL: https://github.com/domokit/mojo.git@master