mercury-rails 0.1.0

data/app/assets/javascripts/mercury/page_editor.js.coffee

@@ -0,0 +1,139 @@
+class @Mercury.PageEditor
+
+  # options
+  # saveStyle: 'form', or 'json' (defaults to json)
+  # ignoredLinks: an array containing classes for links to ignore (eg. lightbox or accordian controls)
+  constructor: (@saveUrl = null, @options = {}) ->
+    throw "Mercury.PageEditor is unsupported in this client. Supported browsers are chrome 10+, firefix 4+, and safari 5+." unless Mercury.supported
+    throw "Mercury.PageEditor can only be instantiated once." if window.mercuryInstance
+
+    window.mercuryInstance = @
+    @regions = []
+    @initializeInterface()
+    Mercury.csrfToken = token if token = $('meta[name="csrf-token"]').attr('content')
+
+
+  initializeInterface: ->
+    @focusableElement = $('<input>', {type: 'text', style: 'position:absolute;opacity:0'}).appendTo(@options.appendTo ? 'body')
+    @iframe = $('<iframe>', {class: 'mercury-iframe', seamless: 'true', frameborder: '0', src: 'about:blank', style: 'position:absolute;top:0;width:100%;visibility:hidden'})
+    @iframe.load => @initializeFrame()
+    @iframe.attr('src', @iframeSrc())
+    @iframe.appendTo($(@options.appendTo).get(0) ? 'body')
+
+    @toolbar = new Mercury.Toolbar(@options)
+    @statusbar = new Mercury.Statusbar(@options)
+
+
+  initializeFrame: ->
+    try
+      return if @iframe.data('loaded')
+      @iframe.data('loaded', true)
+      @document = $(@iframe.get(0).contentWindow.document)
+      $("<style mercury-styles=\"true\">").html(Mercury.config.injectedStyles).appendTo(@document.find('head'))
+
+      @bindEvents()
+      @initializeRegions()
+      @finalizeInterface()
+
+      @iframe.css({visibility: 'visible'})
+    catch error
+      alert("Mercury.PageEditor failed to load: #{error}\n\nPlease try refreshing.")
+
+
+  initializeRegions: ->
+    @buildRegion($(region)) for region in $('.mercury-region', @document)
+    for region in @regions
+      if region.focus
+        region.focus()
+        break
+
+
+  buildRegion: (region) ->
+    try
+      type = region.data('type').titleize()
+      @regions.push(new Mercury.Regions[type](region, @iframe.get(0).contentWindow))
+    catch error
+      alert(error) if Mercury.debug
+      alert("Region type is malformed, no data-type provided, or \"#{type}\" is unknown.")
+
+
+  finalizeInterface: ->
+    @snippetToolbar = new Mercury.SnippetToolbar(@document)
+
+    @hijackLinks()
+    @resize()
+
+
+  bindEvents: ->
+    Mercury.bind 'initialize:frame', => setTimeout(@initializeFrame, 100)
+    Mercury.bind 'focus:frame', => @iframe.focus()
+    Mercury.bind 'focus:window', => setTimeout((=> @focusableElement.focus()), 10)
+
+    Mercury.bind 'action', (event, options) =>
+      @save() if options.action == 'save'
+
+    @document.mousedown (event) ->
+      Mercury.trigger('hide:dialogs')
+      Mercury.trigger('unfocus:regions') unless $(event.target).closest('.mercury-region').get(0) == Mercury.region.element.get(0)
+
+    $(window).resize => @resize()
+    window.onbeforeunload = @beforeUnload
+
+
+  resize: ->
+    width = $(window).width()
+    height = $(window).height()
+    toolbarHeight = @toolbar.height()
+    statusbarHeight = @statusbar.height()
+
+    Mercury.displayRect = {top: toolbarHeight, left: 0, width: width, height: height - statusbarHeight - toolbarHeight}
+
+    @iframe.css {
+      top: toolbarHeight,
+      width: width,
+      height: height - statusbarHeight - toolbarHeight
+    }
+
+    Mercury.trigger('resize')
+
+
+  iframeSrc: (url = null) ->
+    (url ? window.location.href).replace(/([http|https]:\/\/.[^\/]*)\/edit\/?(.*)/i, "$1/$2")
+
+
+  hijackLinks: ->
+    for link in $('a', @document)
+      ignored = false
+      for classname in @options.ignoredLinks || []
+        if $(link).hasClass(classname)
+          ignored = true
+          continue
+      if !ignored && (link.target == '' || link.target == '_self') && !$(link).closest('.mercury-region').length
+        $(link).attr('target', '_top')
+
+
+  beforeUnload: ->
+    if Mercury.changes && !Mercury.silent
+      return "You have unsaved changes.  Are you sure you want to leave without saving them first?"
+    return null
+
+
+  save: ->
+    url = @saveUrl ? @iframeSrc()
+    data = @serialize()
+    Mercury.log('saving', data)
+    data = $.toJSON(data) unless @options.saveStyle == 'form'
+    $.ajax url, {
+      type: 'POST'
+      data: {content: data}
+      success: =>
+        Mercury.changes = false
+      error: =>
+        alert("Mercury was unable to save to the url: #{url}")
+    }
+
+
+  serialize: ->
+    serialized = {}
+    serialized[region.name] = region.serialize() for region in @regions
+    return serialized

