 
   emitCloseEvent: ->
     return @layer.emit(
-      @buildEvent(@closeEventType),
-      callback: @layer.callback(@closeCallbackName),
-      log: "Will close #{@layer}"
+      @buildEvent("up:layer:#{@verb}"),
+      callback: @layer.callback("on#{u.upperCaseFirst(@verb)}"),
+      log: "Will #{@verb} #{@layer}"
     )
 
   emitClosingEvent: ->
+    verbGerund = "#{@verb}ing"
+    verbGerundUpperCaseFirst = u.upperCaseFirst(verbGerund)
+
     return @layer.emit(
-      @buildEvent(@closingEventType),
-      callback: @layer.callback(@closingCallbackName),
-      log: "Closing #{@layer}"
+      @buildEvent("up:layer:#{verbGerund}"),
+      callback: @layer.callback("on#{verbGerundUpperCaseFirst}"),
+      log: "#{verbGerundUpperCaseFirst} #{@layer}"
     )
 
   emitClosedEvent: (formerParent) ->
+    verbPast = "#{@verb}ed"
+    verbPastUpperCaseFirst = u.upperCaseFirst(verbPast)
+
     # layer.emit({ ensureBubbles: true }) will automatically emit a second event on document
     # because the layer is detached. We do not want to emit it on the parent layer where users
     # might confuse it with an event for the parent layer itself. Since @layer.element

    # event listeners can receive it. So we explicitely emit the event a second time
    # on the document.
    return @layer.emit(
      @buildEvent(@closedEventType),
      # Set up.layer.current to the parent of the closed layer, which is now likely
      # to be the front layer.
      currentLayer: formerParent,
      callback: @layer.callback(@closedCallbackName),
      ensureBubbles: true,
      log: "Closed #{@layer}"
    )

  buildEvent: (name) ->


  execute: ->
    if @origin && u.isUndefined(value)
      value = e.jsonAttr(@origin, "up-#{@verb}")

    unless @layer.isOpen()
      return Promise.resolve()
