|
0
|
1 import { Pos } from "../line/pos.js"
|
|
|
2 import { cursorCoords, displayHeight, displayWidth, estimateCoords, paddingTop, paddingVert, scrollGap, textHeight } from "../measurement/position_measurement.js"
|
|
|
3 import { gecko, phantom } from "../util/browser.js"
|
|
|
4 import { elt } from "../util/dom.js"
|
|
|
5 import { signalDOMEvent } from "../util/event.js"
|
|
|
6
|
|
|
7 import { startWorker } from "./highlight_worker.js"
|
|
|
8 import { alignHorizontally } from "./line_numbers.js"
|
|
|
9 import { updateDisplaySimple } from "./update_display.js"
|
|
|
10
|
|
|
11 // SCROLLING THINGS INTO VIEW
|
|
|
12
|
|
|
13 // If an editor sits on the top or bottom of the window, partially
|
|
|
14 // scrolled out of view, this ensures that the cursor is visible.
|
|
|
15 export function maybeScrollWindow(cm, rect) {
|
|
|
16 if (signalDOMEvent(cm, "scrollCursorIntoView")) return
|
|
|
17
|
|
|
18 let display = cm.display, box = display.sizer.getBoundingClientRect(), doScroll = null
|
|
|
19 let doc = display.wrapper.ownerDocument
|
|
|
20 if (rect.top + box.top < 0) doScroll = true
|
|
|
21 else if (rect.bottom + box.top > (doc.defaultView.innerHeight || doc.documentElement.clientHeight)) doScroll = false
|
|
|
22 if (doScroll != null && !phantom) {
|
|
|
23 let scrollNode = elt("div", "\u200b", null, `position: absolute;
|
|
|
24 top: ${rect.top - display.viewOffset - paddingTop(cm.display)}px;
|
|
|
25 height: ${rect.bottom - rect.top + scrollGap(cm) + display.barHeight}px;
|
|
|
26 left: ${rect.left}px; width: ${Math.max(2, rect.right - rect.left)}px;`)
|
|
|
27 cm.display.lineSpace.appendChild(scrollNode)
|
|
|
28 scrollNode.scrollIntoView(doScroll)
|
|
|
29 cm.display.lineSpace.removeChild(scrollNode)
|
|
|
30 }
|
|
|
31 }
|
|
|
32
|
|
|
33 // Scroll a given position into view (immediately), verifying that
|
|
|
34 // it actually became visible (as line heights are accurately
|
|
|
35 // measured, the position of something may 'drift' during drawing).
|
|
|
36 export function scrollPosIntoView(cm, pos, end, margin) {
|
|
|
37 if (margin == null) margin = 0
|
|
|
38 let rect
|
|
|
39 if (!cm.options.lineWrapping && pos == end) {
|
|
|
40 // Set pos and end to the cursor positions around the character pos sticks to
|
|
|
41 // If pos.sticky == "before", that is around pos.ch - 1, otherwise around pos.ch
|
|
|
42 // If pos == Pos(_, 0, "before"), pos and end are unchanged
|
|
|
43 end = pos.sticky == "before" ? Pos(pos.line, pos.ch + 1, "before") : pos
|
|
|
44 pos = pos.ch ? Pos(pos.line, pos.sticky == "before" ? pos.ch - 1 : pos.ch, "after") : pos
|
|
|
45 }
|
|
|
46 for (let limit = 0; limit < 5; limit++) {
|
|
|
47 let changed = false
|
|
|
48 let coords = cursorCoords(cm, pos)
|
|
|
49 let endCoords = !end || end == pos ? coords : cursorCoords(cm, end)
|
|
|
50 rect = {left: Math.min(coords.left, endCoords.left),
|
|
|
51 top: Math.min(coords.top, endCoords.top) - margin,
|
|
|
52 right: Math.max(coords.left, endCoords.left),
|
|
|
53 bottom: Math.max(coords.bottom, endCoords.bottom) + margin}
|
|
|
54 let scrollPos = calculateScrollPos(cm, rect)
|
|
|
55 let startTop = cm.doc.scrollTop, startLeft = cm.doc.scrollLeft
|
|
|
56 if (scrollPos.scrollTop != null) {
|
|
|
57 updateScrollTop(cm, scrollPos.scrollTop)
|
|
|
58 if (Math.abs(cm.doc.scrollTop - startTop) > 1) changed = true
|
|
|
59 }
|
|
|
60 if (scrollPos.scrollLeft != null) {
|
|
|
61 setScrollLeft(cm, scrollPos.scrollLeft)
|
|
|
62 if (Math.abs(cm.doc.scrollLeft - startLeft) > 1) changed = true
|
|
|
63 }
|
|
|
64 if (!changed) break
|
|
|
65 }
|
|
|
66 return rect
|
|
|
67 }
|
|
|
68
|
|
|
69 // Scroll a given set of coordinates into view (immediately).
|
|
|
70 export function scrollIntoView(cm, rect) {
|
|
|
71 let scrollPos = calculateScrollPos(cm, rect)
|
|
|
72 if (scrollPos.scrollTop != null) updateScrollTop(cm, scrollPos.scrollTop)
|
|
|
73 if (scrollPos.scrollLeft != null) setScrollLeft(cm, scrollPos.scrollLeft)
|
|
|
74 }
|
|
|
75
|
|
|
76 // Calculate a new scroll position needed to scroll the given
|
|
|
77 // rectangle into view. Returns an object with scrollTop and
|
|
|
78 // scrollLeft properties. When these are undefined, the
|
|
|
79 // vertical/horizontal position does not need to be adjusted.
|
|
|
80 function calculateScrollPos(cm, rect) {
|
|
|
81 let display = cm.display, snapMargin = textHeight(cm.display)
|
|
|
82 if (rect.top < 0) rect.top = 0
|
|
|
83 let screentop = cm.curOp && cm.curOp.scrollTop != null ? cm.curOp.scrollTop : display.scroller.scrollTop
|
|
|
84 let screen = displayHeight(cm), result = {}
|
|
|
85 if (rect.bottom - rect.top > screen) rect.bottom = rect.top + screen
|
|
|
86 let docBottom = cm.doc.height + paddingVert(display)
|
|
|
87 let atTop = rect.top < snapMargin, atBottom = rect.bottom > docBottom - snapMargin
|
|
|
88 if (rect.top < screentop) {
|
|
|
89 result.scrollTop = atTop ? 0 : rect.top
|
|
|
90 } else if (rect.bottom > screentop + screen) {
|
|
|
91 let newTop = Math.min(rect.top, (atBottom ? docBottom : rect.bottom) - screen)
|
|
|
92 if (newTop != screentop) result.scrollTop = newTop
|
|
|
93 }
|
|
|
94
|
|
|
95 let gutterSpace = cm.options.fixedGutter ? 0 : display.gutters.offsetWidth
|
|
|
96 let screenleft = cm.curOp && cm.curOp.scrollLeft != null ? cm.curOp.scrollLeft : display.scroller.scrollLeft - gutterSpace
|
|
|
97 let screenw = displayWidth(cm) - display.gutters.offsetWidth
|
|
|
98 let tooWide = rect.right - rect.left > screenw
|
|
|
99 if (tooWide) rect.right = rect.left + screenw
|
|
|
100 if (rect.left < 10)
|
|
|
101 result.scrollLeft = 0
|
|
|
102 else if (rect.left < screenleft)
|
|
|
103 result.scrollLeft = Math.max(0, rect.left + gutterSpace - (tooWide ? 0 : 10))
|
|
|
104 else if (rect.right > screenw + screenleft - 3)
|
|
|
105 result.scrollLeft = rect.right + (tooWide ? 0 : 10) - screenw
|
|
|
106 return result
|
|
|
107 }
|
|
|
108
|
|
|
109 // Store a relative adjustment to the scroll position in the current
|
|
|
110 // operation (to be applied when the operation finishes).
|
|
|
111 export function addToScrollTop(cm, top) {
|
|
|
112 if (top == null) return
|
|
|
113 resolveScrollToPos(cm)
|
|
|
114 cm.curOp.scrollTop = (cm.curOp.scrollTop == null ? cm.doc.scrollTop : cm.curOp.scrollTop) + top
|
|
|
115 }
|
|
|
116
|
|
|
117 // Make sure that at the end of the operation the current cursor is
|
|
|
118 // shown.
|
|
|
119 export function ensureCursorVisible(cm) {
|
|
|
120 resolveScrollToPos(cm)
|
|
|
121 let cur = cm.getCursor()
|
|
|
122 cm.curOp.scrollToPos = {from: cur, to: cur, margin: cm.options.cursorScrollMargin}
|
|
|
123 }
|
|
|
124
|
|
|
125 export function scrollToCoords(cm, x, y) {
|
|
|
126 if (x != null || y != null) resolveScrollToPos(cm)
|
|
|
127 if (x != null) cm.curOp.scrollLeft = x
|
|
|
128 if (y != null) cm.curOp.scrollTop = y
|
|
|
129 }
|
|
|
130
|
|
|
131 export function scrollToRange(cm, range) {
|
|
|
132 resolveScrollToPos(cm)
|
|
|
133 cm.curOp.scrollToPos = range
|
|
|
134 }
|
|
|
135
|
|
|
136 // When an operation has its scrollToPos property set, and another
|
|
|
137 // scroll action is applied before the end of the operation, this
|
|
|
138 // 'simulates' scrolling that position into view in a cheap way, so
|
|
|
139 // that the effect of intermediate scroll commands is not ignored.
|
|
|
140 function resolveScrollToPos(cm) {
|
|
|
141 let range = cm.curOp.scrollToPos
|
|
|
142 if (range) {
|
|
|
143 cm.curOp.scrollToPos = null
|
|
|
144 let from = estimateCoords(cm, range.from), to = estimateCoords(cm, range.to)
|
|
|
145 scrollToCoordsRange(cm, from, to, range.margin)
|
|
|
146 }
|
|
|
147 }
|
|
|
148
|
|
|
149 export function scrollToCoordsRange(cm, from, to, margin) {
|
|
|
150 let sPos = calculateScrollPos(cm, {
|
|
|
151 left: Math.min(from.left, to.left),
|
|
|
152 top: Math.min(from.top, to.top) - margin,
|
|
|
153 right: Math.max(from.right, to.right),
|
|
|
154 bottom: Math.max(from.bottom, to.bottom) + margin
|
|
|
155 })
|
|
|
156 scrollToCoords(cm, sPos.scrollLeft, sPos.scrollTop)
|
|
|
157 }
|
|
|
158
|
|
|
159 // Sync the scrollable area and scrollbars, ensure the viewport
|
|
|
160 // covers the visible area.
|
|
|
161 export function updateScrollTop(cm, val) {
|
|
|
162 if (Math.abs(cm.doc.scrollTop - val) < 2) return
|
|
|
163 if (!gecko) updateDisplaySimple(cm, {top: val})
|
|
|
164 setScrollTop(cm, val, true)
|
|
|
165 if (gecko) updateDisplaySimple(cm)
|
|
|
166 startWorker(cm, 100)
|
|
|
167 }
|
|
|
168
|
|
|
169 export function setScrollTop(cm, val, forceScroll) {
|
|
|
170 val = Math.max(0, Math.min(cm.display.scroller.scrollHeight - cm.display.scroller.clientHeight, val))
|
|
|
171 if (cm.display.scroller.scrollTop == val && !forceScroll) return
|
|
|
172 cm.doc.scrollTop = val
|
|
|
173 cm.display.scrollbars.setScrollTop(val)
|
|
|
174 if (cm.display.scroller.scrollTop != val) cm.display.scroller.scrollTop = val
|
|
|
175 }
|
|
|
176
|
|
|
177 // Sync scroller and scrollbar, ensure the gutter elements are
|
|
|
178 // aligned.
|
|
|
179 export function setScrollLeft(cm, val, isScroller, forceScroll) {
|
|
|
180 val = Math.max(0, Math.min(val, cm.display.scroller.scrollWidth - cm.display.scroller.clientWidth))
|
|
|
181 if ((isScroller ? val == cm.doc.scrollLeft : Math.abs(cm.doc.scrollLeft - val) < 2) && !forceScroll) return
|
|
|
182 cm.doc.scrollLeft = val
|
|
|
183 alignHorizontally(cm)
|
|
|
184 if (cm.display.scroller.scrollLeft != val) cm.display.scroller.scrollLeft = val
|
|
|
185 cm.display.scrollbars.setScrollLeft(val)
|
|
|
186 }
|
