KTextEditor

kateviewinternal.cpp
1/*
2 This file is part of the KDE libraries
3 SPDX-FileCopyrightText: 2002 John Firebaugh <jfirebaugh@kde.org>
4 SPDX-FileCopyrightText: 2002 Joseph Wenninger <jowenn@kde.org>
5 SPDX-FileCopyrightText: 2002, 2003 Christoph Cullmann <cullmann@kde.org>
6 SPDX-FileCopyrightText: 2002-2007 Hamish Rodda <rodda@kde.org>
7 SPDX-FileCopyrightText: 2003 Anakim Border <aborder@sources.sourceforge.net>
8 SPDX-FileCopyrightText: 2007 Mirko Stocker <me@misto.ch>
9 SPDX-FileCopyrightText: 2007 Matthew Woehlke <mw_triad@users.sourceforge.net>
10 SPDX-FileCopyrightText: 2008 Erlend Hamberg <ehamberg@gmail.com>
11
12 Based on KWriteView:
13 SPDX-FileCopyrightText: 1999 Jochen Wilhelmy <digisnap@cs.tu-berlin.de>
14
15 SPDX-License-Identifier: LGPL-2.0-only
16*/
17#include "kateviewinternal.h"
18
19#include "kateabstractinputmode.h"
20#include "kateabstractinputmodefactory.h"
21#include "katebuffer.h"
22#include "katecompletionwidget.h"
23#include "kateconfig.h"
24#include "kateglobal.h"
25#include "katehighlight.h"
26#include "katelayoutcache.h"
27#include "katemessagewidget.h"
28#include "katepartdebug.h"
29#include "katerenderer.h"
30#include "katetextanimation.h"
31#include "katetextpreview.h"
32#include "kateview.h"
33#include "kateviewaccessible.h"
34#include "kateviewhelpers.h"
35#include "spellcheck/spellingmenu.h"
36
37#include <KCursor>
38#include <ktexteditor/documentcursor.h>
39#include <ktexteditor/inlinenoteprovider.h>
40#include <ktexteditor/movingrange.h>
41#include <ktexteditor/texthintinterface.h>
42
43#include <QAccessible>
44#include <QApplication>
45#include <QClipboard>
46#include <QKeyEvent>
47#include <QLayout>
48#include <QMenu>
49#include <QMimeData>
50#include <QPainter>
51#include <QPixmap>
52#include <QScopeGuard>
53#include <QScroller>
54#include <QStyle>
55#include <QToolTip>
56
57static const bool debugPainting = false;
58
59class ZoomEventFilter
60{
61public:
62 ZoomEventFilter() = default;
63
64 bool detectZoomingEvent(QWheelEvent *e, Qt::KeyboardModifiers modifier = Qt::ControlModifier)
65 {
66 Qt::KeyboardModifiers modState = e->modifiers();
67 if (modState == modifier) {
68 if (m_lastWheelEvent.isValid()) {
69 const qint64 deltaT = m_lastWheelEvent.elapsed();
70 // Pressing the specified modifier key within 200ms of the previous "unmodified"
71 // wheelevent is not allowed to toggle on text zooming
72 if (m_lastWheelEventUnmodified && deltaT < 200) {
73 m_ignoreZoom = true;
74 } else if (deltaT > 1000) {
75 // the protection is kept active for 1s after the last wheel event
76 // TODO: this value should be tuned, preferably by someone using
77 // Ctrl+Wheel zooming frequently.
78 m_ignoreZoom = false;
79 }
80 } else {
81 // we can't say anything and have to assume there's nothing
82 // accidental to the modifier being pressed.
83 m_ignoreZoom = false;
84 }
85 m_lastWheelEventUnmodified = false;
86 if (m_ignoreZoom) {
87 // unset the modifier so the view scrollbars can handle the scroll
88 // event and produce normal, not accelerated scrolling
89 modState &= ~modifier;
90 e->setModifiers(modState);
91 }
92 } else {
93 // state is reset after any wheel event without the zoom modifier
94 m_lastWheelEventUnmodified = true;
95 m_ignoreZoom = false;
96 }
97 m_lastWheelEvent.start();
98
99 // inform the caller whether this event is allowed to trigger text zooming.
100 return !m_ignoreZoom && modState == modifier;
101 }
102
103protected:
104 QElapsedTimer m_lastWheelEvent;
105 bool m_ignoreZoom = false;
106 bool m_lastWheelEventUnmodified = false;
107};
108
109KateViewInternal::KateViewInternal(KTextEditor::ViewPrivate *view)
110 : QWidget(view)
111 , editSessionNumber(0)
112 , editIsRunning(false)
113 , m_view(view)
114 , m_cursor(doc()->buffer(), KTextEditor::Cursor(0, 0), Kate::TextCursor::MoveOnInsert)
115 , m_mouse()
116 , m_possibleTripleClick(false)
117 , m_bm(doc()->newMovingRange(KTextEditor::Range::invalid(), KTextEditor::MovingRange::DoNotExpand))
118 , m_bmStart(doc()->newMovingRange(KTextEditor::Range::invalid(), KTextEditor::MovingRange::DoNotExpand))
119 , m_bmEnd(doc()->newMovingRange(KTextEditor::Range::invalid(), KTextEditor::MovingRange::DoNotExpand))
120 , m_bmLastFlashPos(doc()->newMovingCursor(KTextEditor::Cursor::invalid()))
121
122 // folding marker
123 , m_fmStart(doc()->newMovingRange(KTextEditor::Range::invalid(), KTextEditor::MovingRange::DoNotExpand))
124 , m_fmEnd(doc()->newMovingRange(KTextEditor::Range::invalid(), KTextEditor::MovingRange::DoNotExpand))
125
126 , m_dummy(nullptr)
127
128 // stay on cursor will avoid that the view scroll around on press return at beginning
129 , m_startPos(doc()->buffer(), KTextEditor::Cursor(0, 0), Kate::TextCursor::StayOnInsert)
130
131 , m_visibleLineCount(0)
132 , m_madeVisible(false)
133 , m_shiftKeyPressed(false)
134 , m_autoCenterLines(0)
135 , m_minLinesVisible(0)
136 , m_selChangedByUser(false)
137 , m_selectAnchor(-1, -1)
138 , m_selectionMode(Default)
139 , m_layoutCache(new KateLayoutCache(renderer(), this))
140 , m_preserveX(false)
141 , m_preservedX(0)
142 , m_cachedMaxStartPos(-1, -1)
143 , m_dragScrollTimer(this)
144 , m_scrollTimer(this)
145 , m_cursorTimer(this)
146 , m_textHintTimer(this)
147 , m_textHintDelay(500)
148 , m_textHintPos(-1, -1)
149 , m_imPreeditRange(nullptr)
150{
151 // setup input modes
152 Q_ASSERT(m_inputModes.size() == KTextEditor::EditorPrivate::self()->inputModeFactories().size());
153 m_inputModes[KTextEditor::View::NormalInputMode].reset(
154 KTextEditor::EditorPrivate::self()->inputModeFactories()[KTextEditor::View::NormalInputMode]->createInputMode(this));
155 m_inputModes[KTextEditor::View::ViInputMode].reset(
156 KTextEditor::EditorPrivate::self()->inputModeFactories()[KTextEditor::View::ViInputMode]->createInputMode(this));
157 m_currentInputMode = m_inputModes[KTextEditor::View::NormalInputMode].get();
158
159 setMinimumSize(0, 0);
160 setAttribute(Qt::WA_OpaquePaintEvent);
161 setAttribute(Qt::WA_InputMethodEnabled);
162
163 // invalidate m_selectionCached.start(), or keyb selection is screwed initially
164 m_selectionCached = KTextEditor::Range::invalid();
165
166 // bracket markers are only for this view and should not be printed
167 m_bm->setView(m_view);
168 m_bmStart->setView(m_view);
169 m_bmEnd->setView(m_view);
170 m_bm->setAttributeOnlyForViews(true);
171 m_bmStart->setAttributeOnlyForViews(true);
172 m_bmEnd->setAttributeOnlyForViews(true);
173
174 // use z depth defined in moving ranges interface
175 m_bm->setZDepth(-1000.0);
176 m_bmStart->setZDepth(-1000.0);
177 m_bmEnd->setZDepth(-1000.0);
178
179 // update mark attributes
180 updateBracketMarkAttributes();
181
182 //
183 // scrollbar for lines
184 //
185 m_lineScroll = new KateScrollBar(Qt::Vertical, this);
186 m_lineScroll->show();
187 m_lineScroll->setTracking(true);
188 m_lineScroll->setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Expanding);
189
190 // Hijack the line scroller's controls, so we can scroll nicely for word-wrap
191 connect(m_lineScroll, &KateScrollBar::actionTriggered, this, &KateViewInternal::scrollAction);
192
193 auto viewScrollLinesSlot = qOverload<int>(&KateViewInternal::scrollLines);
194 connect(m_lineScroll, &KateScrollBar::sliderMoved, this, viewScrollLinesSlot);
195 connect(m_lineScroll, &KateScrollBar::sliderMMBMoved, this, viewScrollLinesSlot);
196 connect(m_lineScroll, &KateScrollBar::valueChanged, this, viewScrollLinesSlot);
197
198 //
199 // scrollbar for columns
200 //
201 m_columnScroll = new QScrollBar(Qt::Horizontal, m_view);
202 m_scroller = QScroller::scroller(this);
207 0.2); // Workaround for QTBUG-88249 (non-flick gestures recognized as accelerating flick)
211 m_scroller->setScrollerProperties(prop);
212#ifndef Q_OS_MACOS
213 // On macOS the trackpad also emits touch events which are sometimes picked up by the flick
214 // gesture recogniser registered by QScroller; this results in some odd scrolling behaviour
215 // as described in bug #442060. Therefore it's better to not let the QScroller register
216 // it on that platform.
217 m_scroller->grabGesture(this);
218#endif
219
220 if (m_view->dynWordWrap()) {
221 m_columnScroll->hide();
222 } else {
223 m_columnScroll->show();
224 }
225
226 m_columnScroll->setTracking(true);
227 m_startX = 0;
228
229 connect(m_columnScroll, &QScrollBar::valueChanged, this, &KateViewInternal::scrollColumns);
230
231 // bottom corner box
232 m_dummy = new QWidget(m_view);
233 m_dummy->setFixedSize(m_lineScroll->width(), m_columnScroll->sizeHint().height());
234 m_dummy->setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed);
235
236 if (m_view->dynWordWrap()) {
237 m_dummy->hide();
238 } else {
239 m_dummy->show();
240 }
241
242 cache()->setWrap(m_view->dynWordWrap());
243
244 //
245 // iconborder ;)
246 //
247 m_leftBorder = new KateIconBorder(this, m_view);
248 m_leftBorder->show();
249
250 // update view if folding ranges change
251 connect(&m_view->textFolding(), &Kate::TextFolding::foldingRangesChanged, this, &KateViewInternal::slotRegionVisibilityChanged);
252
253 m_displayCursor.setPosition(0, 0);
254
255 setAcceptDrops(true);
256
257 m_zoomEventFilter.reset(new ZoomEventFilter());
258 // event filter
259 installEventFilter(this);
260
261 // set initial cursor
262 m_mouseCursor = Qt::IBeamCursor;
263 setCursor(m_mouseCursor);
264
265 // call mouseMoveEvent also if no mouse button is pressed
266 setMouseTracking(true);
267
268 m_dragInfo.state = diNone;
269
270 // timers
271 connect(&m_dragScrollTimer, &QTimer::timeout, this, &KateViewInternal::doDragScroll);
272
273 connect(&m_scrollTimer, &QTimer::timeout, this, &KateViewInternal::scrollTimeout);
274
275 connect(&m_cursorTimer, &QTimer::timeout, this, &KateViewInternal::cursorTimeout);
276
277 connect(&m_textHintTimer, &QTimer::timeout, this, &KateViewInternal::textHintTimeout);
278
279 // selection changed to set anchor
280 connect(m_view, &KTextEditor::ViewPrivate::selectionChanged, this, &KateViewInternal::viewSelectionChanged);
281
282#ifndef QT_NO_ACCESSIBILITY
283 QAccessible::installFactory(accessibleInterfaceFactory);
284#endif
285 connect(doc(), &KTextEditor::DocumentPrivate::textInsertedRange, this, &KateViewInternal::documentTextInserted);
286 connect(doc(), &KTextEditor::DocumentPrivate::textRemoved, this, &KateViewInternal::documentTextRemoved);
287
288 // update is called in KTextEditor::ViewPrivate, after construction and layout is over
289 // but before any other kateviewinternal call
290}
291
292KateViewInternal::~KateViewInternal()
293{
294#ifndef QT_NO_ACCESSIBILITY
295 QAccessible::removeFactory(accessibleInterfaceFactory);
296#endif
297
298 // delete text animation object here, otherwise it updates the view in its destructor
299 delete m_textAnimation;
300
301 // delete border here to not trigger crash later due to access to stuff in painting
302 delete m_leftBorder;
303 m_leftBorder = nullptr;
304}
305
306void KateViewInternal::dynWrapChanged()
307{
308 m_dummy->setFixedSize(m_lineScroll->width(), m_columnScroll->sizeHint().height());
309 if (view()->dynWordWrap()) {
310 m_columnScroll->hide();
311 m_dummy->hide();
312
313 } else {
314 // column scrollbar + bottom corner box
315 m_columnScroll->show();
316 m_dummy->show();
317 }
318
319 cache()->setWrap(view()->dynWordWrap());
320 updateView();
321
322 if (view()->dynWordWrap()) {
323 scrollColumns(0);
324 }
325
326 update();
327}
328
329KTextEditor::Cursor KateViewInternal::endPos() const
330{
331 // Hrm, no lines laid out at all??
332 if (!cache()->viewCacheLineCount()) {
333 return KTextEditor::Cursor();
334 }
335
336 for (int i = qMin(linesDisplayed() - 1, cache()->viewCacheLineCount() - 1); i >= 0; i--) {
337 const KateTextLayout &thisLine = cache()->viewLine(i);
338
339 if (thisLine.line() == -1) {
340 continue;
341 }
342
343 if (thisLine.virtualLine() >= view()->textFolding().visibleLines()) {
344 // Cache is too out of date
345 return KTextEditor::Cursor(view()->textFolding().visibleLines() - 1,
346 doc()->lineLength(view()->textFolding().visibleLineToLine(view()->textFolding().visibleLines() - 1)));
347 }
348
349 return KTextEditor::Cursor(thisLine.virtualLine(), thisLine.wrap() ? thisLine.endCol() - 1 : thisLine.endCol());
350 }
351
352 // can happen, if view is still invisible
353 return KTextEditor::Cursor();
354}
355
356int KateViewInternal::endLine() const
357{
358 return endPos().line();
359}
360
361KateTextLayout KateViewInternal::yToKateTextLayout(int y) const
362{
363 if (y < 0 || y > size().height()) {
364 return KateTextLayout::invalid();
365 }
366
367 int range = y / renderer()->lineHeight();
368
369 // lineRanges is always bigger than 0, after the initial updateView call
370 if (range >= 0 && range < cache()->viewCacheLineCount()) {
371 return cache()->viewLine(range);
372 }
373
374 return KateTextLayout::invalid();
375}
376
377int KateViewInternal::lineToY(int viewLine) const
378{
379 return (viewLine - startLine()) * renderer()->lineHeight();
380}
381
382void KateViewInternal::slotIncFontSizes(qreal step)
383{
384 renderer()->increaseFontSizes(step);
385}
386
387void KateViewInternal::slotDecFontSizes(qreal step)
388{
389 renderer()->decreaseFontSizes(step);
390}
391
392void KateViewInternal::slotResetFontSizes()
393{
394 renderer()->resetFontSizes();
395}
396
397/**
398 * Line is the real line number to scroll to.
399 */
400void KateViewInternal::scrollLines(int line)
401{
402 KTextEditor::Cursor newPos(line, 0);
403 scrollPos(newPos);
404}
405
406// This can scroll less than one true line
407void KateViewInternal::scrollViewLines(int offset)
408{
409 KTextEditor::Cursor c = viewLineOffset(startPos(), offset);
410 scrollPos(c);
411
412 bool blocked = m_lineScroll->blockSignals(true);
413 m_lineScroll->setValue(startLine());
414 m_lineScroll->blockSignals(blocked);
415}
416
417void KateViewInternal::scrollAction(int action)
418{
419 switch (action) {
421 scrollNextLine();
422 break;
423
425 scrollPrevLine();
426 break;
427
429 scrollNextPage();
430 break;
431
433 scrollPrevPage();
434 break;
435
437 top_home();
438 break;
439
441 bottom_end();
442 break;
443 }
444}
445
446void KateViewInternal::scrollNextPage()
447{
448 scrollViewLines(qMax(linesDisplayed() - 1, 0));
449}
450
451void KateViewInternal::scrollPrevPage()
452{
453 scrollViewLines(-qMax(linesDisplayed() - 1, 0));
454}
455
456void KateViewInternal::scrollPrevLine()
457{
458 scrollViewLines(-1);
459}
460
461void KateViewInternal::scrollNextLine()
462{
463 scrollViewLines(1);
464}
465
466KTextEditor::Cursor KateViewInternal::maxStartPos(bool changed)
467{
468 cache()->setAcceptDirtyLayouts(true);
469
470 if (m_cachedMaxStartPos.line() == -1 || changed) {
471 KTextEditor::Cursor end(view()->textFolding().visibleLines() - 1,
472 doc()->lineLength(view()->textFolding().visibleLineToLine(view()->textFolding().visibleLines() - 1)));
473
474 if (view()->config()->scrollPastEnd()) {
475 m_cachedMaxStartPos = viewLineOffset(end, -m_minLinesVisible);
476 } else {
477 m_cachedMaxStartPos = viewLineOffset(end, -(linesDisplayed() - 1));
478 }
479 }
480
481 cache()->setAcceptDirtyLayouts(false);
482
483 return m_cachedMaxStartPos;
484}
485
486// c is a virtual cursor
487void KateViewInternal::scrollPos(KTextEditor::Cursor &c, bool force, bool calledExternally, bool emitSignals)
488{
489 if (!force && ((!view()->dynWordWrap() && c.line() == startLine()) || c == startPos())) {
490 return;
491 }
492
493 if (c.line() < 0) {
494 c.setLine(0);
495 }
496
497 KTextEditor::Cursor limit = maxStartPos();
498 if (c > limit) {
499 c = limit;
500
501 // Re-check we're not just scrolling to the same place
502 if (!force && ((!view()->dynWordWrap() && c.line() == startLine()) || c == startPos())) {
503 return;
504 }
505 }
506
507 int viewLinesScrolled = 0;
508
509 // only calculate if this is really used and useful, could be wrong here, please recheck
510 // for larger scrolls this makes 2-4 seconds difference on my xeon with dyn. word wrap on
511 // try to get it really working ;)
512 bool viewLinesScrolledUsable = !force && (c.line() >= startLine() - linesDisplayed() - 1) && (c.line() <= endLine() + linesDisplayed() + 1);
513
514 if (viewLinesScrolledUsable) {
515 viewLinesScrolled = cache()->displayViewLine(c);
516 }
517
518 m_startPos.setPosition(c);
519
520 // set false here but reversed if we return to makeVisible
521 m_madeVisible = false;
522
523 if (viewLinesScrolledUsable) {
524 int lines = linesDisplayed();
525 if (view()->textFolding().visibleLines() < lines) {
526 KTextEditor::Cursor end(view()->textFolding().visibleLines() - 1,
527 doc()->lineLength(view()->textFolding().visibleLineToLine(view()->textFolding().visibleLines() - 1)));
528 lines = qMin(linesDisplayed(), cache()->displayViewLine(end) + 1);
529 }
530
531 Q_ASSERT(lines >= 0);
532
533 if (!calledExternally && qAbs(viewLinesScrolled) < lines &&
534 // NOTE: on some machines we must update if the floating widget is visible
535 // otherwise strange painting bugs may occur during scrolling...
536 !((view()->m_messageWidgets[KTextEditor::Message::TopInView] && view()->m_messageWidgets[KTextEditor::Message::TopInView]->isVisible())
537 || (view()->m_messageWidgets[KTextEditor::Message::CenterInView] && view()->m_messageWidgets[KTextEditor::Message::CenterInView]->isVisible())
538 || (view()->m_messageWidgets[KTextEditor::Message::BottomInView] && view()->m_messageWidgets[KTextEditor::Message::BottomInView]->isVisible()))) {
539 updateView(false, viewLinesScrolled);
540
541 int scrollHeight = -(viewLinesScrolled * (int)renderer()->lineHeight());
542
543 // scroll excluding child widgets (floating notifications)
544 scroll(0, scrollHeight, rect());
545 m_leftBorder->scroll(0, scrollHeight);
546
547 if (emitSignals) {
548 Q_EMIT view()->verticalScrollPositionChanged(m_view, c);
549 Q_EMIT view()->displayRangeChanged(m_view);
550 }
551 return;
552 }
553 }
554
555 updateView();
556 update();
557 m_leftBorder->update();
558 if (emitSignals) {
559 Q_EMIT view()->verticalScrollPositionChanged(m_view, c);
560 Q_EMIT view()->displayRangeChanged(m_view);
561 }
562}
563
564void KateViewInternal::scrollColumns(int x)
565{
566 if (x < 0) {
567 x = 0;
568 }
569
570 if (x > m_columnScroll->maximum()) {
571 x = m_columnScroll->maximum();
572 }
573
574 if (x == startX()) {
575 return;
576 }
577
578 int dx = startX() - x;
579 m_startX = x;
580
581 if (qAbs(dx) < width()) {
582 // scroll excluding child widgets (floating notifications)
583 scroll(dx, 0, rect());
584 } else {
585 update();
586 }
587
589 Q_EMIT view()->displayRangeChanged(m_view);
590
591 bool blocked = m_columnScroll->blockSignals(true);
592 m_columnScroll->setValue(startX());
593 m_columnScroll->blockSignals(blocked);
594}
595
596// If changed is true, the lines that have been set dirty have been updated.
597void KateViewInternal::updateView(bool changed, int viewLinesScrolled)
598{
599 if (!isVisible() && !viewLinesScrolled && !changed) {
600 return; // When this view is not visible, don't do anything
601 }
602
603 view()->doc()->delayAutoReload(); // Don't reload while user scrolls around
604 bool blocked = m_lineScroll->blockSignals(true);
605
606 int wrapWidth = width();
607 if (view()->config()->dynWrapAtStaticMarker() && view()->config()->dynWordWrap()) {
608 // We need to transform char count to a pixel width, stolen from PrintPainter::updateCache()
609 QString s;
610 s.fill(QLatin1Char('5'), view()->doc()->config()->wordWrapAt());
611 wrapWidth = qMin(width(), static_cast<int>(renderer()->currentFontMetrics().boundingRect(s).width()));
612 }
613
614 if (wrapWidth != cache()->viewWidth()) {
615 cache()->setViewWidth(wrapWidth);
616 changed = true;
617 }
618
619 /* It was observed that height() could be negative here --
620 when the main Kate view has 0 as size (during creation),
621 and there frame around KateViewInternal. In which
622 case we'd set the view cache to 0 (or less!) lines, and
623 start allocating huge chunks of data, later. */
624 int newSize = (qMax(0, height()) / renderer()->lineHeight()) + 1;
625 cache()->updateViewCache(startPos(), newSize, viewLinesScrolled);
626 m_visibleLineCount = newSize;
627
628 KTextEditor::Cursor maxStart = maxStartPos(changed);
629 int maxLineScrollRange = maxStart.line();
630 if (view()->dynWordWrap() && maxStart.column() != 0) {
631 maxLineScrollRange++;
632 }
633 m_lineScroll->setRange(0, maxLineScrollRange);
634
635 m_lineScroll->setValue(startLine());
636 m_lineScroll->setSingleStep(1);
637 m_lineScroll->setPageStep(qMax(0, height()) / renderer()->lineHeight());
638 m_lineScroll->blockSignals(blocked);
639
640 KateViewConfig::ScrollbarMode show_scrollbars = static_cast<KateViewConfig::ScrollbarMode>(view()->config()->showScrollbars());
641
642 bool visible = ((show_scrollbars == KateViewConfig::AlwaysOn) || ((show_scrollbars == KateViewConfig::ShowWhenNeeded) && (maxLineScrollRange != 0)));
643 bool visible_dummy = visible;
644
645 m_lineScroll->setVisible(visible);
646
647 if (!view()->dynWordWrap()) {
648 int max = maxLen(startLine()) - width();
649 if (max < 0) {
650 max = 0;
651 }
652
653 // if we lose the ability to scroll horizontally, move view to the far-left
654 if (max == 0) {
655 scrollColumns(0);
656 }
657
658 blocked = m_columnScroll->blockSignals(true);
659
660 // disable scrollbar
661 m_columnScroll->setDisabled(max == 0);
662
663 visible = ((show_scrollbars == KateViewConfig::AlwaysOn) || ((show_scrollbars == KateViewConfig::ShowWhenNeeded) && (max != 0)));
664 visible_dummy &= visible;
665 m_columnScroll->setVisible(visible);
666
667 m_columnScroll->setRange(0, max + (renderer()->spaceWidth() / 2)); // Add some space for the caret at EOL
668
669 m_columnScroll->setValue(startX());
670
671 // Approximate linescroll
672 m_columnScroll->setSingleStep(renderer()->currentFontMetrics().horizontalAdvance(QLatin1Char('a')));
673 m_columnScroll->setPageStep(width());
674
675 m_columnScroll->blockSignals(blocked);
676 } else {
677 visible_dummy = false;
678 }
679
680 m_dummy->setVisible(visible_dummy);
681
682 if (changed) {
683 updateDirty();
684 }
685}
686
687/**
688 * this function ensures a certain location is visible on the screen.
689 * if endCol is -1, ignore making the columns visible.
690 */
691void KateViewInternal::makeVisible(const KTextEditor::Cursor c, int endCol, bool force, bool center, bool calledExternally)
692{
693 // qCDebug(LOG_KTE) << "MakeVisible start " << startPos() << " end " << endPos() << " -> request: " << c;// , new start [" << scroll.line << "," <<
694 // scroll.col << "] lines " << (linesDisplayed() - 1) << " height " << height(); if the line is in a folded region, unfold all the way up if (
695 // doc()->foldingTree()->findNodeForLine( c.line )->visible )
696 // qCDebug(LOG_KTE)<<"line ("<<c.line<<") should be visible";
697
698 const int lnDisp = linesDisplayed();
699 const int viewLine = cache()->displayViewLine(c, true);
700 const bool curBelowScreen = (viewLine == -2);
701
702 if (force) {
704 scrollPos(scroll, force, calledExternally);
705 } else if (center && (c < startPos() || c > endPos())) {
706 KTextEditor::Cursor scroll = viewLineOffset(c, -int(lnDisp) / 2);
707 scrollPos(scroll, false, calledExternally);
708 } else if ((viewLine >= (lnDisp - m_minLinesVisible)) || (curBelowScreen)) {
709 KTextEditor::Cursor scroll = viewLineOffset(c, -(lnDisp - m_minLinesVisible - 1));
710 scrollPos(scroll, false, calledExternally);
711 } else if (c < viewLineOffset(startPos(), m_minLinesVisible)) {
712 KTextEditor::Cursor scroll = viewLineOffset(c, -m_minLinesVisible);
713 scrollPos(scroll, false, calledExternally);
714 } else {
715 // Check to see that we're not showing blank lines
716 KTextEditor::Cursor max = maxStartPos();
717 if (startPos() > max) {
718 scrollPos(max, max.column(), calledExternally);
719 }
720 }
721
722 if (!view()->dynWordWrap() && (endCol != -1 || view()->wrapCursor())) {
723 KTextEditor::Cursor rc = toRealCursor(c);
724 int sX = renderer()->cursorToX(cache()->textLayout(rc), rc, !view()->wrapCursor());
725
726 int sXborder = sX - 8;
727 if (sXborder < 0) {
728 sXborder = 0;
729 }
730
731 if (sX < startX()) {
732 scrollColumns(sXborder);
733 } else if (sX > startX() + width()) {
734 scrollColumns(sX - width() + 8);
735 }
736 }
737
738 m_madeVisible = !force;
739
740#ifndef QT_NO_ACCESSIBILITY
741 // FIXME -- is this needed?
742// QAccessible::updateAccessibility(this, KateCursorAccessible::ChildId, QAccessible::Focus);
743#endif
744}
745
746void KateViewInternal::slotRegionVisibilityChanged()
747{
748 qCDebug(LOG_KTE);
749
750 // ensure the layout cache is ok for the updateCursor calls below
751 // without the updateView() the view will jump to the bottom on hiding blocks after
752 // change cfb0af25bdfac0d8f86b42db0b34a6bc9f9a361e
753 cache()->clear();
754 updateView();
755
756 m_cachedMaxStartPos.setLine(-1);
757 KTextEditor::Cursor max = maxStartPos();
758 if (startPos() > max) {
759 scrollPos(max, false, false, false /* don't emit signals! */);
760 }
761
762 // if text was folded: make sure the cursor is on a visible line
763 qint64 foldedRangeId = -1;
764 if (!view()->textFolding().isLineVisible(m_cursor.line(), &foldedRangeId)) {
765 KTextEditor::Range foldingRange = view()->textFolding().foldingRange(foldedRangeId);
766 Q_ASSERT(foldingRange.start().isValid());
767
768 // set cursor to start of folding region
769 updateCursor(foldingRange.start(), true);
770 } else {
771 // force an update of the cursor, since otherwise the m_displayCursor
772 // line may be below the total amount of visible lines.
773 updateCursor(m_cursor, true);
774 }
775
776 updateView();
777 update();
778 m_leftBorder->update();
779
780 // emit signals here, scrollPos has this disabled, to ensure we do this after all stuff is updated!
781 Q_EMIT view()->verticalScrollPositionChanged(m_view, max);
782 Q_EMIT view()->displayRangeChanged(m_view);
783}
784
785void KateViewInternal::slotRegionBeginEndAddedRemoved(unsigned int)
786{
787 qCDebug(LOG_KTE);
788 // FIXME: performance problem
789 m_leftBorder->update();
790}
791
792void KateViewInternal::showEvent(QShowEvent *e)
793{
794 updateView();
795
797}
798
799KTextEditor::Attribute::Ptr KateViewInternal::attributeAt(const KTextEditor::Cursor position) const
800{
802 Kate::TextLine kateLine = doc()->kateTextLine(position.line());
803 *attrib = *m_view->renderer()->attribute(kateLine.attribute(position.column()));
804 return attrib;
805}
806
807int KateViewInternal::linesDisplayed() const
808{
809 int h = height();
810
811 // catch zero heights, even if should not happen
812 int fh = qMax(1, renderer()->lineHeight());
813
814 // default to 1, there is always one line around....
815 // too many places calc with linesDisplayed() - 1
816 return qMax(1, (h - (h % fh)) / fh);
817}
818
819QPoint KateViewInternal::cursorToCoordinate(const KTextEditor::Cursor cursor, bool realCursor, bool includeBorder) const
820{
821 if (cursor.line() >= doc()->lines()) {
822 return QPoint(-1, -1);
823 }
824
825 int viewLine = cache()->displayViewLine(realCursor ? toVirtualCursor(cursor) : cursor, true);
826
827 if (viewLine < 0 || viewLine >= cache()->viewCacheLineCount()) {
828 return QPoint(-1, -1);
829 }
830
831 const int y = (int)viewLine * renderer()->lineHeight();
832
833 KateTextLayout layout = cache()->viewLine(viewLine);
834
835 const auto textLength = doc()->lineLength(cursor.line());
836 if (cursor.column() > textLength) {
837 return QPoint(-1, -1);
838 }
839
840 int x = 0;
841
842 // only set x value if we have a valid layout (bug #171027)
843 if (layout.isValid()) {
844 if (!layout.isRightToLeft() || (layout.isRightToLeft() && view()->dynWordWrap())) {
845 x = (int)layout.lineLayout().cursorToX(cursor.column());
846 } else /* rtl + dynWordWrap == false */ {
847 // if text is rtl and dynamic wrap is false, the x offsets are in the opposite
848 // direction i.e., [0] == biggest offset, [1] = next
849 x = (int)layout.lineLayout().cursorToX(textLength - cursor.column());
850 }
851 }
852 // else
853 // qCDebug(LOG_KTE) << "Invalid Layout";
854
855 if (includeBorder) {
856 x += m_leftBorder->width();
857 }
858
859 x -= startX();
860
861 return QPoint(x, y);
862}
863
864QPoint KateViewInternal::cursorCoordinates(bool includeBorder) const
865{
866 return cursorToCoordinate(m_displayCursor, false, includeBorder);
867}
868
869KTextEditor::Cursor KateViewInternal::findMatchingBracket()
870{
872
873 if (!m_bm->toRange().isValid()) {
875 }
876
877 Q_ASSERT(m_bmEnd->toRange().isValid());
878 Q_ASSERT(m_bmStart->toRange().isValid());
879
880 // For e.g. the text "{|}" (where | is the cursor), m_bmStart is equal to [ (0, 0) -> (0, 1) ]
881 // and the closing bracket is in (0, 1). Thus, we check m_bmEnd first.
882 if (m_bmEnd->toRange().contains(m_cursor) || m_bmEnd->end() == m_cursor.toCursor()) {
883 c = m_bmStart->start();
884 } else if (m_bmStart->toRange().contains(m_cursor) || m_bmStart->end() == m_cursor.toCursor()) {
885 c = m_bmEnd->end();
886 // We need to adjust the cursor position in case of override mode, BUG-402594
887 if (doc()->config()->ovr()) {
888 c.setColumn(c.column() - 1);
889 }
890 } else {
891 // should never happen: a range exists, but the cursor position is
892 // neither at the start nor at the end...
894 }
895
896 return c;
897}
898
899class CalculatingCursor
900{
901public:
902 // These constructors constrain their arguments to valid positions
903 // before only the third one did, but that leads to crashes
904 // see bug 227449
905 CalculatingCursor(KateViewInternal *vi)
906 : m_vi(vi)
907 {
908 makeValid();
909 }
910
911 CalculatingCursor(KateViewInternal *vi, const KTextEditor::Cursor c)
912 : m_cursor(c)
913 , m_vi(vi)
914 {
915 makeValid();
916 }
917
918 CalculatingCursor(KateViewInternal *vi, int line, int col)
919 : m_cursor(line, col)
920 , m_vi(vi)
921 {
922 makeValid();
923 }
924
925 virtual ~CalculatingCursor()
926 {
927 }
928
929 int line() const
930 {
931 return m_cursor.line();
932 }
933
934 int column() const
935 {
936 return m_cursor.column();
937 }
938
939 operator KTextEditor::Cursor() const
940 {
941 return m_cursor;
942 }
943
944 virtual CalculatingCursor &operator+=(int n) = 0;
945
946 virtual CalculatingCursor &operator-=(int n) = 0;
947
948 CalculatingCursor &operator++()
949 {
950 return operator+=(1);
951 }
952
953 CalculatingCursor &operator--()
954 {
955 return operator-=(1);
956 }
957
958 void makeValid()
959 {
960 m_cursor.setLine(qBound(0, line(), int(doc()->lines() - 1)));
961 if (view()->wrapCursor()) {
962 m_cursor.setColumn(qBound(0, column(), doc()->lineLength(line())));
963 } else {
964 m_cursor.setColumn(qMax(0, column()));
965 }
966 Q_ASSERT(valid());
967 }
968
969 void toEdge(KateViewInternal::Bias bias)
970 {
971 if (bias == KateViewInternal::left) {
972 m_cursor.setColumn(0);
973 } else if (bias == KateViewInternal::right) {
974 m_cursor.setColumn(doc()->lineLength(line()));
975 }
976 }
977
978 bool atEdge() const
979 {
980 return atEdge(KateViewInternal::left) || atEdge(KateViewInternal::right);
981 }
982
983 bool atEdge(KateViewInternal::Bias bias) const
984 {
985 switch (bias) {
986 case KateViewInternal::left:
987 return column() == 0;
988 case KateViewInternal::none:
989 return atEdge();
990 case KateViewInternal::right:
991 return column() >= doc()->lineLength(line());
992 default:
993 Q_ASSERT(false);
994 return false;
995 }
996 }
997
998protected:
999 bool valid() const
1000 {
1001 return line() >= 0 && line() < doc()->lines() && column() >= 0 && (!view()->wrapCursor() || column() <= doc()->lineLength(line()));
1002 }
1003 KTextEditor::ViewPrivate *view()
1004 {
1005 return m_vi->m_view;
1006 }
1007 const KTextEditor::ViewPrivate *view() const
1008 {
1009 return m_vi->m_view;
1010 }
1011 KTextEditor::DocumentPrivate *doc()
1012 {
1013 return view()->doc();
1014 }
1015 const KTextEditor::DocumentPrivate *doc() const
1016 {
1017 return view()->doc();
1018 }
1019 KTextEditor::Cursor m_cursor;
1020 KateViewInternal *m_vi;
1021};
1022
1023class BoundedCursor final : public CalculatingCursor
1024{
1025public:
1026 BoundedCursor(KateViewInternal *vi)
1027 : CalculatingCursor(vi)
1028 {
1029 }
1030 BoundedCursor(KateViewInternal *vi, const KTextEditor::Cursor c)
1031 : CalculatingCursor(vi, c)
1032 {
1033 }
1034 BoundedCursor(KateViewInternal *vi, int line, int col)
1035 : CalculatingCursor(vi, line, col)
1036 {
1037 }
1038 CalculatingCursor &operator+=(int n) override
1039 {
1040 KateLineLayout *thisLine = m_vi->cache()->line(line());
1041 if (!thisLine || !thisLine->isValid()) {
1042 qCWarning(LOG_KTE) << "Did not retrieve valid layout for line " << line();
1043 return *this;
1044 }
1045
1046 const bool wrapCursor = view()->wrapCursor();
1047 int maxColumn = -1;
1048 if (n >= 0) {
1049 for (int i = 0; i < n; i++) {
1050 if (column() >= thisLine->length()) {
1051 if (wrapCursor) {
1052 break;
1053
1054 } else if (view()->dynWordWrap()) {
1055 // Don't go past the edge of the screen in dynamic wrapping mode
1056 if (maxColumn == -1) {
1057 maxColumn = thisLine->length() + ((m_vi->width() - thisLine->widthOfLastLine()) / m_vi->renderer()->spaceWidth()) - 1;
1058 }
1059
1060 if (column() >= maxColumn) {
1061 m_cursor.setColumn(maxColumn);
1062 break;
1063 }
1064
1065 m_cursor.setColumn(column() + 1);
1066
1067 } else {
1068 m_cursor.setColumn(column() + 1);
1069 }
1070
1071 } else {
1072 m_cursor.setColumn(thisLine->layout()->nextCursorPosition(column()));
1073 }
1074 }
1075 } else {
1076 for (int i = 0; i > n; i--) {
1077 if (column() >= thisLine->length()) {
1078 m_cursor.setColumn(column() - 1);
1079 } else if (column() == 0) {
1080 break;
1081 } else {
1082 m_cursor.setColumn(thisLine->layout()->previousCursorPosition(column()));
1083 }
1084 }
1085 }
1086
1087 Q_ASSERT(valid());
1088 return *this;
1089 }
1090 CalculatingCursor &operator-=(int n) override
1091 {
1092 return operator+=(-n);
1093 }
1094};
1095
1096class WrappingCursor final : public CalculatingCursor
1097{
1098public:
1099 WrappingCursor(KateViewInternal *vi)
1100 : CalculatingCursor(vi)
1101 {
1102 }
1103 WrappingCursor(KateViewInternal *vi, const KTextEditor::Cursor c)
1104 : CalculatingCursor(vi, c)
1105 {
1106 }
1107 WrappingCursor(KateViewInternal *vi, int line, int col)
1108 : CalculatingCursor(vi, line, col)
1109 {
1110 }
1111
1112 CalculatingCursor &operator+=(int n) override
1113 {
1114 KateLineLayout *thisLine = m_vi->cache()->line(line());
1115 if (!thisLine || !thisLine->isValid()) {
1116 qCWarning(LOG_KTE) << "Did not retrieve a valid layout for line " << line();
1117 return *this;
1118 }
1119
1120 if (n >= 0) {
1121 for (int i = 0; i < n; i++) {
1122 if (column() >= thisLine->length()) {
1123 // Have come to the end of a line
1124 if (line() >= doc()->lines() - 1)
1125 // Have come to the end of the document
1126 {
1127 break;
1128 }
1129
1130 // Advance to the beginning of the next line
1131 m_cursor.setColumn(0);
1132 m_cursor.setLine(line() + 1);
1133
1134 // Retrieve the next text range
1135 thisLine = m_vi->cache()->line(line());
1136 if (!thisLine || !thisLine->isValid()) {
1137 qCWarning(LOG_KTE) << "Did not retrieve a valid layout for line " << line();
1138 return *this;
1139 }
1140
1141 continue;
1142 }
1143
1144 m_cursor.setColumn(thisLine->layout()->nextCursorPosition(column()));
1145 }
1146
1147 } else {
1148 for (int i = 0; i > n; i--) {
1149 if (column() == 0) {
1150 // Have come to the start of the document
1151 if (line() == 0) {
1152 break;
1153 }
1154
1155 // Start going back to the end of the last line
1156 m_cursor.setLine(line() - 1);
1157
1158 // Retrieve the next text range
1159 thisLine = m_vi->cache()->line(line());
1160 if (!thisLine || !thisLine->isValid()) {
1161 qCWarning(LOG_KTE) << "Did not retrieve a valid layout for line " << line();
1162 return *this;
1163 }
1164
1165 // Finish going back to the end of the last line
1166 m_cursor.setColumn(thisLine->length());
1167
1168 continue;
1169 }
1170
1171 if (column() > thisLine->length()) {
1172 m_cursor.setColumn(column() - 1);
1173 } else {
1174 m_cursor.setColumn(thisLine->layout()->previousCursorPosition(column()));
1175 }
1176 }
1177 }
1178
1179 Q_ASSERT(valid());
1180 return *this;
1181 }
1182 CalculatingCursor &operator-=(int n) override
1183 {
1184 return operator+=(-n);
1185 }
1186};
1187
1188/**
1189 * @brief The CamelCursor class
1190 *
1191 * This class allows for "camel humps" when moving the cursor
1192 * using Ctrl + Left / Right. Similarly, this will also get triggered
1193 * when you press Ctrl+Shift+Left/Right for selection and Ctrl+Del
1194 * Ctrl + backspace for deletion.
1195 *
1196 * It is absoloutely essential that if you move through a word in 'n'
1197 * jumps, you should be able to move back with exactly same 'n' movements
1198 * which you made when moving forward. Example:
1199 *
1200 * Word: KateViewInternal
1201 *
1202 * Moving cursor towards right while holding control will result in cursor
1203 * landing in the following places (assuming you start from column 0)
1204 *
1205 * | | |
1206 * KateViewInternal
1207 *
1208 * Moving the cursor back to get to the starting position should also
1209 * take exactly 3 movements:
1210 *
1211 * | | |
1212 * KateViewInternal
1213 *
1214 * In addition to simple camel case, this class also handles snake_case
1215 * capitalized snake, and mixtures of Camel + snake/underscore, for example
1216 * m_someMember. If a word has underscores in it, for example:
1217 *
1218 * snake_case_word
1219 *
1220 * the leading underscore is considered part of the word and thus a cursor
1221 * movement will land right after the underscore. Moving the cursor to end
1222 * for the above word should be like this:
1223 *
1224 * startpos: 0
1225 * | | |
1226 * snake_case_word
1227 *
1228 * When jumping back to startpos, exact same "spots" need to be hit on your way
1229 * back.
1230 *
1231 * If a word has multiple leading underscores: snake___case, the underscores will
1232 * be considered part of the word and thus a jump wil land us "after" the last underscore.
1233 *
1234 * There are some other variations in this, for example Capitalized words, or identifiers
1235 * with numbers in betweens. For such cases, All capitalized words are skipped in one go
1236 * till we are on some "non-capitalized" word. In this context, a number is a non-capitalized
1237 * word so will break the jump. Examples:
1238 *
1239 * | |
1240 * W1RD
1241 *
1242 * but for WORD_CAPITAL, following will happen:
1243 *
1244 * | |
1245 * WORD_CAPITAL
1246 *
1247 * The first case here is tricky to handle for reverse movement. I haven't noticed any
1248 * cases which the current implementation is unable to handle but there might be some.
1249 *
1250 * With languages like PHP where you have $ as part of the identifier, the cursor jump
1251 * will break "after" dollar. Consider: $phpVar, Following will happen:
1252 *
1253 * | | |
1254 * $phpVar
1255 *
1256 * And of course, the reverse will be exact opposite.
1257 *
1258 * Similar to PHP, with CSS Colors, jump will break on '#' charachter
1259 *
1260 * Please see the test cases testWordMovementSingleRow() for more examples/data.
1261 *
1262 * It is absoloutely essential to know that this class *only* gets triggered for
1263 * cursor movement if we are in a word.
1264 *
1265 * Note to bugfixer: If some bug occurs, before changing anything please add a test
1266 * case for the bug and make sure everything passes before and after. The test case
1267 * for this can be found autotests/src/camelcursortest.cpp.
1268 *
1269 * @author Waqar Ahmed <waqar.17a@gmail.com>
1270 */
1271class CamelCursor final : public CalculatingCursor
1272{
1273public:
1274 CamelCursor(KateViewInternal *vi, const KTextEditor::Cursor c)
1275 : CalculatingCursor(vi, c)
1276 {
1277 }
1278
1279 CalculatingCursor &operator+=(int n) override
1280 {
1281 KateLineLayout *thisLine = m_vi->cache()->line(line());
1282 if (!thisLine || !thisLine->isValid()) {
1283 qCWarning(LOG_KTE) << "Did not retrieve valid layout for line " << line();
1284 return *this;
1285 }
1286
1287 auto isSurrogate = [](QChar c) {
1288 return c.isLowSurrogate() || c.isHighSurrogate();
1289 };
1290
1291 if (n >= 0) {
1292 auto skipCaps = [](QStringView text, int &col) {
1293 int count = 0;
1294 while (col < text.size() && text.at(col).isUpper()) {
1295 ++count;
1296 ++col;
1297 }
1298 // if this is a letter, then it means we are in the
1299 // middle of a word, step back one position so that
1300 // we are at the last Cap letter
1301 // Otherwise, it's an all cap word
1302 if (count > 1 && col < text.size() && text.at(col).isLetterOrNumber()) {
1303 --col;
1304 }
1305 };
1306
1307 int jump = -1;
1308 int col = column();
1309 const QString &text = thisLine->textLine().text();
1310
1311 if (col < text.size() && text.at(col).isUpper()) {
1312 skipCaps(text, col);
1313 }
1314
1315 for (int i = col; i < thisLine->length(); ++i) {
1316 const auto c = text.at(i);
1317 if (isSurrogate(c)) {
1318 col++;
1319 continue;
1320 } else if (c.isUpper() || !c.isLetterOrNumber()) {
1321 break;
1322 }
1323 ++col;
1324 }
1325
1326 // eat any '_' that are after the word BEFORE any space happens
1327 if (col < text.size() && text.at(col) == QLatin1Char('_')) {
1328 while (col < text.size() && text.at(col) == QLatin1Char('_')) {
1329 ++col;
1330 }
1331 }
1332
1333 // Underscores eaten, so now eat any spaces till next word
1334 if (col < text.size() && text.at(col).isSpace()) {
1335 while (col < text.size() && text.at(col).isSpace()) {
1336 ++col;
1337 }
1338 }
1339
1340 jump = col < 0 || (column() == col) ? (column() + 1) : col;
1341 m_cursor.setColumn(jump);
1342 } else {
1343 int jump = -1;
1344
1345 auto skipCapsRev = [](QStringView text, int &col) {
1346 int count = 0;
1347 while (col > 0 && text.at(col).isUpper()) {
1348 ++count;
1349 --col;
1350 }
1351
1352 // if more than one cap found, and current
1353 // column is not upper, we want to move ahead
1354 // to the upper
1355 if (count >= 1 && col >= 0 && !text.at(col).isUpper()) {
1356 ++col;
1357 }
1358 };
1359
1360 const QString &text = thisLine->textLine().text();
1361 int col = std::min<int>(column(), text.size() - 1);
1362 // decrement because we might be standing at a camel hump
1363 // already and don't want to return the same position
1364 col = col - 1;
1365
1366 // if we are at the end of line
1367 if (column() == text.size()) {
1368 // there is a letter before
1369 if (text.at(col + 1).isLetter()) {
1370 // and a space before that
1371 if (col >= 0 && text.at(col).isSpace()) {
1372 // we have a one letter word,
1373 // so move forward to end of word
1374 ++col;
1375 }
1376 }
1377 }
1378
1379 // skip any spaces
1380 if (col > 0 && text.at(col).isSpace()) {
1381 while (text.at(col).isSpace() && col > 0) {
1382 --col;
1383 }
1384 }
1385
1386 // Skip Underscores
1387 if (col > 0 && text.at(col) == QLatin1Char('_')) {
1388 while (col > 0 && text.at(col) == QLatin1Char('_')) {
1389 --col;
1390 }
1391 }
1392
1393 if (col > 0 && text.at(col).isUpper()) {
1394 skipCapsRev(text, col);
1395 }
1396
1397 for (int i = col; i > 0; --i) {
1398 const auto c = text.at(i);
1399 if (isSurrogate(c)) {
1400 --col;
1401 continue;
1402 } else if (c.isUpper() || !c.isLetterOrNumber()) {
1403 break;
1404 }
1405 --col;
1406 }
1407
1408 if (col >= 0 && !text.at(col).isLetterOrNumber() && !isSurrogate(text.at(col))) {
1409 ++col;
1410 }
1411
1412 if (col < 0) {
1413 jump = 0;
1414 } else if (col == column() && column() > 0) {
1415 jump = column() - 1;
1416 } else {
1417 jump = col;
1418 }
1419
1420 m_cursor.setColumn(jump);
1421 }
1422
1423 Q_ASSERT(valid());
1424 return *this;
1425 }
1426
1427 CalculatingCursor &operator-=(int n) override
1428 {
1429 return operator+=(-n);
1430 }
1431};
1432
1433void KateViewInternal::moveChar(KateViewInternal::Bias bias, bool sel)
1434{
1436 if (view()->wrapCursor()) {
1437 c = WrappingCursor(this, m_cursor) += bias;
1438 } else {
1439 c = BoundedCursor(this, m_cursor) += bias;
1440 }
1441
1442 const auto &sc = view()->m_secondaryCursors;
1444 const int lastLine = doc()->lastLine();
1445 bool shouldEnsureUniqueCursors = false;
1446 for (const auto &c : sc) {
1447 auto oldPos = c.cursor();
1448 if (view()->wrapCursor()) {
1449 c.pos->setPosition(WrappingCursor(this, oldPos) += bias);
1450 } else {
1451 c.pos->setPosition(BoundedCursor(this, oldPos) += bias);
1452 }
1453 const auto newPos = c.pos->toCursor();
1454 multiCursors.push_back({.oldPos=oldPos, .newPos=newPos});
1455 // We only need to do this if cursors were in first or last line
1456 if (!shouldEnsureUniqueCursors) {
1457 shouldEnsureUniqueCursors = newPos.line() == 0 || newPos.line() == lastLine;
1458 }
1459 }
1460
1461 updateSelection(c, sel);
1462 updateCursor(c);
1463 updateSecondaryCursors(multiCursors, sel);
1464 if (shouldEnsureUniqueCursors) {
1465 view()->ensureUniqueCursors();
1466 }
1467}
1468
1469void KateViewInternal::cursorPrevChar(bool sel)
1470{
1471 if (!view()->wrapCursor() && m_cursor.column() == 0) {
1472 return;
1473 }
1474
1475 moveChar(KateViewInternal::left, sel);
1476}
1477
1478void KateViewInternal::cursorNextChar(bool sel)
1479{
1480 moveChar(KateViewInternal::right, sel);
1481}
1482
1483void KateViewInternal::wordPrev(bool sel)
1484{
1485 auto characterAtPreviousColumn = [this](KTextEditor::Cursor cursor) -> QChar {
1486 return doc()->characterAt({cursor.line(), cursor.column() - 1});
1487 };
1488
1489 auto wordPrevious = [this, &characterAtPreviousColumn](KTextEditor::Cursor cursor) -> KTextEditor::Cursor {
1490 WrappingCursor c(this, cursor);
1491
1492 // First we skip backwards all space.
1493 // Then we look up into which category the current position falls:
1494 // 1. a "word" character
1495 // 2. a "non-word" character (except space)
1496 // 3. the beginning of the line
1497 // and skip all preceding characters that fall into this class.
1498 // The code assumes that space is never part of the word character class.
1499
1500 KateHighlighting *h = doc()->highlight();
1501
1502 while (!c.atEdge(left) && (c.column() > doc()->lineLength(c.line()) || characterAtPreviousColumn(c).isSpace())) {
1503 --c;
1504 }
1505
1506 if (c.atEdge(left)) {
1507 --c;
1508 } else if (h->isInWord(characterAtPreviousColumn(c))) {
1509 if (doc()->config()->camelCursor()) {
1510 CamelCursor cc(this, cursor);
1511 --cc;
1512 return cc;
1513 } else {
1514 while (!c.atEdge(left) && h->isInWord(characterAtPreviousColumn(c))) {
1515 --c;
1516 }
1517 }
1518 } else {
1519 while (!c.atEdge(left)
1520 && !h->isInWord(characterAtPreviousColumn(c))
1521 // in order to stay symmetric to wordLeft()
1522 // we must not skip space preceding a non-word sequence
1523 && !characterAtPreviousColumn(c).isSpace()) {
1524 --c;
1525 }
1526 }
1527
1528 return c;
1529 };
1530
1531 const auto &secondaryCursors = view()->m_secondaryCursors;
1532 QVarLengthArray<CursorPair, 16> cursorsToUpdate;
1533 for (const auto &cursor : secondaryCursors) {
1534 auto oldPos = cursor.cursor();
1535 auto newCursorPos = wordPrevious(cursor.cursor());
1536 cursor.pos->setPosition(newCursorPos);
1537 cursorsToUpdate.push_back({.oldPos=oldPos, .newPos=newCursorPos});
1538 }
1539
1540 // update primary cursor
1541 const auto c = wordPrevious(m_cursor);
1542 updateSelection(c, sel);
1543 updateCursor(c);
1544
1545 if (!sel) {
1546 view()->ensureUniqueCursors();
1547 }
1548 updateSecondaryCursors(cursorsToUpdate, sel);
1549}
1550
1551void KateViewInternal::wordNext(bool sel)
1552{
1553 auto nextWord = [this](KTextEditor::Cursor cursor) -> KTextEditor::Cursor {
1554 WrappingCursor c(this, cursor);
1555
1556 // We look up into which category the current position falls:
1557 // 1. a "word" character
1558 // 2. a "non-word" character (except space)
1559 // 3. the end of the line
1560 // and skip all following characters that fall into this class.
1561 // If the skipped characters are followed by space, we skip that too.
1562 // The code assumes that space is never part of the word character class.
1563
1564 KateHighlighting *h = doc()->highlight();
1565 if (c.atEdge(right)) {
1566 ++c;
1567 } else if (h->isInWord(doc()->characterAt(c))) {
1568 if (doc()->config()->camelCursor()) {
1569 CamelCursor cc(this, cursor);
1570 ++cc;
1571 return cc;
1572 } else {
1573 while (!c.atEdge(right) && h->isInWord(doc()->characterAt(c))) {
1574 ++c;
1575 }
1576 }
1577 } else {
1578 while (!c.atEdge(right)
1579 && !h->isInWord(doc()->characterAt(c))
1580 // we must not skip space, because if that space is followed
1581 // by more non-word characters, we would skip them, too
1582 && !doc()->characterAt(c).isSpace()) {
1583 ++c;
1584 }
1585 }
1586
1587 while (!c.atEdge(right) && doc()->characterAt(c).isSpace()) {
1588 ++c;
1589 }
1590
1591 return c;
1592 };
1593
1594 const auto &secondaryCursors = view()->m_secondaryCursors;
1595 QVarLengthArray<CursorPair, 16> cursorsToUpdate;
1596 for (const auto &cursor : secondaryCursors) {
1597 auto oldPos = cursor.cursor();
1598 auto newCursorPos = nextWord(cursor.cursor());
1599 cursor.pos->setPosition(newCursorPos);
1600 cursorsToUpdate.push_back({.oldPos=oldPos, .newPos=newCursorPos});
1601 }
1602
1603 // update primary cursor
1604 const auto c = nextWord(m_cursor);
1605 updateSelection(c, sel);
1606 updateCursor(c);
1607
1608 // Remove cursors which have same position
1609 if (!sel) {
1610 view()->ensureUniqueCursors();
1611 }
1612 updateSecondaryCursors(cursorsToUpdate, sel);
1613}
1614
1615void KateViewInternal::moveEdge(KateViewInternal::Bias bias, bool sel)
1616{
1617 BoundedCursor c(this, m_cursor);
1618 c.toEdge(bias);
1619 updateSelection(c, sel);
1620 updateCursor(c);
1621}
1622
1623KTextEditor::Cursor KateViewInternal::moveCursorToLineStart(KTextEditor::Cursor cursor)
1624{
1625 if (view()->dynWordWrap() && currentLayout(cursor).startCol()) {
1626 // Allow us to go to the real start if we're already at the start of the view line
1627 if (cursor.column() != currentLayout(cursor).startCol()) {
1628 KTextEditor::Cursor c = currentLayout(cursor).start();
1629 return c;
1630 }
1631 }
1632
1633 if (!doc()->config()->smartHome()) {
1634 BoundedCursor c(this, cursor);
1635 c.toEdge(left);
1636 return c;
1637 }
1638
1639 if (cursor.line() < 0 || cursor.line() >= doc()->lines()) {
1641 }
1642
1643 Kate::TextLine l = doc()->kateTextLine(cursor.line());
1644
1646 int lc = l.firstChar();
1647
1648 if (lc < 0 || c.column() == lc) {
1649 c.setColumn(0);
1650 } else {
1651 c.setColumn(lc);
1652 }
1653 return c;
1654}
1655
1656void KateViewInternal::home(bool sel)
1657{
1658 // Multicursor
1659 view()->ensureUniqueCursors(/*matchLine*/ true);
1660 const auto &secondaryCursors = view()->m_secondaryCursors;
1661 QVarLengthArray<CursorPair, 16> cursorsToUpdate;
1662 for (const auto &c : secondaryCursors) {
1663 auto oldPos = c.cursor();
1664 // These will end up in same place so just remove
1665 auto newPos = moveCursorToLineStart(oldPos);
1666 c.pos->setPosition(newPos);
1667 cursorsToUpdate.push_back({.oldPos=oldPos, .newPos=newPos});
1668 }
1669
1670 // Primary cursor
1671 auto newPos = moveCursorToLineStart(m_cursor);
1672 if (newPos.isValid()) {
1673 updateSelection(newPos, sel);
1674 updateCursor(newPos, true);
1675 }
1676 updateSecondaryCursors(cursorsToUpdate, sel);
1677}
1678
1679KTextEditor::Cursor KateViewInternal::moveCursorToLineEnd(KTextEditor::Cursor cursor)
1680{
1681 KateTextLayout layout = currentLayout(cursor);
1682
1683 if (view()->dynWordWrap() && layout.wrap()) {
1684 // Allow us to go to the real end if we're already at the end of the view line
1685 if (cursor.column() < layout.endCol() - 1) {
1686 KTextEditor::Cursor c(cursor.line(), layout.endCol() - 1);
1687 return c;
1688 }
1689 }
1690
1691 if (!doc()->config()->smartHome()) {
1692 BoundedCursor c(this, cursor);
1693 c.toEdge(right);
1694 return c;
1695 }
1696
1697 if (cursor.line() < 0 || cursor.line() >= doc()->lines()) {
1699 }
1700
1701 Kate::TextLine l = doc()->kateTextLine(cursor.line());
1702
1703 // "Smart End", as requested in bugs #78258 and #106970
1704 if (cursor.column() == doc()->lineLength(cursor.line())) {
1706 c.setColumn(l.lastChar() + 1);
1707 return c;
1708 } else {
1709 BoundedCursor c(this, cursor);
1710 c.toEdge(right);
1711 return c;
1712 }
1713}
1714
1715void KateViewInternal::end(bool sel)
1716{
1717 // Multicursor
1718 view()->ensureUniqueCursors(/*matchLine*/ true);
1719
1720 QVarLengthArray<CursorPair, 16> cursorsToUpdate;
1721 const auto &secondaryCursors = view()->m_secondaryCursors;
1722 for (const auto &c : secondaryCursors) {
1723 auto oldPos = c.cursor();
1724 // These will end up in same place so just remove
1725 auto newPos = moveCursorToLineEnd(oldPos);
1726 c.pos->setPosition(newPos);
1727 cursorsToUpdate.push_back({.oldPos=oldPos, .newPos=newPos});
1728 }
1729
1730 auto newPos = moveCursorToLineEnd(m_cursor);
1731 if (newPos.isValid()) {
1732 updateSelection(newPos, sel);
1733 updateCursor(newPos);
1734 }
1735
1736 updateSecondaryCursors(cursorsToUpdate, sel);
1737 paintCursor();
1738}
1739
1740KateTextLayout KateViewInternal::currentLayout(KTextEditor::Cursor c) const
1741{
1742 return cache()->textLayout(c);
1743}
1744
1745KateTextLayout KateViewInternal::previousLayout(KTextEditor::Cursor c) const
1746{
1747 int currentViewLine = cache()->viewLine(c);
1748
1749 if (currentViewLine) {
1750 return cache()->textLayout(c.line(), currentViewLine - 1);
1751 } else {
1752 return cache()->textLayout(view()->textFolding().visibleLineToLine(toVirtualCursor(c).line() - 1), -1);
1753 }
1754}
1755
1756KateTextLayout KateViewInternal::nextLayout(KTextEditor::Cursor c) const
1757{
1758 int currentViewLine = cache()->viewLine(c) + 1;
1759
1760 const KateLineLayout *thisLine = cache()->line(c.line());
1761 if (thisLine && currentViewLine >= thisLine->viewLineCount()) {
1762 currentViewLine = 0;
1763 return cache()->textLayout(view()->textFolding().visibleLineToLine(toVirtualCursor(c).line() + 1), currentViewLine);
1764 } else {
1765 return cache()->textLayout(c.line(), currentViewLine);
1766 }
1767}
1768
1769/*
1770 * This returns the cursor which is offset by (offset) view lines.
1771 * This is the main function which is called by code not specifically dealing with word-wrap.
1772 * The opposite conversion (cursor to offset) can be done with cache()->displayViewLine().
1773 *
1774 * The cursors involved are virtual cursors (ie. equivalent to m_displayCursor)
1775 */
1776
1777KTextEditor::Cursor KateViewInternal::viewLineOffset(const KTextEditor::Cursor virtualCursor, int offset, bool keepX)
1778{
1779 if (!view()->dynWordWrap()) {
1780 KTextEditor::Cursor ret(qMin((int)view()->textFolding().visibleLines() - 1, virtualCursor.line() + offset), 0);
1781
1782 if (ret.line() < 0) {
1783 ret.setLine(0);
1784 }
1785
1786 if (keepX) {
1787 int realLine = view()->textFolding().visibleLineToLine(ret.line());
1788 KateTextLayout t = cache()->textLayout(realLine, 0);
1789 Q_ASSERT(t.isValid());
1790
1791 ret.setColumn(renderer()->xToCursor(t, m_preservedX, !view()->wrapCursor()).column());
1792 }
1793
1794 return ret;
1795 }
1796
1797 KTextEditor::Cursor realCursor = virtualCursor;
1798 realCursor.setLine(view()->textFolding().visibleLineToLine(view()->textFolding().lineToVisibleLine(virtualCursor.line())));
1799
1800 int cursorViewLine = cache()->viewLine(realCursor);
1801
1802 int currentOffset = 0;
1803 int virtualLine = 0;
1804
1805 bool forwards = (offset > 0) ? true : false;
1806
1807 if (forwards) {
1808 currentOffset = cache()->lastViewLine(realCursor.line()) - cursorViewLine;
1809 if (offset <= currentOffset) {
1810 // the answer is on the same line
1811 KateTextLayout thisLine = cache()->textLayout(realCursor.line(), cursorViewLine + offset);
1812 Q_ASSERT(thisLine.virtualLine() == (int)view()->textFolding().lineToVisibleLine(virtualCursor.line()));
1813 return KTextEditor::Cursor(virtualCursor.line(), thisLine.startCol());
1814 }
1815
1816 virtualLine = virtualCursor.line() + 1;
1817
1818 } else {
1819 offset = -offset;
1820 currentOffset = cursorViewLine;
1821 if (offset <= currentOffset) {
1822 // the answer is on the same line
1823 KateTextLayout thisLine = cache()->textLayout(realCursor.line(), cursorViewLine - offset);
1824 Q_ASSERT(thisLine.virtualLine() == (int)view()->textFolding().lineToVisibleLine(virtualCursor.line()));
1825 return KTextEditor::Cursor(virtualCursor.line(), thisLine.startCol());
1826 }
1827
1828 virtualLine = virtualCursor.line() - 1;
1829 }
1830
1831 currentOffset++;
1832
1833 while (virtualLine >= 0 && virtualLine < (int)view()->textFolding().visibleLines()) {
1834 int realLine = view()->textFolding().visibleLineToLine(virtualLine);
1835 KateLineLayout *thisLine = cache()->line(realLine, virtualLine);
1836 if (!thisLine) {
1837 break;
1838 }
1839
1840 for (int i = 0; i < thisLine->viewLineCount(); ++i) {
1841 if (offset == currentOffset) {
1842 KateTextLayout thisViewLine = thisLine->viewLine(i);
1843
1844 if (!forwards) {
1845 // We actually want it the other way around
1846 int requiredViewLine = cache()->lastViewLine(realLine) - thisViewLine.viewLine();
1847 if (requiredViewLine != thisViewLine.viewLine()) {
1848 thisViewLine = thisLine->viewLine(requiredViewLine);
1849 }
1850 }
1851
1852 KTextEditor::Cursor ret(virtualLine, thisViewLine.startCol());
1853
1854 // keep column position
1855 if (keepX) {
1856 realCursor = renderer()->xToCursor(thisViewLine, m_preservedX, !view()->wrapCursor());
1857 ret.setColumn(realCursor.column());
1858 }
1859
1860 return ret;
1861 }
1862
1863 currentOffset++;
1864 }
1865
1866 if (forwards) {
1867 virtualLine++;
1868 } else {
1869 virtualLine--;
1870 }
1871 }
1872
1873 // Looks like we were asked for something a bit exotic.
1874 // Return the max/min valid position.
1875 if (forwards) {
1876 return KTextEditor::Cursor(view()->textFolding().visibleLines() - 1,
1877 doc()->lineLength(view()->textFolding().visibleLineToLine(view()->textFolding().visibleLines() - 1)));
1878 } else {
1879 return KTextEditor::Cursor(0, 0);
1880 }
1881}
1882
1883int KateViewInternal::lineMaxCursorX(const KateTextLayout &range)
1884{
1885 if (!view()->wrapCursor() && !range.wrap()) {
1886 return INT_MAX;
1887 }
1888
1889 int maxX = range.endX();
1890
1891 if (maxX && range.wrap()) {
1892 QChar lastCharInLine = doc()->kateTextLine(range.line()).at(range.endCol() - 1);
1893 maxX -= renderer()->currentFontMetrics().horizontalAdvance(lastCharInLine);
1894 }
1895
1896 return maxX;
1897}
1898
1899int KateViewInternal::lineMaxCol(const KateTextLayout &range)
1900{
1901 int maxCol = range.endCol();
1902
1903 if (maxCol && range.wrap()) {
1904 maxCol--;
1905 }
1906
1907 return maxCol;
1908}
1909
1910void KateViewInternal::cursorUp(bool sel)
1911{
1912 if (!sel && view()->completionWidget()->isCompletionActive()) {
1913 view()->completionWidget()->cursorUp();
1914 return;
1915 }
1916
1917 m_preserveX = true;
1918
1919 // Handle Multi cursors
1920 // usually this will have only one element, rarely
1921 int i = 0;
1922 for (const auto &c : view()->m_secondaryCursors) {
1923 auto cursor = c.pos->toCursor();
1924 auto vCursor = toVirtualCursor(cursor);
1925
1926 // our cursor is in the first line already
1927 if (vCursor.line() == 0 && (!view()->dynWordWrap() || cache()->viewLine(cursor) == 0)) {
1928 auto newPos = moveCursorToLineStart(cursor);
1929 c.pos->setPosition(newPos);
1930 auto newVcursor = toVirtualCursor(newPos);
1931 if (sel) {
1932 updateSecondarySelection(i, cursor, newPos);
1933 } else {
1934 view()->clearSecondarySelections();
1935 }
1936 tagLines(newVcursor.line(), vCursor.line());
1937 i++;
1938 continue;
1939 }
1940
1941 auto lineLayout = currentLayout(cursor);
1942 Q_ASSERT(lineLayout.line() == cursor.line());
1943 Q_ASSERT(lineLayout.startCol() <= cursor.column());
1944 Q_ASSERT(!lineLayout.wrap() || cursor.column() < lineLayout.endCol());
1945
1946 KateTextLayout pRange = previousLayout(cursor);
1947
1948 KTextEditor::Cursor newPos = renderer()->xToCursor(pRange, m_preservedX, !view()->wrapCursor());
1949 c.pos->setPosition(newPos);
1950
1951 auto newVcursor = toVirtualCursor(newPos);
1952 if (sel) {
1953 updateSecondarySelection(i, cursor, newPos);
1954 } else {
1955 view()->clearSecondarySelections();
1956 }
1957 tagLines(newVcursor.line(), vCursor.line());
1958 i++;
1959 }
1960
1961 auto mergeOnFuncEnd = qScopeGuard([this, sel] {
1962 if (sel) {
1963 mergeSelections();
1964 } else {
1965 view()->ensureUniqueCursors();
1966 }
1967 });
1968
1969 // Normal single cursor
1970
1971 // assert that the display cursor is in visible lines
1972 Q_ASSERT(m_displayCursor.line() < view()->textFolding().visibleLines());
1973
1974 // move cursor to start of line, if we are at first line!
1975 if (m_displayCursor.line() == 0 && (!view()->dynWordWrap() || cache()->viewLine(m_cursor) == 0)) {
1976 auto newPos = moveCursorToLineStart(m_cursor);
1977 if (newPos.isValid()) {
1978 updateSelection(newPos, sel);
1979 updateCursor(newPos, true);
1980 }
1981 return;
1982 }
1983
1984 KateTextLayout thisLine = currentLayout(m_cursor);
1985 // This is not the first line because that is already simplified out above
1986 KateTextLayout pRange = previousLayout(m_cursor);
1987
1988 // Ensure we're in the right spot
1989 Q_ASSERT(m_cursor.line() == thisLine.line());
1990 Q_ASSERT(m_cursor.column() >= thisLine.startCol());
1991 Q_ASSERT(!thisLine.wrap() || m_cursor.column() < thisLine.endCol());
1992
1993 KTextEditor::Cursor c = renderer()->xToCursor(pRange, m_preservedX, !view()->wrapCursor());
1994
1995 updateSelection(c, sel);
1996 updateCursor(c);
1997}
1998
1999void KateViewInternal::cursorDown(bool sel)
2000{
2001 if (!sel && view()->completionWidget()->isCompletionActive()) {
2002 view()->completionWidget()->cursorDown();
2003 return;
2004 }
2005
2006 m_preserveX = true;
2007
2008 // Handle multiple cursors
2009 int i = 0;
2010 for (const auto &c : view()->m_secondaryCursors) {
2011 auto cursor = c.cursor();
2012 auto vCursor = toVirtualCursor(cursor);
2013
2014 // at end?
2015 if ((vCursor.line() >= view()->textFolding().visibleLines() - 1)
2016 && (!view()->dynWordWrap() || cache()->viewLine(cursor) == cache()->lastViewLine(cursor.line()))) {
2017 KTextEditor::Cursor newPos = moveCursorToLineEnd(cursor);
2018 c.pos->setPosition(newPos);
2019 if (sel) {
2020 updateSecondarySelection(i, cursor, newPos);
2021 } else {
2022 view()->clearSecondarySelections();
2023 }
2024 auto vNewPos = toVirtualCursor(newPos);
2025 tagLines(vCursor.line(), vNewPos.line());
2026 i++;
2027 continue;
2028 }
2029
2030 KateTextLayout thisLine = currentLayout(cursor);
2031 // This is not the last line because that is already simplified out above
2032 KateTextLayout nRange = nextLayout(cursor);
2033
2034 // Ensure we're in the right spot
2035 Q_ASSERT((cursor.line() == thisLine.line()) && (cursor.column() >= thisLine.startCol()) && (!thisLine.wrap() || cursor.column() < thisLine.endCol()));
2036 KTextEditor::Cursor newPos = renderer()->xToCursor(nRange, m_preservedX, !view()->wrapCursor());
2037
2038 c.pos->setPosition(newPos);
2039 if (sel) {
2040 updateSecondarySelection(i, cursor, newPos);
2041 } else {
2042 view()->clearSecondarySelections();
2043 }
2044 auto vNewPos = toVirtualCursor(newPos);
2045 tagLines(vCursor.line(), vNewPos.line());
2046 i++;
2047 }
2048 auto mergeOnFuncEnd = qScopeGuard([this, sel] {
2049 if (sel) {
2050 mergeSelections();
2051 } else {
2052 view()->ensureUniqueCursors();
2053 }
2054 });
2055
2056 // Handle normal single cursor
2057
2058 // move cursor to end of line, if we are at last line!
2059 if ((m_displayCursor.line() >= view()->textFolding().visibleLines() - 1)
2060 && (!view()->dynWordWrap() || cache()->viewLine(m_cursor) == cache()->lastViewLine(m_cursor.line()))) {
2061 auto newPos = moveCursorToLineEnd(m_cursor);
2062 if (newPos.isValid()) {
2063 updateSelection(newPos, sel);
2064 updateCursor(newPos);
2065 }
2066 return;
2067 }
2068
2069 KateTextLayout thisLine = currentLayout(m_cursor);
2070 // This is not the last line because that is already simplified out above
2071 KateTextLayout nRange = nextLayout(m_cursor);
2072
2073 // Ensure we're in the right spot
2074 Q_ASSERT((m_cursor.line() == thisLine.line()) && (m_cursor.column() >= thisLine.startCol()) && (!thisLine.wrap() || m_cursor.column() < thisLine.endCol()));
2075
2076 KTextEditor::Cursor c = renderer()->xToCursor(nRange, m_preservedX, !view()->wrapCursor());
2077
2078 updateSelection(c, sel);
2079 updateCursor(c);
2080}
2081
2082void KateViewInternal::cursorToMatchingBracket(bool sel)
2083{
2084 KTextEditor::Cursor c = findMatchingBracket();
2085
2086 if (c.isValid()) {
2087 updateSelection(c, sel);
2088 updateCursor(c);
2089 }
2090}
2091
2092void KateViewInternal::topOfView(bool sel)
2093{
2094 view()->clearSecondaryCursors();
2095 KTextEditor::Cursor c = viewLineOffset(startPos(), m_minLinesVisible);
2096 updateSelection(toRealCursor(c), sel);
2097 updateCursor(toRealCursor(c));
2098}
2099
2100void KateViewInternal::bottomOfView(bool sel)
2101{
2102 view()->clearSecondaryCursors();
2103 KTextEditor::Cursor c = viewLineOffset(endPos(), -m_minLinesVisible);
2104 updateSelection(toRealCursor(c), sel);
2105 updateCursor(toRealCursor(c));
2106}
2107
2108// lines is the offset to scroll by
2109void KateViewInternal::scrollLines(int lines, bool sel)
2110{
2111 KTextEditor::Cursor c = viewLineOffset(m_displayCursor, lines, true);
2112
2113 // Fix the virtual cursor -> real cursor
2114 c.setLine(view()->textFolding().visibleLineToLine(c.line()));
2115
2116 updateSelection(c, sel);
2117 updateCursor(c);
2118}
2119
2120// This is a bit misleading... it's asking for the view to be scrolled, not the cursor
2121void KateViewInternal::scrollUp()
2122{
2123 KTextEditor::Cursor newPos = viewLineOffset(startPos(), -1);
2124 scrollPos(newPos);
2125}
2126
2127void KateViewInternal::scrollDown()
2128{
2129 KTextEditor::Cursor newPos = viewLineOffset(startPos(), 1);
2130 scrollPos(newPos);
2131}
2132
2133void KateViewInternal::setAutoCenterLines(int viewLines, bool updateView)
2134{
2135 m_autoCenterLines = viewLines;
2136 m_minLinesVisible = qMin(int((linesDisplayed() - 1) / 2), m_autoCenterLines);
2137 if (updateView) {
2138 KateViewInternal::updateView();
2139 }
2140}
2141
2142void KateViewInternal::pageUp(bool sel, bool half)
2143{
2144 if (view()->isCompletionActive()) {
2145 view()->completionWidget()->pageUp();
2146 return;
2147 }
2148 view()->clearSecondaryCursors();
2149
2150 // jump back to where the cursor is, otherwise it is super
2151 // slow to call cache()->displayViewLine
2152 if (!view()->visibleRange().contains(m_displayCursor)) {
2153 scrollLines(m_displayCursor.line());
2154 }
2155
2156 // remember the view line and x pos
2157 int viewLine = cache()->displayViewLine(m_displayCursor);
2158 bool atTop = startPos().atStartOfDocument();
2159
2160 // Adjust for an auto-centering cursor
2161 int lineadj = m_minLinesVisible;
2162
2163 int linesToScroll;
2164 if (!half) {
2165 linesToScroll = -qMax((linesDisplayed() - 1) - lineadj, 0);
2166 } else {
2167 linesToScroll = -qMax((linesDisplayed() / 2 - 1) - lineadj, 0);
2168 }
2169
2170 m_preserveX = true;
2171
2172 if (!doc()->pageUpDownMovesCursor() && !atTop) {
2173 KTextEditor::Cursor newStartPos = viewLineOffset(startPos(), linesToScroll - 1);
2174 scrollPos(newStartPos);
2175
2176 // put the cursor back approximately where it was
2177 KTextEditor::Cursor newPos = toRealCursor(viewLineOffset(newStartPos, viewLine, true));
2178
2179 KateTextLayout newLine = cache()->textLayout(newPos);
2180
2181 newPos = renderer()->xToCursor(newLine, m_preservedX, !view()->wrapCursor());
2182
2183 m_preserveX = true;
2184 updateSelection(newPos, sel);
2185 updateCursor(newPos);
2186
2187 } else {
2188 scrollLines(linesToScroll, sel);
2189 }
2190}
2191
2192void KateViewInternal::pageDown(bool sel, bool half)
2193{
2194 if (view()->isCompletionActive()) {
2195 view()->completionWidget()->pageDown();
2196 return;
2197 }
2198
2199 view()->clearSecondaryCursors();
2200
2201 // jump back to where the cursor is, otherwise it is super
2202 // slow to call cache()->displayViewLine
2203 if (!view()->visibleRange().contains(m_displayCursor)) {
2204 scrollLines(m_displayCursor.line());
2205 }
2206
2207 // remember the view line
2208 int viewLine = cache()->displayViewLine(m_displayCursor);
2209 bool atEnd = startPos() >= m_cachedMaxStartPos;
2210
2211 // Adjust for an auto-centering cursor
2212 int lineadj = m_minLinesVisible;
2213
2214 int linesToScroll;
2215 if (!half) {
2216 linesToScroll = qMax((linesDisplayed() - 1) - lineadj, 0);
2217 } else {
2218 linesToScroll = qMax((linesDisplayed() / 2 - 1) - lineadj, 0);
2219 }
2220
2221 m_preserveX = true;
2222
2223 if (!doc()->pageUpDownMovesCursor() && !atEnd) {
2224 KTextEditor::Cursor newStartPos = viewLineOffset(startPos(), linesToScroll + 1);
2225 scrollPos(newStartPos);
2226
2227 // put the cursor back approximately where it was
2228 KTextEditor::Cursor newPos = toRealCursor(viewLineOffset(newStartPos, viewLine, true));
2229
2230 KateTextLayout newLine = cache()->textLayout(newPos);
2231
2232 newPos = renderer()->xToCursor(newLine, m_preservedX, !view()->wrapCursor());
2233
2234 m_preserveX = true;
2235 updateSelection(newPos, sel);
2236 updateCursor(newPos);
2237
2238 } else {
2239 scrollLines(linesToScroll, sel);
2240 }
2241}
2242
2243int KateViewInternal::maxLen(int startLine)
2244{
2245 Q_ASSERT(!view()->dynWordWrap());
2246
2247 int displayLines = (view()->height() / renderer()->lineHeight()) + 1;
2248
2249 int maxLen = 0;
2250
2251 for (int z = 0; z < displayLines; z++) {
2252 int virtualLine = startLine + z;
2253
2254 if (virtualLine < 0 || virtualLine >= (int)view()->textFolding().visibleLines()) {
2255 break;
2256 }
2257
2258 const KateLineLayout *line = cache()->line(view()->textFolding().visibleLineToLine(virtualLine));
2259 if (!line) {
2260 continue;
2261 }
2262
2263 maxLen = qMax(maxLen, line->width());
2264 }
2265
2266 return maxLen;
2267}
2268
2269bool KateViewInternal::columnScrollingPossible()
2270{
2271 return !view()->dynWordWrap() && m_columnScroll->isEnabled() && (m_columnScroll->maximum() > 0);
2272}
2273
2274bool KateViewInternal::lineScrollingPossible()
2275{
2276 return m_lineScroll->minimum() != m_lineScroll->maximum();
2277}
2278
2279void KateViewInternal::top(bool sel)
2280{
2281 KTextEditor::Cursor newCursor(0, 0);
2282
2283 newCursor = renderer()->xToCursor(cache()->textLayout(newCursor), m_preservedX, !view()->wrapCursor());
2284
2285 view()->clearSecondaryCursors();
2286 updateSelection(newCursor, sel);
2287 updateCursor(newCursor);
2288}
2289
2290void KateViewInternal::bottom(bool sel)
2291{
2292 KTextEditor::Cursor newCursor(doc()->lastLine(), 0);
2293
2294 newCursor = renderer()->xToCursor(cache()->textLayout(newCursor), m_preservedX, !view()->wrapCursor());
2295
2296 view()->clearSecondaryCursors();
2297 updateSelection(newCursor, sel);
2298 updateCursor(newCursor);
2299}
2300
2301void KateViewInternal::top_home(bool sel)
2302{
2303 if (view()->isCompletionActive()) {
2304 view()->completionWidget()->top();
2305 return;
2306 }
2307
2308 view()->clearSecondaryCursors();
2309 KTextEditor::Cursor c(0, 0);
2310 updateSelection(c, sel);
2311 updateCursor(c);
2312}
2313
2314void KateViewInternal::bottom_end(bool sel)
2315{
2316 if (view()->isCompletionActive()) {
2317 view()->completionWidget()->bottom();
2318 return;
2319 }
2320
2321 view()->clearSecondaryCursors();
2322 KTextEditor::Cursor c(doc()->lastLine(), doc()->lineLength(doc()->lastLine()));
2323 updateSelection(c, sel);
2324 updateCursor(c);
2325}
2326
2327void KateViewInternal::updateSecondarySelection(int cursorIdx, KTextEditor::Cursor old, KTextEditor::Cursor newPos) const
2328{
2329 if (m_selectionMode != SelectionMode::Default) {
2330 view()->clearSecondaryCursors();
2331 }
2332
2333 auto &secondaryCursors = view()->m_secondaryCursors;
2334 if (secondaryCursors.empty()) {
2335 qWarning() << "Invalid updateSecondarySelection with no secondaryCursors";
2336 return;
2337 }
2338 Q_ASSERT(secondaryCursors.size() > (size_t)cursorIdx);
2339
2340 auto &cursor = secondaryCursors[cursorIdx];
2341 if (cursor.cursor() != newPos) {
2342 qWarning() << "Unexpected different cursor at cursorIdx" << cursorIdx << "found" << cursor.cursor() << "looking for: " << newPos;
2343 return;
2344 }
2345
2346 if (cursor.range) {
2347 Q_ASSERT(cursor.anchor.isValid());
2348 cursor.range->setRange(cursor.anchor, newPos);
2349 } else {
2350 cursor.range.reset(view()->newSecondarySelectionRange({old, newPos}));
2351 cursor.anchor = old;
2352 }
2353}
2354
2355void KateViewInternal::updateSelection(const KTextEditor::Cursor _newCursor, bool keepSel)
2356{
2357 KTextEditor::Cursor newCursor = _newCursor;
2358 if (keepSel) {
2359 if (!view()->selection()
2360 || (m_selectAnchor.line() == -1)
2361 // don't kill the selection if we have a persistent selection and
2362 // the cursor is inside or at the boundaries of the selected area
2363 || (view()->config()->persistentSelection()
2364 && !(view()->selectionRange().contains(m_cursor) || view()->selectionRange().boundaryAtCursor(m_cursor)))) {
2365 m_selectAnchor = m_cursor;
2366 setSelection(KTextEditor::Range(m_cursor, newCursor));
2367 } else {
2368 bool doSelect = true;
2369 switch (m_selectionMode) {
2370 case Word: {
2371 // Restore selStartCached if needed. It gets nuked by
2372 // viewSelectionChanged if we drag the selection into non-existence,
2373 // which can legitimately happen if a shift+DC selection is unable to
2374 // set a "proper" (i.e. non-empty) cached selection, e.g. because the
2375 // start was on something that isn't a word. Word select mode relies
2376 // on the cached selection being set properly, even if it is empty
2377 // (i.e. selStartCached == selEndCached).
2378 if (!m_selectionCached.isValid()) {
2379 m_selectionCached.setStart(m_selectionCached.end());
2380 }
2381
2382 int c;
2383 if (newCursor > m_selectionCached.start()) {
2384 m_selectAnchor = m_selectionCached.start();
2385
2386 Kate::TextLine l = doc()->kateTextLine(newCursor.line());
2387
2388 c = newCursor.column();
2389 if (c > 0 && doc()->highlight()->isInWord(l.at(c - 1))) {
2390 for (; c < l.length(); c++) {
2391 if (!doc()->highlight()->isInWord(l.at(c))) {
2392 break;
2393 }
2394 }
2395 }
2396
2397 newCursor.setColumn(c);
2398 } else if (newCursor < m_selectionCached.start()) {
2399 m_selectAnchor = m_selectionCached.end();
2400
2401 Kate::TextLine l = doc()->kateTextLine(newCursor.line());
2402
2403 c = newCursor.column();
2404 if (c > 0 && c < doc()->lineLength(newCursor.line()) && doc()->highlight()->isInWord(l.at(c))
2405 && doc()->highlight()->isInWord(l.at(c - 1))) {
2406 for (c -= 2; c >= 0; c--) {
2407 if (!doc()->highlight()->isInWord(l.at(c))) {
2408 break;
2409 }
2410 }
2411 newCursor.setColumn(c + 1);
2412 }
2413 } else {
2414 doSelect = false;
2415 }
2416
2417 } break;
2418 case Line:
2419 if (!m_selectionCached.isValid()) {
2420 m_selectionCached = KTextEditor::Range(endLine(), 0, endLine(), 0);
2421 }
2422 if (newCursor.line() > m_selectionCached.start().line()) {
2423 if (newCursor.line() + 1 >= doc()->lines()) {
2424 newCursor.setColumn(doc()->line(newCursor.line()).length());
2425 } else {
2426 newCursor.setPosition(newCursor.line() + 1, 0);
2427 }
2428 // Grow to include the entire line
2429 m_selectAnchor = m_selectionCached.start();
2430 m_selectAnchor.setColumn(0);
2431 } else if (newCursor.line() < m_selectionCached.start().line()) {
2432 newCursor.setColumn(0);
2433 // Grow to include entire line
2434 m_selectAnchor = m_selectionCached.end();
2435 if (m_selectAnchor.column() > 0) {
2436 if (m_selectAnchor.line() + 1 >= doc()->lines()) {
2437 m_selectAnchor.setColumn(doc()->line(newCursor.line()).length());
2438 } else {
2439 m_selectAnchor.setPosition(m_selectAnchor.line() + 1, 0);
2440 }
2441 }
2442 } else { // same line, ignore
2443 doSelect = false;
2444 }
2445 break;
2446 case Mouse: {
2447 if (!m_selectionCached.isValid()) {
2448 break;
2449 }
2450
2451 if (newCursor > m_selectionCached.end()) {
2452 m_selectAnchor = m_selectionCached.start();
2453 } else if (newCursor < m_selectionCached.start()) {
2454 m_selectAnchor = m_selectionCached.end();
2455 } else {
2456 doSelect = false;
2457 }
2458 } break;
2459 default: /* nothing special to do */;
2460 }
2461
2462 if (doSelect) {
2463 setSelection(KTextEditor::Range(m_selectAnchor, newCursor));
2464 } else if (m_selectionCached.isValid()) { // we have a cached selection, so we restore that
2465 setSelection(m_selectionCached);
2466 }
2467 }
2468
2469 m_selChangedByUser = true;
2470 } else if (!view()->config()->persistentSelection()) {
2471 view()->clearSelection();
2472
2473 m_selectionCached = KTextEditor::Range::invalid();
2474 m_selectAnchor = KTextEditor::Cursor::invalid();
2475 }
2476
2477#ifndef QT_NO_ACCESSIBILITY
2478// FIXME KF5
2479// QAccessibleTextSelectionEvent ev(this, /* selection start, selection end*/);
2480// QAccessible::updateAccessibility(&ev);
2481#endif
2482}
2483
2484void KateViewInternal::setSelection(KTextEditor::Range range)
2485{
2486 disconnect(m_view, &KTextEditor::ViewPrivate::selectionChanged, this, &KateViewInternal::viewSelectionChanged);
2487 view()->setSelection(range);
2488 connect(m_view, &KTextEditor::ViewPrivate::selectionChanged, this, &KateViewInternal::viewSelectionChanged);
2489}
2490
2491void KateViewInternal::moveCursorToSelectionEdge(bool scroll)
2492{
2493 if (!view()->selection()) {
2494 return;
2495 }
2496
2497 int tmp = m_minLinesVisible;
2498 m_minLinesVisible = 0;
2499
2500 if (view()->selectionRange().start() < m_selectAnchor) {
2501 updateCursor(view()->selectionRange().start(), false, false, false, scroll);
2502 } else {
2503 updateCursor(view()->selectionRange().end(), false, false, false, scroll);
2504 }
2505 if (!scroll) {
2506 m_madeVisible = false;
2507 }
2508
2509 m_minLinesVisible = tmp;
2510}
2511
2512KTextEditor::Range KateViewInternal::findMatchingFoldingMarker(const KTextEditor::Cursor currentCursorPos,
2513 const KSyntaxHighlighting::FoldingRegion foldingRegion,
2514 const int maxLines)
2515{
2516 const int direction = (foldingRegion.type() == KSyntaxHighlighting::FoldingRegion::Begin) ? 1 : -1;
2517 int foldCounter = 0;
2518 int lineCounter = 0;
2519 const auto foldMarkers = m_view->doc()->buffer().computeFoldings(currentCursorPos.line());
2520
2521 // searching a end folding marker? go left to right
2522 // otherwise, go right to left
2523 long i = direction == 1 ? 0 : (long)foldMarkers.size() - 1;
2524
2525 // For the first line, we start considering the first folding after the cursor
2526 for (; i >= 0 && i < (long)foldMarkers.size(); i += direction) {
2527 if ((foldMarkers[i].offset - currentCursorPos.column()) * direction > 0 && foldMarkers[i].foldingRegion.id() == foldingRegion.id()) {
2528 if (foldMarkers[i].foldingRegion.type() == foldingRegion.type()) {
2529 foldCounter += 1;
2530 } else if (foldCounter > 0) {
2531 foldCounter -= 1;
2532 } else if (foldCounter == 0) {
2533 return KTextEditor::Range(currentCursorPos.line(),
2534 getStartOffset(direction, foldMarkers[i].offset, foldMarkers[i].length),
2535 currentCursorPos.line(),
2536 getEndOffset(direction, foldMarkers[i].offset, foldMarkers[i].length));
2537 }
2538 }
2539 }
2540
2541 // for the other lines
2542 int currentLine = currentCursorPos.line() + direction;
2543 for (; currentLine >= 0 && currentLine < m_view->doc()->lines() && lineCounter < maxLines; currentLine += direction) {
2544 // update line attributes
2545 const auto foldMarkers = m_view->doc()->buffer().computeFoldings(currentLine);
2546 i = direction == 1 ? 0 : (long)foldMarkers.size() - 1;
2547
2548 // iterate through the markers
2549 for (; i >= 0 && i < (long)foldMarkers.size(); i += direction) {
2550 if (foldMarkers[i].foldingRegion.id() == foldingRegion.id()) {
2551 if (foldMarkers[i].foldingRegion.type() == foldingRegion.type()) {
2552 foldCounter += 1;
2553 } else if (foldCounter != 0) {
2554 foldCounter -= 1;
2555 } else if (foldCounter == 0) {
2556 return KTextEditor::Range(currentLine,
2557 getStartOffset(direction, foldMarkers[i].offset, foldMarkers[i].length),
2558 currentLine,
2559 getEndOffset(direction, foldMarkers[i].offset, foldMarkers[i].length));
2560 }
2561 }
2562 }
2563 lineCounter += 1;
2564 }
2565
2566 // got out of loop, no matching folding found
2567 // returns a invalid folding range
2569}
2570
2571void KateViewInternal::updateFoldingMarkersHighlighting()
2572{
2573 const auto foldings = m_view->doc()->buffer().computeFoldings(m_cursor.line());
2574 for (unsigned long i = 0; i < foldings.size(); i++) {
2575 // 1 -> left to right, the current folding is start type
2576 // -1 -> right to left, the current folding is end type
2577 int direction = (foldings[i].foldingRegion.type() == KSyntaxHighlighting::FoldingRegion::Begin) ? 1 : -1;
2578
2579 int startOffset = getStartOffset(-direction, foldings[i].offset, foldings[i].length);
2580 int endOffset = getEndOffset(-direction, foldings[i].offset, foldings[i].length);
2581
2582 if (m_cursor.column() >= startOffset && m_cursor.column() <= endOffset) {
2583 const auto foldingMarkerMatch = findMatchingFoldingMarker(KTextEditor::Cursor(m_cursor.line(), m_cursor.column()), foldings[i].foldingRegion, 2000);
2584
2585 if (!foldingMarkerMatch.isValid()) {
2586 break;
2587 }
2588
2589 // set fmStart to Opening Folding Marker and fmEnd to Ending Folding Marker
2590 if (direction == 1) {
2591 m_fmStart->setRange(KTextEditor::Range(m_cursor.line(), startOffset, m_cursor.line(), endOffset));
2592 m_fmEnd->setRange(foldingMarkerMatch);
2593 } else {
2594 m_fmStart->setRange(foldingMarkerMatch);
2595 m_fmEnd->setRange(KTextEditor::Range(m_cursor.line(), startOffset, m_cursor.line(), endOffset));
2596 }
2597
2599 fill->setBackground(view()->rendererConfig()->highlightedBracketColor());
2600
2601 m_fmStart->setAttribute(fill);
2602 m_fmEnd->setAttribute(fill);
2603 return;
2604 }
2605 }
2606 m_fmStart->setRange(KTextEditor::Range::invalid());
2607 m_fmEnd->setRange(KTextEditor::Range::invalid());
2608}
2609
2610void KateViewInternal::updateSecondaryCursors(const QVarLengthArray<CursorPair, 16> &cursors, bool sel)
2611{
2612 if (sel) {
2613 for (int i = 0; i < cursors.size(); ++i) {
2614 updateSecondarySelection(i, cursors[i].oldPos, cursors[i].newPos);
2615 }
2616 if (!cursors.isEmpty()) {
2617 mergeSelections();
2618 }
2619 } else {
2620 view()->clearSecondarySelections();
2621 }
2622
2623 QVarLengthArray<int> linesToUpdate;
2624 for (auto cpair : cursors) {
2625 linesToUpdate.push_back(cpair.oldPos.line());
2626 linesToUpdate.push_back(cpair.newPos.line());
2627 }
2628 // Remove duplicate stuff
2629 std::sort(linesToUpdate.begin(), linesToUpdate.end());
2630 auto it = std::unique(linesToUpdate.begin(), linesToUpdate.end());
2631
2632 // Collapse ranges to avoid extra work
2633 using Range = std::pair<int, int>; // start, length
2635 int prev = 0;
2636 for (auto i = linesToUpdate.begin(); i != it; ++i) {
2637 int curLine = *i;
2638 if (!ranges.isEmpty() && prev + 1 == curLine) {
2639 ranges.back().second++;
2640 } else {
2641 ranges.push_back({curLine, 0});
2642 }
2643 prev = curLine;
2644 }
2645
2646 for (auto range : ranges) {
2647 int startLine = range.first;
2648 int endLine = range.first + range.second;
2649 tagLines(startLine, endLine, /*realLines=*/true);
2650 }
2651 updateDirty();
2652}
2653
2654void KateViewInternal::mergeSelections()
2655{
2656 using SecondaryCursor = KTextEditor::ViewPrivate::SecondaryCursor;
2657 using Range = KTextEditor::Range;
2658 auto doMerge = [](Range newRange, SecondaryCursor &a, SecondaryCursor &b) {
2659 a.range->setRange(newRange);
2660
2661 b.pos.reset();
2662 b.range.reset();
2663 };
2664
2665 auto &cursors = view()->m_secondaryCursors;
2666 for (auto it = cursors.begin(); it != cursors.end(); ++it) {
2667 if (!it->range)
2668 continue;
2669 if (it + 1 == cursors.end()) {
2670 break;
2671 }
2672
2673 auto n = std::next(it);
2674 if (/*!it->range || */ !n->range) {
2675 continue;
2676 }
2677
2678 auto curRange = it->range->toRange();
2679 auto nextRange = n->range->toRange();
2680 if (!curRange.overlaps(nextRange)) {
2681 continue;
2682 }
2683
2684 bool isLefSel = it->cursor() < it->anchor;
2685
2686 // if the ranges overlap we expand the next range
2687 // to include the current one. This allows us to
2688 // check all ranges for overlap in one go
2689 auto curPos = it->cursor();
2690 nextRange.expandToRange(curRange);
2691 if (isLefSel) {
2692 // in left selection our next cursor
2693 // is ahead somewhere, we want to keep
2694 // the smallest position
2695 n->pos->setPosition(curPos);
2696 n->anchor = qMax(n->anchor, it->anchor);
2697 } else {
2698 n->anchor = qMin(n->anchor, it->anchor);
2699 }
2700 doMerge(nextRange, *n, *it);
2701 }
2702
2703 if (view()->selection()) {
2704 auto primarySel = view()->m_selection.toRange();
2705 auto primCursor = cursorPosition();
2706 for (auto it = cursors.begin(); it != cursors.end(); ++it) {
2707 // If range is valid, we merge selection into primary
2708 // Otherwise if cursor is inside primary selection, it
2709 // is removed
2710 auto curRange = it->range ? it->range->toRange() : Range::invalid();
2711 if (curRange.isValid() && primarySel.overlaps(curRange)) {
2712 primarySel.expandToRange(curRange);
2713 bool isLeft = it->cursor() < it->anchor;
2714
2715 if (isLeft) {
2716 if (it->cursor() < primCursor) {
2717 updateCursor(it->cursor());
2718 }
2719 m_selectAnchor = qMax(m_selectAnchor, it->anchor);
2720 } else {
2721 if (it->cursor() > primCursor) {
2722 updateCursor(it->cursor());
2723 }
2724 m_selectAnchor = qMin(m_selectAnchor, it->anchor);
2725 }
2726
2727 setSelection(primarySel);
2728 it->pos.reset();
2729 it->range.reset();
2730 } else if (it->pos) {
2731 // This only needs to be done for primary selection
2732 // because remember, mouse selection is always with
2733 // primary cursor
2734 auto pos = it->cursor();
2735 if (!primarySel.boundaryAtCursor(pos) && primarySel.contains(pos)) {
2736 it->pos.reset();
2737 }
2738 }
2739 }
2740 }
2741
2742 cursors.erase(std::remove_if(cursors.begin(),
2743 cursors.end(),
2744 [](const SecondaryCursor &c) {
2745 return !c.pos.get();
2746 }),
2747 cursors.end());
2748}
2749
2750void KateViewInternal::updateCursor(const KTextEditor::Cursor newCursor, bool force, bool center, bool calledExternally, bool scroll)
2751{
2752 if (!force && (m_cursor.toCursor() == newCursor)) {
2753 m_displayCursor = toVirtualCursor(newCursor);
2754 if (scroll && !m_madeVisible && m_view == doc()->activeView()) {
2755 // unfold if required
2756 view()->textFolding().ensureLineIsVisible(newCursor.line());
2757
2758 makeVisible(m_displayCursor, m_displayCursor.column(), false, center, calledExternally);
2759 }
2760
2761 return;
2762 }
2763
2764 if (m_cursor.line() != newCursor.line()) {
2765 m_leftBorder->updateForCursorLineChange();
2766 }
2767
2768 // unfold if required
2769 view()->textFolding().ensureLineIsVisible(newCursor.line());
2770
2771 KTextEditor::Cursor oldDisplayCursor = m_displayCursor;
2772
2773 m_displayCursor = toVirtualCursor(newCursor);
2774 m_cursor.setPosition(newCursor);
2775
2776 if (m_view == doc()->activeView() && scroll) {
2777 makeVisible(m_displayCursor, m_displayCursor.column(), false, center, calledExternally);
2778 }
2779
2780 updateBracketMarks();
2781
2782 updateFoldingMarkersHighlighting();
2783
2784 // avoid double work, tagLine => tagLines => not that cheap, much more costly than to compare 2 ints
2785 tagLine(oldDisplayCursor);
2786 if (oldDisplayCursor.line() != m_displayCursor.line()) {
2787 tagLine(m_displayCursor);
2788 }
2789
2791
2792 if (m_cursorTimer.isActive()) {
2794 m_cursorTimer.start(QApplication::cursorFlashTime() / 2);
2795 }
2796 renderer()->setDrawCaret(true);
2797 }
2798
2799 // Remember the maximum X position if requested
2800 if (m_preserveX) {
2801 m_preserveX = false;
2802 } else {
2803 m_preservedX = renderer()->cursorToX(cache()->textLayout(m_cursor), m_cursor, !view()->wrapCursor());
2804 }
2805
2806 // qCDebug(LOG_KTE) << "m_preservedX: " << m_preservedX << " (was "<< oldmaxx << "), m_cursorX: " << m_cursorX;
2807 // qCDebug(LOG_KTE) << "Cursor now located at real " << cursor.line << "," << cursor.col << ", virtual " << m_displayCursor.line << ", " <<
2808 // m_displayCursor.col << "; Top is " << startLine() << ", " << startPos().col;
2809
2810 cursorMoved();
2811
2812 updateDirty(); // paintText(0, 0, width(), height(), true);
2813
2814 Q_EMIT view()->cursorPositionChanged(m_view, m_cursor);
2815}
2816
2817void KateViewInternal::updateBracketMarkAttributes()
2818{
2820 bracketFill->setBackground(view()->rendererConfig()->highlightedBracketColor());
2821 bracketFill->setBackgroundFillWhitespace(false);
2822 if (QFontInfo(renderer()->currentFont()).fixedPitch()) {
2823 // make font bold only for fixed fonts, otherwise text jumps around
2824 bracketFill->setFontBold();
2825 }
2826
2827 m_bmStart->setAttribute(bracketFill);
2828 m_bmEnd->setAttribute(bracketFill);
2829
2830 if (view()->rendererConfig()->showWholeBracketExpression()) {
2832 expressionFill->setBackground(view()->rendererConfig()->highlightedBracketColor());
2833 expressionFill->setBackgroundFillWhitespace(false);
2834
2835 m_bm->setAttribute(expressionFill);
2836 } else {
2837 m_bm->setAttribute(KTextEditor::Attribute::Ptr(new KTextEditor::Attribute()));
2838 }
2839}
2840
2841void KateViewInternal::updateBracketMarks()
2842{
2843 // add some limit to this, this is really endless on big files without limit
2844 const int maxLines = 5000;
2845 const KTextEditor::Range newRange = doc()->findMatchingBracket(m_cursor, maxLines);
2846
2847 // new range valid, then set ranges to it
2848 if (newRange.isValid()) {
2849 if (m_bm->toRange() == newRange) {
2850 // hide preview as it now (probably) blocks the top of the view
2851 hideBracketMatchPreview();
2852 return;
2853 }
2854
2855 // modify full range
2856 m_bm->setRange(newRange);
2857
2858 // modify start and end ranges
2859 m_bmStart->setRange(KTextEditor::Range(m_bm->start(), KTextEditor::Cursor(m_bm->start().line(), m_bm->start().column() + 1)));
2860 m_bmEnd->setRange(KTextEditor::Range(m_bm->end(), KTextEditor::Cursor(m_bm->end().line(), m_bm->end().column() + 1)));
2861
2862 // show preview of the matching bracket's line
2863 if (m_view->config()->value(KateViewConfig::ShowBracketMatchPreview).toBool()) {
2864 showBracketMatchPreview();
2865 }
2866
2867 // flash matching bracket
2868 if (!m_view->rendererConfig()->animateBracketMatching()) {
2869 return;
2870 }
2871
2872 const KTextEditor::Cursor flashPos = (m_cursor == m_bmStart->start() || m_cursor == m_bmStart->end()) ? m_bmEnd->start() : m_bm->start();
2873 if (flashPos != m_bmLastFlashPos->toCursor()) {
2874 m_bmLastFlashPos->setPosition(flashPos);
2875
2876 KTextEditor::Attribute::Ptr attribute = attributeAt(flashPos);
2877 attribute->setBackground(view()->rendererConfig()->highlightedBracketColor());
2878 if (m_bmStart->attribute()->fontBold()) {
2879 attribute->setFontBold(true);
2880 }
2881
2882 flashChar(flashPos, attribute);
2883 }
2884 return;
2885 }
2886
2887 // new range was invalid
2888 m_bm->setRange(KTextEditor::Range::invalid());
2889 m_bmStart->setRange(KTextEditor::Range::invalid());
2890 m_bmEnd->setRange(KTextEditor::Range::invalid());
2891 m_bmLastFlashPos->setPosition(KTextEditor::Cursor::invalid());
2892 hideBracketMatchPreview();
2893}
2894
2895bool KateViewInternal::tagLine(const KTextEditor::Cursor virtualCursor)
2896{
2897 // we had here some special case handling for one line, it was just randomly wrong for dyn. word wrapped stuff => use the generic function
2898 return tagLines(virtualCursor, virtualCursor, false);
2899}
2900
2901bool KateViewInternal::tagLines(int start, int end, bool realLines)
2902{
2903 return tagLines(KTextEditor::Cursor(start, 0), KTextEditor::Cursor(end, -1), realLines);
2904}
2905
2906bool KateViewInternal::tagLines(KTextEditor::Cursor start, KTextEditor::Cursor end, bool realCursors)
2907{
2908 if (realCursors) {
2909 cache()->relayoutLines(start.line(), end.line());
2910
2911 // qCDebug(LOG_KTE)<<"realLines is true";
2912 start = toVirtualCursor(start);
2913 end = toVirtualCursor(end);
2914
2915 } else {
2916 cache()->relayoutLines(toRealCursor(start).line(), toRealCursor(end).line());
2917 }
2918
2919 if (end.line() < startLine()) {
2920 // qCDebug(LOG_KTE)<<"end<startLine";
2921 return false;
2922 }
2923 // Used to be > endLine(), but cache may not be valid when checking, so use a
2924 // less optimal but still adequate approximation (potential overestimation but minimal performance difference)
2925 if (start.line() > startLine() + cache()->viewCacheLineCount()) {
2926 // qCDebug(LOG_KTE)<<"start> endLine"<<start<<" "<<(endLine());
2927 return false;
2928 }
2929
2930 cache()->updateViewCache(startPos());
2931
2932 // qCDebug(LOG_KTE) << "tagLines( [" << start << "], [" << end << "] )";
2933
2934 bool ret = false;
2935
2936 for (int z = 0; z < cache()->viewCacheLineCount(); z++) {
2937 KateTextLayout &line = cache()->viewLine(z);
2938 if ((line.virtualLine() > start.line() || (line.virtualLine() == start.line() && line.endCol() >= start.column() && start.column() != -1))
2939 && (line.virtualLine() < end.line() || (line.virtualLine() == end.line() && (line.startCol() <= end.column() || end.column() == -1)))) {
2940 ret = true;
2941 break;
2942 // qCDebug(LOG_KTE) << "Tagged line " << line.line();
2943 }
2944 }
2945
2946 // full update of border it we have indentation based hl and show the markers always
2947 if (!m_view->config()->showFoldingOnHoverOnly() && doc()->highlight() && doc()->highlight()->foldingIndentationSensitive()) {
2948 // not the default setting, can be optimized if ever some issue
2949 m_leftBorder->update();
2950 } else if (!view()->dynWordWrap()) {
2951 int y = lineToY(start.line());
2952 // FIXME is this enough for when multiple lines are deleted
2953 int h = (end.line() - start.line() + 2) * renderer()->lineHeight();
2954 if (end.line() >= view()->textFolding().visibleLines() - 1) {
2955 h = height();
2956 }
2957
2958 m_leftBorder->update(0, y, m_leftBorder->width(), h);
2959 } else {
2960 // FIXME Do we get enough good info in editRemoveText to optimize this more?
2961 // bool justTagged = false;
2962 for (int z = 0; z < cache()->viewCacheLineCount(); z++) {
2963 KateTextLayout &line = cache()->viewLine(z);
2964 if (!line.isValid()
2965 || ((line.virtualLine() > start.line() || (line.virtualLine() == start.line() && line.endCol() >= start.column() && start.column() != -1))
2966 && (line.virtualLine() < end.line() || (line.virtualLine() == end.line() && (line.startCol() <= end.column() || end.column() == -1))))) {
2967 // justTagged = true;
2968 m_leftBorder->update(0, z * renderer()->lineHeight(), m_leftBorder->width(), m_leftBorder->height());
2969 break;
2970 }
2971 /*else if (justTagged)
2972 {
2973 justTagged = false;
2974 leftBorder->update (0, z * doc()->viewFont.fontHeight, leftBorder->width(), doc()->viewFont.fontHeight);
2975 break;
2976 }*/
2977 }
2978 }
2979
2980 return ret;
2981}
2982
2983bool KateViewInternal::tagRange(KTextEditor::Range range, bool realCursors)
2984{
2985 return tagLines(range.start(), range.end(), realCursors);
2986}
2987
2988void KateViewInternal::tagAll()
2989{
2990 // clear the cache...
2991 cache()->clear();
2992
2993 m_leftBorder->updateFont();
2994 m_leftBorder->update();
2995}
2996
2997void KateViewInternal::paintCursor()
2998{
2999 QVarLengthArray<int, 64> updatedLines;
3000 if (tagLine(m_displayCursor)) {
3001 updatedLines.push_back(m_displayCursor.line());
3002 }
3003
3004 const int s = view()->firstDisplayedLine();
3005 const int e = view()->lastDisplayedLine();
3006 for (const auto &c : view()->m_secondaryCursors) {
3007 auto p = c.cursor();
3008 if (p.line() >= s - 1 && p.line() <= e + 1 && !updatedLines.contains(p.line())) {
3009 updatedLines.push_back(p.line());
3010 tagLines(p, p, true);
3011 }
3012 }
3013
3014 if (!updatedLines.isEmpty()) {
3015 updateDirty(); // paintText (0,0,width(), height(), true);
3016 }
3017}
3018
3019KTextEditor::Cursor KateViewInternal::cursorForPoint(QPoint p)
3020{
3021 KateTextLayout thisLine = yToKateTextLayout(p.y());
3023
3024 if (!thisLine.isValid()) { // probably user clicked below the last line -> use the last line
3025 thisLine = cache()->textLayout(doc()->lines() - 1, -1);
3026 }
3027
3028 c = renderer()->xToCursor(thisLine, startX() + p.x(), !view()->wrapCursor());
3029
3030 if (c.line() < 0 || c.line() >= doc()->lines()) {
3032 }
3033
3034 // loop over all notes and check if the point is inside it
3035 const auto inlineNotes = view()->inlineNotes(c.line());
3036 p = mapToGlobal(p);
3037 for (const auto &note : inlineNotes) {
3038 auto noteCursor = note.m_position;
3039 // we are not interested in notes that are past the end or at 0
3040 if (note.m_position.column() >= doc()->lineLength(c.line()) || note.m_position.column() == 0) {
3041 continue;
3042 }
3043 // an inline note is "part" of a char i.e., char width is increased so that
3044 // an inline note can be painted beside it. So we need to find the actual
3045 // char width
3046 const auto caretWidth = renderer()->caretStyle() == KTextEditor::caretStyles::Line ? 2. : 0.;
3047 const auto width = KTextEditor::InlineNote(note).width() + caretWidth;
3048 const auto charWidth = renderer()->currentFontMetrics().horizontalAdvance(doc()->characterAt(noteCursor));
3049 const auto halfCharWidth = (charWidth / 2);
3050 // we leave the first half of the char width. If the user has clicked in the first half, let it go the
3051 // previous column.
3052 const auto totalWidth = width + halfCharWidth;
3053 auto start = mapToGlobal(cursorToCoordinate(noteCursor, true, false));
3054 start = start - QPoint(totalWidth, 0);
3055 QRect r(start, QSize{(int)halfCharWidth, renderer()->lineHeight()});
3056 if (r.contains(p)) {
3057 c = noteCursor;
3058 break;
3059 }
3060 }
3061
3062 return c;
3063}
3064
3065// Point in content coordinates
3066void KateViewInternal::placeCursor(const QPoint &p, bool keepSelection, bool updateSelection)
3067{
3068 KTextEditor::Cursor c = cursorForPoint(p);
3069 if (!c.isValid()) {
3070 return;
3071 }
3072
3073 if (updateSelection) {
3074 KateViewInternal::updateSelection(c, keepSelection);
3075 }
3076
3077 int tmp = m_minLinesVisible;
3078 m_minLinesVisible = 0;
3079 updateCursor(c);
3080 m_minLinesVisible = tmp;
3081
3082 if (updateSelection && keepSelection) {
3083 moveCursorToSelectionEdge();
3084 }
3085}
3086
3087// Point in content coordinates
3088bool KateViewInternal::isTargetSelected(const QPoint &p)
3089{
3090 const KateTextLayout &thisLine = yToKateTextLayout(p.y());
3091 if (!thisLine.isValid()) {
3092 return false;
3093 }
3094
3095 return view()->cursorSelected(renderer()->xToCursor(thisLine, startX() + p.x(), !view()->wrapCursor()));
3096}
3097
3098// BEGIN EVENT HANDLING STUFF
3099
3100bool KateViewInternal::eventFilter(QObject *obj, QEvent *e)
3101{
3102 switch (e->type()) {
3103 case QEvent::ChildAdded:
3104 case QEvent::ChildRemoved: {
3105 QChildEvent *c = static_cast<QChildEvent *>(e);
3106 if (c->added()) {
3107 c->child()->installEventFilter(this);
3108
3109 } else if (c->removed()) {
3110 c->child()->removeEventFilter(this);
3111 }
3112 } break;
3113
3115 QKeyEvent *k = static_cast<QKeyEvent *>(e);
3116
3117 if (k->key() == Qt::Key_Escape && k->modifiers() == Qt::NoModifier) {
3118 if (!view()->m_secondaryCursors.empty()) {
3119 view()->clearSecondaryCursors();
3120 k->accept();
3121 return true;
3122 }
3123
3124 if (view()->isCompletionActive()) {
3125 view()->abortCompletion();
3126 k->accept();
3127 // qCDebug(LOG_KTE) << obj << "shortcut override" << k->key() << "aborting completion";
3128 return true;
3129 } else if (view()->bottomViewBar()->barWidgetVisible()) {
3130 view()->bottomViewBar()->hideCurrentBarWidget();
3131 k->accept();
3132 // qCDebug(LOG_KTE) << obj << "shortcut override" << k->key() << "closing view bar";
3133 return true;
3134 } else if (!view()->config()->persistentSelection() && view()->selection()) {
3135 m_currentInputMode->clearSelection();
3136 k->accept();
3137 // qCDebug(LOG_KTE) << obj << "shortcut override" << k->key() << "clearing selection";
3138 return true;
3139 }
3140 }
3141
3142 if (k->modifiers() == Qt::AltModifier && view()->isCompletionActive()) {
3143 if (view()->completionWidget()->handleShortcutOverride(k)) {
3144 k->accept();
3145 return true;
3146 }
3147 }
3148
3149 if (m_currentInputMode->stealKey(k)) {
3150 k->accept();
3151 return true;
3152 }
3153
3154 // CompletionReplayer.replay only gets called when a Ctrl-Space gets to InsertViMode::handleKeyPress
3155 // Workaround for BUG: 334032 (https://bugs.kde.org/show_bug.cgi?id=334032)
3156 if (k->key() == Qt::Key_Space && k->modifiers() == Qt::ControlModifier) {
3157 keyPressEvent(k);
3158 if (k->isAccepted()) {
3159 return true;
3160 }
3161 }
3162 } break;
3163
3164 case QEvent::KeyPress: {
3165 QKeyEvent *k = static_cast<QKeyEvent *>(e);
3166
3167 // Override all other single key shortcuts which do not use a modifier other than Shift
3168 if (obj == this && (!k->modifiers() || k->modifiers() == Qt::ShiftModifier)) {
3169 keyPressEvent(k);
3170 if (k->isAccepted()) {
3171 // qCDebug(LOG_KTE) << obj << "shortcut override" << k->key() << "using keystroke";
3172 return true;
3173 }
3174 }
3175
3176 // qCDebug(LOG_KTE) << obj << "shortcut override" << k->key() << "ignoring";
3177 } break;
3178
3179 case QEvent::DragMove: {
3180 QPoint currentPoint = ((QDragMoveEvent *)e)->position().toPoint();
3181
3182 QRect doNotScrollRegion(s_scrollMargin, s_scrollMargin, width() - s_scrollMargin * 2, height() - s_scrollMargin * 2);
3183
3184 if (!doNotScrollRegion.contains(currentPoint)) {
3185 startDragScroll();
3186 // Keep sending move events
3187 ((QDragMoveEvent *)e)->accept(QRect(0, 0, 0, 0));
3188 }
3189
3190 dragMoveEvent((QDragMoveEvent *)e);
3191 } break;
3192
3193 case QEvent::DragLeave:
3194 // happens only when pressing ESC while dragging
3195 stopDragScroll();
3196 break;
3197
3199 hideBracketMatchPreview();
3200 break;
3201
3202 case QEvent::ScrollPrepare: {
3203 QScrollPrepareEvent *s = static_cast<QScrollPrepareEvent *>(e);
3204 scrollPrepareEvent(s);
3205 }
3206 return true;
3207
3208 case QEvent::Scroll: {
3209 QScrollEvent *s = static_cast<QScrollEvent *>(e);
3210 scrollEvent(s);
3211 }
3212 return true;
3213
3214 default:
3215 break;
3216 }
3217
3218 return QWidget::eventFilter(obj, e);
3219}
3220
3221void KateViewInternal::keyPressEvent(QKeyEvent *e)
3222{
3223 m_shiftKeyPressed = e->modifiers() & Qt::ShiftModifier;
3224 if (e->key() == Qt::Key_Left && e->modifiers() == Qt::AltModifier) {
3225 view()->emitNavigateLeft();
3226 e->setAccepted(true);
3227 return;
3228 }
3229 if (e->key() == Qt::Key_Right && e->modifiers() == Qt::AltModifier) {
3230 view()->emitNavigateRight();
3231 e->setAccepted(true);
3232 return;
3233 }
3234 if (e->key() == Qt::Key_Up && e->modifiers() == Qt::AltModifier) {
3235 view()->emitNavigateUp();
3236 e->setAccepted(true);
3237 return;
3238 }
3239 if (e->key() == Qt::Key_Down && e->modifiers() == Qt::AltModifier) {
3240 view()->emitNavigateDown();
3241 e->setAccepted(true);
3242 return;
3243 }
3244 if (e->key() == Qt::Key_Return && e->modifiers() == Qt::AltModifier) {
3245 view()->emitNavigateAccept();
3246 e->setAccepted(true);
3247 return;
3248 }
3249 if (e->key() == Qt::Key_Backspace && e->modifiers() == Qt::AltModifier) {
3250 view()->emitNavigateBack();
3251 e->setAccepted(true);
3252 return;
3253 }
3254
3255 if (e->key() == Qt::Key_Alt && view()->completionWidget()->isCompletionActive()) {
3256 view()->completionWidget()->toggleDocumentation();
3257 }
3258
3259 // Note: AND'ing with <Shift> is a quick hack to fix Key_Enter
3260 const int key = e->key() | (e->modifiers() & Qt::ShiftModifier);
3261
3262 if (m_currentInputMode->keyPress(e)) {
3263 return;
3264 }
3265
3266 if (!doc()->isReadWrite()) {
3267 e->ignore();
3268 return;
3269 }
3270
3271 if ((key == Qt::Key_Return) || (key == Qt::Key_Enter) || key == (Qt::SHIFT | Qt::Key_Return).toCombined()
3272 || key == (Qt::SHIFT | Qt::Key_Enter).toCombined()) {
3273 view()->keyReturn();
3274 e->accept();
3275 return;
3276 }
3277
3278 if (key == Qt::Key_Backspace || key == (Qt::SHIFT | Qt::Key_Backspace).toCombined()) {
3279 // view()->backspace();
3280 e->accept();
3281
3282 return;
3283 }
3284
3285 if (key == Qt::Key_Tab || key == (Qt::SHIFT | Qt::Key_Backtab).toCombined() || key == Qt::Key_Backtab) {
3286 if (key == Qt::Key_Tab) {
3287 uint tabHandling = doc()->config()->tabHandling();
3288 // convert tabSmart into tabInsertsTab or tabIndents:
3289 if (tabHandling == KateDocumentConfig::tabSmart) {
3290 // multiple lines selected
3291 if (view()->selection() && !view()->selectionRange().onSingleLine()) {
3292 tabHandling = KateDocumentConfig::tabIndents;
3293 }
3294
3295 // otherwise: take look at cursor position
3296 else {
3297 // if the cursor is at or before the first non-space character
3298 // or on an empty line,
3299 // Tab indents, otherwise it inserts a tab character.
3300 Kate::TextLine line = doc()->kateTextLine(m_cursor.line());
3301 int first = line.firstChar();
3302 if (first < 0 || m_cursor.column() <= first) {
3303 tabHandling = KateDocumentConfig::tabIndents;
3304 } else {
3305 tabHandling = KateDocumentConfig::tabInsertsTab;
3306 }
3307 }
3308 }
3309
3310 // either we just insert a tab or we convert that into an indent action
3311 if (tabHandling == KateDocumentConfig::tabInsertsTab) {
3312 doc()->typeChars(m_view, QStringLiteral("\t"));
3313 } else {
3314 doc()->editStart();
3315 for (const auto &c : std::as_const(m_view->m_secondaryCursors)) {
3316 auto cursor = c.cursor();
3317 doc()->indent(KTextEditor::Range(cursor.line(), 0, cursor.line(), 0), 1);
3318 }
3319
3320 doc()->indent(view()->selection() ? view()->selectionRange() : KTextEditor::Range(m_cursor.line(), 0, m_cursor.line(), 0), 1);
3321 doc()->editEnd();
3322 }
3323
3324 e->accept();
3325
3326 return;
3327 } else if (doc()->config()->tabHandling() != KateDocumentConfig::tabInsertsTab) {
3328 // key == Qt::SHIFT+Qt::Key_Backtab || key == Qt::Key_Backtab
3329 doc()->indent(view()->selection() ? view()->selectionRange() : KTextEditor::Range(m_cursor.line(), 0, m_cursor.line(), 0), -1);
3330 e->accept();
3331
3332 return;
3333 }
3334 }
3335
3336 if (isAcceptableInput(e)) {
3337 doc()->typeChars(m_view, e->text());
3338 e->accept();
3339 return;
3340 }
3341
3342 e->ignore();
3343}
3344
3345void KateViewInternal::keyReleaseEvent(QKeyEvent *e)
3346{
3347 if (m_shiftKeyPressed && (e->modifiers() & Qt::ShiftModifier) == 0) {
3348 m_shiftKeyPressed = false;
3349
3350 if (m_selChangedByUser) {
3351 if (view()->selection()) {
3352 QApplication::clipboard()->setText(view()->selectionText(), QClipboard::Selection);
3353 }
3354
3355 m_selChangedByUser = false;
3356 }
3357 }
3358
3359 e->ignore();
3360 return;
3361}
3362
3363bool KateViewInternal::isAcceptableInput(const QKeyEvent *e)
3364{
3365 // reimplemented from QInputControl::isAcceptableInput()
3366
3367 const QString text = e->text();
3368 if (text.isEmpty()) {
3369 return false;
3370 }
3371
3372 const QChar c = text.at(0);
3373
3374 // Formatting characters such as ZWNJ, ZWJ, RLM, etc. This needs to go before the
3375 // next test, since CTRL+SHIFT is sometimes used to input it on Windows.
3376 // see bug 389796 (typing formatting characters such as ZWNJ)
3377 // and bug 396764 (typing soft-hyphens)
3378 if (c.category() == QChar::Other_Format) {
3379 return true;
3380 }
3381
3382 // QTBUG-35734: ignore Ctrl/Ctrl+Shift; accept only AltGr (Alt+Ctrl) on German keyboards
3384 return false;
3385 }
3386
3387 if (c.isPrint() || (c.category() == QChar::Other_PrivateUse)) {
3388 return true;
3389 };
3390
3391 if (c.isHighSurrogate() && text.size() > 1 && text.at(1).isLowSurrogate()) {
3392 return true;
3393 }
3394
3395 return false;
3396}
3397
3398void KateViewInternal::contextMenuEvent(QContextMenuEvent *e)
3399{
3400 // calculate where to show the context menu
3401
3402 QPoint p = e->pos();
3403
3404 if (e->reason() == QContextMenuEvent::Keyboard) {
3405 makeVisible(m_displayCursor, 0);
3406 p = cursorCoordinates(false);
3407 p.rx() -= startX();
3408 } else if (!view()->selection() || view()->config()->persistentSelection()) {
3409 placeCursor(e->pos());
3410 }
3411
3412 // show it
3413 QMenu *cm = view()->contextMenu();
3414 if (cm) {
3415 view()->spellingMenu()->prepareToBeShown(cm);
3416 cm->popup(mapToGlobal(p));
3417 e->accept();
3418 }
3419}
3420
3421void KateViewInternal::mousePressEvent(QMouseEvent *e)
3422{
3423 if (sendMouseEventToInputContext(e)) {
3424 return;
3425 }
3426
3427 // was an inline note clicked?
3428 const auto noteData = inlineNoteAt(e->globalPosition().toPoint());
3429 const KTextEditor::InlineNote note(noteData);
3430 if (note.position().isValid()) {
3431 note.provider()->inlineNoteActivated(noteData, e->button(), e->globalPosition().toPoint());
3432 return;
3433 }
3434
3435 commitPreedit();
3436
3437 // no -- continue with normal handling
3438 switch (e->button()) {
3439 case Qt::LeftButton:
3440
3441 m_selChangedByUser = false;
3442
3443 if (!view()->isMulticursorNotAllowed() && e->modifiers() == view()->config()->multiCursorModifiers()) {
3444 auto pos = cursorForPoint(e->pos());
3445 if (pos.isValid()) {
3446 view()->addSecondaryCursor(pos);
3447 e->accept();
3448 return;
3449 }
3450 } else {
3451 view()->clearSecondaryCursors();
3452 }
3453
3454 if (m_possibleTripleClick) {
3455 m_possibleTripleClick = false;
3456
3457 m_selectionMode = Line;
3458
3459 if (e->modifiers() & Qt::ShiftModifier) {
3460 updateSelection(m_cursor, true);
3461 } else {
3462 view()->selectLine(m_cursor);
3463 if (view()->selection()) {
3464 m_selectAnchor = view()->selectionRange().start();
3465 }
3466 }
3467
3468 if (view()->selection()) {
3469 QApplication::clipboard()->setText(view()->selectionText(), QClipboard::Selection);
3470 }
3471
3472 // Keep the line at the select anchor selected during further
3473 // mouse selection
3474 if (m_selectAnchor.line() > view()->selectionRange().start().line()) {
3475 // Preserve the last selected line
3476 if (m_selectAnchor == view()->selectionRange().end() && m_selectAnchor.column() == 0) {
3477 m_selectionCached.setStart(KTextEditor::Cursor(m_selectAnchor.line() - 1, 0));
3478 } else {
3479 m_selectionCached.setStart(KTextEditor::Cursor(m_selectAnchor.line(), 0));
3480 }
3481 m_selectionCached.setEnd(view()->selectionRange().end());
3482 } else {
3483 // Preserve the first selected line
3484 m_selectionCached.setStart(view()->selectionRange().start());
3485 if (view()->selectionRange().end().line() > view()->selectionRange().start().line()) {
3486 m_selectionCached.setEnd(KTextEditor::Cursor(view()->selectionRange().start().line() + 1, 0));
3487 } else {
3488 m_selectionCached.setEnd(view()->selectionRange().end());
3489 }
3490 }
3491
3492 moveCursorToSelectionEdge();
3493
3494 m_scrollX = 0;
3495 m_scrollY = 0;
3496 m_scrollTimer.start(50);
3497
3498 e->accept();
3499 return;
3500 } else if (m_selectionMode == Default) {
3501 m_selectionMode = Mouse;
3502 }
3503
3504 // request the software keyboard, if any
3505 if (e->button() == Qt::LeftButton && qApp->autoSipEnabled()) {
3507 if (hasFocus() || behavior == QStyle::RSIP_OnMouseClick) {
3510 }
3511 }
3512
3513 if (e->modifiers() & Qt::ShiftModifier) {
3514 if (!m_selectAnchor.isValid()) {
3515 m_selectAnchor = m_cursor;
3516 }
3517 } else {
3518 m_selectionCached = KTextEditor::Range::invalid();
3519 }
3520
3521 if (view()->config()->textDragAndDrop() && !(e->modifiers() & Qt::ShiftModifier) && isTargetSelected(e->pos())) {
3522 m_dragInfo.state = diPending;
3523 m_dragInfo.start = e->pos();
3524 } else {
3525 m_dragInfo.state = diNone;
3526
3527 if (e->modifiers() & Qt::ShiftModifier) {
3528 placeCursor(e->pos(), true, false);
3529 if (m_selectionCached.start().isValid()) {
3530 if (m_cursor.toCursor() < m_selectionCached.start()) {
3531 m_selectAnchor = m_selectionCached.end();
3532 } else {
3533 m_selectAnchor = m_selectionCached.start();
3534 }
3535 }
3536
3537 // update selection and do potential clipboard update, see bug 443642
3538 setSelection(KTextEditor::Range(m_selectAnchor, m_cursor));
3539 if (view()->selection()) {
3540 QApplication::clipboard()->setText(view()->selectionText(), QClipboard::Selection);
3541 }
3542 } else {
3543 placeCursor(e->pos());
3544 }
3545
3546 m_scrollX = 0;
3547 m_scrollY = 0;
3548
3549 m_scrollTimer.start(50);
3550 }
3551
3552 e->accept();
3553 break;
3554
3555 case Qt::RightButton:
3556 if (e->pos().x() == 0) {
3557 // Special handling for folding by right click
3558 placeCursor(e->pos());
3559 e->accept();
3560 }
3561 break;
3562
3563 default:
3564 e->ignore();
3565 break;
3566 }
3567}
3568
3569void KateViewInternal::mouseDoubleClickEvent(QMouseEvent *e)
3570{
3571 if (sendMouseEventToInputContext(e)) {
3572 return;
3573 }
3574 if (e->button() == Qt::LeftButton) {
3575 m_selectionMode = Word;
3576
3577 if (e->modifiers() & Qt::ShiftModifier) {
3578 // Now select the word under the select anchor
3579 int cs;
3580 int ce;
3581 Kate::TextLine l = doc()->kateTextLine(m_selectAnchor.line());
3582
3583 ce = m_selectAnchor.column();
3584 if (ce > 0 && doc()->highlight()->isInWord(l.at(ce))) {
3585 for (; ce < l.length(); ce++) {
3586 if (!doc()->highlight()->isInWord(l.at(ce))) {
3587 break;
3588 }
3589 }
3590 }
3591
3592 cs = m_selectAnchor.column() - 1;
3593 if (cs < doc()->lineLength(m_selectAnchor.line()) && doc()->highlight()->isInWord(l.at(cs))) {
3594 for (cs--; cs >= 0; cs--) {
3595 if (!doc()->highlight()->isInWord(l.at(cs))) {
3596 break;
3597 }
3598 }
3599 }
3600
3601 // ...and keep it selected
3602 if (cs + 1 < ce) {
3603 m_selectionCached.setStart(KTextEditor::Cursor(m_selectAnchor.line(), cs + 1));
3604 m_selectionCached.setEnd(KTextEditor::Cursor(m_selectAnchor.line(), ce));
3605 } else {
3606 m_selectionCached.setStart(m_selectAnchor);
3607 m_selectionCached.setEnd(m_selectAnchor);
3608 }
3609 // Now word select to the mouse cursor
3610 placeCursor(e->pos(), true);
3611 } else {
3612 // first clear the selection, otherwise we run into bug #106402
3613 // ...and set the cursor position, for the same reason (otherwise there
3614 // are *other* idiosyncrasies we can't fix without reintroducing said
3615 // bug)
3616 // Parameters: don't redraw, and don't emit selectionChanged signal yet
3617 view()->clearSelection(false, false);
3618 placeCursor(e->pos());
3619 view()->selectWord(m_cursor);
3620 cursorToMatchingBracket(true);
3621
3622 if (view()->selection()) {
3623 m_selectAnchor = view()->selectionRange().start();
3624 m_selectionCached = view()->selectionRange();
3625 } else {
3626 m_selectAnchor = m_cursor;
3627 m_selectionCached = KTextEditor::Range(m_cursor, m_cursor);
3628 }
3629 }
3630
3631 // Move cursor to end (or beginning) of selected word
3632#ifndef Q_OS_MACOS
3633 if (view()->selection()) {
3634 QApplication::clipboard()->setText(view()->selectionText(), QClipboard::Selection);
3635 }
3636#endif
3637
3638 moveCursorToSelectionEdge();
3639 m_possibleTripleClick = true;
3640 QTimer::singleShot(QApplication::doubleClickInterval(), this, SLOT(tripleClickTimeout()));
3641
3642 m_scrollX = 0;
3643 m_scrollY = 0;
3644
3645 m_scrollTimer.start(50);
3646
3647 e->accept();
3648 } else {
3649 e->ignore();
3650 }
3651}
3652
3653void KateViewInternal::tripleClickTimeout()
3654{
3655 m_possibleTripleClick = false;
3656}
3657
3658void KateViewInternal::beginSelectLine(const QPoint &pos)
3659{
3660 placeCursor(pos);
3661 m_possibleTripleClick = true; // set so subsequent mousePressEvent will select line
3662}
3663
3664void KateViewInternal::mouseReleaseEvent(QMouseEvent *e)
3665{
3666 if (sendMouseEventToInputContext(e)) {
3667 return;
3668 }
3669
3670 switch (e->button()) {
3671 case Qt::LeftButton:
3672 m_selectionMode = Default;
3673 // m_selectionCached.start().setLine( -1 );
3674
3675 if (m_selChangedByUser) {
3676 if (view()->selection()) {
3677 QApplication::clipboard()->setText(view()->selectionText(), QClipboard::Selection);
3678 }
3679 moveCursorToSelectionEdge();
3680
3681 m_selChangedByUser = false;
3682 }
3683
3684 if (m_dragInfo.state == diPending) {
3685 placeCursor(e->pos(), e->modifiers() & Qt::ShiftModifier);
3686 } else if (m_dragInfo.state == diNone) {
3687 m_scrollTimer.stop();
3688 }
3689
3690 m_dragInfo.state = diNone;
3691
3692 // merge any overlapping selections/cursors
3693 if (view()->selection() && !view()->m_secondaryCursors.empty()) {
3694 mergeSelections();
3695 }
3696
3697 e->accept();
3698 break;
3699
3700 case Qt::MiddleButton:
3701 if (!view()->config()->mousePasteAtCursorPosition()) {
3702 placeCursor(e->pos());
3703 }
3704
3705 if (doc()->isReadWrite()) {
3707 view()->paste(&clipboard);
3708 }
3709
3710 e->accept();
3711 break;
3712
3713 default:
3714 e->ignore();
3715 break;
3716 }
3717}
3718
3719void KateViewInternal::leaveEvent(QEvent *)
3720{
3721 m_textHintTimer.stop();
3722
3723 // fix bug 194452, scrolling keeps going if you scroll via mouse drag and press and other mouse
3724 // button outside the view area
3725 if (m_dragInfo.state == diNone) {
3726 m_scrollTimer.stop();
3727 }
3728
3729 hideBracketMatchPreview();
3730}
3731
3732KTextEditor::Cursor KateViewInternal::coordinatesToCursor(const QPoint &_coord, bool includeBorder) const
3733{
3734 QPoint coord(_coord);
3735
3737
3738 if (includeBorder) {
3739 coord.rx() -= m_leftBorder->width();
3740 }
3741 coord.rx() += startX();
3742
3743 const KateTextLayout &thisLine = yToKateTextLayout(coord.y());
3744 if (thisLine.isValid()) {
3745 ret = renderer()->xToCursor(thisLine, coord.x(), !view()->wrapCursor());
3746 }
3747
3748 if (ret.column() > view()->document()->lineLength(ret.line())) {
3749 // The cursor is beyond the end of the line; in that case the renderer
3750 // gives the index of the character behind the last one.
3752 }
3753
3754 return ret;
3755}
3756
3757void KateViewInternal::mouseMoveEvent(QMouseEvent *e)
3758{
3759 if (m_scroller->state() != QScroller::Inactive) {
3760 // Touchscreen is handled by scrollEvent()
3761 return;
3762 }
3763 KTextEditor::Cursor newPosition = coordinatesToCursor(e->pos(), false);
3764 if (newPosition != m_mouse) {
3765 m_mouse = newPosition;
3766 mouseMoved();
3767 }
3768
3769 if (e->buttons() == Qt::NoButton) {
3770 auto noteData = inlineNoteAt(e->globalPosition().toPoint());
3771 auto focusChanged = false;
3772 if (noteData.m_position.isValid()) {
3773 if (!m_activeInlineNote.m_position.isValid()) {
3774 // no active note -- focus in
3775 tagLine(noteData.m_position);
3776 focusChanged = true;
3777 noteData.m_underMouse = true;
3778 noteData.m_provider->inlineNoteFocusInEvent(KTextEditor::InlineNote(noteData), e->globalPosition().toPoint());
3779 m_activeInlineNote = noteData;
3780 } else {
3781 noteData.m_provider->inlineNoteMouseMoveEvent(KTextEditor::InlineNote(noteData), e->globalPosition().toPoint());
3782 }
3783 } else if (m_activeInlineNote.m_position.isValid()) {
3784 tagLine(m_activeInlineNote.m_position);
3785 focusChanged = true;
3786 m_activeInlineNote.m_underMouse = false;
3787 m_activeInlineNote.m_provider->inlineNoteFocusOutEvent(KTextEditor::InlineNote(m_activeInlineNote));
3788 m_activeInlineNote = {};
3789 }
3790 if (focusChanged) {
3791 // the note might change its appearance in reaction to the focus event
3792 updateDirty();
3793 }
3794 }
3795
3796 if (e->buttons() & Qt::LeftButton) {
3797 if (m_dragInfo.state == diPending) {
3798 // we had a mouse down, but haven't confirmed a drag yet
3799 // if the mouse has moved sufficiently, we will confirm
3800 QPoint p(e->pos() - m_dragInfo.start);
3801
3802 // we've left the drag square, we can start a real drag operation now
3804 doDrag();
3805 }
3806
3807 return;
3808 } else if (m_dragInfo.state == diDragging) {
3809 // Don't do anything after a canceled drag until the user lets go of
3810 // the mouse button!
3811 return;
3812 }
3813
3814 m_mouseX = e->position().x();
3815 m_mouseY = e->position().y();
3816
3817 m_scrollX = 0;
3818 m_scrollY = 0;
3819 int d = renderer()->lineHeight();
3820
3821 if (m_mouseX < 0) {
3822 m_scrollX = -d;
3823 }
3824
3825 if (m_mouseX > width()) {
3826 m_scrollX = d;
3827 }
3828
3829 if (m_mouseY < 0) {
3830 m_mouseY = 0;
3831 m_scrollY = -d;
3832 }
3833
3834 if (m_mouseY > height()) {
3835 m_mouseY = height();
3836 m_scrollY = d;
3837 }
3838
3839 if (!m_scrollY) {
3840 // We are on top of line number area and dragging
3841 // Since we never get negative y, ensure to scroll up
3842 // a bit otherwise we get stuck on the topview line
3843 if (!m_mouseY) {
3844 m_scrollY -= d;
3845 }
3846 placeCursor(QPoint(m_mouseX, m_mouseY), true);
3847 }
3848 } else {
3849 if (view()->config()->textDragAndDrop() && isTargetSelected(e->pos())) {
3850 // mouse is over selected text. indicate that the text is draggable by setting
3851 // the arrow cursor as other Qt text editing widgets do
3852 if (m_mouseCursor != Qt::ArrowCursor) {
3853 m_mouseCursor = Qt::ArrowCursor;
3854 setCursor(m_mouseCursor);
3855 }
3856 } else {
3857 // normal text cursor
3858 if (m_mouseCursor != Qt::IBeamCursor) {
3859 m_mouseCursor = Qt::IBeamCursor;
3860 setCursor(m_mouseCursor);
3861 }
3862 }
3863 // We need to check whether the mouse position is actually within the widget,
3864 // because other widgets like the icon border forward their events to this,
3865 // and we will create invalid text hint requests if we don't check
3866 if (textHintsEnabled() && geometry().contains(parentWidget()->mapFromGlobal(e->globalPosition()).toPoint())) {
3867 if (QToolTip::isVisible()) {
3869 }
3870 m_textHintTimer.start(m_textHintDelay);
3871 m_textHintPos = e->pos();
3872 }
3873 }
3874}
3875
3876void KateViewInternal::updateDirty()
3877{
3878 const int h = renderer()->lineHeight();
3879
3880 int currentRectStart = -1;
3881 int currentRectEnd = -1;
3882
3883 QRegion updateRegion;
3884
3885 {
3886 for (int i = 0; i < cache()->viewCacheLineCount(); ++i) {
3887 if (cache()->viewLine(i).isDirty()) {
3888 if (currentRectStart == -1) {
3889 currentRectStart = h * i;
3890 currentRectEnd = h;
3891 } else {
3892 currentRectEnd += h;
3893 }
3894
3895 } else if (currentRectStart != -1) {
3896 updateRegion += QRect(0, currentRectStart, width(), currentRectEnd);
3897 currentRectStart = -1;
3898 currentRectEnd = -1;
3899 }
3900 }
3901 }
3902
3903 if (currentRectStart != -1) {
3904 updateRegion += QRect(0, currentRectStart, width(), currentRectEnd);
3905 }
3906
3907 if (!updateRegion.isEmpty()) {
3908 if (debugPainting) {
3909 qCDebug(LOG_KTE) << "Update dirty region " << updateRegion;
3910 }
3911 update(updateRegion);
3912 }
3913}
3914
3915void KateViewInternal::hideEvent(QHideEvent *e)
3916{
3917 Q_UNUSED(e);
3918 if (view()->isCompletionActive()) {
3919 view()->completionWidget()->abortCompletion();
3920 }
3921}
3922
3923void KateViewInternal::paintEvent(QPaintEvent *e)
3924{
3925 if (debugPainting) {
3926 qCDebug(LOG_KTE) << "GOT PAINT EVENT: Region" << e->region();
3927 }
3928
3929 const QRect &unionRect = e->rect();
3930
3931 int xStart = startX() + unionRect.x();
3932 int xEnd = xStart + unionRect.width();
3933 uint h = renderer()->lineHeight();
3934 uint startz = (unionRect.y() / h);
3935 uint endz = startz + 1 + (unionRect.height() / h);
3936 uint lineRangesSize = cache()->viewCacheLineCount();
3937 const KTextEditor::Cursor pos = m_cursor;
3938
3939 QPainter paint(this);
3940
3941 // THIS IS ULTRA EVIL AND ADDS STRANGE RENDERING ARTIFACTS WITH SCALING!!!!
3942 // SEE BUG https://bugreports.qt.io/browse/QTBUG-66036
3943 // paint.setRenderHints(QPainter::TextAntialiasing);
3944
3945 paint.save();
3946
3947 renderer()->setCaretStyle(m_currentInputMode->caretStyle());
3948 renderer()->setShowTabs(doc()->config()->showTabs());
3949 renderer()->setShowSpaces(doc()->config()->showSpaces());
3950 renderer()->updateMarkerSize();
3951
3952 // paint line by line
3953 // this includes parts that span areas without real lines
3954 // translate to first line to paint
3955 paint.translate(unionRect.x(), startz * h);
3956 for (uint z = startz; z <= endz; z++) {
3957 // paint regions without lines mapped to
3958 if ((z >= lineRangesSize) || (cache()->viewLine(z).line() == -1)) {
3959 if (!(z >= lineRangesSize)) {
3960 cache()->viewLine(z).setDirty(false);
3961 }
3962 paint.fillRect(0, 0, unionRect.width(), h, m_view->rendererConfig()->backgroundColor());
3963 }
3964
3965 // paint text lines
3966 else {
3967 // If viewLine() returns non-zero, then a document line was split
3968 // in several visual lines, and we're trying to paint visual line
3969 // that is not the first. In that case, this line was already
3970 // painted previously, since KateRenderer::paintTextLine paints
3971 // all visual lines.
3972 //
3973 // Except if we're at the start of the region that needs to
3974 // be painted -- when no previous calls to paintTextLine were made.
3975 KateTextLayout &thisLine = cache()->viewLine(z);
3976 if (!thisLine.viewLine() || z == startz) {
3977 // paint our line
3978 // set clipping region to only paint the relevant parts
3979 paint.save();
3980 const int thisLineTop = h * thisLine.viewLine();
3981 paint.translate(QPoint(0, -thisLineTop));
3982
3983 // compute rect for line, fill the stuff
3984 // important: as we allow some ARGB colors for other stuff, it is REALLY important to fill the full range once!
3985 const QRectF lineRect(0, 0, unionRect.width(), h * thisLine.kateLineLayout()->viewLineCount());
3986 paint.fillRect(lineRect, m_view->rendererConfig()->backgroundColor());
3987
3988 // THIS IS ULTRA EVIL AND ADDS STRANGE RENDERING ARTIFACTS WITH SCALING!!!!
3989 // SEE BUG https://bugreports.qt.io/browse/QTBUG-66036
3990 // => using a QRectF solves the cut of 1 pixel, the same call with QRect does create artifacts!
3991 paint.setClipRect(lineRect);
3992
3993 // QTextLayout::draw does not take into account QPainter's viewport, so it will try to render
3994 // lines outside visible bounds. This causes a significant slowdown when a very long line
3995 // dynamically broken into multiple lines. To avoid this, an explicit text clip rect is set.
3996 const QRect textClipRect{xStart, thisLineTop, xEnd - xStart, height()};
3997
3998 renderer()->paintTextLine(paint, thisLine.kateLineLayout(), xStart, xEnd, textClipRect.toRectF(), &pos);
3999 paint.restore();
4000
4001 // line painted, reset and state + mark line as non-dirty
4002 thisLine.setDirty(false);
4003 }
4004 }
4005
4006 // translate to next line
4007 paint.translate(0, h);
4008 }
4009
4010 paint.restore();
4011
4012 if (m_textAnimation) {
4013 m_textAnimation->draw(paint);
4014 }
4015}
4016
4017void KateViewInternal::resizeEvent(QResizeEvent *e)
4018{
4019 bool expandedHorizontally = width() > e->oldSize().width();
4020 bool expandedVertically = height() > e->oldSize().height();
4021 bool heightChanged = height() != e->oldSize().height();
4022
4023 m_dummy->setFixedSize(m_lineScroll->width(), m_columnScroll->sizeHint().height());
4024 m_madeVisible = false;
4025
4026 // resize the bracket match preview
4027 if (m_bmPreview) {
4028 showBracketMatchPreview();
4029 }
4030
4031 if (heightChanged) {
4032 setAutoCenterLines(m_autoCenterLines, false);
4033 m_cachedMaxStartPos.setPosition(-1, -1);
4034 }
4035
4036 if (view()->dynWordWrap()) {
4037 bool dirtied = false;
4038
4039 for (int i = 0; i < cache()->viewCacheLineCount(); i++) {
4040 // find the first dirty line
4041 // the word wrap updateView algorithm is forced to check all lines after a dirty one
4042 KateTextLayout viewLine = cache()->viewLine(i);
4043
4044 if (viewLine.wrap() || viewLine.isRightToLeft() || viewLine.width() > width()) {
4045 dirtied = true;
4046 viewLine.setDirty();
4047 break;
4048 }
4049 }
4050
4051 if (dirtied || heightChanged) {
4052 updateView(true);
4053 m_leftBorder->update();
4054 }
4055 } else {
4056 updateView();
4057
4058 if (expandedHorizontally && startX() > 0) {
4059 scrollColumns(startX() - (width() - e->oldSize().width()));
4060 }
4061 }
4062
4063 if (width() < e->oldSize().width() && !view()->wrapCursor()) {
4064 // May have to restrain cursor to new smaller width...
4065 if (m_cursor.column() > doc()->lineLength(m_cursor.line())) {
4066 KateTextLayout thisLine = currentLayout(m_cursor);
4067
4068 KTextEditor::Cursor newCursor(m_cursor.line(),
4069 thisLine.endCol() + ((width() - thisLine.xOffset() - (thisLine.width() - startX())) / renderer()->spaceWidth()) - 1);
4070 if (newCursor.column() < m_cursor.column()) {
4071 updateCursor(newCursor);
4072 }
4073 }
4074 }
4075
4076 if (expandedVertically) {
4077 KTextEditor::Cursor max = maxStartPos();
4078 if (startPos() > max) {
4079 scrollPos(max);
4080 return; // already fired displayRangeChanged
4081 }
4082 }
4083 Q_EMIT view()->displayRangeChanged(m_view);
4084}
4085
4086void KateViewInternal::moveEvent(QMoveEvent *e)
4087{
4088 // move the bracket match preview to the new location
4089 if (e->pos() != e->oldPos() && m_bmPreview) {
4090 showBracketMatchPreview();
4091 }
4092
4094}
4095
4096void KateViewInternal::scrollTimeout()
4097{
4098 if (m_scrollX || m_scrollY) {
4099 const int scrollTo = startPos().line() + (m_scrollY / (int)renderer()->lineHeight());
4100 placeCursor(QPoint(m_mouseX, m_mouseY), true);
4101 scrollLines(scrollTo);
4102 }
4103}
4104
4105void KateViewInternal::cursorTimeout()
4106{
4107 if (!debugPainting && m_currentInputMode->blinkCaret()) {
4108 renderer()->setDrawCaret(!renderer()->drawCaret());
4109 paintCursor();
4110 }
4111}
4112
4113void KateViewInternal::textHintTimeout()
4114{
4115 m_textHintTimer.stop();
4116
4117 KTextEditor::Cursor c = coordinatesToCursor(m_textHintPos, false);
4118 if (!c.isValid()) {
4119 return;
4120 }
4121
4122 QStringList textHints;
4123 for (KTextEditor::TextHintProvider *const p : m_textHintProviders) {
4124 if (!p) {
4125 continue;
4126 }
4127
4128 const QString hint = p->textHint(m_view, c);
4129 if (!hint.isEmpty()) {
4130 textHints.append(hint);
4131 }
4132 }
4133
4134 if (!textHints.isEmpty()) {
4135 qCDebug(LOG_KTE) << "Hint text: " << textHints;
4136 QString hint;
4137 for (const QString &str : std::as_const(textHints)) {
4138 hint += QStringLiteral("<p>%1</p>").arg(str);
4139 }
4140 QPoint pos(startX() + m_textHintPos.x(), m_textHintPos.y());
4142 }
4143}
4144
4145void KateViewInternal::focusInEvent(QFocusEvent *)
4146{
4148 m_cursorTimer.start(QApplication::cursorFlashTime() / 2);
4149 }
4150
4151 paintCursor();
4152
4153 doc()->setActiveView(m_view);
4154
4155 // this will handle focus stuff in kateview
4156 view()->slotGotFocus();
4157}
4158
4159void KateViewInternal::focusOutEvent(QFocusEvent *)
4160{
4161 // if (view()->isCompletionActive())
4162 // view()->abortCompletion();
4163
4164 m_cursorTimer.stop();
4165 view()->renderer()->setDrawCaret(true);
4166 paintCursor();
4167
4168 m_textHintTimer.stop();
4169
4170 view()->slotLostFocus();
4171
4172 hideBracketMatchPreview();
4173}
4174
4175void KateViewInternal::doDrag()
4176{
4177 m_dragInfo.state = diDragging;
4178 m_dragInfo.dragObject = new QDrag(this);
4179 std::unique_ptr<QMimeData> mimeData(new QMimeData());
4180 mimeData->setText(view()->selectionText());
4181
4182 const auto startCur = view()->selectionRange().start();
4183 const auto endCur = view()->selectionRange().end();
4184 if (!startCur.isValid() || !endCur.isValid()) {
4185 return;
4186 }
4187
4188 int startLine = startCur.line();
4189 int endLine = endCur.line();
4190
4191 /**
4192 * Get real first and last visible line nos.
4193 * This is important as startLine() / endLine() are virtual and we can't use
4194 * them here
4195 */
4196 const int firstVisibleLine = view()->firstDisplayedLineInternal(KTextEditor::View::RealLine);
4197 const int lastVisibleLine = view()->lastDisplayedLineInternal(KTextEditor::View::RealLine);
4198
4199 // get visible selected lines
4200 for (int l = startLine; l <= endLine; ++l) {
4201 if (l >= firstVisibleLine) {
4202 break;
4203 }
4204 ++startLine;
4205 }
4206 for (int l = endLine; l >= startLine; --l) {
4207 if (l <= lastVisibleLine) {
4208 break;
4209 }
4210 --endLine;
4211 }
4212
4213 // calculate the height / width / scale
4214 int w = 0;
4215 int h = 0;
4216 const QFontMetricsF &fm = renderer()->currentFontMetrics();
4217 for (int l = startLine; l <= endLine; ++l) {
4218 w = std::max((int)fm.horizontalAdvance(doc()->line(l)), w);
4219 h += renderer()->lineHeight();
4220 }
4221 qreal scale = h > m_view->height() / 2 ? 0.75 : 1.0;
4222
4223 // Calculate start x pos on start line
4224 int sX = 0;
4225 if (startLine == startCur.line()) {
4226 sX = renderer()->cursorToX(cache()->textLayout(startCur), startCur, !view()->wrapCursor());
4227 }
4228
4229 // Calculate end x pos on end line
4230 int eX = 0;
4231 if (endLine == endCur.line()) {
4232 eX = renderer()->cursorToX(cache()->textLayout(endCur), endCur, !view()->wrapCursor());
4233 }
4234
4235 // These are the occurunce highlights, the ones you get when you select a word
4236 // We clear them here so that they don't come up in the dragged pixmap
4237 // After we are done creating the pixmap, we restore them
4238 if (view()->selection()) {
4239 view()->clearHighlights();
4240 }
4241
4242 // Create a pixmap this selection
4243 const qreal dpr = devicePixelRatioF();
4244 QPixmap pixmap(w * dpr, h * dpr);
4245 if (!pixmap.isNull()) {
4246 pixmap.setDevicePixelRatio(dpr);
4247 pixmap.fill(Qt::transparent);
4248 renderer()->paintSelection(&pixmap, startLine, sX, endLine, eX, scale);
4249
4250 if (view()->selection()) {
4251 // Tell the view to restore the highlights
4252 Q_EMIT view()->selectionChanged(view());
4253 }
4254 }
4255
4256 // Calculate position where pixmap will appear when user
4257 // starts dragging
4258 const int x = 0;
4259 /**
4260 * lineToVisibleLine() = real line => virtual line
4261 * This is necessary here because if there is a folding in the current
4262 * view lines, the y pos can be incorrect. So, we make sure to convert
4263 * it to virtual line before calculating y
4264 */
4265 const int y = lineToY(view()->m_textFolding.lineToVisibleLine(startLine));
4266 const QPoint pos = mapFromGlobal(QCursor::pos()) - QPoint(x, y);
4267
4268 m_dragInfo.dragObject->setPixmap(pixmap);
4269 m_dragInfo.dragObject->setHotSpot(pos);
4270 m_dragInfo.dragObject->setMimeData(mimeData.release());
4271 m_dragInfo.dragObject->exec(Qt::MoveAction | Qt::CopyAction);
4272}
4273
4274void KateViewInternal::dragEnterEvent(QDragEnterEvent *event)
4275{
4276 if (event->source() == this) {
4277 event->setDropAction(Qt::MoveAction);
4278 }
4279 event->setAccepted((event->mimeData()->hasText() && doc()->isReadWrite()) || event->mimeData()->hasUrls());
4280}
4281
4282void KateViewInternal::fixDropEvent(QDropEvent *event)
4283{
4284 if (event->source() != this) {
4285 event->setDropAction(Qt::CopyAction);
4286 } else {
4288#ifdef Q_WS_MAC
4289 if (event->modifiers() & Qt::AltModifier) {
4290 action = Qt::CopyAction;
4291 }
4292#else
4293 if (event->modifiers() & Qt::ControlModifier) {
4294 action = Qt::CopyAction;
4295 }
4296#endif
4297 event->setDropAction(action);
4298 }
4299}
4300
4301void KateViewInternal::dragMoveEvent(QDragMoveEvent *event)
4302{
4303 // track the cursor to the current drop location
4304 placeCursor(event->position().toPoint(), true, false);
4305
4306 // important: accept action to switch between copy and move mode
4307 // without this, the text will always be copied.
4308 fixDropEvent(event);
4309}
4310
4311void KateViewInternal::dropEvent(QDropEvent *event)
4312{
4313 // if we have urls, pass this event off to the hosting application
4314 if (event->mimeData()->hasUrls()) {
4315 Q_EMIT dropEventPass(event);
4316 return;
4317 }
4318
4319 if (event->mimeData()->hasText() && doc()->isReadWrite()) {
4320 const QString text = event->mimeData()->text();
4321 const bool blockMode = view()->blockSelection();
4322
4323 fixDropEvent(event);
4324
4325 // Remember where to paste/move...
4326 KTextEditor::Cursor targetCursor(m_cursor);
4327 // Use powerful MovingCursor to track our changes we may do
4328 std::unique_ptr<KTextEditor::MovingCursor> targetCursor2(doc()->newMovingCursor(m_cursor));
4329
4330 // As always need the BlockMode some special treatment
4331 const KTextEditor::Range selRange(view()->selectionRange());
4332 const KTextEditor::Cursor blockAdjust(selRange.numberOfLines(), selRange.columnWidth());
4333
4334 // Restore the cursor position before editStart(), so that it is correctly stored for the undo action
4335 if (event->dropAction() != Qt::CopyAction) {
4336 editSetCursor(selRange.end());
4337 } else {
4338 view()->clearSelection();
4339 }
4340
4341 // use one transaction
4342 doc()->editStart();
4343
4344 if (event->dropAction() != Qt::CopyAction) {
4345 view()->removeSelectedText();
4346 if (targetCursor2->toCursor() != targetCursor) {
4347 // Hm, multi line selection moved down, we need to adjust our dumb cursor
4348 targetCursor = targetCursor2->toCursor();
4349 }
4350 doc()->insertText(targetCursor2->toCursor(), text, blockMode);
4351
4352 } else {
4353 doc()->insertText(targetCursor, text, blockMode);
4354 }
4355
4356 if (blockMode) {
4357 setSelection(KTextEditor::Range(targetCursor, targetCursor + blockAdjust));
4358 editSetCursor(targetCursor + blockAdjust);
4359 } else {
4360 setSelection(KTextEditor::Range(targetCursor, targetCursor2->toCursor()));
4361 editSetCursor(targetCursor2->toCursor()); // Just to satisfy autotest
4362 }
4363
4364 doc()->editEnd();
4365
4366 event->acceptProposedAction();
4367 updateView();
4368 }
4369
4370 // finally finish drag and drop mode
4371 m_dragInfo.state = diNone;
4372 // important, because the eventFilter`s DragLeave does not occur
4373 stopDragScroll();
4374}
4375// END EVENT HANDLING STUFF
4376
4377void KateViewInternal::clear()
4378{
4379 m_startPos.setPosition(0, 0);
4380 m_displayCursor = KTextEditor::Cursor(0, 0);
4381 m_cursor.setPosition(0, 0);
4382 view()->clearSecondaryCursors();
4383 cache()->clear();
4384 updateView(true);
4385 m_lineScroll->updatePixmap();
4386}
4387
4388void KateViewInternal::wheelEvent(QWheelEvent *e)
4389{
4390 // check if this event should change the font size (Ctrl pressed, angle reported and not accidentally so)
4391 // Note: if detectZoomingEvent() doesn't unset the ControlModifier we'll get accelerated scrolling.
4392 if (m_zoomEventFilter->detectZoomingEvent(e)) {
4393 if (e->angleDelta().y() > 0) {
4394 slotIncFontSizes(qreal(e->angleDelta().y()) / (qreal)QWheelEvent::DefaultDeltasPerStep);
4395 } else if (e->angleDelta().y() < 0) {
4396 slotDecFontSizes(qreal(-e->angleDelta().y()) / (qreal)QWheelEvent::DefaultDeltasPerStep);
4397 }
4398
4399 // accept always and be done for zooming
4400 e->accept();
4401 return;
4402 }
4403
4404 // handle vertical scrolling via the scrollbar
4405 if (e->angleDelta().y() != 0) {
4406 // compute distance
4407 auto sign = m_lineScroll->invertedControls() ? -1 : 1;
4408 auto offset = sign * qreal(e->angleDelta().y()) / 120.0;
4409 if (e->modifiers() & Qt::ShiftModifier) {
4410 const auto pageStep = m_lineScroll->pageStep();
4411 offset = qBound(-pageStep, int(offset * pageStep), pageStep);
4412 } else {
4414 }
4415
4416 // handle accumulation
4417 m_accumulatedScroll += offset - int(offset);
4418 const auto extraAccumulated = int(m_accumulatedScroll);
4419 m_accumulatedScroll -= extraAccumulated;
4420
4421 // do scroll
4422 scrollViewLines(int(offset) + extraAccumulated);
4423 e->accept();
4424 }
4425
4426 // handle horizontal scrolling via the scrollbar
4427 if (e->angleDelta().x() != 0) {
4428 // if we have dyn word wrap, we should ignore the scroll events
4429 if (view()->dynWordWrap()) {
4430 e->accept();
4431 return;
4432 }
4433
4434 // if we scroll up/down we do not want to trigger unintended sideways scrolls
4435 if (qAbs(e->angleDelta().y()) > qAbs(e->angleDelta().x())) {
4436 e->accept();
4437 return;
4438 }
4439
4440 if (QApplication::sendEvent(m_columnScroll, e)) {
4441 e->accept();
4442 }
4443 }
4444
4445 // hide bracket match preview so that it won't linger while scrolling'
4446 hideBracketMatchPreview();
4447}
4448
4449void KateViewInternal::scrollPrepareEvent(QScrollPrepareEvent *event)
4450{
4451 int lineHeight = renderer()->lineHeight();
4452 event->setViewportSize(QSizeF(0.0, 0.0));
4453 event->setContentPosRange(QRectF(0.0, 0.0, 0.0, m_lineScroll->maximum() * lineHeight));
4454 event->setContentPos(QPointF(0.0, m_lineScroll->value() * lineHeight));
4455 event->accept();
4456}
4457
4458void KateViewInternal::scrollEvent(QScrollEvent *event)
4459{
4460 // FIXME Add horizontal scrolling, overscroll, scroll between lines, and word wrap awareness
4461 KTextEditor::Cursor newPos((int)event->contentPos().y() / renderer()->lineHeight(), 0);
4462 scrollPos(newPos);
4463 event->accept();
4464}
4465
4466void KateViewInternal::startDragScroll()
4467{
4468 if (!m_dragScrollTimer.isActive()) {
4469 m_dragScrollTimer.start(s_scrollTime);
4470 }
4471}
4472
4473void KateViewInternal::stopDragScroll()
4474{
4475 m_dragScrollTimer.stop();
4476 updateView();
4477}
4478
4479void KateViewInternal::doDragScroll()
4480{
4481 QPoint p = this->mapFromGlobal(QCursor::pos());
4482
4483 int dx = 0;
4484 int dy = 0;
4485 if (p.y() < s_scrollMargin) {
4486 dy = p.y() - s_scrollMargin;
4487 } else if (p.y() > height() - s_scrollMargin) {
4488 dy = s_scrollMargin - (height() - p.y());
4489 }
4490
4491 if (p.x() < s_scrollMargin) {
4492 dx = p.x() - s_scrollMargin;
4493 } else if (p.x() > width() - s_scrollMargin) {
4494 dx = s_scrollMargin - (width() - p.x());
4495 }
4496
4497 dy /= 4;
4498
4499 if (dy) {
4500 scrollLines(startLine() + dy);
4501 }
4502
4503 if (columnScrollingPossible() && dx) {
4504 scrollColumns(qMin(startX() + dx, m_columnScroll->maximum()));
4505 }
4506
4507 if (!dy && !dx) {
4508 stopDragScroll();
4509 }
4510}
4511
4512void KateViewInternal::registerTextHintProvider(KTextEditor::TextHintProvider *provider)
4513{
4514 if (std::find(m_textHintProviders.cbegin(), m_textHintProviders.cend(), provider) == m_textHintProviders.cend()) {
4515 m_textHintProviders.push_back(provider);
4516 }
4517
4518 // we have a client, so start timeout
4519 m_textHintTimer.start(m_textHintDelay);
4520}
4521
4522void KateViewInternal::unregisterTextHintProvider(KTextEditor::TextHintProvider *provider)
4523{
4524 const auto it = std::find(m_textHintProviders.cbegin(), m_textHintProviders.cend(), provider);
4525 if (it != m_textHintProviders.cend()) {
4526 m_textHintProviders.erase(it);
4527 }
4528
4529 if (m_textHintProviders.empty()) {
4530 m_textHintTimer.stop();
4531 }
4532}
4533
4534void KateViewInternal::setTextHintDelay(int delay)
4535{
4536 if (delay <= 0) {
4537 m_textHintDelay = 200; // ms
4538 } else {
4539 m_textHintDelay = delay; // ms
4540 }
4541}
4542
4543int KateViewInternal::textHintDelay() const
4544{
4545 return m_textHintDelay;
4546}
4547
4548bool KateViewInternal::textHintsEnabled()
4549{
4550 return !m_textHintProviders.empty();
4551}
4552
4553// BEGIN EDIT STUFF
4554void KateViewInternal::editStart()
4555{
4556 editSessionNumber++;
4557
4558 if (editSessionNumber > 1) {
4559 return;
4560 }
4561
4562 editIsRunning = true;
4563 editOldCursor = m_cursor;
4564 editOldSelection = view()->selectionRange();
4565}
4566
4567void KateViewInternal::editEnd(int editTagLineStart, int editTagLineEnd, bool tagFrom)
4568{
4569 if (editSessionNumber == 0) {
4570 return;
4571 }
4572
4573 editSessionNumber--;
4574
4575 if (editSessionNumber > 0) {
4576 return;
4577 }
4578
4579 // fix start position, might have moved from column 0
4580 // try to clever calculate the right start column for the tricky dyn word wrap case
4581 int col = 0;
4582 if (view()->dynWordWrap()) {
4583 if (KateLineLayout *layout = cache()->line(startLine())) {
4584 int index = layout->viewLineForColumn(startPos().column());
4585 if (index >= 0 && index < layout->viewLineCount()) {
4586 col = layout->viewLine(index).startCol();
4587 }
4588 }
4589 }
4590 m_startPos.setPosition(startLine(), col);
4591
4592 if (tagFrom && (editTagLineStart <= int(view()->textFolding().visibleLineToLine(startLine())))) {
4593 tagAll();
4594 } else {
4595 tagLines(editTagLineStart, tagFrom ? qMax(doc()->lastLine() + 1, editTagLineEnd) : editTagLineEnd, true);
4596 }
4597
4598 if (editOldCursor == m_cursor.toCursor()) {
4599 updateBracketMarks();
4600 }
4601
4602 updateView(true);
4603
4604 if (editOldCursor != m_cursor.toCursor() || m_view == doc()->activeView()) {
4605 // Only scroll the view to the cursor if the insertion happens at the cursor.
4606 // This might not be the case for e.g. collaborative editing, when a remote user
4607 // inserts text at a position not at the caret.
4608 if (m_cursor.line() >= editTagLineStart && m_cursor.line() <= editTagLineEnd) {
4609 m_madeVisible = false;
4610 updateCursor(m_cursor, true);
4611 }
4612 }
4613
4614 // selection changed?
4615 // fixes bug 316226
4616 if (editOldSelection != view()->selectionRange()
4617 || (editOldSelection.isValid() && !editOldSelection.isEmpty()
4618 && !(editTagLineStart > editOldSelection.end().line() && editTagLineEnd < editOldSelection.start().line()))) {
4619 Q_EMIT view()->selectionChanged(m_view);
4620 }
4621
4622 editIsRunning = false;
4623}
4624
4625void KateViewInternal::editSetCursor(const KTextEditor::Cursor _cursor)
4626{
4627 if (m_cursor.toCursor() != _cursor) {
4628 m_cursor.setPosition(_cursor);
4629 }
4630}
4631// END
4632
4633void KateViewInternal::viewSelectionChanged()
4634{
4635 if (!view()->selection()) {
4636 m_selectAnchor = KTextEditor::Cursor::invalid();
4637 } else {
4638 const auto r = view()->selectionRange();
4639 m_selectAnchor = r.start() == m_cursor ? r.end() : r.start();
4640 }
4641 // Do NOT nuke the entire range! The reason is that a shift+DC selection
4642 // might (correctly) set the range to be empty (i.e. start() == end()), and
4643 // subsequent dragging might shrink the selection into non-existence. When
4644 // this happens, we use the cached end to restore the cached start so that
4645 // updateSelection is not confused. See also comments in updateSelection.
4646 m_selectionCached.setStart(KTextEditor::Cursor::invalid());
4648}
4649
4650KateLayoutCache *KateViewInternal::cache() const
4651{
4652 return m_layoutCache;
4653}
4654
4655KTextEditor::Cursor KateViewInternal::toRealCursor(const KTextEditor::Cursor virtualCursor) const
4656{
4657 return KTextEditor::Cursor(view()->textFolding().visibleLineToLine(virtualCursor.line()), virtualCursor.column());
4658}
4659
4660KTextEditor::Cursor KateViewInternal::toVirtualCursor(const KTextEditor::Cursor realCursor) const
4661{
4662 // only convert valid lines, folding doesn't like invalid input!
4663 // don't validate whole cursor, column might be -1
4664 if (realCursor.line() < 0) {
4666 }
4667
4668 return KTextEditor::Cursor(view()->textFolding().lineToVisibleLine(realCursor.line()), realCursor.column());
4669}
4670
4671KateRenderer *KateViewInternal::renderer() const
4672{
4673 return view()->renderer();
4674}
4675
4676void KateViewInternal::mouseMoved()
4677{
4678 view()->notifyMousePositionChanged(m_mouse);
4679 view()->updateRangesIn(KTextEditor::Attribute::ActivateMouseIn);
4680}
4681
4682void KateViewInternal::cursorMoved()
4683{
4684 view()->updateRangesIn(KTextEditor::Attribute::ActivateCaretIn);
4685
4686#ifndef QT_NO_ACCESSIBILITY
4687 if (view()->m_accessibilityEnabled && QAccessible::isActive()) {
4688 QAccessibleTextCursorEvent ev(this, static_cast<KateViewAccessible *>(QAccessible::queryAccessibleInterface(this))->positionFromCursor(this, m_cursor));
4690 }
4691#endif
4692}
4693
4694KTextEditor::DocumentPrivate *KateViewInternal::doc()
4695{
4696 return m_view->doc();
4697}
4698
4699KTextEditor::DocumentPrivate *KateViewInternal::doc() const
4700{
4701 return m_view->doc();
4702}
4703
4704bool KateViewInternal::rangeAffectsView(KTextEditor::Range range, bool realCursors) const
4705{
4706 int startLine = KateViewInternal::startLine();
4707 int endLine = startLine + (int)m_visibleLineCount;
4708
4709 if (realCursors) {
4710 startLine = (int)view()->textFolding().visibleLineToLine(startLine);
4711 endLine = (int)view()->textFolding().visibleLineToLine(endLine);
4712 }
4713
4714 return (range.end().line() >= startLine) || (range.start().line() <= endLine);
4715}
4716
4717// BEGIN IM INPUT STUFF
4718QVariant KateViewInternal::inputMethodQuery(Qt::InputMethodQuery query) const
4719{
4720 switch (query) {
4721 case Qt::ImCursorRectangle: {
4722 // Cursor placement code is changed for Asian input method that
4723 // shows candidate window. This behavior is same as Qt/E 2.3.7
4724 // which supports Asian input methods. Asian input methods need
4725 // start point of IM selection text to place candidate window as
4726 // adjacent to the selection text.
4727 //
4728 // in Qt5, cursor rectangle is used as QRectF internally, and it
4729 // will be checked by QRectF::isValid(), which will mark rectangle
4730 // with width == 0 or height == 0 as invalid.
4731 auto lineHeight = renderer()->lineHeight();
4732 return QRect(cursorToCoordinate(m_cursor, true, false), QSize(1, lineHeight ? lineHeight : 1));
4733 }
4734
4735 case Qt::ImFont:
4736 return renderer()->currentFont();
4737
4739 return m_cursor.column();
4740
4742 // If selectAnchor is at the same line, return the real anchor position
4743 // Otherwise return the same position of cursor
4744 if (view()->selection() && m_selectAnchor.line() == m_cursor.line()) {
4745 return m_selectAnchor.column();
4746 } else {
4747 return m_cursor.column();
4748 }
4749
4751 return doc()->kateTextLine(m_cursor.line()).text();
4752
4754 if (view()->selection()) {
4755 return view()->selectionText();
4756 } else {
4757 return QString();
4758 }
4759 default:
4760 /* values: ImMaximumTextLength */
4761 break;
4762 }
4763
4764 return QWidget::inputMethodQuery(query);
4765}
4766
4767void KateViewInternal::inputMethodEvent(QInputMethodEvent *e)
4768{
4769 if (doc()->readOnly()) {
4770 e->ignore();
4771 return;
4772 }
4773
4774 // qCDebug(LOG_KTE) << "Event: cursor" << m_cursor << "commit" << e->commitString() << "preedit" << e->preeditString() << "replacement start" <<
4775 // e->replacementStart() << "length" << e->replacementLength();
4776
4777 if (!m_imPreeditRange) {
4778 m_imPreeditRange.reset(
4780 }
4781
4782 if (!m_imPreeditRange->toRange().isEmpty()) {
4783 doc()->inputMethodStart();
4784 doc()->removeText(*m_imPreeditRange);
4785 doc()->inputMethodEnd();
4786 }
4787
4788 if (!e->commitString().isEmpty() || e->replacementLength() || !e->preeditString().isEmpty()) {
4789 view()->removeSelectedText();
4790 }
4791
4792 if (!e->commitString().isEmpty() || e->replacementLength()) {
4793 KTextEditor::Range preeditRange = *m_imPreeditRange;
4794
4795 KTextEditor::Cursor start(m_imPreeditRange->start().line(), m_imPreeditRange->start().column() + e->replacementStart());
4797
4798 doc()->editStart();
4799 if (start != removeEnd) {
4800 doc()->removeText(KTextEditor::Range(start, removeEnd));
4801 }
4802
4803 // if the input method event is text that should be inserted, call KTextEditor::DocumentPrivate::typeChars()
4804 // with the text. that method will handle the input and take care of overwrite mode, etc.
4805 // we call this via keyPressEvent, as that handles our input methods, see bug 357062
4807 keyPressEvent(&ke);
4808
4809 doc()->editEnd();
4810
4811 // Revert to the same range as above
4812 m_imPreeditRange->setRange(preeditRange);
4813 }
4814
4815 if (!e->preeditString().isEmpty()) {
4816 doc()->inputMethodStart();
4817 doc()->insertText(m_imPreeditRange->start(), e->preeditString());
4818 doc()->inputMethodEnd();
4819 // The preedit range gets automatically repositioned
4820 }
4821
4822 // Finished this input method context?
4823 if (m_imPreeditRange && e->preeditString().isEmpty()) {
4824 // delete the range and reset the pointer
4825 m_imPreeditRange.reset();
4826 m_imPreeditRangeChildren.clear();
4827
4829 renderer()->setDrawCaret(false);
4830 }
4831 renderer()->setCaretOverrideColor(QColor());
4832
4833 e->accept();
4834 return;
4835 }
4836
4837 KTextEditor::Cursor newCursor = m_cursor;
4838 bool hideCursor = false;
4839 QColor caretColor;
4840
4841 if (m_imPreeditRange) {
4842 m_imPreeditRangeChildren.clear();
4843
4844 int decorationColumn = 0;
4845 const auto &attributes = e->attributes();
4846 for (auto &a : attributes) {
4847 if (a.type == QInputMethodEvent::Cursor) {
4848 const int cursor = qMin(a.start, e->preeditString().length());
4849 newCursor = m_imPreeditRange->start() + KTextEditor::Cursor(0, cursor);
4850 hideCursor = !a.length;
4851 QColor c = qvariant_cast<QColor>(a.value);
4852 if (c.isValid()) {
4853 caretColor = c;
4854 }
4855
4856 } else if (a.type == QInputMethodEvent::TextFormat) {
4857 QTextCharFormat f = qvariant_cast<QTextFormat>(a.value).toCharFormat();
4858 const int start = qMin(a.start, e->preeditString().length());
4859 const int end = qMin(a.start + a.length, e->preeditString().length());
4860 if (f.isValid() && decorationColumn <= start && start != end) {
4861 const KTextEditor::MovingCursor &preEditRangeStart = m_imPreeditRange->start();
4862 const int startLine = preEditRangeStart.line();
4863 const int startCol = preEditRangeStart.column();
4864 KTextEditor::Range fr(startLine, startCol + start, startLine, startCol + end);
4865 std::unique_ptr<KTextEditor::MovingRange> formatRange(doc()->newMovingRange(fr));
4867 attribute->merge(f);
4868 formatRange->setAttribute(attribute);
4869 decorationColumn = end;
4870 m_imPreeditRangeChildren.push_back(std::move(formatRange));
4871 }
4872 }
4873 }
4874 }
4875
4876 renderer()->setDrawCaret(hideCursor);
4877 renderer()->setCaretOverrideColor(caretColor);
4878
4879 if (newCursor != m_cursor.toCursor()) {
4880 updateCursor(newCursor);
4881 }
4882
4883 e->accept();
4884}
4885
4886// END IM INPUT STUFF
4887
4888void KateViewInternal::flashChar(const KTextEditor::Cursor pos, KTextEditor::Attribute::Ptr attribute)
4889{
4890 Q_ASSERT(pos.isValid());
4891 Q_ASSERT(attribute.constData());
4892
4893 // if line is folded away, do nothing
4894 if (!view()->textFolding().isLineVisible(pos.line())) {
4895 return;
4896 }
4897
4898 KTextEditor::Range range(pos, KTextEditor::Cursor(pos.line(), pos.column() + 1));
4899 if (m_textAnimation) {
4900 m_textAnimation->deleteLater();
4901 }
4902 m_textAnimation = new KateTextAnimation(range, std::move(attribute), this);
4903}
4904
4905void KateViewInternal::showBracketMatchPreview()
4906{
4907 // only show when main window is active
4908 if (window() && !window()->isActiveWindow()) {
4909 return;
4910 }
4911
4912 const KTextEditor::Cursor openBracketCursor = m_bmStart->start();
4913 // make sure that the matching bracket is an opening bracket that is not visible on the current view, and that the preview won't be blocking the cursor
4914 if (m_cursor == openBracketCursor || toVirtualCursor(openBracketCursor).line() >= startLine() || m_cursor.line() - startLine() < 2) {
4915 hideBracketMatchPreview();
4916 return;
4917 }
4918
4919 if (!m_bmPreview) {
4920 m_bmPreview.reset(new KateTextPreview(m_view, this));
4921 m_bmPreview->setAttribute(Qt::WA_ShowWithoutActivating);
4922 m_bmPreview->setFrameStyle(QFrame::Box);
4923 }
4924
4925 const int previewLine = openBracketCursor.line();
4926 KateRenderer *const renderer_ = renderer();
4927 KateLineLayout *lineLayout(new KateLineLayout(*renderer_));
4928 lineLayout->setLine(previewLine, -1);
4929
4930 // If the opening bracket is on its own line, start preview at the line above it instead (where the context is likely to be)
4931 const int col = lineLayout->textLine().firstChar();
4932 if (previewLine > 0 && (col == -1 || col == openBracketCursor.column())) {
4933 lineLayout->setLine(previewLine - 1, lineLayout->virtualLine() - 1);
4934 }
4935
4936 renderer_->layoutLine(lineLayout, -1 /* no wrap */, false /* no layout cache */);
4937 const int lineWidth =
4938 qBound(m_view->width() / 5, int(lineLayout->width() + renderer_->spaceWidth() * 2), m_view->width() - m_leftBorder->width() - m_lineScroll->width());
4939 m_bmPreview->resize(lineWidth, renderer_->lineHeight() * 2);
4940 const QPoint topLeft = mapToGlobal(QPoint(0, 0));
4941 m_bmPreview->move(topLeft.x(), topLeft.y());
4942 m_bmPreview->setLine(lineLayout->virtualLine());
4943 m_bmPreview->setCenterView(false);
4944 m_bmPreview->raise();
4945 m_bmPreview->show();
4946}
4947
4948void KateViewInternal::hideBracketMatchPreview()
4949{
4950 m_bmPreview.reset();
4951}
4952
4953void KateViewInternal::documentTextInserted(KTextEditor::Document *, KTextEditor::Range range)
4954{
4955#ifndef QT_NO_ACCESSIBILITY
4956 if (view()->m_accessibilityEnabled && QAccessible::isActive()) {
4957 auto doc = view()->doc();
4958 QAccessibleTextInsertEvent ev(this, doc->cursorToOffset(range.start()), doc->text(range));
4960 }
4961#endif
4962}
4963
4964void KateViewInternal::documentTextRemoved(KTextEditor::Document * /*document*/, KTextEditor::Range range, const QString &oldText)
4965{
4966#ifndef QT_NO_ACCESSIBILITY
4967 if (view()->m_accessibilityEnabled && QAccessible::isActive()) {
4968 auto doc = view()->doc();
4969 QAccessibleTextRemoveEvent ev(this, doc->cursorToOffset(range.start()), oldText);
4971 }
4972#endif
4973}
4974
4975QRect KateViewInternal::inlineNoteRect(const KateInlineNoteData &noteData) const
4976{
4977 KTextEditor::InlineNote note(noteData);
4978 // compute note width and position
4979 const auto noteWidth = note.width();
4980 auto noteCursor = note.position();
4981
4982 // The cursor might be outside of the text. In that case, clamp it to the text and
4983 // later on add the missing x offset.
4984 const auto lineLength = view()->document()->lineLength(noteCursor.line());
4985 int extraOffset = -noteWidth;
4986 if (noteCursor.column() == lineLength) {
4987 extraOffset = 0;
4988 } else if (noteCursor.column() > lineLength) {
4989 extraOffset = (noteCursor.column() - lineLength) * renderer()->spaceWidth();
4990 noteCursor.setColumn(lineLength);
4991 }
4992 auto noteStartPos = mapToGlobal(cursorToCoordinate(noteCursor, true, false));
4993 bool rtl = false;
4994 if (view()->dynWordWrap()) {
4995 const KateLineLayout *lineLayout = cache()->line(noteCursor.line());
4996 rtl = lineLayout && lineLayout->layout()->textOption().textDirection() == Qt::RightToLeft;
4997 }
4998 if (rtl) {
4999 noteStartPos.rx() -= note.width();
5000 extraOffset = -extraOffset;
5001 }
5002
5003 // compute the note's rect
5004 auto globalNoteRect = QRect(noteStartPos + QPoint{extraOffset, 0}, QSize(noteWidth, renderer()->lineHeight()));
5005
5006 return globalNoteRect;
5007}
5008
5009KateInlineNoteData KateViewInternal::inlineNoteAt(const QPoint &globalPos) const
5010{
5011 // compute the associated cursor to get the right line
5012 const int line = coordinatesToCursor(mapFromGlobal(globalPos)).line();
5013 const auto inlineNotes = view()->inlineNotes(line);
5014 // loop over all notes and check if the point is inside it
5015 for (const auto &note : inlineNotes) {
5016 auto globalNoteRect = inlineNoteRect(note);
5017 if (globalNoteRect.contains(globalPos)) {
5018 return note;
5019 }
5020 }
5021 // none found -- return an invalid note
5022 return {};
5023}
5024
5025bool KateViewInternal::sendMouseEventToInputContext(QMouseEvent *e)
5026{
5027 if (!m_imPreeditRange) {
5028 return false;
5029 }
5030
5031 KTextEditor::Cursor c = cursorForPoint(e->pos());
5032 if (!m_imPreeditRange->contains(c) && c != m_imPreeditRange->end()) {
5033 return false;
5034 }
5035
5036 auto cursorPos = (c - m_imPreeditRange->start());
5037
5038 if (cursorPos.column() >= 0) {
5039 if (e->type() == QEvent::MouseButtonRelease)
5041 e->setAccepted(true);
5042 return true;
5043 }
5044 return false;
5045}
5046
5047void KateViewInternal::commitPreedit()
5048{
5049 if (!m_imPreeditRange) {
5050 return;
5051 }
5052
5054}
5055
5056#include "moc_kateviewinternal.cpp"
A class which provides customized text decorations.
Definition attribute.h:51
@ ActivateMouseIn
Activate attribute on mouse in.
Definition attribute.h:246
@ ActivateCaretIn
Activate attribute on caret in.
Definition attribute.h:248
QExplicitlySharedDataPointer< Attribute > Ptr
Shared data pointer for Attribute.
Definition attribute.h:56
The Cursor represents a position in a Document.
Definition cursor.h:75
constexpr int column() const noexcept
Retrieve the column on which this cursor is situated.
Definition cursor.h:192
void setColumn(int column) noexcept
Set the cursor column to column.
Definition cursor.h:201
void setPosition(Cursor position) noexcept
Set the current cursor position to position.
Definition cursor.h:150
constexpr bool isValid() const noexcept
Returns whether the current position of this cursor is a valid position (line + column must both be >...
Definition cursor.h:102
constexpr bool atStartOfDocument() const noexcept
Determine if this cursor is located at the start of a document (= at position (0, 0)).
Definition cursor.h:219
static constexpr Cursor start() noexcept
Returns a cursor representing the start of any document - i.e., line 0, column 0.
Definition cursor.h:120
void setLine(int line) noexcept
Set the cursor line to line.
Definition cursor.h:183
constexpr int line() const noexcept
Retrieve the line on which this cursor is situated.
Definition cursor.h:174
static constexpr Cursor invalid() noexcept
Returns an invalid cursor.
Definition cursor.h:112
A KParts derived class representing a text document.
Definition document.h:284
virtual int lineLength(int line) const =0
Get the length of a given line in characters.
const std::array< std::unique_ptr< KateAbstractInputModeFactory >, KTextEditor::View::ViInputMode+1 > & inputModeFactories()
Definition kateglobal.h:382
static KTextEditor::EditorPrivate * self()
Kate Part Internal stuff ;)
virtual void inlineNoteMouseMoveEvent(const InlineNote &note, const QPoint &globalPos)
Invoked when the mouse cursor moves inside the note.
virtual void inlineNoteFocusOutEvent(const InlineNote &note)
Invoked when the mouse cursor leaves the note.
Describes an inline note.
Definition inlinenote.h:40
qreal width() const
Returns the width of this note in pixels.
@ TopInView
show message as view overlay in the top right corner.
Definition message.h:123
@ CenterInView
show message as view overlay in the center of the view.
Definition message.h:128
@ BottomInView
show message as view overlay in the bottom right corner.
Definition message.h:125
A Cursor which is bound to a specific Document, and maintains its position.
const Cursor toCursor() const
Convert this clever cursor into a dumb one.
virtual int column() const =0
Retrieve the column on which this cursor is situated.
virtual int line() const =0
Retrieve the line on which this cursor is situated.
@ ExpandRight
Expand to encapsulate new characters to the right of the range.
@ ExpandLeft
Expand to encapsulate new characters to the left of the range.
An object representing a section of text, from one Cursor to another.
constexpr Cursor end() const noexcept
Get the end position of this range.
constexpr Cursor start() const noexcept
Get the start position of this range.
void setEnd(Cursor end) noexcept
Set the end cursor to end.
constexpr bool isEmpty() const noexcept
Returns true if this range contains no characters, ie.
void setRange(Range range) noexcept
Set the start and end cursors to range.start() and range.end() respectively.
static constexpr Range invalid() noexcept
Returns an invalid range.
constexpr bool isValid() const noexcept
Validity check.
void setStart(Cursor start) noexcept
Set the start cursor to start.
Class to provide text hints for a View.
void horizontalScrollPositionChanged(KTextEditor::View *view)
This signal should be emitted whenever the view is scrolled horizontally.
int lastDisplayedLine(LineType lineType=RealLine) const
Get the last displayed line in the view.
int firstDisplayedLine(LineType lineType=RealLine) const
Get the first displayed line in the view.
@ ViInputMode
Vi mode.
Definition view.h:288
@ NormalInputMode
Normal Mode.
Definition view.h:287
@ RealLine
Real line.
Definition view.h:312
void cursorPositionChanged(KTextEditor::View *view, KTextEditor::Cursor newPosition)
This signal is emitted whenever the view's cursor position changed.
void selectionChanged(KTextEditor::View *view)
This signal is emitted whenever the view's selection changes.
void verticalScrollPositionChanged(KTextEditor::View *view, KTextEditor::Cursor newPos)
This signal should be emitted whenever the view is scrolled vertically.
QVariant value(const int key) const
Get a config value.
Internal data container for KTextEditor::InlineNote interface.
This class handles Kate's caching of layouting information (in KateLineLayout and KateTextLayout).
KateTextLayout & viewLine(int viewLine)
Returns the layout of the corresponding line in the view.
KateLineLayout * line(int realLine, int virtualLine=-1)
Returns the KateLineLayout for the specified line.
KateTextLayout textLayout(const KTextEditor::Cursor realCursor)
Returns the layout describing the text line which is occupied by realCursor.
int displayViewLine(const KTextEditor::Cursor virtualCursor, bool limitToVisible=false)
Find the view line of the cursor, relative to the display (0 = top line of view, 1 = second line,...
Handles all of the work of rendering the text (used for the views and printing)
void increaseFontSizes(qreal step=1.0) const
Change to a different font (soon to be font set?)
void paintSelection(QPaintDevice *d, int startLine, int xStart, int endLine, int xEnd, qreal scale=1.0)
Paints a range of text into d.
void setShowTabs(bool showTabs)
Set whether a mark should be painted to help identifying tabs.
const QFont & currentFont() const
Access currently used font.
const AttributePtr & attribute(uint pos) const
This takes an in index, and returns all the attributes for it.
KTextEditor::caretStyles caretStyle() const
The style of the caret (text cursor) to be painted.
void setDrawCaret(bool drawCaret)
Set whether the caret (text cursor) will be drawn.
int cursorToX(const KateTextLayout &range, int col, bool returnPastLine=false) const
Returns the x position of cursor col on the line range.
KTextEditor::Cursor xToCursor(const KateTextLayout &range, int x, bool returnPastLine=false) const
Returns the real cursor which is occupied by the specified x value, or that closest to it.
void setShowSpaces(KateDocumentConfig::WhitespaceRendering showSpaces)
Set which spaces should be rendered.
const QFontMetricsF & currentFontMetrics() const
Access currently used font metrics.
void setCaretOverrideColor(const QColor &color)
Set a brush with which to override drawing of the caret.
void setCaretStyle(KTextEditor::caretStyles style)
Set the style of caret to be painted.
void layoutLine(KateLineLayout *line, int maxwidth=-1, bool cacheLayout=false) const
Text width & height calculation functions...
void updateMarkerSize()
Update marker size shown.
void paintTextLine(QPainter &paint, KateLineLayout *range, int xStart, int xEnd, const QRectF &textClipRect=QRectF(), const KTextEditor::Cursor *cursor=nullptr, PaintTextLineFlags flags=PaintTextLineFlags())
This is the ultimate function to perform painting of a text line.
This class is required because QScrollBar's sliderMoved() signal is really supposed to be a sliderDra...
This class is used to flash text in the text view.
This class represents one visible line of text; with dynamic wrapping, many KateTextLayouts can be ne...
int endCol(bool indicateEOL=false) const
Return the end column of this text line.
int viewLine() const
Return the index of this visual line inside the document line (KateLineLayout).
This class implements a QAccessible-interface for a KateViewInternal.
int column() const override
Retrieve the column on which this cursor is situated.
void setPosition(const TextCursor &position)
Fast way to set the current cursor position to position.
int line() const override
Retrieve the line on which this cursor is situated.
void foldingRangesChanged()
If the folding state of existing ranges changes or ranges are added/removed, this signal is emitted.
int visibleLines() const
Query number of visible lines.
KTextEditor::Range foldingRange(qint64 id) const
Returns the folding range associated with id.
int visibleLineToLine(int visibleLine) const
Convert a visible line number to a line number in the text buffer.
void ensureLineIsVisible(int line)
Ensure that a given line will be visible.
Class representing a single text line.
int attribute(int pos) const
Gets the attribute at the given position use KRenderer::attributes to get the KTextAttribute for this...
const QString & text() const
Accessor to the text contained in this line.
int length() const
Returns the line's length.
int lastChar() const
Returns the position of the last non-whitespace character.
QChar at(int column) const
Returns the character at the given column.
int firstChar() const
Returns the position of the first non-whitespace character.
const KTextEditor::Range toRange() const
Convert this clever range into a dumb one.
Q_SCRIPTABLE Q_NOREPLY void start()
QAction * hint(const QObject *recvr, const char *slot, QObject *parent)
const QList< QKeySequence > & end()
The KTextEditor namespace contains all the public API that is required to use the KTextEditor compone...
void actionTriggered(int action)
void setPageStep(int)
void setRange(int min, int max)
void setSingleStep(int)
void sliderMoved(int value)
void setValue(int)
void valueChanged(int value)
void installFactory(InterfaceFactory factory)
bool isActive()
QAccessibleInterface * queryAccessibleInterface(QObject *object)
void removeFactory(InterfaceFactory factory)
void updateAccessibility(QAccessibleEvent *event)
Category category(char32_t ucs4)
bool isHighSurrogate(char32_t ucs4)
bool isLetter(char32_t ucs4)
bool isLetterOrNumber(char32_t ucs4)
bool isLowSurrogate(char32_t ucs4)
bool isPrint(char32_t ucs4)
bool isSpace(char32_t ucs4)
bool isUpper(char32_t ucs4)
bool added() const const
QObject * child() const const
bool removed() const const
void setText(const QString &text, Mode mode)
QString text(Mode mode) const const
bool isValid() const const
const QPoint & pos() const const
Reason reason() const const
bool sendEvent(QObject *receiver, QEvent *event)
QPoint pos()
Qt::DropAction exec(Qt::DropActions supportedActions)
void setHotSpot(const QPoint &hotspot)
void setMimeData(QMimeData *data)
void setPixmap(const QPixmap &pixmap)
qint64 elapsed() const const
bool isValid() const const
void accept()
bool isAccepted() const const
void ignore()
Type type() const const
const T * constData() const const
qreal horizontalAdvance(QChar ch) const const
QClipboard * clipboard()
QInputMethod * inputMethod()
Qt::KeyboardModifiers modifiers() const const
void invokeAction(Action a, int cursorPosition)
const QList< Attribute > & attributes() const const
const QString & commitString() const const
const QString & preeditString() const const
int replacementLength() const const
int replacementStart() const const
int key() const const
Qt::KeyboardModifiers modifiers() const const
QString text() const const
void append(QList< T > &&value)
bool isEmpty() const const
void popup(const QPoint &p, QAction *atAction)
QPoint pos() const const
const QPoint & oldPos() const const
const QPoint & pos() const const
Q_EMITQ_EMIT
bool blockSignals(bool block)
QMetaObject::Connection connect(const QObject *sender, PointerToMemberFunction signal, Functor functor)
bool disconnect(const QMetaObject::Connection &connection)
virtual bool eventFilter(QObject *watched, QEvent *event)
void installEventFilter(QObject *filterObj)
void removeEventFilter(QObject *obj)
qreal devicePixelRatioF() const const
const QRect & rect() const const
const QRegion & region() const const
int manhattanLength() const const
int & rx()
int x() const const
int y() const const
virtual void setAccepted(bool accepted) override
QPoint toPoint() const const
qreal x() const const
qreal y() const const
int height() const const
int width() const const
int x() const const
int y() const const
bool isEmpty() const const
const QSize & oldSize() const const
virtual QSize sizeHint() const const override
QScroller * scroller(QObject *target)
void setScrollMetric(ScrollMetric metric, const QVariant &value)
Qt::MouseButton button() const const
Qt::MouseButtons buttons() const const
QPointF globalPosition() const const
QPointF position() const const
int height() const const
int width() const const
const QChar at(qsizetype position) const const
QString & fill(QChar ch, qsizetype size)
bool isEmpty() const const
qsizetype length() const const
qsizetype size() const const
QChar at(qsizetype n) const const
qsizetype size() const const
RequestSoftwareInputPanel
SH_RequestSoftwareInputPanel
IBeamCursor
MoveAction
transparent
InputMethodQuery
Key_Escape
typedef KeyboardModifiers
RightToLeft
LeftButton
Vertical
WA_OpaquePaintEvent
bool isValid() const const
QTextCharFormat toCharFormat() const const
int nextCursorPosition(int oldPos, CursorMode mode) const const
int previousCursorPosition(int oldPos, CursorMode mode) const const
const QTextOption & textOption() const const
Qt::LayoutDirection textDirection() const const
QFuture< ArgsType< Signal > > connect(Sender *sender, Signal signal)
bool isActive() const const
void start()
void stop()
void timeout()
void hideText()
bool isVisible()
void showText(const QPoint &pos, const QString &text, QWidget *w, const QRect &rect, int msecDisplayTime)
bool toBool() const const
iterator begin()
bool contains(const AT &value) const const
iterator end()
iterator erase(const_iterator begin, const_iterator end)
bool isEmpty() const const
void push_back(T &&t)
qsizetype size() const const
QPoint angleDelta() const const
bool isEnabled() const const
virtual bool event(QEvent *event) override
bool hasFocus() const const
void hide()
virtual QVariant inputMethodQuery(Qt::InputMethodQuery query) const const
QLayout * layout() const const
QPoint mapFromGlobal(const QPoint &pos) const const
QPoint mapToGlobal(const QPoint &pos) const const
virtual void moveEvent(QMoveEvent *event)
QWidget * parentWidget() const const
void scroll(int dx, int dy)
void setDisabled(bool disable)
void setFixedSize(const QSize &s)
void show()
virtual void showEvent(QShowEvent *event)
QStyle * style() const const
void update()
void updateMicroFocus(Qt::InputMethodQuery query)
bool isVisible() const const
QWidget * window() const const
This file is part of the KDE documentation.
Documentation copyright © 1996-2024 The KDE developers.
Generated on Fri Jun 14 2024 11:57:26 by doxygen 1.10.0 written by Dimitri van Heesch, © 1997-2006

KDE's Doxygen guidelines are available online.