X-Git-Url: https://jasonwoof.com/gitweb/?a=blobdiff_plain;f=editor.coffee;h=36c66609209c028a0d957054917727f2cb472a0d;hb=d27bf60d438b9cf3f595923e9a5c80b2f8d480fb;hp=9f6d8eb34473d0b762c37e059887afa244d57378;hpb=e63123d22c65f954f27b830f149c1a1500ba0c97;p=peach-html5-editor.git
diff --git a/editor.coffee b/editor.coffee
index 9f6d8eb..36c6660 100644
--- a/editor.coffee
+++ b/editor.coffee
@@ -16,7 +16,7 @@
# SETTINGS
overlay_padding = 10
-breathing_room = 30 # minimum pixels above/below cursor
+breathing_room = 30 # minimum pixels above/below cursor (scrolling)
timeout = (ms, cb) -> return setTimeout cb, ms
next_frame = (cb) ->
@@ -59,15 +59,22 @@ ws_props =
space: true
newline: true
wrap: false
+ to_collapse: 'nowrap'
'pre-wrap':
space: true
newline: true
wrap: true
+ to_collapse: 'normal'
# xml 1.0 spec, chromium and firefox accept these, plus lots of unicode chars
valid_attr_regex = new RegExp '^[a-zA-Z_:][-a-zA-Z0-9_:.]*$'
# html5 spec is much more lax, but chromium won't let me make at attribute with the name "4"
js_attr_regex = new RegExp '^[oO][nN].'
+# html5 spec says that only these characters are collapsable
+multi_sp_regex = new RegExp '[\u0020\u0009\u000a\u000c\u000d][\u0020\u0009\u000a\u000c\u000d]'
+
+str_has_ws_run = (str) ->
+ return multi_sp_regex.test str
debug_dot_at = (doc, x, y) ->
return # disabled
@@ -318,8 +325,8 @@ first_cursor_position = (tree) ->
cursor = new_cursor_position n: node, i: 0
if cursor?
found = cursor
- return true
- return false
+ return true # done traversing
+ return false # not done traversing
return found # maybe null
# this will fail when text has non-locatable cursor positions
@@ -335,10 +342,10 @@ find_next_cursor_position = (tree, cursor) ->
new_cursor = new_cursor_position n: node, i: 0
if new_cursor?
found = new_cursor
- return true
+ return true # done traversing
if node is cursor.n
state_before = false
- return false
+ return false # not done traversing
if found?
return found
return null
@@ -350,7 +357,7 @@ last_cursor_position = (tree) ->
cursor = new_cursor_position n: node, i: node.text.length
if cursor?
found = cursor
- return false
+ return false # not done traversing
return found # maybe null
# this will fail when text has non-locatable cursor positions
@@ -364,12 +371,12 @@ find_prev_cursor_position = (tree, cursor) ->
traverse_tree tree, (node) ->
if node is cursor.n
found = found_prev # maybe null
- return true
+ return true # done traversing
if node.type is 'text'
new_cursor = new_cursor_position n: node, i: node.text.length
if new_cursor?
found_prev = new_cursor
- return false
+ return false # not done traversing
return found # maybe null
find_up_cursor_position = (tree, cursor, ideal_x) ->
@@ -504,7 +511,7 @@ tree_remove_empty_text_nodes = (tree) ->
if n.type is 'text'
if n.text.length is 0
empties.unshift n
- return false
+ return false # not done traversing
for n in empties
# don't completely empty the tree
if tree.length is 1
@@ -947,7 +954,7 @@ class PeachHTML5Editor
return false unless @cursor?
return false unless @cursor.i < @cursor.n.text.length
@remove_character @cursor.n, @cursor.i
- @adjust_whitespace_style @cursor.n
+ @text_cleanup @cursor.n
@changed()
new_cursor = new_cursor_position n: @cursor.n, i: @cursor.i
if new_cursor?
@@ -983,7 +990,7 @@ class PeachHTML5Editor
if char and @cursor?
char = String.fromCharCode char
@insert_character @cursor.n, @cursor.i, char
- @adjust_whitespace_style @cursor.n
+ @text_cleanup @cursor.n
@changed()
new_cursor = new_cursor_position n: @cursor.n, i: @cursor.i + 1
if new_cursor
@@ -1039,139 +1046,204 @@ class PeachHTML5Editor
loop
n = n.parent
return null unless n?
- return n if is_display_block n.el
+ return n if @is_display_block n
return n if n is @tree_parent
return null
- on_key_backspace: (e) ->
- return false unless @cursor?
- if @is_lone_space @cursor.n # false if it's not in a tag
- if @cursor.i is 1
- # don't delete the space, because then it would collapse
- # instead leave a space after the cursor
- new_cursor = new_cursor_position n: @cursor.n, i: 0
- if new_cursor?
- @move_cursor new_cursor
+ # return a flat array of nodes (text,
, and later also inline-block)
+ # that are flowing/wrapping together. n can be the containing block, or any
+ # element inside it.
+ get_text_run: (n) ->
+ ret = []
+ if @is_display_block n
+ block = n
+ else
+ block = @find_block_parent n
+ return ret unless block?
+ traverse_tree block.children, (n) =>
+ if n.type is 'text'
+ ret.push n
+ else if n.type is 'tag'
+ if n.name is 'br'
+ ret.push n
else
- @kill_cursor()
- else
- # cursor at the begining of an element that contains only a space
- parent = @cursor.n.parent
- new_cursor = find_prev_cursor_position @tree, @cursor
- if new_cursor?
- if new_cursor.n is @cursor.n or new_cursor.n is parent
- new_cursor = null
- tag = @cursor.n.parent
- if tag is @tree_parent
- console.log "top-level text not supported" # FIXME
- return false
- for n, i in tag.parent.children
- if n is tag
- tag.parent.el.removeChild tag.el
- tag.parent.children.splice i, 1
- break
- @changed()
- if new_cursor?
- # re-check, in case it moved or is invalid now
- new_cursor = new_cursor_position n: new_cursor.n, i: new_cursor.i
+ disp = @computed_style n
+ if disp is 'inline-block'
+ ret.push n
+ return false # not done traversing
+ return ret
+ node_is_decendant: (young, old) ->
+ while young? and young != @tree_parent
+ return true if young is old
+ young = young.parent
+ return false
+ # helper for on_key_backspace
+ _merge_left: (state) ->
+ # the node prev to n was not prev to it a moment ago, merge with it if reasonable
+ pi = state.n.parent.children.indexOf(state.n)
+ if pi > 0
+ prev = state.n.parent.children[pi - 1]
+ if prev.type is 'text'
+ state.i = prev.text.length
+ prev.text = prev.el.textContent = prev.text + state.n.text
+ @remove_node state.n
+ state.n = prev
+ state.changed = true
+ state.moved_cursor = true
+ # else # TODO merge possible consecutive matching inline tags at @cursor
+ return state
+ # helper for on_key_backspace
+ # remove n from the dom, also remove its inline parents that are emptied by removing n
+ _backspace_node_helper: (n, run = @get_text_run(n), run_i = run.indexOf(n)) ->
+ block = @find_block_parent n
+ # delete text node
+ @remove_node n
+ # delete any inline parents
+ n = n.parent
+ while n? and n isnt block
+ # bail if the previous node in this run is also inside the same parent
+ if run_i > 0
+ break if @node_is_decendant run[run_i - 1], n
+ # bail if the next node in this run is also inside the same parent
+ if run_i + 1 < run.length
+ break if @node_is_decendant run[run_i + 1], n
+ # move any sibling nodes to parent. These nodes are not in the text run
+ while n.children.length > 0
+ @move_node n.children[0], n.parent, n
+ # remove (now completely empty) inline parent
+ @remove_node n
+ # proceed to outer parent
+ n = n.parent
+ return
+ on_key_backspace: (e) ->
+ return unless @cursor?
+ new_cursor = null
+ run = null
+ changed = true
+ if @cursor.i is 0 # cursor is at start of text node
+ run ?= @get_text_run @cursor.n
+ run_i = run.indexOf(@cursor.n)
+ if run_i is 0 # if at start of text run
+ block = @find_block_parent @cursor.n
+ prev_cursor = find_prev_cursor_position @tree, n: @cursor.n, i: 0
+ if prev_cursor is null # if in first text run of document
+ # do nothing (there's nothing text-like to the left of the cursor)
+ return
+ # else merge with prev/outer text run
+ pcb = @find_block_parent prev_cursor.n
+ while block.children.length > 0
+ @move_node block.children[0], pcb
+ @remove_node block
+ # merge possible consecutive text nodes at @cursor
+ merge_state = n: @cursor.n
+ @_merge_left merge_state
+ @text_cleanup merge_state.n
+ new_cursor = new_cursor_position n: merge_state.n, i: merge_state.i
+ else # at start of text node, but not start of text run
+ prev = run[run_i - 1]
+ if prev.type is 'text' # if previous in text run is text
+ if prev.text.length is 1 # if emptying prev (in text run)
+ @_backspace_node_helper prev, run, run_i
+ merge_state = n: @cursor.n, i: @cursor.i
+ @_merge_left merge_state
+ @text_cleanup merge_state.n
+ new_cursor = new_cursor_position n: merge_state.n, i: merge_state.i
+ else # prev in run is text with muliple chars
+ # delete last character in prev
+ prev.text = prev.text.substr(0, prev.text.length - 1)
+ prev.el.textContent = prev.text
+ @text_cleanup @cursor.n
+ new_cursor = new_cursor_position n: @cursor.n, i: @cursor.i
+ else if prev.name is 'br' or prev.name is 'hr'
+ @_backspace_node_helper prev, run, run_i
+ merge_state = n: @cursor.n, i: @cursor.i
+ @_merge_left merge_state
+ @text_cleanup merge_state.n
+ new_cursor = new_cursor_position n: merge_state.n, i: merge_state.i
+ # FIXME CONTINUE
+ # else # if prev (in run) is inline-block
+ # if that inline-block has text in it
+ # delete last char in prev inlineblock
+ # if that empties it
+ # delete it
+ # merge left
+ # else
+ # move cursor inside
+ # else
+ # delete prev (inline) block
+ # merge left
+ # auto-delete this @cursor.parent(s) if this empties them
+ else # cursor is not at start of text node
+ run ?= @get_text_run @cursor.n
+ if @cursor.n.text.length is 1 # if emptying text node
+ if run.length is 1 # if emptying text run (of text/br/hr/inline-block)
+ # remove inline-parents of @cursor.n
+ block = @find_block_parent @cursor.n
+ changed = false
+ n = @cursor.n.parent
+ # note: this doesn't use _backspace_node_helper because:
+ # 1. we don't want to delete the target node (we're replacing it's contents)
+ # 2. we want to track whether anything was removed
+ # 3. we know already know there's no other text from this run anywhere
+ while n and n isnt block
+ changed = true
+ while n.children.length > 0
+ @move_node n.children[0], n.parent, n
+ @remove_node n
+ n = n.parent
+ # replace @cursor.n with a single (preserved) space
+ if @cursor.n.text != ' '
+ changed = true
+ @cursor.n.text = @cursor.n.el.textContent = ' '
+ if changed
+ @text_cleanup @cursor.n
+ # place the cursor to the left of that space
+ new_cursor = new_cursor_position n: @cursor.n, i: 0
+ else # emptying a text node (but not a whole text run)
+ # figure out where cursor should land
+ block = @find_block_parent @cursor.n
+ new_cursor = find_prev_cursor_position @tree, n: @cursor.n, i: 0
+ ncb = @find_block_parent new_cursor.n
+ if ncb isnt block
+ new_cursor = find_next_cursor_position @tree, n: @cursor.n, i: 1
+ # delete text node and cleanup emptied parents
+ run_i = run.indexOf @cursor.n
+ @_backspace_node_helper @cursor.n, run, run_i
+ # see if new adjacent siblings should merge
+ # TODO make smarter
+ if run_i > 0 and run_i + 1 < run.length
+ if run[run_i - 1].type is 'text' and run[run_i + 1].type is 'text'
+ merge_state = n: run[run_i + 1]
+ @_merge_left merge_state
+ if merge_state.moved_cursor
+ new_cursor = merge_state
+ # update whitespace preservation
+ @text_cleanup(block)
+ # update cursor x/y in case things moved around
if new_cursor?
- @move_cursor new_cursor
- return
- new_cursor = first_cursor_position @tree
- if new_cursor?
- @move_cursor new_cursor
- else
- @kill_cursor
- return
- else if @cursor.i is 0 # start of text chunk
- # FIXME clean this up: use new code for text runs
- # FIXME handle backspacing a
even if it's near a inline tag boundary
- # determine if cursor is at start of text run (text formatted inline)
- block = @find_block_parent @cursor.n
- return unless block
- at_block_start = true
- prev_pos = find_prev_cursor_position @tree, @cursor
- unless prev_pos?
- # if the cursor can't go back, then there's probably nowhere we can merge into
- # TODO consider case of nested blocks. should backspace remove one?
- return
- prev_pos_block = @find_block_parent prev_pos.n
- if prev_pos_block is block
- # context: there is text before the cursor within the same block.
- # FIXME clean up this hack for looking for
(see above)
- cursor_text_pi = @cursor.n.parent.children.indexOf @cursor.n
- if cursor_text_pi > 0
- prev_node = @cursor.n.parent.children[cursor_text_pi - 1]
- if prev_node.type is 'tag' and prev_node.name is 'br'
- @remove_node prev_node
- @text_cleanup @cursor.n.parent
- @changed()
- new_cursor = new_cursor_position n: prev_pos.n, i: prev_pos.i
- if new_cursor?
- @move_cursor new_cursor
+ if new_cursor.n.el.parentNode # still in dom after cleanup
+ new_cursor = new_cursor_position n: new_cursor.n, i: new_cursor.i
else
- @kill_cursor
- return
- # note: find_prev_cursor_position just crossed a boundary, not a character
- # prev_pos is within the same block, try deleting there
- @move_cursor prev_pos
- # FIXME cleanup: don't call @move_cursor twice if the next line succeeds
- return @on_key_backspace()
- # context: backspace pressed at start of a display:block
- return if block is @tree_parent # top level text
- parent = block.parent
- parent_i = parent.children.indexOf block
- if parent_i is -1
- throw "BUG #98270918347"
- return
- if parent_i is 0
- # no previous sibling to merge into, so instead move contents into parent
- dest = parent
- before = block
- else
- # FIXME prev_sib should be the previous in-flow element
- # ie it should skip comments, hidden things, floating things, etc.
- prev_sib = parent.children[parent_i - 1]
- if @is_display_block prev_sib
- dest = prev_sib
- before = null # null means append
- else
- dest = parent
- before = block
- if dest is @tree_parent
- # don't remove outer-most blocks
- return
- while block.children.length > 0
- n = block.children[block.children.length - 1]
- @move_node n, dest, before
- block.children.pop()
- before = n
- @remove_node block
- @text_cleanup dest
+ new_cursor = null
+ else # there's a char left of cursor that we can delete without emptying anything
+ # delete character
+ need_text_cleanup = true
+ if @cursor.i > 1 and @cursor.i < @cursor.n.text.length
+ pre = @cursor.n.text.substr(@cursor.i - 2, 3)
+ post = pre.charAt(0) + pre.charAt(2)
+ if str_has_ws_run(pre) is str_has_ws_run(post)
+ need_text_cleanup = false
+ @remove_character(@cursor.n, @cursor.i - 1)
+ # call text_cleanup if whe created/removed a whitespace run
+ if need_text_cleanup
+ @text_cleanup @cursor.n
+ new_cursor = new_cursor_position n: @cursor.n, i: @cursor.i - 1
+ # mark document changed and move the cursor
+ if changed?
@changed()
- new_cursor = new_cursor_position n: prev_pos.n, i: prev_pos.i
- if new_cursor?
- @move_cursor new_cursor
- else
- @kill_cursor
- return
+ if new_cursor?
+ @move_cursor new_cursor
else
- # TODO handle case of removing last char
- # CONTINUE
- if @is_only_char_in_tag @cursor.n
- if @is_display_block @cursor.n.parent
- @cursor.n.el.textContent = @cursor.n.text = ' '
- else
- console.log "unimplemented: delete last char in inline" # FIXME
- return
- else
- @remove_character @cursor.n, @cursor.i - 1
- @adjust_whitespace_style @cursor.n
- @changed()
- new_cursor = new_cursor_position n: @cursor.n, i: @cursor.i - 1
- if new_cursor?
- @move_cursor new_cursor
- else
- @kill_cursor()
+ @kill_cursor()
return
on_page_up_key: (e) ->
if @wrap2.scrollTop is 0
@@ -1308,49 +1380,6 @@ class PeachHTML5Editor
if is_space_code n.text.charCodeAt n.text.length - 1
return true
return false
- # add/remove "white-space: pre[-wrap]" to/from style="" on tags with direct
- # child text nodes with multiple spaces in a row, or spaces at the
- # start/end.
- #
- # text inside child tags are not consulted. Child tags are expected to have
- # this function applied to them when their content changes.
- adjust_whitespace_style: (n) ->
- loop
- break if @is_display_block n
- n = n.parent
- return unless n?
- return if n is @tree_parent
- # which css rule should be used to preserve spaces (should we need to)
- style = @iframe.contentWindow.getComputedStyle n.el, null
- ws = style.getPropertyValue 'white-space'
- if ws_props[ws].space
- preserve_rule = ws
- else
- preserve_rule = ws_props[ws].to_preserve
- preserve_rule = "white-space: #{preserve_rule}"
- if @has_collapsable_space n
- # make sure preserve_rule exists
- if n.el.style['white-space']
- # FIXME check that it matches
- return
- if n.attrs[style]?
- n.attrs.style += "; #{preserve_rule}"
- else
- n.attrs.style = preserve_rule
- n.el.setAttribute 'style', n.attrs.style
- else
- # remove preserve_rule if it exists
- return unless n.attrs.style?
- # FIXME don't assume whitespace is just so
- if n.attrs.style is "white-space: #{ws}"
- delete n.attrs.style
- n.el.removeAttribute 'style'
- else
- # FIXME find it in the middle and at the start
- needle = "; white-space: #{ws}"
- if needle is n.attrs.style.substr n.attrs.style.length - needle
- n.attrs.style = n.attrs.style.substr 0, n.attrs.style.length - needle
- n.el.setAttribute n.attrs.style
# true if n is text node with only one caracter, and the only child of a tag
is_only_char_in_tag: (n, i) ->
return false unless n.type is 'text'
@@ -1376,10 +1405,9 @@ class PeachHTML5Editor
# n is only child
return true
return false
- # after calling this, you MUST call changed() and adjust_whitespace_style()
+ # after calling this, you MUST call changed() and text_cleanup()
insert_character: (n, i, char) ->
- return if @cursor.n.parent is @tree_parent # FIXME implement text nodes at top level
- parent = @cursor.n.parent
+ return if n.parent is @tree_parent # FIXME implement text nodes at top level
# insert the character
if @insert_should_replace n, i
n.text = char
@@ -1394,17 +1422,150 @@ class PeachHTML5Editor
char +
n.text.substr(i)
n.el.nodeValue = n.text
- # WARNING: after calling this, you MUST call changed() and adjust_whitespace_style()
+ # WARNING: after calling this, you MUST call changed() and text_cleanup()
remove_character: (n, i) ->
n.text = n.text.substr(0, i) + n.text.substr(i + 1)
n.el.nodeValue = n.text
+ computed_style: (n, prop) ->
+ if n.type is 'text'
+ n = n.parent
+ style = @iframe.contentWindow.getComputedStyle n.el, null
+ return style.getPropertyValue prop
+ # returns the new white-space value that will preserve spaces for node n
+ preserve_space: (n, ideal_target) ->
+ if n.type is 'text'
+ target = n.parent
+ else
+ target = n
+ while target isnt ideal_target and not target.el.style.whiteSpace
+ unless target?
+ console.log "bug #967123"
+ return
+ target = target.parent
+ ws = ws_props[target.el.style.whiteSpace]?.to_preserve
+ ws ?= 'pre-wrap'
+ target.el.style.whiteSpace = ws
+ @update_style_from_el target
+ return ws
+ update_style_from_el: (n) ->
+ style = n.el.getAttribute 'style'
+ if style?
+ n.attrs.style = style
+ else
+ if n.attrs.style?
+ delete n.attrs.style
# call this after you insert or remove inline nodes. It will:
# merge consecutive text nodes
# remove empty text nodes
# adjust white-space property
text_cleanup: (n) ->
+ if @is_display_block n
+ block = n
+ else
+ block = @find_block_parent n
+ return unless block?
+ run = @get_text_run block
+ return unless run?
+ # merge consecutive text nodes
+ if run.length > 1
+ i = 1
+ prev = run[0]
+ while i < run.length
+ n = run[i]
+ if prev.type is 'text' and n.type is 'text'
+ if prev.parent is n.parent
+ prev_i = n.parent.children.indexOf prev
+ n_i = n.parent.children.indexOf n
+ if n_i is prev_i + 1
+ prev.text = prev.text + n.text
+ prev.el.textContent = prev.text
+ @remove_node n
+ run.splice i, 1
+ continue # don't increment i or change prev
+ i += 1
+ prev = n
+ # remove empty text nodes
+ i = 0
+ while i < run.length
+ n = run[i]
+ if n.type is 'text'
+ if n.text is ''
+ @remove_node n
+ # FIXME maybe remove parents recursively if this makes them empty
+ run.splice i, 1
+ continue # don't increment i
+ i += 1
+ # note: inline tags can have white-space:pre-line/etc
+ # note: inline-blocks have their whitespace collapsed independantly of outer run
+ # note: inline-blocks are treated like non-whitespace char even if empty
+ if block.el.style.whiteSpace?
+ ws = block.el.style.whiteSpace
+ if ws_props[ws]
+ if ws_props[ws].space
+ if ws_props[ws].to_collapse is 'normal'
+ block.el.style.whiteSpace = null
+ else
+ block.el.style.whiteSpace = ws_props[ws].to_collapse
+ @update_style_from_el block
+ # note: space after
colapses, but not space before
+ # check for spaces that would collapse without help
+ eats_start_sp = true # if the next node starts with space it collapses (unless pre)
+ prev = null
+ for n in run
+ if n.type is 'tag'
+ if n.name is 'br'
+ eats_start_sp = true
+ else
+ eats_start_sp = false
+ else # TEXT
+ need_preserve = false
+ if n.type isnt 'text'
+ console.log "bug #232308"
+ return
+ if eats_start_sp
+ if is_space_code n.text.charCodeAt 0
+ need_preserve = true
+ unless need_preserve
+ need_preserve = multi_sp_regex.test n.text
+ if need_preserve
+ # do we have it already?
+ ws = @computed_style n, 'white-space' # FIXME implement this
+ unless ws_props[ws]?.space
+ # 2nd arg is ideal target for css rule
+ ws = @preserve_space n, block
+ eats_start_sp = false
+ else
+ if is_space_code n.text.charCodeAt(n.text.length - 1)
+ ws = @computed_style n, 'white-space' # FIXME implement this
+ if ws_props[ws]?.space
+ eats_start_sp = false
+ else
+ eats_start_sp = true
+ else
+ eats_start_sp = false
+ # check if text ends with a collapsable space
+ if run.length > 0
+ last = run[run.length - 1]
+ if last.type is 'text'
+ if eats_start_sp
+ @preserve_space last, block
+ return
+ css_clear: (n, prop) ->
+ return unless n.attrs.style?
+ return if n.attrs.style is ''
+ css_delimiter_regex = new RegExp('\s*;\s*', 'g') # FIXME make this global
+ styles = n.attrs.style.trim().split css_delimiter
+ return unless styles.length > 0
+ if styles[styles.length - 1] is ''
+ styles.pop()
+ return unless styles.length > 0
+ i = 0
+ while i < styles.length
+ if styles[i].substr(0, 12) is 'white-space:'
+ styles.splice i, 1
+ else
+ i += 1
return
- # FIXME implement this
# WARNING: after calling this one or more times, you MUST:
# if it's inline: call @text_cleanup
# call @changed()
@@ -1436,7 +1597,7 @@ class PeachHTML5Editor
else
new_parent.el.appendChild n.el, insert_before
new_parent.children.push n
- n.parent = new_parent
+ n.parent = new_parent
return
kill_cursor: -> # remove it, forget where it was
if @cursor_visible