mirror of
https://github.com/SpaceVim/SpaceVim.git
synced 2025-02-03 06:50:05 +08:00
156 lines
3.4 KiB
VimL
Vendored
156 lines
3.4 KiB
VimL
Vendored
" =============================================================================
|
|
" Filename: autoload/calendar/text.vim
|
|
" Author: itchyny
|
|
" License: MIT License
|
|
" Last Change: 2015/03/29 06:32:06.
|
|
" =============================================================================
|
|
|
|
let s:save_cpo = &cpo
|
|
set cpo&vim
|
|
|
|
" Text object, string with a position to display, and syntaxes.
|
|
" s: The string (if it is a string) or the length of spaces (if it is a number)
|
|
" x: Position x
|
|
" y: Position y
|
|
" syn: The syntax string (For example, Sunday, Saturday and Cursor)
|
|
fu! calendar#text#new(s, x, y, syn) abort
|
|
retu extend(copy(s:self),{'s':a:s,'x':a:x,'y':a:y,'t':!type(a:s),'syn':[[a:syn,a:y,a:x,a:x+(type(a:s)?len(a:s):a:s),0]]})
|
|
endfu
|
|
|
|
let s:self = {}
|
|
|
|
" Move all the things.
|
|
fu! s:self.move(x, y) dict abort
|
|
let self.x += a:x
|
|
let self.y += a:y
|
|
cal map(self.syn, '[v:val[0],v:val[1]+a:y,v:val[2]+a:x,v:val[3]+a:x,v:val[4]]')
|
|
retu self
|
|
endfu
|
|
|
|
" Extend the syntaxes.
|
|
fu! s:self.height(h) dict abort
|
|
for s in self.syn
|
|
if a:h
|
|
let s[4] = a:h
|
|
en
|
|
endfo
|
|
retu self
|
|
endfu
|
|
|
|
" Split all the extend the syntaxes.
|
|
fu! s:self.split() dict abort
|
|
let syn = []
|
|
for s in self.syn
|
|
if s[4]
|
|
let t = s
|
|
let l = s[4]
|
|
let s[4] = 0
|
|
wh l > 1
|
|
let t = copy(t)
|
|
let t[1] += 1
|
|
cal add(syn, t)
|
|
let l -= 1
|
|
endw
|
|
en
|
|
endfo
|
|
retu map(syn, 'calendar#text#new(v:val[3] - v:val[2], v:val[2], v:val[1], v:val[0])')
|
|
endfu
|
|
|
|
" :h version7 | /7.2.061
|
|
silent! call calendar#string#strdisplaywidth('')
|
|
|
|
let s:W = function((exists('*strdisplaywidth') ? '' : 'calendar#string#') . 'strdisplaywidth')
|
|
let s:T = function('calendar#string#truncate')
|
|
let s:R = function('calendar#string#truncate_reverse')
|
|
|
|
fu! s:self.concat(t) dict abort
|
|
let s = self.syn
|
|
let t = a:t.syn
|
|
let q = range(len(s))
|
|
let l = s:T(self.s, a:t.x)
|
|
let r = s:R(self.s, s:W(self.s) - s:W(a:t.s) - a:t.x)
|
|
let x = len(l) - a:t.x
|
|
let e = len(l) + len(a:t.s)
|
|
let f = len(self.s) - len(r)
|
|
let y = min([e, f])
|
|
let m = e - f
|
|
if !a:t.t
|
|
let self.s = l . a:t.s . r
|
|
en
|
|
if x
|
|
cal s:shift(t, x)
|
|
en
|
|
for i in q
|
|
if s[i][2] >= y | let s[i][2] += m | en
|
|
if s[i][3] >= y | let s[i][3] += m | en
|
|
endfo
|
|
retu x
|
|
endfu
|
|
|
|
fu! s:shift(t, x) abort
|
|
let p = range(len(a:t))
|
|
for i in p
|
|
let a:t[i][2] += a:x
|
|
let a:t[i][3] += a:x
|
|
endfo
|
|
endfu
|
|
|
|
fu! s:over(j, v, u) abort
|
|
let [s, d] = [[], []]
|
|
let v = a:v
|
|
let u = a:u
|
|
if u[2] < v[2]
|
|
if u[3] <= v[3]
|
|
let u[3] = v[2]
|
|
el
|
|
let syn = copy(u)
|
|
let u[3] = v[2]
|
|
let syn[2] = v[3]
|
|
cal add(s, syn)
|
|
en
|
|
el
|
|
if u[3] <= v[3]
|
|
cal add(d, a:j)
|
|
el
|
|
let u[2] = v[3]
|
|
en
|
|
en
|
|
retu [s, d]
|
|
endfu
|
|
|
|
" Text piling, the most important method of text object.
|
|
fu! s:self.over(t) dict abort
|
|
let s = self.syn
|
|
let t = a:t.syn
|
|
let x = a:t.t ? 0 : self.concat(a:t)
|
|
if len(s) == 1 && s[0][0] == ''
|
|
let self.syn = t
|
|
retu x
|
|
en
|
|
let p = range(len(t))
|
|
for i in p
|
|
let d = []
|
|
for j in range(len(s))
|
|
if s[j][3] <= t[i][2]
|
|
con
|
|
elsei s[j][2] >= t[i][3]
|
|
con
|
|
elsei t[i][0] != 'Cursor' && s[j][0] != 'Cursor'
|
|
let [b, c] = s:over(j, t[i], s[j])
|
|
cal extend(s, b)
|
|
cal extend(d, c)
|
|
en
|
|
endfo
|
|
if len(d)
|
|
for n in reverse(d)
|
|
cal remove(s, n)
|
|
endfo
|
|
en
|
|
endfo
|
|
cal extend(s, t)
|
|
retu x
|
|
endfu
|
|
|
|
let &cpo = s:save_cpo
|
|
unlet s:save_cpo
|