$("#tree").fancytree({
  extensions: ["edit"],
  edit: {
    // Available options with their default:
    adjustWidthOfs: 4,   // null: don't adjust input size to content
    inputCss: { minWidth: "3em" },
    triggerStart: ["clickActive", "f2", "dblclick", "shift+click", "mac+enter"],
    beforeEdit: $.noop,   // Return false to prevent edit mode
    edit: $.noop,         // Editor was opened (available as data.input)
    beforeClose: $.noop,  // Return false to prevent cancel/save (data.input is available)
    save: $.noop,         // Save data.input.val() or return false to keep editor open
    close: $.noop,        // Editor was removed
  },
  [...]
});

$("#tree").fancytree({
  extensions: ["edit"],
  ...
  edit: {
    beforeEdit: function(event, data){
      // `data.node` is about to be edited.
      // Return false to prevent this.
    },
    edit: function(event, data){
      // `data.node` switched into edit mode.
      // The <input> element was created (available as jQuery object `data.input`)
      // and contains the original `data.node.title`.
    },
    beforeClose: function(event, data){
      // Editing is about to end (either cancel or save).
      // Additional information is available:
      // - `data.dirty`:    true if text was modified by user.
      // - `data.input`:    The input element (jQuery object).
      //                    `data.input.val()` returns the new node title.
      // - `data.isNew`:    true if this node was newly created using `editCreateNode()`.
      // - `data.orgTitle`: The previous node title text.
      // - `data.originalEvent`:
      //                    Contains the originating event (i.e. blur, mousdown, keydown).
      // - `data.save`:     false if saving is not required, i.e. user pressed  
      //                    cancel or text is unchanged.
      //                    This value may be changed to override default behavior.
      // Return false to prevent this (keep the editor open), for example when
      // validations fail.
    },
    save: function(event, data){
      // Only called when the text was modified and the user pressed enter or
      // the <input> lost focus.
      // Additional information is available (see `beforeClose`).
      // Return false to keep editor open, for example when validations fail.
      // Otherwise the user input is accepted as `node.title` and the <input>
      // is removed.
      // Typically we would also issue an Ajax request here to send the new data
      // to the server (and handle potential errors when the asynchronous request
      // returns).
    },
    close: function(event, data){
      // Editor was removed.
      // Additional information is available (see `beforeClose`).
    }
  }
});

node.editCreateNode("after", {
  title: "Node title",
  folder: true
});

$("#tree").fancytree({
  extensions: ["edit"],
  ...
  edit: {
    beforeClose: function(event, data) {
      if( data.originalEvent.type === "mousedown" ) {
        // We could prevent the mouse click from generating a blur event
        // (which would then again close the editor) and return `false` to keep
        // the editor open:
//      data.originalEvent.preventDefault();
//      return false;
        // Or go on with closing the editor, but discard any changes:
        data.save = false;
      }
    },
    ...
  },
  ...
});

$("#tree").fancytree({
  extensions: ["edit"],
  ...
  edit: {
    save: function(event, data){
      var node = data.node;

      // Save data.input.val() or return false to keep the editor open
      $.ajax({
        url: "saveNode",
        data: { key: node.key, title: data.input.val() }

      }).done(function(result){
        // Server might return an error or a modified title
        node.setTitle(result.acceptedTitle); // in case server modified it
        // Maybe also check for non-ajax errors, e.g. 'title invalid', ...

      }).fail(function(result){
        // Ajax error: reset title (and maybe issue a warning)
        node.setTitle(data.orgTitle);

      }).always(function(){
        data.input.removeClass("pending");
      });
      // Optimistically assume that save will succeed. Accept the user input
      return true;
    },
    close: function(event, data){
      // Editor was removed. If we started an async request, mark the node as pending
      if( data.save ) {
        $(data.node.span).addClass("pending");
      }
    },
  },
  ...
});

$("#tree").fancytree({
  extensions: ["edit"],
  ...
  edit: {
    ...
    save: function(event, data){
      var node = data.node,
          newTitle = data.input.val(),
          originalTitle = data.orgTitle;
      
      // Save data.input.val() asynchr. but also return false to keep the editor open
      // (optionally disable the input control)
      $.ajax({
        <your_ajax_call_to_validate_and_update_title_in_server|db)>
      }).done(function(result){
        // Server might return an application error
        if (result.retcode>0) { // validation error
          // Do something related to application error here
          // (optionally enable the input control again)
        } else {
          // server returned OK
          node.setTitle('<server_updated_value>');
          // Important: exit sucessfull editing
          node.editEnd(false);
        }
      }).fail(function(result){
        // maybe update title with original value
        node.setTitle(originalTitle);
        // (optionally enable the input control again)
      }).always(function(){
        $(data.node.span).removeClass("pending");
      });
      // Always return false except when receives server validation successfully
      return false;
    },
  },
});

$("#tree").fancytree({
  extensions: ["dnd", "edit"],
  dnd: {
    focusOnClick: true,  // Focus, although draggable cancels mousedown event
    ...
  },
  edit: {
    ...
  },
  [...]
});