data/app/assets/javascripts/mercury/palette.js.coffee

@@ -0,0 +1,29 @@
+class @Mercury.Palette extends Mercury.Dialog
+
+  constructor: (@url, @name, @options = {}) ->
+    super
+
+
+  build: ->
+    @element = $('<div>', {class: "mercury-palette mercury-#{@name}-palette loading", style: 'display:none'})
+    @element.appendTo($(@options.appendTo).get(0) ? 'body')
+
+
+  bindEvents: ->
+    Mercury.bind 'hide:dialogs', (event, dialog) => @hide() unless dialog == @
+    super
+
+
+  position: (keepVisible) ->
+    @element.css({top: 0, left: 0, display: 'block', visibility: 'hidden'})
+    position = @button.offset()
+    width = @element.width()
+
+    position.left = position.left - width + @button.width() if position.left + width > $(window).width()
+
+    @element.css {
+      top: position.top + @button.height(),
+      left: position.left,
+      display: if keepVisible then 'block' else 'none',
+      visibility: 'visible'
+    }

data/app/assets/javascripts/mercury/panel.js.coffee

@@ -0,0 +1,97 @@
+class @Mercury.Panel extends Mercury.Dialog
+
+  constructor: (@url, @name, @options = {}) ->
+    super
+
+
+  build: ->
+    @element = $('<div>', {class: 'mercury-panel loading', style: 'display:none;'})
+    @titleElement = $("<h1>#{@options.title}</h1>").appendTo(@element)
+    @paneElement = $('<div>', {class: 'mercury-panel-pane'}).appendTo(@element)
+
+    @element.appendTo($(@options.appendTo).get(0) ? 'body');
+
+
+  bindEvents: ->
+    Mercury.bind 'resize', => @position(@visible)
+    Mercury.bind 'hide:panels', (event, panel) =>
+      unless panel == @
+        @button.removeClass('pressed')
+        @hide()
+
+    @element.mousedown (event) -> event.stopPropagation()
+
+    super
+
+
+  show: ->
+    Mercury.trigger('hide:panels', @)
+    super
+
+
+  resize: ->
+    @paneElement.css({display: 'none'})
+    preWidth = @element.width()
+
+    @paneElement.css({visibility: 'hidden', width: 'auto', display: 'block'})
+    postWidth = @element.width()
+
+    @paneElement.css({visibility: 'visible', display: 'none'})
+    position = @element.offset()
+    @element.animate {left: position.left - (postWidth - preWidth), width: postWidth}, 200, 'easeInOutSine', =>
+      @paneElement.css({display: 'block', width: postWidth})
+      @makeDraggable()
+
+    @hide() unless @visible
+
+
+  position: (keepVisible) ->
+    @element.css({display: 'block', visibility: 'hidden'})
+    offset = @element.offset()
+    elementWidth = @element.width()
+    height = Mercury.displayRect.height - 16
+
+    paneHeight = height - @titleElement.outerHeight()
+    @paneElement.css({height: paneHeight, overflowY: if paneHeight < 30 then 'hidden' else 'auto'})
+
+    left = Mercury.displayRect.width - elementWidth - 20 unless @moved
+    left = 8 if left <= 8
+
+    if @pinned || elementWidth + offset.left > Mercury.displayRect.width - 20
+      left = Mercury.displayRect.width - elementWidth - 20
+
+    @element.css {
+      top: Mercury.displayRect.top + 8,
+      left: left,
+      height: height,
+      display: if keepVisible then 'block' else 'none',
+      visibility: 'visible'
+    }
+
+    @makeDraggable()
+    @element.hide() unless keepVisible
+
+
+  loadContent: (data) ->
+    @loaded = true
+    @element.removeClass('loading')
+    @paneElement.css({visibility: 'hidden'})
+    @paneElement.html(data)
+
+
+  makeDraggable: ->
+    elementWidth = @element.width()
+    @element.draggable {
+      handle: 'h1',
+      axis: 'x',
+      opacity: 0.70
+      scroll: false,
+      addClasses: false,
+      iframeFix: true,
+      containment: [8, 0, Mercury.displayRect.width - elementWidth - 20, 0]  #[x1, y1, x2, y2]
+      stop: =>
+        left = @element.offset().left
+        @moved = true
+        @pinned = if left > Mercury.displayRect.width - elementWidth - 30 then true else false
+        return true
+    }

