cola/widgets/text.py

   1 from __future__ import division, absolute_import, unicode_literals
   2
   3 from PyQt4 import QtGui, QtCore
   4 from PyQt4.QtCore import Qt, SIGNAL
   5
   6 from cola import qtutils
   7 from cola.compat import ustr
   8 from cola.i18n import N_
   9 from cola.models import prefs
  10 from cola.widgets import defs
  11
  12
  13 def get_value_stripped(widget):
  14     return widget.as_unicode().strip()
  15
  16
  17 class LineEdit(QtGui.QLineEdit):
  18
  19     def __init__(self, parent=None, row=1, get_value=None):
  20         QtGui.QLineEdit.__init__(self, parent)
  21         self._row = row
  22         if get_value is None:
  23             get_value = get_value_stripped
  24         self._get_value = get_value
  25         self.cursor_position = LineEditCursorPosition(self, row)
  26
  27     def value(self):
  28         return self._get_value(self)
  29
  30     def set_value(self, value, block=False):
  31         if block:
  32             blocksig = self.blockSignals(True)
  33         pos = self.cursorPosition()
  34         self.setText(value)
  35         self.setCursorPosition(pos)
  36         if block:
  37             self.blockSignals(blocksig)
  38
  39     def as_unicode(self):
  40         return ustr(self.text())
  41
  42     def reset_cursor(self):
  43         self.setCursorPosition(0)
  44
  45
  46 class LineEditCursorPosition(object):
  47     """Translate cursorPositionChanged(int,int) into cursorPosition(int,int)
  48     """
  49     def __init__(self, widget, row):
  50         self._widget = widget
  51         self._row = row
  52         # Translate cursorPositionChanged into cursorPosition
  53         widget.connect(widget, SIGNAL('cursorPositionChanged(int,int)'),
  54                        lambda old, new: self.emit())
  55
  56     def emit(self):
  57         widget = self._widget
  58         row = self._row
  59         col = widget.cursorPosition()
  60         widget.emit(SIGNAL('cursorPosition(int,int)'), row, col)
  61
  62     def reset(self):
  63         self._widget.setCursorPosition(0)
  64
  65
  66 class TextEdit(QtGui.QTextEdit):
  67
  68     def __init__(self, parent=None, get_value=None):
  69         QtGui.QTextEdit.__init__(self, parent)
  70         self.cursor_position = TextEditCursorPosition(self)
  71         if get_value is None:
  72             get_value = get_value_stripped
  73         self._get_value = get_value
  74         self._tabwidth = 8
  75         self.setMinimumSize(QtCore.QSize(1, 1))
  76         self.setLineWrapMode(QtGui.QTextEdit.NoWrap)
  77         self.setAcceptRichText(False)
  78         self.setCursorWidth(2)
  79
  80     def as_unicode(self):
  81         return ustr(self.toPlainText())
  82
  83     def value(self):
  84         return self._get_value(self)
  85
  86     def set_value(self, value, block=False):
  87         if block:
  88             blocksig = self.blockSignals(True)
  89         cursor = self.textCursor()
  90         self.setPlainText(value)
  91         self.setTextCursor(cursor)
  92         if block:
  93             self.blockSignals(blocksig)
  94
  95     def reset_cursor(self):
  96         cursor = self.textCursor()
  97         cursor.setPosition(0)
  98         self.setTextCursor(cursor)
  99
 100     def tabwidth(self):
 101         return self._tabwidth
 102
 103     def set_tabwidth(self, width):
 104         self._tabwidth = width
 105         font = self.font()
 106         fm = QtGui.QFontMetrics(font)
 107         pixels = fm.width('M' * width)
 108         self.setTabStopWidth(pixels)
 109
 110     def set_textwidth(self, width):
 111         font = self.font()
 112         fm = QtGui.QFontMetrics(font)
 113         pixels = fm.width('M' * (width + 1)) + 1
 114         self.setLineWrapColumnOrWidth(pixels)
 115
 116     def set_linebreak(self, brk):
 117         if brk:
 118             wrapmode = QtGui.QTextEdit.FixedPixelWidth
 119         else:
 120             wrapmode = QtGui.QTextEdit.NoWrap
 121         self.setLineWrapMode(wrapmode)
 122
 123     def selected_line(self):
 124         cursor = self.textCursor()
 125         offset = cursor.position()
 126         contents = ustr(self.toPlainText())
 127         while (offset >= 1
 128                 and contents[offset-1]
 129                 and contents[offset-1] != '\n'):
 130             offset -= 1
 131         data = contents[offset:]
 132         if '\n' in data:
 133             line, rest = data.split('\n', 1)
 134         else:
 135             line = data
 136         return line
 137
 138     def mousePressEvent(self, event):
 139         # Move the text cursor so that the right-click events operate
 140         # on the current position, not the last left-clicked position.
 141         if event.button() == Qt.RightButton:
 142             if not self.textCursor().hasSelection():
 143                 self.setTextCursor(self.cursorForPosition(event.pos()))
 144         QtGui.QTextEdit.mousePressEvent(self, event)
 145
 146
 147 class TextEditCursorPosition(object):
 148
 149     def __init__(self, widget):
 150         self._widget = widget
 151         widget.connect(widget, SIGNAL('cursorPositionChanged()'), self.emit)
 152
 153     def emit(self):
 154         widget = self._widget
 155         cursor = widget.textCursor()
 156         position = cursor.position()
 157         txt = widget.as_unicode()
 158         before = txt[:position]
 159         row = before.count('\n')
 160         line = before.split('\n')[row]
 161         col = cursor.columnNumber()
 162         col += line[:col].count('\t') * (widget.tabwidth() - 1)
 163         widget.emit(SIGNAL('cursorPosition(int,int)'), row+1, col)
 164
 165     def reset(self):
 166         widget = self._widget
 167         cursor = widget.textCursor()
 168         cursor.setPosition(0)
 169         widget.setTextCursor(cursor)
 170
 171
 172 def setup_mono_font(widget):
 173     widget.setFont(qtutils.diff_font())
 174     widget.set_tabwidth(prefs.tabwidth())
 175
 176
 177 def setup_readonly_flags(widget):
 178     widget.setAcceptDrops(False)
 179     widget.setTabChangesFocus(True)
 180     widget.setUndoRedoEnabled(False)
 181     widget.setTextInteractionFlags(Qt.TextSelectableByKeyboard |
 182                                    Qt.TextSelectableByMouse)
 183
 184
 185 class MonoTextEdit(TextEdit):
 186
 187     def __init__(self, parent):
 188         TextEdit.__init__(self, parent)
 189         setup_mono_font(self)
 190
 191
 192 class MonoTextView(MonoTextEdit):
 193
 194     def __init__(self, parent):
 195         MonoTextEdit.__init__(self, parent)
 196         setup_readonly_flags(self)
 197
 198
 199 def get_value_hinted(widget):
 200     text = get_value_stripped(widget)
 201     hint = widget.hint.value()
 202     if text == hint:
 203         return ''
 204     else:
 205         return text
 206
 207
 208 class HintWidget(QtCore.QObject):
 209     """Extend a widget to provide hint messages"""
 210
 211     def __init__(self, widget, hint):
 212         QtCore.QObject.__init__(self, widget)
 213         self._widget = widget
 214         self._hint = hint
 215         widget.installEventFilter(self)
 216
 217         # Palette for normal text
 218         self.default_palette = QtGui.QPalette(widget.palette())
 219
 220         # Palette used for the placeholder text
 221         self.hint_palette = pal = QtGui.QPalette(widget.palette())
 222         color = self.hint_palette.text().color()
 223         color.setAlpha(128)
 224         pal.setColor(QtGui.QPalette.Active, QtGui.QPalette.Text, color)
 225         pal.setColor(QtGui.QPalette.Inactive, QtGui.QPalette.Text, color)
 226
 227     def widget(self):
 228         """Return the parent text widget"""
 229         return self._widget
 230
 231     def active(self):
 232         """Return True when hint-mode is active"""
 233         return self.value() == get_value_stripped(self._widget)
 234
 235     def value(self):
 236         """Return the current hint text"""
 237         return self._hint
 238
 239     def set_value(self, hint):
 240         """Change the hint text"""
 241         # If hint-mode is currently active, re-activate it with the new text
 242         active = self.active()
 243         self._hint = hint
 244         if active or self.active():
 245             self.enable(True)
 246
 247     def enable(self, hint):
 248         """Enable/disable hint-mode"""
 249         if hint:
 250             self._widget.set_value(self.value(), block=True)
 251             self._widget.cursor_position.reset()
 252         else:
 253             self._widget.clear()
 254         self._enable_hint_palette(hint)
 255
 256     def refresh(self):
 257         """Update the palette to match the current mode"""
 258         self._enable_hint_palette(self.active())
 259
 260     def _enable_hint_palette(self, hint):
 261         """Enable/disable the hint-mode palette"""
 262         if hint:
 263             self._widget.setPalette(self.hint_palette)
 264         else:
 265             self._widget.setPalette(self.default_palette)
 266
 267     def eventFilter(self, obj, event):
 268         """Enable/disable hint-mode when focus changes"""
 269         etype = event.type()
 270         if etype == QtCore.QEvent.FocusIn:
 271             self._widget.hint.focus_in()
 272         elif etype == QtCore.QEvent.FocusOut:
 273             self._widget.hint.focus_out()
 274         return False
 275
 276     def focus_in(self):
 277         """Disable hint-mode when focused"""
 278         widget = self.widget()
 279         if self.active():
 280             self.enable(False)
 281         widget.cursor_position.emit()
 282
 283     def focus_out(self):
 284         """Re-enable hint-mode when losing focus"""
 285         widget = self.widget()
 286         if not bool(widget.value()):
 287             self.enable(True)
 288
 289
 290 class HintedTextEdit(TextEdit):
 291
 292     def __init__(self, hint, parent=None):
 293         TextEdit.__init__(self, parent=parent, get_value=get_value_hinted)
 294         self.hint = HintWidget(self, hint)
 295         setup_mono_font(self)
 296         # Refresh palettes when text changes
 297         self.connect(self, SIGNAL('textChanged()'), self.hint.refresh)
 298
 299
 300 # The read-only variant.
 301 class HintedTextView(HintedTextEdit):
 302
 303     def __init__(self, hint, parent=None):
 304         HintedTextEdit.__init__(self, hint, parent=parent)
 305         setup_readonly_flags(self)
 306
 307
 308 # The vim-like read-only text view
 309
 310 class VimMixin(object):
 311
 312     def __init__(self, base):
 313         self._base = base
 314         # Common vim/unix-ish keyboard actions
 315         self.add_navigation('Up', Qt.Key_K, shift=True)
 316         self.add_navigation('Down', Qt.Key_J, shift=True)
 317         self.add_navigation('Left', Qt.Key_H, shift=True)
 318         self.add_navigation('Right', Qt.Key_L, shift=True)
 319         self.add_navigation('WordLeft', Qt.Key_B)
 320         self.add_navigation('WordRight', Qt.Key_W)
 321         self.add_navigation('StartOfLine', Qt.Key_0)
 322         self.add_navigation('EndOfLine', Qt.Key_Dollar)
 323
 324         qtutils.add_action(self, 'PageUp',
 325                            lambda: self.page(-self.height()//2),
 326                            Qt.ShiftModifier + Qt.Key_Shift)
 327
 328         qtutils.add_action(self, 'PageDown',
 329                            lambda: self.page(self.height()//2),
 330                            Qt.Key_Space)
 331
 332     def add_navigation(self, name, hotkey, shift=False):
 333         """Add a hotkey along with a shift-variant"""
 334         direction = getattr(QtGui.QTextCursor, name)
 335         qtutils.add_action(self, name,
 336                            lambda: self.move(direction), hotkey)
 337         if shift:
 338             qtutils.add_action(self, 'Shift'+name,
 339                                lambda: self.move(direction, True),
 340                                Qt.ShiftModifier+hotkey)
 341
 342     def move(self, direction, select=False, n=1):
 343         cursor = self.textCursor()
 344         if select:
 345             mode = QtGui.QTextCursor.KeepAnchor
 346         else:
 347             mode = QtGui.QTextCursor.MoveAnchor
 348         if cursor.movePosition(direction, mode, n):
 349             self.set_text_cursor(cursor)
 350
 351     def page(self, offset):
 352         rect = self.cursorRect()
 353         x = rect.x()
 354         y = rect.y() + offset
 355         new_cursor = self.cursorForPosition(QtCore.QPoint(x, y))
 356         if new_cursor is not None:
 357             self.set_text_cursor(new_cursor)
 358
 359     def set_text_cursor(self, cursor):
 360         self.setTextCursor(cursor)
 361         self.ensureCursorVisible()
 362         self.viewport().update()
 363
 364     def keyPressEvent(self, event):
 365         """Custom keyboard behaviors
 366
 367         The leave() signal is emitted when `Up` is pressed and we're already
 368         at the beginning of the text.  This allows the parent widget to
 369         orchestrate some higher-level interaction, such as giving focus to
 370         another widget.
 371
 372         When in the  middle of the first line and `Up` is pressed, the cursor
 373         is moved to the beginning of the line.
 374
 375         """
 376         if event.key() == Qt.Key_Up:
 377             cursor = self.textCursor()
 378             position = cursor.position()
 379             if position == 0:
 380                 # The cursor is at the beginning of the line.
 381                 # Emit a signal so that the parent can e.g. change focus.
 382                 self.emit(SIGNAL('leave()'))
 383             elif self.value()[:position].count('\n') == 0:
 384                 # The cursor is in the middle of the first line of text.
 385                 # We can't go up ~ jump to the beginning of the line.
 386                 # Select the text if shift is pressed.
 387                 if event.modifiers() & Qt.ShiftModifier:
 388                     mode = QtGui.QTextCursor.KeepAnchor
 389                 else:
 390                     mode = QtGui.QTextCursor.MoveAnchor
 391                 cursor.movePosition(QtGui.QTextCursor.StartOfLine, mode)
 392                 self.setTextCursor(cursor)
 393
 394         return self._base.keyPressEvent(self, event)
 395
 396
 397 class VimHintedTextView(VimMixin, HintedTextView):
 398
 399     def __init__(self, hint='', parent=None):
 400         HintedTextView.__init__(self, hint, parent=parent)
 401         VimMixin.__init__(self, HintedTextView)
 402
 403
 404 class VimMonoTextView(VimMixin, MonoTextView):
 405
 406     def __init__(self, parent=None):
 407         MonoTextView.__init__(self, parent)
 408         VimMixin.__init__(self, MonoTextView)
 409
 410
 411 class HintedLineEdit(LineEdit):
 412
 413     def __init__(self, hint='', parent=None):
 414         LineEdit.__init__(self, parent=parent, get_value=get_value_hinted)
 415         self.hint = HintWidget(self, hint)
 416         self.setFont(qtutils.diff_font())
 417         self.connect(self, SIGNAL('textChanged(QString)'),
 418                      lambda text: self.hint.refresh())
 419
 420
 421 def text_dialog(text, title):
 422     """Show a wall of text in a dialog"""
 423     parent = qtutils.active_window()
 424     label = QtGui.QLabel(parent)
 425     label.setFont(qtutils.diff_font())
 426     label.setText(text)
 427     label.setTextInteractionFlags(Qt.NoTextInteraction)
 428
 429     widget = QtGui.QDialog(parent)
 430     widget.setWindowModality(Qt.WindowModal)
 431     widget.setWindowTitle(title)
 432
 433     layout = qtutils.hbox(defs.margin, defs.spacing, label)
 434     widget.setLayout(layout)
 435
 436     qtutils.add_action(widget, N_('Close'), widget.accept,
 437                        Qt.Key_Question, Qt.Key_Enter, Qt.Key_Return)
 438     widget.show()
 439     return widget