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
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
|
#------------------------------------------------------------------------------
# Copyright (c) 2007, Riverbank Computing Limited
# All rights reserved.
#
# This software is provided without warranty under the terms of the BSD license.
# However, when used with the GPL version of PyQt the additional terms described in the PyQt GPL exception also apply
#
# Author: Riverbank Computing Limited
#------------------------------------------------------------------------------
""" Defines the key binding editor for use with the KeyBinding class. This is a
specialized editor used to associate a particular key with a control (i.e., the
key binding editor).
"""
#-------------------------------------------------------------------------------
# Imports:
#-------------------------------------------------------------------------------
from pyface.qt import QtCore, QtGui
from traits.api \
import Bool, Event
# FIXME: ToolkitEditorFactory is a proxy class defined here just for backward
# compatibility. The class has been moved to the
# traitsui.editors.key_binding_editor file.
from traitsui.editors.key_binding_editor \
import KeyBindingEditor as ToolkitEditorFactory
from editor \
import Editor
from key_event_to_name \
import key_event_to_name
#-------------------------------------------------------------------------------
# 'KeyBindingEditor' class:
#-------------------------------------------------------------------------------
class KeyBindingEditor ( Editor ):
""" An editor for modifying bindings of keys to controls.
"""
#---------------------------------------------------------------------------
# Trait definitions:
#---------------------------------------------------------------------------
# Does the editor's control have focus currently?
has_focus = Bool(False)
# Keyboard event
key = Event
# Clear field event
clear = Event
#---------------------------------------------------------------------------
# Finishes initializing the editor by creating the underlying toolkit
# widget:
#---------------------------------------------------------------------------
def init (self, parent):
""" Finishes initializing the editor by creating the underlying toolkit
widget.
"""
self.control = KeyBindingCtrl(self)
#---------------------------------------------------------------------------
# Handles the user entering input data in the edit control:
#---------------------------------------------------------------------------
def update_object ( self, event ):
""" Handles the user entering input data in the edit control.
"""
try:
self.value = value = key_event_to_name( event )
self._binding.text = value
except:
pass
#---------------------------------------------------------------------------
# Updates the editor when the object trait changes external to the editor:
#---------------------------------------------------------------------------
def update_editor ( self ):
""" Updates the editor when the object trait changes externally to the
editor.
"""
self.control.setText(self.value)
#---------------------------------------------------------------------------
# Updates the current focus setting of the control:
#---------------------------------------------------------------------------
def update_focus ( self, has_focus ):
""" Updates the current focus setting of the control.
"""
if has_focus:
self._binding.border_size = 1
self.object.owner.focus_owner = self._binding
#---------------------------------------------------------------------------
# Handles a keyboard event:
#---------------------------------------------------------------------------
def _key_changed ( self, event ):
""" Handles a keyboard event.
"""
binding = self.object
key_name = key_event_to_name( event )
cur_binding = binding.owner.key_binding_for( binding, key_name )
if cur_binding is not None:
if QtGui.QMessageBox.question(self.control,
"Duplicate Key Definition",
"'%s' has already been assigned to '%s'.\n"
"Do you wish to continue?" % (key_name,
cur_binding.description),
QtGui.QMessageBox.Yes | QtGui.QMessageBox.No,
QtGui.QMessageBox.No) != QtGui.QMessageBox.Yes:
return
self.value = key_name
#---------------------------------------------------------------------------
# Handles a clear field event:
#---------------------------------------------------------------------------
def _clear_changed ( self ):
""" Handles a clear field event.
"""
self.value = ''
#-------------------------------------------------------------------------------
# 'KeyBindingCtrl' class:
#-------------------------------------------------------------------------------
class KeyBindingCtrl(QtGui.QLabel):
""" PyQt control for editing key bindings.
"""
#---------------------------------------------------------------------------
# Initialize the object:
#---------------------------------------------------------------------------
def __init__(self, editor, parent=None):
super(KeyBindingCtrl, self).__init__(parent)
self.setFocusPolicy(QtCore.Qt.StrongFocus)
self.setIndent(4)
self.setMinimumWidth(160)
pal = QtGui.QPalette(self.palette())
pal.setColor(QtGui.QPalette.Window, QtCore.Qt.white)
self.setPalette(pal)
self.setAutoFillBackground(True)
# Save the reference to the controlling editor object:
self.editor = editor
# Indicate we don't have the focus right now:
editor.has_focus = False
#---------------------------------------------------------------------------
# Handle keyboard keys being pressed:
#---------------------------------------------------------------------------
def keyPressEvent(self, event):
""" Handle keyboard keys being pressed.
"""
# Ignore presses of the control and shift keys.
if event.key() not in (QtCore.Qt.Key_Control, QtCore.Qt.Key_Shift):
self.editor.key = event
#---------------------------------------------------------------------------
# Do a GUI toolkit specific screen update:
#---------------------------------------------------------------------------
def paintEvent(self, event):
""" Updates the screen.
"""
QtGui.QLabel.paintEvent(self, event)
w = self.width()
h = self.height()
p = QtGui.QPainter(self)
if self.editor.has_focus:
p.setRenderHint(QtGui.QPainter.Antialiasing, True)
pen = QtGui.QPen(QtGui.QColor('tomato'))
pen.setWidth(2)
p.setPen(pen)
p.drawRect(1, 1, w - 2, h - 2)
else:
p.setPen(self.palette().color(QtGui.QPalette.Mid))
p.drawRect(0, 0, w - 1, h - 1)
p.end()
#---------------------------------------------------------------------------
# Handles getting/losing the focus:
#---------------------------------------------------------------------------
def focusInEvent(self, event):
""" Handles getting the focus.
"""
self.editor.has_focus = True
self.update()
def focusOutEvent(self, event):
""" Handles losing the focus.
"""
self.editor.has_focus = False
self.update()
#---------------------------------------------------------------------------
# Handles the user double clicking the control to clear its contents:
#---------------------------------------------------------------------------
def mouseDoubleClickEvent(self, event):
""" Handles the user double clicking the control to clear its contents.
"""
self.editor.clear = True
|