data/app/assets/javascripts/mercury/region.js.coffee

@@ -0,0 +1,103 @@
+class @Mercury.Region
+  type = 'region'
+
+  constructor: (@element, @window, @options = {}) ->
+    @type = 'region' unless @type
+    Mercury.log("building #{@type}", @element, @options)
+
+    @document = @window.document
+    @name = @element.attr('id')
+    @history = new Mercury.HistoryBuffer()
+    @build()
+    @bindEvents()
+    @pushHistory()
+
+
+  build: ->
+
+
+  focus: ->
+
+
+  bindEvents: ->
+    Mercury.bind 'mode', (event, options) =>
+      @togglePreview() if options.mode == 'preview'
+
+    Mercury.bind 'focus:frame', =>
+      return if @previewing
+      return unless Mercury.region == @
+      @focus()
+
+    Mercury.bind 'action', (event, options) =>
+      return if @previewing
+      return unless Mercury.region == @
+      @execCommand(options.action, options) if options.action
+
+    @element.mousemove (event) =>
+      return if @previewing
+      return unless Mercury.region == @
+      snippet = $(event.target).closest('.mercury-snippet')
+      if snippet.length
+        @snippet = snippet
+        Mercury.trigger('show:toolbar', {type: 'snippet', snippet: @snippet})
+
+    @element.mouseout (event) =>
+      return if @previewing
+      Mercury.trigger('hide:toolbar', {type: 'snippet', immediately: false})
+
+
+  html: (value = null, filterSnippets = false) ->
+    if value != null
+      @element.html(value)
+    else
+      # sanitize the html before we return it
+      container = $('<div>').appendTo(@document.createDocumentFragment())
+      container.html(@element.html().replace(/^\s+|\s+$/g, ''))
+
+      # replace snippet contents to be an identifier
+      if filterSnippets then for snippet, index in container.find('.mercury-snippet')
+        snippet = $(snippet)
+        snippet.attr({contenteditable: null, 'data-version': null})
+        snippet.html("[#{snippet.data('snippet')}]")
+
+      return container.html()
+
+
+  togglePreview: ->
+    if @previewing
+      @previewing = false
+      @element.addClass('mercury-region').removeClass('mercury-region-preview')
+      @focus() if Mercury.region == @
+    else
+      @previewing = true
+      @element.addClass('mercury-region-preview').removeClass('mercury-region')
+      Mercury.trigger('region:blurred', {region: @})
+
+
+  execCommand: (action, options = {}) ->
+    @focus()
+    @pushHistory() unless action == 'redo'
+
+    Mercury.log('execCommand', action, options.value)
+    Mercury.changes = true
+
+
+  pushHistory: ->
+    @history.push(@html())
+
+
+  snippets: ->
+    snippets = {}
+    for element in @element.find('[data-snippet]')
+      snippet = Mercury.Snippet.find($(element).data('snippet'))
+      snippet.setVersion($(element).data('version'))
+      snippets[snippet.identity] = snippet.serialize()
+    return snippets
+
+
+  serialize: ->
+    return {
+      type: @type,
+      value: @html(null, true)
+      snippets: @snippets()
+    }

