def keyPressEvent(self, event: QKeyEvent):
if event.key() == 0x01000013:
self.keyboard_state['North'] = True
elif event.key() == 0x01000015:
self.keyboard_state['South'] = True
elif event.key() == 0x01000012:
self.keyboard_state['West'] = True
elif event.key() == 0x01000014:
self.keyboard_state['East'] = True
def keyReleaseEvent(self, event : QKeyEvent):
if event.key() == 0x01000013:
self.keyboard_state['North'] = False
elif event.key() == 0x01000015:
self.keyboard_state['South'] = False
elif event.key() == 0x01000012:
self.keyboard_state['West'] = False
elif event.key() == 0x01000014:
self.keyboard_state['East'] = False
def keyPressEvent(self, event: QtGui.QKeyEvent) -> None:
if event.text() or event.key() in (Qt.Key_Left, Qt.Key_Right):
QtWidgets.QLineEdit.keyPressEvent(self, event)
self.reset_ac_suggestions.emit()
self.reset_history_travel.emit()
elif event.key() == Qt.Key_Up:
self.history_up.emit()
elif event.key() == Qt.Key_Down:
self.history_down.emit()
else:
return super().keyPressEvent(event)
def keyPressEvent(self, event: QKeyEvent):
"""
Handle key presses for mouse-drag transforms and arrow-key panning.
"""
if not self._has_focus: # we don't have focus -> ignore keypress
return
if event.key() == self._key_mod:
self._transform_enable = True
QGraphicsView.keyPressEvent(self, event)
elif event.key() == Qt.Key_Left:
transform = self.scene_root_item.transform()
transform.translate(self.keyPanDeltaX(), 0)
self.scene_root_item.setTransform(transform)
elif event.key() == Qt.Key_Up:
transform = self.scene_root_item.transform()
transform.translate(0, self.keyPanDeltaY())
self.scene_root_item.setTransform(transform)
elif event.key() == Qt.Key_Right:
transform = self.scene_root_item.transform()
transform.translate(-self.keyPanDeltaX(), 0)
self.scene_root_item.setTransform(transform)
elif event.key() == Qt.Key_Down:
transform = self.scene_root_item.transform()
transform.translate(0, -self.keyPanDeltaY())
self.scene_root_item.setTransform(transform)
elif event.key() == Qt.Key_Plus:
self.zoomIn(0.3)
elif event.key() == Qt.Key_Minus:
self.zoomIn(0.03)
elif event.key() == Qt.Key_Escape:
QGraphicsView.keyPressEvent(self, event)
else:
if hasattr(self.scene_root_item, KEY_PRESS_EVENT):
getattr(self.scene_root_item, KEY_PRESS_EVENT)(event)
def keyPressEvent(self, event: QKeyEvent):
if event.key() == Qt.Key_F:
self.scene().views()[0].zoomToFit()
for na_part_item in self.instance_items.values():
if hasattr(na_part_item, 'keyPressEvent'):
getattr(na_part_item, 'keyPressEvent')(event)
def keyPressEvent(self, event: QKeyEvent):
if event.key() in (Qt.Key_Enter, Qt.Key_Return):
selected = [index.row() for index in self.selectedIndexes()]
if len(selected) > 0:
self.edit_on_item_triggered.emit(min(selected))
else:
super().keyPressEvent(event)
def keyPressEvent(self, event):
key = event.key()
cursor = self.textCursor()
if key == Qt.Key_Backspace and event.modifiers() & Qt.GroupSwitchModifier:
# Workaround for https://bugreports.qt.io/browse/QTBUG-49771
event = QKeyEvent(event.type(), event.key(),
event.modifiers() ^ Qt.GroupSwitchModifier)
if key == Qt.Key_Tab:
documentIndentMore(self.document(), cursor)
elif key == Qt.Key_Backtab:
documentIndentLess(self.document(), cursor)
elif key == Qt.Key_Return and not cursor.hasSelection():
if event.modifiers() & Qt.ShiftModifier:
# Insert Markdown-style line break
markupClass = self.tab.getActiveMarkupClass()
if markupClass == MarkdownMarkup:
cursor.insertText(' ')
if event.modifiers() & Qt.ControlModifier:
cursor.insertText('\n')
self.ensureCursorVisible()
else:
self.handleReturn(cursor)
else:
if event.text() and self.tableModeEnabled:
cursor.beginEditBlock()
QTextEdit.keyPressEvent(self, event)
if event.text() and self.tableModeEnabled:
cursor.endEditBlock()
def keyPressEvent(self, event: QKeyEvent):
if event.key() == Qt.Key_Delete:
# Delete selected rows
rows = [i.row() for i in self.selectedIndexes()]
for row in sorted(rows, reverse=True):
self.model().remove_label_at(row)
else:
event.accept()
def keyReleaseEvent(self, event: QKeyEvent):
if event.key() == self._key_mod:
self._transform_enable = False
self._dolly_zoom_enable = False
self._panDisable()
else:
if hasattr(self.scene_root_item, KEY_RELEASE_EVENT):
getattr(self.scene_root_item, KEY_RELEASE_EVENT)(event)
def keyPressEvent(self, event: QKeyEvent) -> None:
if event.key() in (Qt.Key_Return, Qt.Key_Enter):
if self.state() == QAbstractItemView.EditingState:
# if we are editing, inform base
super(TreeView, self).keyPressEvent(event)
else:
self.onEnterEvent()
else:
# any other key was pressed, inform base
super(TreeView, self).keyPressEvent(event)
def keyPressEvent(self, a0: QKeyEvent):
if (a0.key() == QtCore.Qt.Key_Escape):
self.stop()
for Mod in self.Modules:
Mod.__del__()
super().keyPressEvent(a0)
for Mod in self.Modules:
Mod.keyPressEvent(a0)
self.update()
def keyPressEvent(self, event: QKeyEvent):
if type(event) == QKeyEvent:
# here accept the event and do something
if (event.key() == Qt.Key_W):
print("w")
runMotors("w")
elif (event.key() == Qt.Key_A):
runMotors("a")
print("a")
elif (event.key() == Qt.Key_S):
runMotors("s")
print("s")
elif (event.key() == Qt.Key_D):
runMotors("d")
print("d")
event.accept()
else:
event.ignore()
def keyReleaseEvent(self, event: QKeyEvent):
if event.key() == Qt.Key_Shift:
self.shift_mode = False
self.shift_state_changed.emit(False)
if self.hold_shift_to_drag:
self.unsetCursor()
self.grab_start = None
else:
self.setCursor(Qt.OpenHandCursor)
def keyPressEvent(self, e: QtGui.QKeyEvent) -> None:
"""
Replace tab inputs with spaces, if desired (for 'grammar' and 'transformer' mode only)
"""
if self.mode in ('grammar', 'transformer') and settings[
'options.edit.tabs.replace'] and e.key() == QtCore.Qt.Key_Tab:
self.insertPlainText(
' ' * settings['options.edit.tabs.replacement_spaces'])
else:
super().keyPressEvent(e)
def keyPressEvent(self, e: QKeyEvent) -> None:
"""
Fonction héritée de Qt qui permet de prendre en charge les évènements du type
touche clavier.
Args:
e (PyQt5.QtGui.QKeyEvent): évènement de type touche de clavier
"""
if e.key() == Qt.Key_Escape:
self.close()
def keyReleaseEvent(self, event0: QtGui.QKeyEvent) -> None:
event0.accept()
if event0.key() == Qt.Key_A:
self._select_items_flag = False
if self._temp_seed:
compare_to_seed(
self._image,
self._circle_seed_items[self._current_item_index],
self._temp_seed)
self._temp_seed = None
def keyPressEvent(self, event: QKeyEvent):
"""Must intercept invalid input events. Make changes here
Args:
event: Description
"""
a = event.key()
if a in [Qt.Key_Control, Qt.Key_Left, Qt.Key_Right, Qt.Key_Up, Qt.Key_Down]:
QGraphicsObject.keyPressEvent(self, event)
else:
self.deactivate()
def keyPressEvent(self, ev: QKeyEvent):
# Player 1
if ev.key() == QtCore.Qt.Key_Left:
self.__engine.setSnakeDirection(0, Direction.Left)
if ev.key() == QtCore.Qt.Key_Right:
self.__engine.setSnakeDirection(0, Direction.Right)
if ev.key() == QtCore.Qt.Key_Up:
self.__engine.setSnakeDirection(0, Direction.Up)
if ev.key() == QtCore.Qt.Key_Down:
self.__engine.setSnakeDirection(0, Direction.Down)
# Player 2
# if ev.key() == QtCore.Qt.Key_W:
# self.__engine.setSnakeDirection(1, Direction.Up)
# if ev.key() == QtCore.Qt.Key_A:
# self.__engine.setSnakeDirection(1, Direction.Left)
# if ev.key() == QtCore.Qt.Key_S:
# self.__engine.setSnakeDirection(1, Direction.Down)
# if ev.key() == QtCore.Qt.Key_D:
# self.__engine.setSnakeDirection(1, Direction.Right)
return super().keyPressEvent(ev)
def keyReleaseEvent(self, event0: QtGui.QKeyEvent) -> None:
event0.accept()
if event0.key() == Qt.Key_A:
self._select_items_flag = False
if self._temp_seed:
compare_tow_seed_of_spectral_info(
self._cv_image,
self._circle_seeds_list[self._current_item_index],
self._temp_seed)
# self._selected_indexes = self._road_detection.validation_road_pixels_proportion(self._circle_seeds_list[self._current_item_index])
self._temp_seed = None
def keyPressEvent(self, event: QKeyEvent) -> None:
"""
Listen to the user's input
"""
# Enter is the key located in the keypad, usually denoted by the text "Intro"
# Return is the big key we usually use to create a break in a sentence
start = [Qt.Key_Return, Qt.Key_Enter]
# Game can be played using Arrow keys and WASD
directions = [
Qt.Key_Left, Qt.Key_A, Qt.Key_Right, Qt.Key_D, Qt.Key_Up, Qt.Key_W,
Qt.Key_Down, Qt.Key_S
]
# Starts a new game if not already playing
if not self.playing and event.key() in start:
self.startGame()
# Change the Snake's movement direction
if self.playing and event.key() in directions:
self.snake.changeDirection(event.key())
def keyReleaseEvent(self, event: QKeyEvent):
if event.key() == Qt.Key_Shift:
self.shift_mode = False
if self.hold_shift_to_drag:
self.unsetCursor()
self.grab_start = None
else:
self.setCursor(Qt.OpenHandCursor)
super().keyPressEvent(event)
def keyPressEvent(self, event: QKeyEvent) -> None:
"""This event handler, for event event, can be reimplemented in a
subclass to receive key press events for the widget.
We add handling of 'Esc' and 'Q' to close the window.
"""
key = event.key()
if key in (Qt.Key_Q, Qt.Key_Escape) and self._application is not None:
self._application.quit()
else:
super().keyPressEvent(event)
def keyReleaseEvent(self, event: QKeyEvent):
if event.key() == Qt.Key_Shift:
self.shift_mode = False
if self.hold_shift_to_drag:
self.unsetCursor()
self.grab_start = None
else:
self.setCursor(Qt.OpenHandCursor)
super().keyPressEvent(event)
def keyPressEvent(self, event: QKeyEvent) -> None:
if event.key() in {Qt.Key_F, Qt.Key_Escape}:
event.accept()
if self.parent is None:
self.originalParent.toggleFullscreen()
else:
self.parent.toggleFullscreen()
elif self.isFullScreen():
self.originalParent.keyPressEvent(event)
else:
super(mpvWidget, self).keyPressEvent(event)
def keyPressEvent(self, event: QtGui.QKeyEvent) -> None:
"""
ctrl+shift+alt+F8
:param event:
:return:
"""
if (event.modifiers() == Qt.ControlModifier | Qt.AltModifier | Qt.ShiftModifier) \
and (event.key() == Qt.Key_F8):
if MIN_AFTER_SHOT:
self.parentWidget().showMinimized()
self.ui.pushButtonCapture.clicked.emit()
def keyReleaseEvent(self, a0: QKeyEvent):
if a0.key() == Qt.Key_Return:
c = self.ui.dsCostBt.value()
self.ui.canvas.dang_state.dang_state.setCost(c)
if self.selectedState is not None and self.selectedState.isClass(
figures.IniStateFigure):
p = self.ui.doubleSpinBox.value()
self.selectedState.setProbability(p)
self.ui.probLabel.setText('Вероятность')
self.selectedState = None
self.ui.canvas.update()
def keyPressEvent(self, event: QKeyEvent) -> None:
if event.key() == Qt.Key_Return and self.input_open:
text = self.toPlainText()
line = text.split('\n')[-1]
self.line.emit(line)
cursor = self.textCursor()
cursor.movePosition(QTextCursor.End)
self.setTextCursor(cursor)
QTextEdit.keyPressEvent(self, event)
elif event.modifiers() == Qt.ControlModifier and event.key(
) == Qt.Key_C:
if not self.textCursor().selectedText():
self.RaiseKeyboardInterrupt()
else:
self.copy()
elif event.key() in [Qt.Key_Backspace, Qt.Key_Delete]:
if self.textCursor().position() - 1 >= self.min_char:
QTextEdit.keyPressEvent(self, event)
else:
QTextEdit.keyPressEvent(self, event)
def keyPressEvent(self, event: QtGui.QKeyEvent):
code = event.key()
if code in self._key_map:
functions = self._key_map[code]
if type(functions) == list:
for func in functions:
func()
else:
functions()
else:
log.info('key: code %i not mapped to any function' % code)
def eventFilter(self, obj, event: QtGui.QKeyEvent):
if obj is not self.ui.recordsTableView:
return False
if event.type() != QtCore.QEvent.KeyPress:
return False
if event.key() == QtCore.Qt.Key_Delete:
self._remove_selected_records()
return True
return False
def keyPressEvent(self, event: QtGui.QKeyEvent) -> None:
row = self.images_list_widget.currentRow()
last_index = self.images_list_widget.count() - 1
if event.key() == QtCore.Qt.Key_A:
self.save_annotations()
if row > 0:
self.images_list_widget.setCurrentRow(row - 1)
else:
self.images_list_widget.setCurrentRow(last_index)
if event.key() == QtCore.Qt.Key_D:
self.save_annotations()
if row < last_index:
self.images_list_widget.setCurrentRow(row + 1)
else:
self.images_list_widget.setCurrentRow(0)
if event.key() == QtCore.Qt.Key_W:
self.viewer.selection_mode = SELECTION_MODE.POLYGON
if event.key() == QtCore.Qt.Key_S:
self.viewer.selection_mode = SELECTION_MODE.BOX
super(ImageViewerWidget, self).keyPressEvent(event)
def __init__(self, key_event: QtGui.QKeyEvent):
if key_event is None:
self.key = None
self.char = ''
self.count = 0
self.modifiers = QtCore.Qt.NoModifier
else:
self.key = key_event.key()
self.char = key_event.text()
self.count = key_event.count()
self.modifiers = key_event.modifiers()
def from_event(cls, e: QKeyEvent) -> 'KeyInfo':
"""Get a KeyInfo object from a QKeyEvent.
This makes sure that key/modifiers are never mixed and also remaps
UTF-16 surrogates to work around QTBUG-72776.
"""
key = _remap_unicode(Qt.Key(e.key()), e.text())
modifiers = e.modifiers()
_assert_plain_key(key)
_assert_plain_modifier(modifiers)
return cls(key, modifiers)
def keyPressEvent(self, e: QKeyEvent):
# if len(self.tanks) == 0: return
key = e.key()
if key == Qt.Key_Escape:
self.paused = (self.paused + 1) % 2
if self.paused:
self.stop_game()
return
else:
self.start_game()
self.do_for_every_player(partial(self.treat_key, key))
def keyPressEvent(self, event: QtGui.QKeyEvent):
current_level = self.current_level
if not current_level:
return
if event.key() == 0x41: # A
current_level.left = True
current_level.right = False
elif event.key() == 0x44: # D
current_level.right = True
current_level.left = False
elif event.key() == 0x20: # Space
current_level.shoot(self.penetrate)
elif event.key() == 0x01000020: # Shift
self.penetrate = True
elif event.key() == 0x01000000: # Esc
if self.paused:
self.game.resume()
else:
self.game.pause()
self.paused = not self.paused
def _get_base_keysequence(event: QKeyEvent) -> SequenceT:
"""Get main keyname part of QKeyEvent.
Converts special keys to usable names and uses event.text() otherwise. Is a sequence
to allow prepending <shift> to special keys.
Args:
event: The emitted QKeyEvent.
Returns:
Name of the main key press escaping special keys.
"""
special_keys = {
Qt.Key_Space: "<space>",
Qt.Key_Backtab: "<tab>",
Qt.Key_Tab: "<tab>",
Qt.Key_Escape: "<escape>",
Qt.Key_Enter: "<enter>",
Qt.Key_Return: "<return>",
Qt.Key_Backspace: "<backspace>",
Qt.Key_Left: "<left>",
Qt.Key_Right: "<right>",
Qt.Key_Up: "<up>",
Qt.Key_Down: "<down>",
Qt.Key_Home: "<home>",
Qt.Key_End: "<end>",
Qt.Key_PageUp: "<page-up>",
Qt.Key_PageDown: "<page-down>",
Qt.Key_Home: "<home>",
Qt.Key_End: "<end>",
}
if event.key() in special_keys:
# Parse shift here as the key does not support it otherwise
text = special_keys[event.key()] # type: ignore
if event.modifiers() & Qt.ShiftModifier: # type: ignore
return "<shift>", text
return (text,)
if event.key() == Qt.Key_Colon: # Required as : is the separator
return ("<colon>",)
if event.text().isprintable():
return (event.text(),)
return (QKeySequence(event.key()).toString().lower(),)
def keyPressEvent(self, event: QKeyEvent):
key = event.key()
if key == Qt.Key_Up:
self.translateVerticalEvent(-100)
elif key == Qt.Key_Down:
self.translateVerticalEvent(100)
elif key == Qt.Key_Left:
self.translateHorizontalEvent(-100)
elif key == Qt.Key_Right:
self.translateHorizontalEvent(100)
else:
super().keyPressEvent(event)
def keyPressEvent(self, ke: QtGui.QKeyEvent):
key = ke.key()
if key == QtCore.Qt.Key_Left or key == QtCore.Qt.Key_Q:
self.prev_frame()
elif key == QtCore.Qt.Key_Right or key == QtCore.Qt.Key_E:
self.next_frame()
elif key == QtCore.Qt.Key_Delete or key == QtCore.Qt.Key_D:
idx = self.ui.listWidget.currentRow()
if idx is not None and len(self.tag_list[self.current_frame]):
self.tag_list[self.current_frame].pop(idx)
self.update_list()
def keyPressEvent(self, event: QKeyEvent):
if event.key() == Qt.Key_Shift:
self.shift_mode = True
self.shift_state_changed.emit(True)
if self.hold_shift_to_drag:
self.setCursor(Qt.OpenHandCursor)
else:
self.unsetCursor()
self.grab_start = None
super().keyPressEvent(event)
def keyPressEvent(self, event: QKeyEvent) -> None:
"""Overriden method.
Args:
event (QKeyEvent): [description]"""
if event.key() in (Qt.Key_Enter, Qt.Key_Return):
self.control_window.Callbacks.send_command(
command=self.toPlainText(),
stocker=self.control_window.stocker,
log_scroll_area=self.control_window.log_scroll_area)
self.setText("")
super().keyPressEvent(event)
def keyPressEvent(self, event: QKeyEvent) -> None:
"""Debug-related keyboard controls."""
if self.DEBUG:
if event.key() == Qt.Key_Escape:
possible_plants = [plant for i, plant in enumerate(self.PLANTS) if self.plant_checkboxes[i].isChecked()]
if len(possible_plants) != 0:
self.plant = choice(possible_plants)()
self.canvas.set_drawable(self.plant)
self.plant.set_max_age(1)
self.plant.set_age(1)
self.canvas.update()
def onKeyPress(self, event: QKeyEvent):
try:
event = dict(event="gui",
type="keyPress",
key=event.key(),
modifiers=event.modifiers(),
nativeModifiers=event.nativeModifiers(),
nativeScanCode=event.nativeScanCode(),
nativeVirtualKey=event.nativeVirtualKey())
except Exception as err:
print(f"HCApplication.keyPressEvent error: {err}")
self.submitEvent(event, EventMode.Gui)
def keyPressEvent(self, event: QKeyEvent):
if event.key() == Qt.Key_Delete:
selected = self.selectionModel().selection()
""":type: QtGui.QItemSelection """
if selected.isEmpty():
return
min_row = numpy.min([rng.top() for rng in selected])
max_row = numpy.max([rng.bottom() for rng in selected])
self.deletion_wanted.emit(min_row, max_row)
else:
super().keyPressEvent(event)
def keyPressEvent(self, event: QKeyEvent):
"""
Must intercept invalid input events. Make changes here
Args:
event (TYPE): Description
"""
key = event.key()
if key in [Qt.Key_Backspace, Qt.Key_Delete]:
self.selectionbox.deleteSelection()
self.clearSelection(False)
return QGraphicsItemGroup.keyPressEvent(self, event)
else:
return QGraphicsItemGroup.keyPressEvent(self, event)
def keyPressEvent(self, event: QKeyEvent):
"""Must intercept invalid input events. Make changes here
"""
a = event.key()
text = event.text()
if a in [Qt.Key_Space, Qt.Key_Tab]:
return
elif a in [Qt.Key_Escape]:
self.updateLabel()
self.focusOut()
return
elif a in [Qt.Key_Return, Qt.Key_Enter]:
self.inputMethodEvent(event)
return
elif text.isalpha():
return
else:
return QGraphicsTextItem.keyPressEvent(self, event)
def cflagsListKeyPressed(self, event: QKeyEvent):
key = event.key()
if key == Qt.Key_Return or key == Qt.Key_Enter:
self.cFlagAddClicked(False)
def keyReleaseEvent(self, e: QKeyEvent):
self._handleEvent(Event(evType=Event.Type.KeyReleased,
key=e.key()))
def keyPressEvent(self, event: QKeyEvent):
if event.key() == Qt.Key_Enter or event.key() == Qt.Key_Return:
return
else:
super().keyPressEvent(event)
def keyPressEvent(self, event: QKeyEvent):
if event.key() == Qt.Key_Enter:
event.ignore()
else:
event.accept()
def keyPressEvent(self, event: QKeyEvent):
if event.key() == Qt.Key_F:
self.scene().views()[0].zoomToFit()
def keyPressEvent(self, event: QKeyEvent):
"""
Args:
event: Description
"""
self.prexoveritem_manager.handlePreXoverKeyPress(event.key())
def keyPressEvent(self, event: QKeyEvent):
if event.key() == Qt.Key_Delete:
min_row, max_row, start, end = self.selection_range()
if min_row == max_row == start == end == -1:
return
self.setEnabled(False)
self.setCursor(Qt.WaitCursor)
self.model().delete_range(min_row, max_row, start, end - 1)
self.unsetCursor()
self.setEnabled(True)
self.setFocus()
if event.matches(QKeySequence.Copy):
self.on_copy_action_triggered()
return
if event.key() == Qt.Key_Space:
min_row, max_row, start, _ = self.selection_range()
if start == -1:
return
self.model().insert_column(start, list(range(min_row, max_row + 1)))
if event.key() not in (Qt.Key_Right, Qt.Key_Left, Qt.Key_Up, Qt.Key_Down) \
or event.modifiers() == Qt.ShiftModifier:
super().keyPressEvent(event)
return
min_row, max_row, min_col, max_col = self.selection_range()
if min_row == max_row == min_col == max_col == -1:
super().keyPressEvent(event)
return
max_col -= 1
scroll_to_start = True
if event.key() == Qt.Key_Right and max_col < self.model().col_count - 1:
max_col += 1
min_col += 1
scroll_to_start = False
elif event.key() == Qt.Key_Left and min_col > 0:
min_col -= 1
max_col -= 1
elif event.key() == Qt.Key_Down and max_row < self.model().row_count - 1:
first_unhidden = -1
for row in range(max_row + 1, self.model().row_count):
if not self.isRowHidden(row):
first_unhidden = row
break
if first_unhidden != -1:
sel_len = max_row - min_row
max_row = first_unhidden
min_row = max_row - sel_len
scroll_to_start = False
elif event.key() == Qt.Key_Up and min_row > 0:
first_unhidden = -1
for row in range(min_row - 1, -1, -1):
if not self.isRowHidden(row):
first_unhidden = row
break
if first_unhidden != -1:
sel_len = max_row - min_row
min_row = first_unhidden
max_row = min_row + sel_len
start = self.model().index(min_row, min_col)
end = self.model().index(max_row, max_col)
selection = QItemSelection()
selection.select(start, end)
self.setCurrentIndex(start)
self.selectionModel().setCurrentIndex(end, QItemSelectionModel.ClearAndSelect)
self.selectionModel().select(selection, QItemSelectionModel.ClearAndSelect)
if scroll_to_start:
self.scrollTo(start)
else:
self.scrollTo(end)
