def mouseMove(self, event: QKeyEvent):
if not self.editType:
return
begin = self.curMemento.begin
end = self.curMemento.end
newPoint: QPoint = event.pos()
if self.editType == 'BEGIN':
# Shift pressed
if event.modifiers() == Qt.ShiftModifier:
# Parallel to x axis
if getBiggerDiff(end, newPoint) == 'X':
newPoint = QPoint(newPoint.x(), end.y())
else:
# Parallel to Y axis
newPoint = QPoint(end.x(), newPoint.y())
self.selected.setBegin(newPoint)
elif self.editType == 'END':
# Shift pressed
if event.modifiers() == Qt.ShiftModifier:
# Parallel to x axis
if getBiggerDiff(begin, newPoint) == 'X':
newPoint = QPoint(newPoint.x(), begin.y())
else:
# Parallel to y axis
newPoint = QPoint(begin.x(), newPoint.y())
self.selected.setEnd(newPoint)
self.app.repaint()
def keyPressEvent(self, event: QKeyEvent):
super().keyPressEvent(event)
if self.currentIndex():
if event.key() == 16777220:
if self.hasFocus():
self.contextMenuShowed.emit()
elif event.key() == 16777219:
self.contextMenuDeleted.emit()
def _replace_current_word(self):
self._current_lang = "ENG" if self._current_lang == "RUS" else "RUS"
self._current_word = self.switch_charset(self._current_word,
self._current_lang)
backspace = QKeyEvent(QEvent.KeyPress, Qt.Key_Backspace, Qt.NoModifier)
events = [backspace for _ in range(len(self._current_word))]
for c in self._current_word:
key_event = QKeyEvent(QEvent.KeyPress, 0, Qt.NoModifier, c)
events.append(key_event)
return events
def key_press_release(widget, key, modifier=Qt.NoModifier):
"""
Функция для отправления события нажатия кнопки.
# Имитация нажатия на пробел:
key_press_release(widget, Qt.Key_Space)
"""
key_press = QKeyEvent(QKeyEvent.KeyPress, key, modifier, None, False, 0)
QApplication.sendEvent(widget, key_press)
key_release = QKeyEvent(QKeyEvent.KeyRelease, key, modifier, None, False,
0)
QApplication.sendEvent(widget, key_release)
def mouseMove(self, event: QKeyEvent):
if not self.begin or not self.isDrawing:
return
if event.modifiers() == Qt.ShiftModifier:
if getBiggerDiff(event.pos(), self.begin) == 'X':
self.end = QPoint(event.pos().x(), self.begin.y())
else:
self.end = QPoint(self.begin.x(), event.pos().y())
else:
self.end = event.pos()
self.app.repaint()
def scroll_line(key, window, focus_widget, key_filter, *args, **kwargs):
if focus_widget is not None:
with key_filter.disable_filtering:
QApplication.sendEvent(
focus_widget,
QKeyEvent(QEvent.KeyPress, key, Qt.KeyboardModifiers(0)))
return True
def key_click(self,
widget: QWidget,
key: int = 0,
txt: str = "",
modifier: int = Qt.NoModifier,
delay: float = 0) -> None:
"""Send press key event to widget"""
widget.setFocus()
key_press = QKeyEvent(QEvent.KeyPress, key, modifier, txt, False)
key_release = QKeyEvent(QEvent.KeyRelease, key, modifier, txt, False)
QCoreApplication.postEvent(widget, key_press)
QCoreApplication.postEvent(widget, key_release)
self.sleep(delay)
def scroll_to_boundary(top, window, focus_widget, key_filter, *args, **kwargs):
if focus_widget is not None:
with key_filter.disable_filtering:
key = Qt.Key_Home if top else Qt.Key_End
QApplication.sendEvent(
focus_widget,
QKeyEvent(QEvent.KeyPress, key, Qt.KeyboardModifiers(0)))
return True
def scroll_page(up, window, focus_widget, key_filter, *args, **kwargs):
if focus_widget is not None:
with key_filter.disable_filtering:
key = Qt.Key_PageUp if up else Qt.Key_PageDown
QApplication.sendEvent(
focus_widget,
QKeyEvent(QEvent.KeyPress, key, Qt.KeyboardModifiers(0)))
return True
def keyPressEvent(self, event: QKeyEvent):
if event.key() == Qt.Key_Delete:
item = self.currentItem()
row_idx = item.row()
if row_idx < self.rowCount() - 1:
self.takeItem(row_idx, 0)
self.takeItem(row_idx, 1)
self.removeRow(row_idx)
else:
super(QTableWidgetMaterial, self).keyPressEvent(event)
def checkKey(self, ev: Qt.QKeyEvent):
if ev.key() == QtCore.Qt.Key_Backspace:
if self.activePoints[0] and self.activePoints[1]:
self.activePoints[1] = False
self.grphEnd.scene().removeItem(self.ellipsi[1])
self.grphEnd.show()
elif self.activePoints[0] and self.activePoints[1] is False:
self.activePoints[0] = False
self.grphStart.scene().removeItem(self.ellipsi[0])
self.grphStart.show()
def keyReleaseEvent(self, _event: QKeyEvent):
key = _event.key()
if key == QtCore.Qt.Key_Up:
self.wizard.zoomIn()
elif key == QtCore.Qt.Key_Down:
self.wizard.zoomOut()
elif key == QtCore.Qt.Key_Left:
self.wizard.scrollLeft()
elif key == QtCore.Qt.Key_Right:
self.wizard.scrollRight()
else:
pass
def keyPressEvent(self, evt: QKeyEvent):
"""
Ignore escape key event, because it would close startup window.
Any other key will be passed to the super class key event handler for further
processing.
:param evt: key event
:return:
"""
if evt.key() == QtCore.Qt.Key_Escape:
self.request_close_dialog()
else:
super().keyPressEvent(evt)
def keyPressEvent(self, evt: QKeyEvent):
"""
Ignore escape key event, because it would close startup window.
Any other key will be passed to the super class key event handler for further
processing.
:param evt: key event
:return:
"""
if evt.key() == QtCore.Qt.Key_Escape:
pass
else:
super().keyPressEvent(evt)
def send_text_using_keys(self, text):
if self.host_widget is not None and not sip.isdeleted(
self.host_widget):
self.host_widget.setFocus(Qt.OtherFocusReason)
with QApplication.instance().key_filter.disable_filtering:
for ch in text:
key = getattr(Qt, f'Key_{ch.upper()}', Qt.Key_A)
QApplication.sendEvent(
self.host_widget,
QKeyEvent(QKeyEvent.KeyPress, key,
Qt.KeyboardModifiers(0), ch))
# Ensure key events are delivered before any other processing
while QApplication.instance().processEvents():
pass
def keyReleaseEvent(self, _event: QKeyEvent):
"""
implement the key interaction
"""
key = _event.key()
if key == QtCore.Qt.Key_Up:
self.wizard.zoomIn()
elif key == QtCore.Qt.Key_Down:
self.wizard.zoomOut()
elif key == QtCore.Qt.Key_Left:
self.wizard.scrollLeft()
elif key == QtCore.Qt.Key_Right:
self.wizard.scrollRight()
else:
pass
def mouseMove(self, event: QKeyEvent):
if not self.begin or not self.isDrawing:
return
end = event.pos()
if event.modifiers() & Qt.ShiftModifier:
# if shift then draw square with bigger size
if getBiggerDiff(event.pos(), self.begin) == 'X':
end = QPoint(end.x(),
end.x() - self.begin.x() + self.begin.y())
else:
end = QPoint(end.y() - self.begin.y() + self.begin.x(),
end.y())
if event.modifiers() & Qt.AltModifier:
# calculate new end point
newEndX = end.x() + (end.x() - self.begin.x())
newEndY = end.y() + (end.y() - self.begin.y())
end = QPoint(newEndX, newEndY)
self.end = end
self.app.repaint()
def key_clicks(self,
widget: QWidget,
txt: str = "",
modifier: int = Qt.NoModifier,
delay: float = 0) -> None:
"""Send string to widget"""
timeout: float = self._tests_delay_key if delay else 0
if not self.is_interactive():
timeout = 0
for char in txt:
key = QKeyEvent(QEvent.KeyPress, 0, modifier, char, False)
QCoreApplication.postEvent(widget, key)
if timeout:
self.sleep(timeout)
self.sleep(delay)
def keyPressEvent(self, keyPressed: QKeyEvent, *args, **kwargs):
key = keyPressed.key()
if key == Qt.Key_Escape:
self.searchEdit.clearFocus()
return False
elif key == Qt.Key_Up:
self.map.move_on_map(CONST.MOVE_UP)
elif key == Qt.Key_Down:
self.map.move_on_map(CONST.MOVE_DOWN)
elif key == Qt.Key_Left:
self.map.move_on_map(CONST.MOVE_LEFT)
elif key == Qt.Key_Right:
self.map.move_on_map(CONST.MOVE_RIGHT)
elif key == Qt.Key_PageUp:
self.map.setScale(CONST.UP_SCALE)
elif key == Qt.Key_PageDown:
self.map.setScale(CONST.DOWN_SCALE)
else:
return False
def keyPressEvent(self, e: Qt.QKeyEvent):
if e.key() == Qt.Qt.Key_Escape:
self.close()
def paste_and_search(self):
self.paste()
ev = QKeyEvent(QKeyEvent.KeyPress, Qt.Key_Enter, Qt.NoModifier)
self.keyPressEvent(ev)
def keyReleaseEvent(self, event: QKeyEvent):
if event.key() == Qt.Key_Q:
self.close()
def test_key_press(self):
self.text = self.editor._view.text
self.test.sleep()
# ---------------------------------------------------------------------
# Qt.Key_L
key_event = QKeyEvent(QEvent.KeyPress, Qt.Key_L, Qt.ControlModifier,
"", False)
self.spell._enabled_all = False
result = self.keyswitcher.key_press(key_event)
self.assertEqual(result, [])
self.spell._enabled_all = True
# ---------------------------------------------------------------------
def key_switcher_params(widget):
test = QTestHelper()
test.sleep()
test.mouse_click(widget.controls[-1], QPoint(1, 1))
self.test.handle_modal_widget(key_switcher_params)
result = self.keyswitcher.key_press(key_event)
self.assertEqual(result, [])
self.test.sleep(1)
# ---------------------------------------------------------------------
# Qt.Key_F12
self.test.wrd_d_click(self.editor._view.text, "hello1")
self.test.sleep(1)
key_event = QKeyEvent(QEvent.KeyPress, Qt.Key_F12, Qt.NoModifier, "",
False)
point = self.test.get_xy_for_word(self.editor._view.text, "hello1")
x = point.x()
self.assertTrue(x)
result = self.keyswitcher.key_press(key_event)
self.assertEqual(result, [])
point = self.test.get_xy_for_word(self.editor._view.text, "hello1")
self.assertFalse(point.x())
point = self.test.get_xy_for_word(self.editor._view.text,
"руддщ1") # i18n
self.assertEqual(point.x(), x)
# no selection -> no change
cursor = self.text.textCursor()
cursor.clearSelection()
self.text.setTextCursor(cursor)
self.keyswitcher._replace_selection()
self.assertEqual(point.x(), x)
self.test.sleep(1)
# ---------------------------------------------------------------------
# not enabled keyswitcher
key_event = QKeyEvent(QEvent.KeyPress, Qt.Key_Backspace, Qt.NoModifier,
"", False)
self.keyswitcher._enabled = False
result = self.keyswitcher.key_press(key_event)
self.assertEqual(result[0], key_event)
# ---------------------------------------------------------------------
# Qt.Key_Backspace
self.keyswitcher._enabled = True
self.test.wrd_d_click(self.editor._view.text, "2")
self.test.sleep()
self.editor._view.text.setFocus()
self.editor._view.text.setFocus()
with patch.object(self.text, 'hasFocus', return_value=True):
self.test.key_clicks(self.text, " wo")
self.test.sleep()
self.assertEqual(self.keyswitcher._current_word, "wo")
self.test.sleep()
with patch.object(self.text, 'hasFocus', return_value=True):
self.test.key_click(self.text, Qt.Key_Backspace)
self.assertEqual(result[0], key_event)
self.assertEqual(self.keyswitcher._current_word, "w")
self.test.sleep()
# ---------------------------------------------------------------------
# not char
key_event = QKeyEvent(QEvent.KeyPress, Qt.Key_Up, Qt.NoModifier, "",
False)
result = self.keyswitcher.key_press(key_event)
self.assertEqual(result[0], key_event)
self.assertEqual(self.keyswitcher._current_word, "")
self.test.sleep()
# ---------------------------------------------------------------------
# char and there was mouse movement
with patch.object(self.text, 'hasFocus', return_value=True):
self.test.key_clicks(self.text, " wo")
self.assertEqual(self.keyswitcher._current_word, "wo")
self.test.wrd_click(self.editor._view.text, "")
self.test.key_click(self.editor._view.text, Qt.Key_A, "A")
self.assertEqual(self.keyswitcher._current_word, "")
self.test.sleep()
# ---------------------------------------------------------------------
# add char to current word
self.assertEqual(self.keyswitcher._current_lang, "ENG")
self.test.wrd_d_click(self.editor._view.text, "wo")
with patch.object(self.text, 'hasFocus', return_value=True):
self.test.key_clicks(self.text, " a")
self.test.key_clicks(self.text, "ф") # i18n
self.assertEqual(self.keyswitcher._current_word, "aa")
self.test.sleep()
# ---------------------------------------------------------------------
# check switch lang
self.test.wrd_d_click(self.editor._view.text, "aa")
with patch.object(self.text, 'hasFocus', return_value=True):
self.test.key_clicks(self.text, " 123") # no switch
self.test.sleep()
self.test.wrd_d_click(self.editor._view.text, "123")
with patch.object(self.text, 'hasFocus', return_value=True):
self.test.key_clicks(self.text, " rybu")
self.test.sleep()
self.assertEqual(self.keyswitcher._current_word, "книг") # i18n
self.test.wrd_d_click(self.editor._view.text, "книг") # i18n
self.test.sleep()
with patch.object(self.text, 'hasFocus', return_value=True):
self.test.key_clicks(self.text, " рудд") # i18n
self.test.sleep()
self.assertEqual(self.keyswitcher._current_word, "hell")
# ---------------------------------------------------------------------
self.keyswitcher.set_enabled(False)
with patch.object(self.text, 'hasFocus', return_value=True):
self.test.key_clicks(self.text, " фFфF") # i18n
self.keyswitcher.set_enabled(True)
self.keyswitcher._current_word = "фFфF" # i18n
with patch.object(self.text, 'hasFocus', return_value=True):
self.test.key_clicks(self.text, "1")
self.assertEqual(self.keyswitcher._current_word, "фFфF1") # i18n
self.test.sleep()
def keyPressEvent(self, event: QKeyEvent):
super().keyPressEvent(event)
if self.currentIndex():
if event.key() == 16777219:
self.model().removeRow(int(self.currentIndex().row()))
def key_press(self, event: QKeyEvent):
if event.key() == Qt.Key_L and event.modifiers() & Qt.ControlModifier:
if not self._spell.enabled():
return []
f_param = KeySwitcherParams(self._textedit, self._current_lang,
self._enabled)
if f_param.exec_():
self._enabled = f_param.params["enabled"]
self._current_lang = "ENG" if f_param.params["eng"] else "RUS"
return []
if event.key() == Qt.Key_F12:
self._replace_selection()
return []
if not self._enabled:
return [event]
if event.key() == Qt.Key_Backspace:
if self._current_word.strip():
self._current_word = self._current_word.strip()[:-1]
return [event]
char = event.text().strip()
if not char:
shift = event.modifiers() & Qt.ShiftModifier
ctrl = event.modifiers() & Qt.ControlModifier
if not (shift or ctrl):
self._current_word = ""
return [event]
# ---------------------------------------------------------------------
# check the current word, if there was any movement, e.g. mouse
old_cur = self._textedit.textCursor()
cursor = self._textedit.textCursor()
cursor.select(QTextCursor.WordUnderCursor)
word = cursor.selectedText()
self._textedit.setTextCursor(old_cur)
if self._current_word.strip() != word.strip():
self._current_word = ""
return [event]
# ---------------------------------------------------------------------
# detect char language
char_lang = "UNKNOWN"
if char.lower() in KeySwitcher.RUSSIAN:
char_lang = "RUS"
if char.lower() in KeySwitcher.ENGLISH:
char_lang = "ENG"
# add char to current word
if self._current_lang != char_lang: # and char_lang != "UNKNOWN":
char = KeySwitcher.switch_charset(char, self._current_lang)
event = QKeyEvent(QEvent.KeyPress, event.key(), event.modifiers(),
char)
self._current_word += char
# early to check language
if len(self._current_word) < 2:
return [event]
# detect language
rus_chars = 0
eng_chars = 0
for char in set(self._current_word.lower()):
if char in KeySwitcher.RUSSIAN:
rus_chars += 1
if char in KeySwitcher.ENGLISH:
eng_chars += 1
if rus_chars and eng_chars:
return [event]
if not self._ok_locale(
self._current_word,
KeySwitcher.switch_charset(self._current_word,
"ENG" if rus_chars else "RUS")):
return [event] + self._replace_current_word()
return [event]
def editDelete(self):
ev = QKeyEvent(QEvent.KeyPress, Qt.Key_Delete, Qt.NoModifier)
QApplication.sendEvent(self, ev)
def eventFilter(self, obj, event): # noqa C901
'''
@param obj QObject
@param event QEvent
@return: bool
'''
# Event filter based on QCompleter::eventFilter from qcompleter.cpp
if obj == self or obj == self._view or not self.isVisible():
return False
evtType = event.type()
if obj == self._view.viewport():
if evtType == QEvent.MouseButtonRelease:
# QMouseEvent
e = event
index = self._view.indexAt(e.pos())
if not index.isValid():
return False
# Qt::MouseButton
button = e.button()
# Qt::KeyboardModifiers
modifiers = e.modifiers()
if button == Qt.LeftButton and modifiers == Qt.NoModifier:
self.indexActivated.emit(index)
return True
if button == Qt.MiddleButton or (button == Qt.LeftButton
and modifiers
== Qt.ControlModifier):
self.indexCtrlActivated.emit(index)
return True
if button == Qt.LeftButton and modifiers == Qt.ShiftModifier:
self.indexShiftActivated.emit(index)
return True
return False
if evtType == QEvent.KeyPress:
# QKeyEvent
keyEvent = event
evtKey = keyEvent.key()
modifiers = keyEvent.modifiers()
index = self._view.currentIndex()
item = self.model().index(0, 0)
if item.data(LocationCompleterModel.VisitSearchItemRole):
visitSearchIndex = item
else:
visitSearchIndex = QModelIndex()
if (evtKey == Qt.Key_Up or evtKey == Qt.Key_Down) and \
self._view.currentIndex() != index:
self._view.setCurrentIndex(index) # TODO: ?
if evtKey in (Qt.Key_Return, Qt.Key_Enter):
if index.isValid():
if modifiers == Qt.NoModifier or modifiers == Qt.KeypadModifier:
self.indexActivated.emit(index)
return True
if modifiers == Qt.ControlModifier:
self.indexCtrlActivated.emit(index)
return True
if modifiers == Qt.ShiftModifier:
self.indexShiftActivated.emit(index)
return True
elif evtKey == Qt.Key_End:
if modifiers & Qt.ControlModifier:
self._view.setCurrentIndex(self.model().index(
self.model().rowCount() - 1, 0))
return True
else:
self.close()
elif evtKey == Qt.Key_Home:
if modifiers & Qt.ControlModifier:
self._view.setCurrentIndex(self.model().index(0, 0))
self._view.scrollToTop()
return True
else:
self.close()
elif evtKey == Qt.Key_Escape:
self.close()
return True
elif evtKey == Qt.Key_F4:
if modifiers == Qt.AltModifier:
self.close()
return False
elif evtKey in (Qt.Key_Tab, Qt.Key_Backtab):
if modifiers != Qt.NoModifier and modifiers != Qt.ShiftModifier:
return False
isBack = evtKey == Qt.Key_Backtab
if evtKey == Qt.Key_Tab and modifiers == Qt.ShiftModifier:
isBack = True
ev = QKeyEvent(QKeyEvent.KeyPress, isBack and Qt.Key_Up
or Qt.Key_Down, Qt.NoModifier)
QApplication.sendEvent(self.focusProxy(), ev)
return True
elif evtKey in (Qt.Key_Up, Qt.Key_PageUp):
if modifiers != Qt.NoModifier:
return False
step = evtKey == Qt.Key_PageUp and 5 or 1
if not index.isValid() or index == visitSearchIndex:
rowCount = self.model().rowCount()
lastIndex = self.model().index(rowCount - 1, 0)
self._view.setCurrentIndex(lastIndex)
elif index.row() == 0:
self._view.setCurrentIndex(QModelIndex())
else:
row = max(0, index.row() - step)
self._view.setCurrentIndex(self.model().index(row, 0))
return True
elif evtKey in (Qt.Key_Down, Qt.Key_PageDown):
if modifiers != Qt.NoModifier:
return False
step = evtKey == Qt.Key_PageDown and 5 or 1
if not index.isValid():
firstIndex = self.model().index(0, 0)
self._view.setCurrentIndex(firstIndex)
elif index != visitSearchIndex and index.row(
) == self.model().rowCount() - 1:
self._view.setCurrentIndex(visitSearchIndex)
self._view.scrollToTop()
else:
row = min(self.model().rowCount() - 1, index.row() + step)
self._view.setCurrentIndex(self.model().index(row, 0))
return True
elif evtKey == Qt.Key_Delete:
if index != visitSearchIndex and self._view.viewport().rect(
).contains(self._view.visualRect(index)):
self.indexDeleteRequested.emit(index)
return True
elif evtKey == Qt.Key_Shift:
self._delegate.setForceVisitItem(True)
self._view.viewport().update()
# end of switch evtKey
if self.focusProxy():
self.focusProxy().event(keyEvent)
return True
elif evtType == QEvent.KeyRelease:
if event.key() == Qt.Key_Shift:
self._delegate.setForceVisitItem(False)
self._view.viewport().update()
return True
elif evtType in (QEvent.Wheel, QEvent.MouseButtonPress):
if not self.underMouse():
self.close()
return False
elif evtType == QEvent.FocusOut:
# QFocusEvent
focusEvent = event
reason = focusEvent.reason()
if reason != Qt.PopupFocusReason and reason != Qt.MouseFocusReason:
self.close()
elif evtType in (QEvent.Move, QEvent.Resize):
w = obj
if isinstance(w, QWidget) and w.isWindow() and self.focusProxy(
) and w == self.focusProxy().window():
self.close()
# end of switch evtType
return False