data/app/assets/javascripts/mercury/regions/editable.js.coffee

@@ -0,0 +1,546 @@
+class @Mercury.Regions.Editable extends Mercury.Region
+  type = 'editable'
+
+  constructor: (@element, @window, @options = {}) ->
+    @type = 'editable'
+    super
+
+
+  build: ->
+    # mozilla: set some initial content so everything works correctly
+    @html(' ') if $.browser.mozilla && @html() == ''
+
+    # set overflow just in case
+    @element.data({originalOverflow: @element.css('overflow')})
+    @element.css({overflow: 'auto'})
+
+    # mozilla: there's some weird behavior when the element isn't a div
+    @specialContainer = $.browser.mozilla && @element.get(0).tagName != 'DIV'
+
+    # make it editable
+    # gecko: in this makes double clicking in textareas fail: https://bugzilla.mozilla.org/show_bug.cgi?id=490367
+    @element.get(0).contentEditable = true
+
+    # make all snippets not editable, and set their versions to 1
+    for element in @element.find('.mercury-snippet')
+      element.contentEditable = false
+      $(element).attr('data-version', '1')
+
+    # add the basic editor settings to the document (only once)
+    unless @document.mercuryEditing
+      @document.execCommand('styleWithCSS', false, false)
+      @document.execCommand('insertBROnReturn', false, true)
+      @document.execCommand('enableInlineTableEditing', false, false)
+      @document.execCommand('enableObjectResizing', false, false)
+      @document.mercuryEditing = true
+
+
+  bindEvents: ->
+    super
+
+    Mercury.bind 'region:update', =>
+      return if @previewing
+      return unless Mercury.region == @
+      setTimeout((=> @selection().forceSelection(@element.get(0))), 1)
+      currentElement = @currentElement()
+      if currentElement.length
+        # setup the table editor if we're inside a table
+        table = currentElement.closest('table', @element)
+        Mercury.tableEditor(table, currentElement) if table.length
+        # display a tooltip if we're in an anchor
+        anchor = currentElement.closest('a', @element)
+        if anchor.length && anchor.attr('href')
+          Mercury.tooltip(anchor, "<a href=\"#{anchor.attr('href')}\" target=\"_blank\">#{anchor.attr('href')}</a>", {position: 'below'})
+        else
+          Mercury.tooltip.hide()
+
+    @element.bind 'dragenter', (event) =>
+      return if @previewing
+      event.preventDefault() if event.shiftKey
+      event.originalEvent.dataTransfer.dropEffect = 'copy'
+
+    @element.bind 'dragover', (event) =>
+      return if @previewing
+      event.preventDefault() if event.shiftKey
+      event.originalEvent.dataTransfer.dropEffect = 'copy'
+      if $.browser.webkit
+        clearTimeout(@dropTimeout)
+        @dropTimeout = setTimeout((=> @element.trigger('possible:drop')), 10)
+
+    @element.bind 'drop', (event) =>
+      return if @previewing
+
+      # handle dropping snippets
+      clearTimeout(@dropTimeout)
+      @dropTimeout = setTimeout((=> @element.trigger('possible:drop')), 1)
+
+      # handle any files that were dropped
+      return unless event.originalEvent.dataTransfer.files.length
+      event.preventDefault()
+      @focus()
+      Mercury.uploader(event.originalEvent.dataTransfer.files[0])
+
+    # possible:drop custom event: we have to do this because webkit doesn't fire the drop event unless both dragover and
+    # dragstart default behaviors are canceled.. but when we do that and observe the drop event, the default behavior
+    # isn't handled (eg, putting the image where it was dropped,) so to allow the browser to do it's thing, and also do
+    # our thing we have this little hack.  *sigh*
+    # read: http://www.quirksmode.org/blog/archives/2009/09/the_html5_drag.html
+    @element.bind 'possible:drop', (event) =>
+      return if @previewing
+      if snippet = @element.find('img[data-snippet]').get(0)
+        @focus()
+        Mercury.Snippet.displayOptionsFor($(snippet).data('snippet'))
+        @document.execCommand('undo', false, null)
+
+    # custom paste handling: we have to do some hackery to get the pasted content since it's not exposed normally
+    # through a clipboard in firefox (heaven forbid), and to keep the behavior across all browsers, we manually detect
+    # what was pasted by running a quick diff, removing it by calling undo, making our adjustments, and then putting the
+    # content back.  This is possible, so it doesn't make sense why it wouldn't be exposed in a sensible way.  *sigh*
+    @element.bind 'paste', =>
+      return if @previewing
+      return unless Mercury.region == @
+      Mercury.changes = true
+      html = @html()
+      event.preventDefault() if @specialContainer
+      setTimeout((=> @handlePaste(html)), 1)
+
+    @element.focus =>
+      return if @previewing
+      Mercury.region = @
+      setTimeout((=> @selection().forceSelection(@element.get(0))), 1)
+      Mercury.trigger('region:focused', {region: @})
+
+    @element.blur =>
+      return if @previewing
+      Mercury.trigger('region:blurred', {region: @})
+      Mercury.tooltip.hide()
+
+    @element.click (event) =>
+      $(event.target).closest('a').attr('target', '_top') if @previewing
+
+    @element.dblclick (event) =>
+      return if @previewing
+      image = $(event.target).closest('img', @element)
+      if image.length
+        @selection().selectNode(image.get(0), true)
+        Mercury.trigger('button', {action: 'insertmedia'})
+
+    @element.mouseup =>
+      return if @previewing
+      @pushHistory()
+      Mercury.trigger('region:update', {region: @})
+
+    @element.keydown (event) =>
+      return if @previewing
+      Mercury.changes = true
+      switch event.keyCode
+
+        when 90 # undo / redo
+          return unless event.metaKey
+          event.preventDefault()
+          if event.shiftKey then @execCommand('redo') else @execCommand('undo')
+          return
+
+        when 13 # enter
+          if $.browser.webkit && @selection().commonAncestor().closest('li, ul', @element).length == 0
+            event.preventDefault()
+            @document.execCommand('insertlinebreak', false, null)
+          else if @specialContainer
+            # mozilla: pressing enter in any elemeny besides a div handles strangely
+            event.preventDefault()
+            @document.execCommand('insertHTML', false, '<br/>')
+
+        when 9 # tab
+          event.preventDefault()
+          container = @selection().commonAncestor()
+          handled = false
+
+          # indent when inside of an li
+          if container.closest('li', @element).length
+            handled = true
+            if event.shiftKey then @execCommand('outdent') else @execCommand('indent')
+
+          @execCommand('insertHTML', {value: '&nbsp; '}) unless handled
+
+      if event.metaKey
+        switch event.keyCode
+
+          when 66 # b
+            @execCommand('bold')
+            event.preventDefault()
+
+          when 73 # i
+            @execCommand('italic')
+            event.preventDefault()
+
+          when 85 # u
+            @execCommand('underline')
+            event.preventDefault()
+
+      @pushHistory(event.keyCode)
+
+    @element.keyup =>
+      return if @previewing
+      Mercury.trigger('region:update', {region: @})
+
+
+  focus: ->
+    @element.focus()
+    setTimeout((=> @selection().forceSelection(@element.get(0))), 1)
+    Mercury.trigger('region:update', {region: @})
+
+
+  html: (value = null, filterSnippets = true, includeMarker = false) ->
+    if value != null
+      # sanitize the html before we insert it
+      container = $('<div>').appendTo(@document.createDocumentFragment())
+      container.html(value)
+
+      # fill in the snippet contents
+      for element in container.find('[data-snippet]')
+        element.contentEditable = false
+        element = $(element)
+        if snippet = Mercury.Snippet.find(element.data('snippet'))
+          unless element.data('version')
+            try
+              version = parseInt(element.html().match(/\/(\d+)\]/)[1])
+              if version
+                snippet.setVersion(version)
+                element.attr({'data-version': version})
+                element.html(snippet.data)
+            catch error
+
+      # set the html
+      @element.html(container.html())
+
+      # create a selection if there's markers
+      @selection().selectMarker(@element)
+    else
+      # remove any meta tags
+      @element.find('meta').remove()
+
+      # place markers for the selection
+      if includeMarker
+        selection = @selection()
+        selection.placeMarker()
+
+      # sanitize the html before we return it
+      container = $('<div>').appendTo(@document.createDocumentFragment())
+      container.html(@element.html().replace(/^\s+|\s+$/g, ''))
+
+      # replace snippet contents to be an identifier
+      if filterSnippets then for element, index in container.find('[data-snippet]')
+        element = $(element)
+        if snippet = Mercury.Snippet.find(element.data("snippet"))
+          snippet.data = element.html()
+        element.html("[#{element.data("snippet")}/#{element.data("version")}]")
+        element.attr({contenteditable: null, 'data-version': null})
+
+      # get the html before removing the markers
+      html = container.html()
+
+      # remove the markers from the dom
+      selection.removeMarker() if includeMarker
+
+      return html
+
+
+  togglePreview: ->
+    if @previewing
+      @element.get(0).contentEditable = true
+      @element.css({overflow: 'auto'})
+    else
+      @html(@html())
+      @element.get(0).contentEditable = false
+      @element.css({overflow: @element.data('originalOverflow')})
+      @element.blur()
+    super
+
+
+  execCommand: (action, options = {}) ->
+    super
+
+    # use a custom handler if there's one, otherwise use execCommand
+    if handler = Mercury.config.behaviors[action] || Mercury.Regions.Editable.actions[action]
+      handler.call(@, @selection(), options)
+    else
+      sibling = @element.get(0).previousSibling if action == 'indent'
+      options.value = $('<div>').html(options.value).html() if action == 'insertHTML' && options.value && options.value.get
+      try
+        @document.execCommand(action, false, options.value)
+      catch error
+        # mozilla: indenting when there's no br tag handles strangely
+        @element.prev().remove() if action == 'indent' && @element.prev() != sibling
+
+
+  pushHistory: (keyCode) ->
+    # when pressing return, delete or backspace it should push to the history
+    # all other times it should store if there's a 1 second pause
+    keyCodes = [13, 46, 8]
+    waitTime = 2.5
+    knownKeyCode = keyCodes.indexOf(keyCode) if keyCode
+
+    # clear any pushes to the history
+    clearTimeout(@historyTimeout)
+
+    # if the key code was return, delete, or backspace store now -- unless it was the same as last time
+    if knownKeyCode >= 0 && knownKeyCode != @lastKnownKeyCode # || !keyCode
+      @history.push(@html(null, false, true))
+    else if keyCode
+      # set a timeout for pushing to the history
+      @historyTimeout = setTimeout((=> @history.push(@html(null, false, true))), waitTime * 1000)
+    else
+      # push to the history immediately
+      @history.push(@html(null, false, true))
+
+    @lastKnownKeyCode = knownKeyCode
+
+
+  selection: ->
+    return new Mercury.Regions.Editable.Selection(@window.getSelection(), @document)
+
+
+  path: ->
+    container = @selection().commonAncestor()
+    return [] unless container
+    return if container.get(0) == @element.get(0) then [] else container.parentsUntil(@element)
+
+
+  currentElement: ->
+    element = []
+    selection = @selection()
+    if selection.range
+      element = selection.commonAncestor()
+      element = element.parent() if element.get(0).nodeType == 3
+    return element
+
+
+  handlePaste: (prePasteHTML) ->
+    prePasteHTML = prePasteHTML.replace(/^\<br\>/, '')
+
+    # remove any regions that might have been pasted
+    @element.find('.mercury-region').remove()
+
+    # handle pasting from ms office etc
+    html = @html()
+    if html.indexOf('<!--StartFragment-->') > -1 || html.indexOf('="mso-') > -1 || html.indexOf('<o:') > -1 || html.indexOf('="Mso') > -1
+      # clean out all the tags from the pasted contents
+      cleaned = prePasteHTML.singleDiff(@html()).sanitizeHTML()
+      try
+        # try to undo and put the cleaned html where the selection was
+        @document.execCommand('undo', false, null)
+        @execCommand('insertHTML', {value: cleaned})
+      catch error
+        # remove the pasted html and load up the cleaned contents into a modal
+        @html(prePasteHTML)
+        Mercury.modal '/mercury/modals/sanitizer', {
+          title: 'HTML Sanitizer (Starring Clippy)',
+          afterLoad: -> @element.find('textarea').val(cleaned.replace(/<br\/>/g, '\n'))
+        }
+    else if Mercury.config.cleanStylesOnPaste
+      # strip styles
+      pasted = prePasteHTML.singleDiff(@html())
+
+      container = $('<div>').appendTo(@document.createDocumentFragment()).html(pasted)
+      container.find('[style]').attr({style: null})
+
+      @document.execCommand('undo', false, null)
+      @execCommand('insertHTML', {value: container.html()})
+
+
+  # Custom actions (eg. things that execCommand doesn't do, or doesn't do well)
+  @actions: {
+    insertrowbefore: -> Mercury.tableEditor.addRow('before')
+
+    insertrowafter: -> Mercury.tableEditor.addRow('after')
+
+    insertcolumnbefore: -> Mercury.tableEditor.addColumn('before')
+
+    insertcolumnafter: -> Mercury.tableEditor.addColumn('after')
+
+    deletecolumn: -> Mercury.tableEditor.removeColumn()
+
+    deleterow: -> Mercury.tableEditor.removeRow()
+
+    increasecolspan: -> Mercury.tableEditor.increaseColspan()
+
+    decreasecolspan: -> Mercury.tableEditor.decreaseColspan()
+
+    increaserowspan: -> Mercury.tableEditor.increaseRowspan()
+
+    decreaserowspan: -> Mercury.tableEditor.decreaseRowspan()
+
+    undo: -> @html(@history.undo())
+
+    redo: -> @html(@history.redo())
+
+    removeformatting: (selection) -> selection.insertTextNode(selection.textContent())
+
+    backcolor: (selection, options) -> selection.wrap("<span style=\"background-color:#{options.value.toHex()}\">", true)
+
+    overline: (selection) -> selection.wrap('<span style="text-decoration:overline">', true)
+
+    style: (selection, options) -> selection.wrap("<span class=\"#{options.value}\">", true)
+
+    replaceHTML: (selection, options) -> @html(options.value)
+
+    insertImage: (selection, options) -> @execCommand('insertHTML', {value: $('<img/>', options.value)})
+
+    insertLink: (selection, options) ->
+      anchor = $("<#{options.value.tagName}>").attr(options.value.attrs).html(options.value.content)
+      selection.insertNode(anchor)
+
+    replaceLink: (selection, options) ->
+      anchor = $("<#{options.value.tagName}>").attr(options.value.attrs).html(options.value.content)
+      selection.selectNode(options.node)
+      html = $('<div>').html(selection.content()).find('a').html()
+      selection.replace($(anchor, selection.context).html(html))
+
+    insertsnippet: (selection, options) ->
+      snippet = options.value
+      if (existing = @element.find("[data-snippet=#{snippet.identity}]")).length
+        selection.selectNode(existing.get(0))
+      selection.insertNode(snippet.getHTML(@document))
+
+    editsnippet: ->
+      return unless @snippet
+      snippet = Mercury.Snippet.find(@snippet.data('snippet'))
+      snippet.displayOptions()
+
+    removesnippet: ->
+      @snippet.remove() if @snippet
+      Mercury.trigger('hide:toolbar', {type: 'snippet', immediately: true})
+  }
+
+
+# Helper class for managing selection and getting information from it
+class Mercury.Regions.Editable.Selection
+
+  constructor: (@selection, @context) ->
+    return unless @selection.rangeCount >= 1
+    @range = @selection.getRangeAt(0)
+    @fragment = @range.cloneContents()
+    @clone = @range.cloneRange()
+
+
+  commonAncestor: (onlyTag = false) ->
+    return null unless @range
+    ancestor = @range.commonAncestorContainer
+    ancestor = ancestor.parentNode if ancestor.nodeType == 3 && onlyTag
+    return $(ancestor)
+
+
+  wrap: (element, replace = false) ->
+    element = $(element, @context).html(@fragment)
+    @replace(element) if replace
+    return element
+
+
+  textContent: ->
+    return @range.cloneContents().textContent
+
+
+  content: ->
+    return @range.cloneContents()
+
+
+  is: (elementType) ->
+    content = @content()
+    return $(content.firstChild) if content.childNodes.length == 1 && $(content.firstChild).is(elementType)
+    return false
+
+
+  forceSelection: (element) ->
+    return unless $.browser.webkit
+    range = @context.createRange()
+
+    if @range
+      if @commonAncestor(true).closest('.mercury-snippet').length
+        lastChild = @context.createTextNode('\00')
+        element.appendChild(lastChild)
+    else
+      if element.lastChild && element.lastChild.nodeType == 3 && element.lastChild.textContent.replace(/^[\s+|\n+]|[\s+|\n+]$/, '') == ''
+        lastChild = element.lastChild
+        element.lastChild.textContent = '\00'
+      else
+        lastChild = @context.createTextNode('\00')
+        element.appendChild(lastChild)
+
+    if lastChild
+      range.setStartBefore(lastChild)
+      range.setEndBefore(lastChild)
+      @selection.addRange(range)
+
+
+  selectMarker: (context) ->
+    markers = context.find('em.mercury-marker')
+    return unless markers.length
+
+    range = @context.createRange()
+    range.setStartBefore(markers.get(0))
+    range.setEndBefore(markers.get(1)) if markers.length >= 2
+
+    markers.remove()
+
+    @selection.removeAllRanges()
+    @selection.addRange(range)
+
+
+  placeMarker: ->
+    return unless @range
+
+    @startMarker = $('<em class="mercury-marker"/>', @context).get(0)
+    @endMarker = $('<em class="mercury-marker"/>', @context).get(0)
+
+    # put a single marker (the end)
+    rangeEnd = @range.cloneRange()
+    rangeEnd.collapse(false)
+    rangeEnd.insertNode(@endMarker)
+
+    unless @range.collapsed
+      # put a start marker
+      rangeStart = @range.cloneRange()
+      rangeStart.collapse(true)
+      rangeStart.insertNode(@startMarker)
+
+    @selection.removeAllRanges()
+    @selection.addRange(@range)
+
+
+  removeMarker: ->
+    $(@startMarker).remove()
+    $(@endMarker).remove()
+
+
+  insertTextNode: (string) ->
+    node = @context.createTextNode(string)
+    @range.extractContents()
+    @range.insertNode(node)
+    @range.selectNodeContents(node)
+    @selection.addRange(@range)
+
+
+  insertNode: (element) ->
+    element = element.get(0) if element.get
+    element = $(element, @context).get(0) if $.type(element) == 'string'
+
+    @range.deleteContents()
+    @range.insertNode(element)
+    @range.selectNodeContents(element)
+    @selection.addRange(@range)
+
+
+  selectNode: (node, removeExisting = false) ->
+    @range.selectNode(node)
+    @selection.removeAllRanges() if removeExisting
+    @selection.addRange(@range)
+
+
+  replace: (element) ->
+    element = element.get(0) if element.get
+    element = $(element, @context).get(0) if $.type(element) == 'string'
+
+    @range.deleteContents()
+    @range.insertNode(element)
+    @range.selectNodeContents(element)
+    @selection.addRange(@range)