OLD | NEW |
1 // Copyright 2014 The Chromium Authors. All rights reserved. | 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 | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "athena/input/accelerator_manager_impl.h" | 5 #include "athena/input/accelerator_manager_impl.h" |
6 | 6 |
7 #include "athena/input/public/input_manager.h" | 7 #include "athena/input/public/input_manager.h" |
8 #include "athena/util/switches.h" | 8 #include "athena/util/switches.h" |
9 #include "base/logging.h" | 9 #include "base/logging.h" |
10 #include "ui/aura/window.h" | 10 #include "ui/aura/window.h" |
(...skipping 11 matching lines...) Expand all Loading... |
22 | 22 |
23 namespace athena { | 23 namespace athena { |
24 | 24 |
25 // This wrapper interface provides a common interface that handles global | 25 // This wrapper interface provides a common interface that handles global |
26 // accelerators as well as local accelerators. | 26 // accelerators as well as local accelerators. |
27 class AcceleratorManagerImpl::AcceleratorWrapper { | 27 class AcceleratorManagerImpl::AcceleratorWrapper { |
28 public: | 28 public: |
29 virtual ~AcceleratorWrapper() {} | 29 virtual ~AcceleratorWrapper() {} |
30 virtual void Register(const ui::Accelerator& accelerator, | 30 virtual void Register(const ui::Accelerator& accelerator, |
31 ui::AcceleratorTarget* target) = 0; | 31 ui::AcceleratorTarget* target) = 0; |
| 32 virtual void Unregister(const ui::Accelerator& accelerator, |
| 33 ui::AcceleratorTarget* target) = 0; |
32 virtual bool Process(const ui::Accelerator& accelerator) = 0; | 34 virtual bool Process(const ui::Accelerator& accelerator) = 0; |
33 virtual ui::AcceleratorTarget* GetCurrentTarget( | 35 virtual ui::AcceleratorTarget* GetCurrentTarget( |
34 const ui::Accelerator& accelertor) const = 0; | 36 const ui::Accelerator& accelertor) const = 0; |
35 }; | 37 }; |
36 | 38 |
37 namespace { | 39 namespace { |
38 | 40 |
39 // Accelerators inside nested message loop are handled by | 41 // Accelerators inside nested message loop are handled by |
40 // wm::NestedAcceleratorController while accelerators in normal case are | 42 // wm::NestedAcceleratorController while accelerators in normal case are |
41 // handled by wm::AcceleratorFilter. These delegates act bridges in these | 43 // handled by wm::AcceleratorFilter. These delegates act bridges in these |
(...skipping 93 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
135 | 137 |
136 class UIAcceleratorManagerWrapper | 138 class UIAcceleratorManagerWrapper |
137 : public AcceleratorManagerImpl::AcceleratorWrapper { | 139 : public AcceleratorManagerImpl::AcceleratorWrapper { |
138 public: | 140 public: |
139 UIAcceleratorManagerWrapper() | 141 UIAcceleratorManagerWrapper() |
140 : ui_accelerator_manager_(new ui::AcceleratorManager) {} | 142 : ui_accelerator_manager_(new ui::AcceleratorManager) {} |
141 virtual ~UIAcceleratorManagerWrapper() {} | 143 virtual ~UIAcceleratorManagerWrapper() {} |
142 | 144 |
143 virtual void Register(const ui::Accelerator& accelerator, | 145 virtual void Register(const ui::Accelerator& accelerator, |
144 ui::AcceleratorTarget* target) override { | 146 ui::AcceleratorTarget* target) override { |
145 return ui_accelerator_manager_->Register( | 147 ui_accelerator_manager_->Register( |
146 accelerator, ui::AcceleratorManager::kNormalPriority, target); | 148 accelerator, ui::AcceleratorManager::kNormalPriority, target); |
147 } | 149 } |
148 | 150 |
| 151 virtual void Unregister(const ui::Accelerator& accelerator, |
| 152 ui::AcceleratorTarget* target) override { |
| 153 ui_accelerator_manager_->Unregister(accelerator, target); |
| 154 } |
| 155 |
149 virtual bool Process(const ui::Accelerator& accelerator) override { | 156 virtual bool Process(const ui::Accelerator& accelerator) override { |
150 return ui_accelerator_manager_->Process(accelerator); | 157 return ui_accelerator_manager_->Process(accelerator); |
151 } | 158 } |
152 | 159 |
153 virtual ui::AcceleratorTarget* GetCurrentTarget( | 160 virtual ui::AcceleratorTarget* GetCurrentTarget( |
154 const ui::Accelerator& accelerator) const override { | 161 const ui::Accelerator& accelerator) const override { |
155 return ui_accelerator_manager_->GetCurrentTarget(accelerator); | 162 return ui_accelerator_manager_->GetCurrentTarget(accelerator); |
156 } | 163 } |
157 | 164 |
158 private: | 165 private: |
159 scoped_ptr<ui::AcceleratorManager> ui_accelerator_manager_; | 166 scoped_ptr<ui::AcceleratorManager> ui_accelerator_manager_; |
160 | 167 |
161 DISALLOW_COPY_AND_ASSIGN(UIAcceleratorManagerWrapper); | 168 DISALLOW_COPY_AND_ASSIGN(UIAcceleratorManagerWrapper); |
162 }; | 169 }; |
163 | 170 |
164 class FocusManagerWrapper : public AcceleratorManagerImpl::AcceleratorWrapper { | 171 class FocusManagerWrapper : public AcceleratorManagerImpl::AcceleratorWrapper { |
165 public: | 172 public: |
166 explicit FocusManagerWrapper(views::FocusManager* focus_manager) | 173 explicit FocusManagerWrapper(views::FocusManager* focus_manager) |
167 : focus_manager_(focus_manager) {} | 174 : focus_manager_(focus_manager) {} |
168 virtual ~FocusManagerWrapper() {} | 175 virtual ~FocusManagerWrapper() {} |
169 | 176 |
170 virtual void Register(const ui::Accelerator& accelerator, | 177 virtual void Register(const ui::Accelerator& accelerator, |
171 ui::AcceleratorTarget* target) override { | 178 ui::AcceleratorTarget* target) override { |
172 return focus_manager_->RegisterAccelerator( | 179 return focus_manager_->RegisterAccelerator( |
173 accelerator, ui::AcceleratorManager::kNormalPriority, target); | 180 accelerator, ui::AcceleratorManager::kNormalPriority, target); |
174 } | 181 } |
175 | 182 |
| 183 virtual void Unregister(const ui::Accelerator& accelerator, |
| 184 ui::AcceleratorTarget* target) override { |
| 185 focus_manager_->UnregisterAccelerator(accelerator, target); |
| 186 } |
| 187 |
176 virtual bool Process(const ui::Accelerator& accelerator) override { | 188 virtual bool Process(const ui::Accelerator& accelerator) override { |
177 NOTREACHED(); | 189 NOTREACHED(); |
178 return true; | 190 return true; |
179 } | 191 } |
180 | 192 |
181 virtual ui::AcceleratorTarget* GetCurrentTarget( | 193 virtual ui::AcceleratorTarget* GetCurrentTarget( |
182 const ui::Accelerator& accelerator) const override { | 194 const ui::Accelerator& accelerator) const override { |
183 return focus_manager_->GetCurrentTargetForAccelerator(accelerator); | 195 return focus_manager_->GetCurrentTargetForAccelerator(accelerator); |
184 } | 196 } |
185 | 197 |
(...skipping 131 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
317 ? ui::ET_KEY_PRESSED | 329 ? ui::ET_KEY_PRESSED |
318 : ui::ET_KEY_RELEASED); | 330 : ui::ET_KEY_RELEASED); |
319 accelerator_wrapper_->Register(accelerator, this); | 331 accelerator_wrapper_->Register(accelerator, this); |
320 accelerators_.insert( | 332 accelerators_.insert( |
321 std::make_pair(accelerator, | 333 std::make_pair(accelerator, |
322 InternalData(accelerator_data.command_id, | 334 InternalData(accelerator_data.command_id, |
323 handler, | 335 handler, |
324 accelerator_data.accelerator_flags))); | 336 accelerator_data.accelerator_flags))); |
325 } | 337 } |
326 | 338 |
| 339 void AcceleratorManagerImpl::UnregisterAccelerator( |
| 340 const AcceleratorData& accelerator_data, |
| 341 AcceleratorHandler* handler) { |
| 342 ui::Accelerator accelerator(accelerator_data.keycode, |
| 343 accelerator_data.keyevent_flags); |
| 344 accelerator.set_type(accelerator_data.trigger_event == TRIGGER_ON_PRESS |
| 345 ? ui::ET_KEY_PRESSED |
| 346 : ui::ET_KEY_RELEASED); |
| 347 accelerator_wrapper_->Unregister(accelerator, this); |
| 348 accelerators_.erase(accelerator); |
| 349 } |
| 350 |
327 // static | 351 // static |
328 AcceleratorManager* AcceleratorManager::Get() { | 352 AcceleratorManager* AcceleratorManager::Get() { |
329 return InputManager::Get()->GetAcceleratorManager(); | 353 return InputManager::Get()->GetAcceleratorManager(); |
330 } | 354 } |
331 | 355 |
332 // static | 356 // static |
333 scoped_ptr<AcceleratorManager> AcceleratorManager::CreateForFocusManager( | 357 scoped_ptr<AcceleratorManager> AcceleratorManager::CreateForFocusManager( |
334 views::FocusManager* focus_manager) { | 358 views::FocusManager* focus_manager) { |
335 return AcceleratorManagerImpl::CreateForFocusManager(focus_manager).Pass(); | 359 return AcceleratorManagerImpl::CreateForFocusManager(focus_manager).Pass(); |
336 } | 360 } |
337 | 361 |
338 } // namespace athena | 362 } // namespace athena |
OLD | NEW |