blob: 0a02e39d4cc1a4817a4ee5d2106e72b9b38dd472 (
plain)
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
|
// Copyright (c) 2012 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.
// This class describe a keyboard accelerator (or keyboard shortcut).
// Keyboard accelerators are registered with the FocusManager.
// It has a copy constructor and assignment operator so that it can be copied.
// It also defines the < operator so that it can be used as a key in a std::map.
//
#ifndef UI_BASE_ACCELERATORS_ACCELERATOR_H_
#define UI_BASE_ACCELERATORS_ACCELERATOR_H_
#include <utility>
#include "base/memory/scoped_ptr.h"
#include "base/strings/string16.h"
#include "ui/base/accelerators/platform_accelerator.h"
#include "ui/base/ui_base_export.h"
#include "ui/events/event_constants.h"
#include "ui/events/keycodes/keyboard_codes.h"
namespace ui {
class KeyEvent;
class PlatformAccelerator;
// This is a cross-platform class for accelerator keys used in menus.
// |platform_accelerator| should be used to store platform specific data.
class UI_BASE_EXPORT Accelerator {
public:
Accelerator();
Accelerator(ui::KeyboardCode keycode, int modifiers);
explicit Accelerator(const KeyEvent& key_event);
Accelerator(const Accelerator& accelerator);
~Accelerator();
// Masks out all the non-modifiers KeyEvent |flags| and returns only the
// available modifier ones.
static int MaskOutKeyEventFlags(int flags);
Accelerator& operator=(const Accelerator& accelerator);
// Define the < operator so that the KeyboardShortcut can be used as a key in
// a std::map.
bool operator <(const Accelerator& rhs) const;
bool operator ==(const Accelerator& rhs) const;
bool operator !=(const Accelerator& rhs) const;
ui::KeyboardCode key_code() const { return key_code_; }
// Sets the event type if the accelerator should be processed on an event
// other than ui::ET_KEY_PRESSED.
void set_type(ui::EventType type) { type_ = type; }
ui::EventType type() const { return type_; }
int modifiers() const { return modifiers_; }
bool IsShiftDown() const;
bool IsCtrlDown() const;
bool IsAltDown() const;
bool IsCmdDown() const;
bool IsRepeat() const;
// Returns a string with the localized shortcut if any.
base::string16 GetShortcutText() const;
void set_platform_accelerator(scoped_ptr<PlatformAccelerator> p) {
platform_accelerator_ = std::move(p);
}
// This class keeps ownership of the returned object.
const PlatformAccelerator* platform_accelerator() const {
return platform_accelerator_.get();
}
void set_is_repeat(bool is_repeat) { is_repeat_ = is_repeat; }
protected:
// The keycode (VK_...).
KeyboardCode key_code_;
// The event type (usually ui::ET_KEY_PRESSED).
EventType type_;
// The state of the Shift/Ctrl/Alt keys.
int modifiers_;
// True if the accelerator is created for an auto repeated key event.
bool is_repeat_;
// Stores platform specific data. May be NULL.
scoped_ptr<PlatformAccelerator> platform_accelerator_;
};
// An interface that classes that want to register for keyboard accelerators
// should implement.
class UI_BASE_EXPORT AcceleratorTarget {
public:
// Should return true if the accelerator was processed.
virtual bool AcceleratorPressed(const Accelerator& accelerator) = 0;
// Should return true if the target can handle the accelerator events. The
// AcceleratorPressed method is invoked only for targets for which
// CanHandleAccelerators returns true.
virtual bool CanHandleAccelerators() const = 0;
protected:
virtual ~AcceleratorTarget() {}
};
// Since accelerator code is one of the few things that can't be cross platform
// in the chrome UI, separate out just the GetAcceleratorForCommandId() from
// the menu delegates.
class AcceleratorProvider {
public:
// Gets the accelerator for the specified command id. Returns true if the
// command id has a valid accelerator, false otherwise.
virtual bool GetAcceleratorForCommandId(int command_id,
ui::Accelerator* accelerator) = 0;
protected:
virtual ~AcceleratorProvider() {}
};
} // namespace ui
#endif // UI_BASE_ACCELERATORS_ACCELERATOR_H_
|
