>>>>>???@@@AAABBBCCCDDDEEEFFFGGGHHHIIIJJJKKKLLLMMMOOOPPPQQQRRRRRRSSSTTTUUUWWWXXXYYYYYYZZZ[[[\\\^^^___```aaaaaacccdddeeefffggghhhiiilllooosssxxx||| 8$Z5#-fi
+%VX Bi!A
˄UƄa2UIN
+<
+Q^,u9BZ3LH2U XL̎Jyk*! h/dž"}z(PN*Z8pU<0TR2EW -S Ԡ/Q@
Z2iϢ%՝Q2]r*aPBf&0|"ȫ+f&!$l_ S*'ZzVsEEn~o9@
իT>c-\&8zrz4"&J J!n1sKP2%@}%S@ !
+ ,
+
+
+
+
+
+
!!!"""######$$$%%%%%%%%%&&&'''(((***+++---///111222444444555666777888999:::;;;<<<<<<<<<======>>>???@@@AAABBBCCCDDDFFFFFFFFFGGGGGGHHHHHHHHHIIIJJJJJJLLLMMMOOOPPPQQQRRRSSSTTTUUUVVVXXXYYY[[[]]]^^^```aaacccdddfffgggjjjmmmppprrrtttuuuvvvxxx{{{}}} 8֤Uy #P#\W%$PVT Vj`U:iѩIc}MR 2:
p٩Erl.?{
QtmdLXHd3eAADPS%m2&p$Ī QT
+BADJTMV)^ukћ5 7
+eYp|gN=iÇuժ)ѫ.9*Es1OxD lӢDG <| #xk)c&-䱔:p˴IQBJ!ʴ,}HJqZUiQ)r}MJTj_|0G52 Ms&rX* I"'KQ5 CGrX@ ;
\ No newline at end of file
diff --git a/core/modules/edit/includes/form.inc b/core/modules/edit/includes/form.inc
new file mode 100644
index 0000000..573f162
--- /dev/null
+++ b/core/modules/edit/includes/form.inc
@@ -0,0 +1,147 @@
+ $form_state['field_name']);
+ field_attach_form($entity->entityType(), $entity, $form, $form_state, $langcode, $options);
+
+ $form['#validate'][] = 'edit_field_form_validate';
+ // @todo Verify that this is indeed not necessary anymore, see edit_field_form_validate().
+ // $form['#submit'][] = '';
+
+ // Add revisions form items if necessary.
+ // @todo We may be able to get rid of this when http://drupal.org/node/1678002 is solved.
+ list($use_revisions, $control_revisions) = edit_entity_allows_revisions($entity->entityType(), $entity->bundle(), $entity);
+ if ($use_revisions) {
+ $form_state['use revisions'] = TRUE;
+ $form['revision_information'] = array(
+ '#weight' => 11,
+ );
+
+ $form['revision_information']['revision'] = array(
+ '#type' => 'checkbox',
+ '#title' => t('Create new revision'),
+ '#default_value' => $entity->revision,
+ '#id' => 'edit-revision',
+ '#access' => $control_revisions,
+ );
+
+ if ($control_revisions || $entity->revision) {
+ $form['revision_information']['log'] = array(
+ '#type' => 'textarea',
+ '#title' => t('Log message'),
+ '#description' => t('Provide an explanation of the changes you are making. This will help other authors understand your motivations.'),
+ '#default_value' => $entity->log,
+ );
+
+ if ($control_revisions) {
+ $form['revision_information']['log']['#dependency'] = array('edit-revision' => array(1));
+ }
+ }
+ $form['#submit'][] = 'edit_field_form_revision_submit';
+ }
+
+ $form['actions'] = array('#type' => 'actions');
+ $form['actions']['submit'] = array(
+ '#type' => 'submit',
+ '#value' => t('Save'),
+ );
+
+ // Simplify the form.
+ _simplify_edit_field_edit_form($form);
+
+ return $form;
+}
+
+/**
+ * Helper function to simplify the field edit form for in-place editing.
+ */
+function _simplify_edit_field_edit_form(&$form) {
+ $elements = element_children($form);
+
+ // Required internal form properties.
+ $internal_elements = array('actions', 'form_build_id', 'form_token', 'form_id');
+
+ // Calculate the remaining form elements.
+ $remaining_elements = array_diff($elements, $internal_elements);
+
+ // Only simplify the form if there is a single element remaining.
+ if (count($remaining_elements) === 1) {
+ $element = $remaining_elements[0];
+
+ if ($form[$element]['#type'] == 'container') {
+ $language = $form[$element]['#language'];
+ $children = element_children($form[$element][$language]);
+
+ // Certain fields require different processing depending on the form
+ // structure.
+ if (count($children) == 0) {
+ // Checkbox elements don't have a title.
+ if ($form[$element][$language]['#type'] != 'checkbox') {
+ $form[$element][$language]['#title_display'] = 'invisible';
+ }
+ }
+ elseif (count($children) == 1) {
+ $form[$element][$language][0]['value']['#title_display'] = 'invisible';
+
+ // UX improvement: make the number of rows of textarea form elements
+ // fit the content. (i.e. no wads of whitespace)
+ if (isset($form[$element][$language][0]['value']['#type'])
+ && $form[$element][$language][0]['value']['#type'] == 'textarea')
+ {
+ $lines = count(explode("\n", $form[$element][$language][0]['value']['#default_value']));
+ $form[$element][$language][0]['value']['#rows'] = $lines + 1;
+ }
+ }
+ }
+
+ // Handle pseudo-fields that are language-independent, such as title,
+ // author, and creation date.
+ elseif (empty($form[$element]['#language'])) {
+ $form[$element]['#title_display'] = 'invisible';
+ }
+ }
+
+ // Make it easy for the JavaScript to identify the submit button.
+ $form['actions']['submit']['#attributes'] = array('class' => array('edit-form-submit'));
+}
+
+/**
+ * Validate field editing form.
+ */
+function edit_field_form_validate($form, &$form_state) {
+ $entity = $form_state['entity'];
+ $options = array('field_name' => $form_state['field_name']);
+
+ // 'submit' in D8 is for "building the entity object", not for actual
+ // submission. It appears though that if there were no validation errors, it
+ // is submitted automatically.
+ field_attach_submit($entity->entityType(), $entity, $form, $form_state, $options);
+
+ // Validation.
+ field_attach_form_validate($entity->entityType(), $entity, $form, $form_state, $options);
+}
+
+/**
+ * Submit callback that handles entity revisioning.
+ */
+function edit_field_form_revision_submit($form, &$form_state) {
+ $entity = $form_state['entity'];
+ if (!empty($form_state['use revisions'])) {
+ $entity->revision = $form_state['values']['revision'];
+ $entity->log = $form_state['values']['log'];
+ }
+}
diff --git a/core/modules/edit/includes/missing-api.inc b/core/modules/edit/includes/missing-api.inc
new file mode 100644
index 0000000..1b2f08a
--- /dev/null
+++ b/core/modules/edit/includes/missing-api.inc
@@ -0,0 +1,43 @@
+revision = $retval[0];
+ $entity->log = '';
+ return $retval;
+}
+
+/**
+ * @} End of "ingroup Missing in Entity API.".
+ */
diff --git a/core/modules/edit/includes/pages.inc b/core/modules/edit/includes/pages.inc
new file mode 100644
index 0000000..d59442a
--- /dev/null
+++ b/core/modules/edit/includes/pages.inc
@@ -0,0 +1,179 @@
+bundle());
+ if (empty($field_instance)) {
+ throw new NotFoundHttpException();
+ }
+
+ $form_state = array(
+ 'entity' => $entity,
+ 'field_name' => $field_name,
+ 'langcode' => $langcode,
+ 'no_redirect' => TRUE,
+ 'build_info' => array('args' => array()),
+ );
+ $commands = array();
+ form_load_include($form_state, 'inc', 'edit', 'includes/form');
+ $form = drupal_build_form('edit_field_form', $form_state);
+
+ $id = "$entity_type:$entity_id:$field_name:$langcode:$view_mode";
+ if (!empty($form_state['executed'])) {
+ $form_state['entity']->save();
+
+ $options = array('field_name' => $field_name);
+ field_attach_prepare_view($entity->entityType(), array($entity->id() => $entity), $view_mode, $langcode, $options);
+ $output = field_attach_view($entity->entityType(), $entity, $view_mode, $langcode, $options);
+
+ $commands[] = array(
+ 'command' => 'edit_field_form_saved',
+ 'id' => $id,
+ 'data' => drupal_render($output),
+ );
+ }
+ else {
+ $commands[] = array(
+ 'command' => 'edit_field_form',
+ 'id' => $id,
+ 'data' => drupal_render($form),
+ );
+ }
+
+ // When working with a hidden form, we don't want any CSS or JS to be loaded.
+ if (isset($_POST['nocssjs']) && $_POST['nocssjs'] === 'true') {
+ drupal_static_reset('drupal_add_css');
+ drupal_static_reset('drupal_add_js');
+ }
+
+ return array('#type' => 'ajax', '#commands' => $commands);
+}
+
+/**
+ * Page callback: render a processed text field without transformation filters.
+ *
+ * @param string $entity_type
+ * The entity type of the entity of which a processed text field is being
+ * rerendered.
+ * @param int $entity_id
+ * The entity ID of the entity of which a processed text field is being
+ * rerendered.
+ * @param string $field_name
+ * The name of the (processed text) field that that is being rerendered
+ * @param string $langcode
+ * The name of the language for which the processed text field is being
+ * rererendered.
+ * @param string $view_mode
+ * The view mode the processed text field should be rerendered in.
+ * @return array
+ * A render array.
+ */
+function edit_text_field_render_without_transformation_filters($entity_type, $entity_id, $field_name, $langcode, $view_mode) {
+ // Ensure the entity type is valid.
+ if (empty($entity_type)) {
+ throw new NotFoundHttpException();
+ }
+
+ $entity_info = entity_get_info($entity_type);
+ if (!$entity_info) {
+ throw new NotFoundHttpException();
+ }
+
+ $entities = entity_load_multiple($entity_type, array($entity_id));
+ if (!$entities) {
+ throw new NotFoundHttpException();
+ }
+
+ $entity = reset($entities);
+ if (!$entity) {
+ throw new NotFoundHttpException();
+ }
+
+ // Ensure a valid language code is set.
+ $langcode = field_valid_language($langcode);
+
+ // Ensure access to update this particular entity is granted.
+ if (!edit_entity_access('update', $entity_type, $entity)) {
+ throw new AccessDeniedHttpException();
+ }
+
+ // Ensure access to update this particular field is granted.
+ if (!field_access('edit', $field_name, $entity_type, $entity)) {
+ throw new AccessDeniedHttpException();
+ }
+
+ $field_instance = field_info_instance($entity_type, $field_name, $entity->bundle());
+ if (empty($field_instance)) {
+ throw new NotFoundHttpException();
+ }
+
+ $commands = array();
+
+ // Render the field in our custom display mode; retrieve the re-rendered
+ // markup, this is what we're after.
+ $field_output = field_view_field($entity_type, $entity, $field_name, 'edit-render-without-transformation-filters');
+ $output = $field_output[0]['#markup'];
+
+ $commands[] = array(
+ 'command' => 'edit_field_rendered_without_transformation_filters',
+ 'id' => "$entity_type:$entity_id:$field_name:$langcode:$view_mode",
+ 'data' => $output,
+ );
+
+ return array('#type' => 'ajax', '#commands' => $commands);
+}
diff --git a/core/modules/edit/js/ajax.js b/core/modules/edit/js/ajax.js
new file mode 100644
index 0000000..f2bdd3b
--- /dev/null
+++ b/core/modules/edit/js/ajax.js
@@ -0,0 +1,124 @@
+(function($) {
+
+/**
+ * @file ajax.js
+ *
+ * AJAX commands for Edit module.
+ */
+
+// Hide these in a ready to ensure that Drupal.ajax is set up first.
+$(function() {
+ Drupal.ajax.prototype.commands.edit_field_form = function(ajax, response, status) {
+ console.log('edit_field_form', ajax, response, status);
+
+ // Only apply the form immediately if this form is currently being edited.
+ if (Drupal.edit.state.editedEditable == response.id && ajax.$field.hasClass('edit-type-form')) {
+ Drupal.ajax.prototype.commands.insert(ajax, {
+ data: response.data,
+ selector: '.edit-form-container .placeholder'
+ });
+
+ // Indicate in the 'info' toolgroup that the form has loaded, but only do
+ // it after half a second to prevent it from flashing, which is bad UX.
+ setTimeout(function() {
+ Drupal.edit.toolbar.removeClass(ajax.$editable, 'info', 'loading');
+ }, 500);
+
+ // Detect changes in this form.
+ Drupal.edit.form.get(ajax.$editable)
+ .delegate(':input', 'formUpdated.edit', function() {
+ ajax.$editable
+ .data('edit-content-changed', true)
+ .trigger('edit-content-changed.edit');
+ })
+ .delegate('input', 'keypress.edit', function(event) {
+ if (event.keyCode == 13) {
+ return false;
+ }
+ });
+
+ var $submit = Drupal.edit.form.get(ajax.$editable).find('.edit-form-submit');
+ var element_settings = {
+ url : $submit.closest('form').attr('action'),
+ setClick : true,
+ event : 'click.edit',
+ progress : { type : 'throbber' },
+ // IPE-specific settings.
+ $editable : ajax.$editable,
+ $field : ajax.$field
+ };
+ var base = $submit.attr('id');
+ Drupal.ajax[base] = new Drupal.ajax(base, $submit[0], element_settings);
+
+ // Give focus to the first input in the form.
+ //$('.edit-form').find('form :input:visible:enabled:first').focus()
+ }
+ else if (Drupal.edit.state.editedEditable == response.id && ajax.$field.hasClass('edit-type-direct')) {
+ Drupal.edit.state.directEditableFormResponse = response;
+ $('#edit_backstage').append(response.data);
+
+ var $submit = $('#edit_backstage form .edit-form-submit');
+ var element_settings = {
+ url : $submit.closest('form').attr('action'),
+ setClick : true,
+ event : 'click.edit',
+ progress : { type : 'throbber' },
+ // IPE-specific settings.
+ $editable : ajax.$editable,
+ $field : ajax.$field
+ };
+ var base = $submit.attr('id');
+ Drupal.ajax[base] = new Drupal.ajax(base, $submit[0], element_settings);
+ }
+ else {
+ console.log('queueing', response);
+ }
+
+ // Animations.
+ Drupal.edit.toolbar.show(ajax.$editable, 'ops');
+ ajax.$editable.trigger('edit-form-loaded.edit');
+ };
+ Drupal.ajax.prototype.commands.edit_field_rendered_without_transformation_filters = function(ajax, response, status) {
+ console.log('edit_field_rendered_without_transformation_filters', ajax, response, status);
+
+ if (Drupal.edit.state.editedEditable == response.id
+ && ajax.$field.hasClass('edit-type-direct')
+ && ajax.$field.hasClass('edit-text-with-transformation-filters')
+ )
+ {
+ // Indicate in the 'info' toolgroup that the form has loaded, but only do
+ // it after half a second to prevent it from flashing, which is bad UX.
+ setTimeout(function() {
+ Drupal.edit.toolbar.removeClass(ajax.$editable, 'info', 'loading');
+ }, 500);
+
+ // Update the HTML of the editable and enable WYSIWYG editing on it.
+ ajax.$editable.html(response.data);
+ Drupal.edit.editables._wysiwygify(ajax.$editable);
+ }
+ };
+ Drupal.ajax.prototype.commands.edit_field_form_saved = function(ajax, response, status) {
+ console.log('edit_field_form_saved', ajax, response, status);
+
+ // Stop the editing.
+ Drupal.edit.editables.stopEdit(ajax.$editable);
+
+ // Response.data contains the updated rendering of the field, if any.
+ if (response.data) {
+ // Replace the old content with the new content.
+ var $field = $('.edit-field[data-edit-id="' + response.id + '"]');
+ var $parent = $field.parent();
+ if ($field.css('display') == 'inline') {
+ $parent.html(response.data);
+ }
+ else {
+ $field.replaceWith(response.data);
+ }
+
+ // Make the freshly rendered field(s) in-place-editable again.
+ Drupal.edit.startEditableFields(Drupal.edit.findEditableFields($parent));
+ }
+ };
+});
+
+})(jQuery);
diff --git a/core/modules/edit/js/edit.js b/core/modules/edit/js/edit.js
new file mode 100644
index 0000000..d851ee2
--- /dev/null
+++ b/core/modules/edit/js/edit.js
@@ -0,0 +1,689 @@
+(function ($) {
+
+Drupal.edit = Drupal.edit || {};
+Drupal.edit.wysiwyg = Drupal.edit.wysiwyg || {};
+
+/**
+ * Attach toggling behavior and in-place editing.
+ */
+Drupal.behaviors.edit = {
+ attach: function(context) {
+ $('#edit_view-edit-toggles').once('edit-init', Drupal.edit.init);
+ $('#edit_view-edit-toggles').once('edit-toggle', Drupal.edit.toggle.render);
+
+ // TODO: remove this; this is to make the current prototype somewhat usable.
+ $('a.edit_view-edit-toggle').click(function() {
+ $(this).trigger('click.edit');
+ });
+ }
+};
+
+Drupal.edit.const = {};
+Drupal.edit.const.transitionEnd = "transitionEnd.edit webkitTransitionEnd.edit transitionend.edit msTransitionEnd.edit oTransitionEnd.edit";
+
+Drupal.edit.init = function() {
+ Drupal.edit.state = {};
+ // We always begin in view mode.
+ Drupal.edit.state.isViewing = true;
+ Drupal.edit.state.fieldBeingHighlighted = [];
+ Drupal.edit.state.fieldBeingEdited = [];
+ Drupal.edit.state.higlightedEditable = null;
+ Drupal.edit.state.editedEditable = null;
+ Drupal.edit.state.queues = {};
+ Drupal.edit.state.wysiwygReady = false;
+
+ // Build inventory.
+ var IDMapper = function() { return Drupal.edit.getID($(this)); };
+ Drupal.edit.state.fields = Drupal.edit.findEditableFields().map(IDMapper);
+ console.log('Fields:', Drupal.edit.state.fields.length, ';', Drupal.edit.state.fields);
+
+ // Form preloader.
+ Drupal.edit.state.queues.preload = Drupal.edit.findEditableFields().filter('.edit-type-form').map(IDMapper);
+ console.log('Fields with (server-generated) forms:', Drupal.edit.state.queues.preload);
+
+ // Initialize WYSIWYG, if any.
+ if (Drupal.settings.edit.wysiwyg) {
+ $(document).bind('edit-wysiwyg-ready.edit', function() {
+ Drupal.edit.state.wysiwygReady = true;
+ console.log('edit: WYSIWYG ready');
+ });
+ Drupal.edit.wysiwyg[Drupal.settings.edit.wysiwyg].init();
+ }
+
+ // Create a backstage area.
+ $(Drupal.theme('editBackstage', {})).appendTo('body');
+
+ // Transition between view/edit states.
+ $("a.edit_view-edit-toggle").bind('click.edit', function() {
+ var wasViewing = Drupal.edit.state.isViewing;
+ var isViewing = Drupal.edit.state.isViewing = $(this).hasClass('edit-view');
+ // Swap active class among the two links.
+ $('a.edit_view-edit-toggle').removeClass('active');
+ $('a.edit_view-edit-toggle').parent().removeClass('active');
+ $('a.edit_view-edit-toggle.edit-' + (isViewing ? 'view' : 'edit')).addClass('active');
+ $('a.edit_view-edit-toggle.edit-' + (isViewing ? 'view' : 'edit')).parent().addClass('active');
+
+ if (wasViewing && !isViewing) {
+ $(Drupal.theme('editOverlay', {}))
+ .appendTo('body')
+ .addClass('edit-animate-slow edit-animate-invisible')
+ .bind('click.edit', Drupal.edit.clickOverlay);;
+
+ var $f = Drupal.edit.findEditableFields();
+ Drupal.edit.startEditableFields($f);
+
+ // TODO: preload forms. We could do one request per form, but that's more
+ // RTTs than needed. Instead, the server should support batch requests.
+ console.log('Preloading forms that we might need!', Drupal.edit.state.queues.preload);
+
+ // Animations. Integrate with both navbar and toolbar.
+ $('#edit_overlay').css('top', $('#navbar, #toolbar').outerHeight());
+ $('#edit_overlay').removeClass('edit-animate-invisible');
+
+ // Disable contextual links in edit mode.
+ $('.contextual-links-region')
+ .addClass('edit-contextual-links-region')
+ .removeClass('contextual-links-region');
+ }
+ else if (!wasViewing && isViewing) {
+ // Animations.
+ $('#edit_overlay')
+ .addClass('edit-animate-invisible')
+ .bind(Drupal.edit.const.transitionEnd, function(e) {
+ $('#edit_overlay, .edit-form-container, .edit-toolbar-container, #edit_modal, #edit_backstage').remove();
+ });
+
+ var $f = Drupal.edit.findEditableFields();
+ Drupal.edit.stopEditableFields($f);
+
+ // Re-enable contextual links in view mode.
+ $('.edit-contextual-links-region')
+ .addClass('contextual-links-region')
+ .removeClass('edit-contextual-links-region');
+ }
+ else {
+ // No state change.
+ }
+ return false;
+ });
+};
+
+Drupal.edit.findEditableFields = function(context) {
+ return $('.edit-field.edit-allowed', context || Drupal.settings.edit.context);
+};
+
+/*
+ * findEditableFields() just looks for fields that are editable, i.e. for the
+ * field *wrappers*. Depending on the field, however, either the whole field wrapper
+ * will be marked as editable (in this case, an inline form will be used for editing),
+ * *or* a specific (field-specific even!) DOM element within that field wrapper will be
+ * marked as editable.
+ * This function is for finding the *editables* themselves, given the *editable fields*.
+ */
+Drupal.edit.findEditablesForFields = function($fields) {
+ var $editables = $();
+
+ // type = form
+ $editables = $editables.add($fields.filter('.edit-type-form'));
+
+ // type = direct
+ var $direct = $fields.filter('.edit-type-direct');
+ $editables = $editables.add($direct.find('.field-item'));
+ // Edge case: "title" pseudofield on pages with lists of nodes.
+ $editables = $editables.add($direct.filter('h2').find('a'));
+ // Edge case: "title" pseudofield on node pages.
+ $editables = $editables.add($direct.find('h1'));
+
+ return $editables;
+};
+
+Drupal.edit.getID = function($field) {
+ return $field.data('edit-id');
+};
+
+Drupal.edit.findFieldForID = function(id, context) {
+ return $('[data-edit-id="' + id + '"]', context || $('#content'));
+};
+
+Drupal.edit.findFieldForEditable = function($editable) {
+ return $editable.filter('.edit-type-form').length ? $editable : $editable.closest('.edit-type-direct');
+};
+
+Drupal.edit.startEditableFields = function($fields) {
+ var $fields = $fields.once('edit');
+ // Ignore fields that need a WYSIWYG editor if no WYSIWYG editor is present
+ if (!Drupal.settings.edit.wysiwyg) {
+ $fields = $fields.filter(':not(.edit-type-direct-with-wysiwyg)');
+ }
+ var $editables = Drupal.edit.findEditablesForFields($fields);
+
+ $editables
+ .addClass('edit-animate-fast')
+ .addClass('edit-candidate edit-editable')
+ .bind('mouseenter.edit', function(e) {
+ var $editable = $(this);
+ Drupal.edit.util.ignoreHoveringVia(e, '.edit-toolbar-container', function() {
+ console.log('field:mouseenter');
+ if (!$editable.hasClass('edit-editing')) {
+ Drupal.edit.editables.startHighlight($editable);
+ }
+ });
+ })
+ .bind('mouseleave.edit', function(e) {
+ var $editable = $(this);
+ Drupal.edit.util.ignoreHoveringVia(e, '.edit-toolbar-container', function() {
+ console.log('field:mouseleave');
+ if (!$editable.hasClass('edit-editing')) {
+ Drupal.edit.editables.stopHighlight($editable);
+ }
+ });
+ })
+ .bind('click.edit', function() {
+ Drupal.edit.editables.startEdit($(this)); return false;
+ })
+ // Some transformations are editable-specific.
+ .map(function() {
+ $(this).data('edit-background-color', Drupal.edit.util.getBgColor($(this)));
+ });
+};
+
+Drupal.edit.stopEditableFields = function($fields) {
+ var $editables = Drupal.edit.findEditablesForFields($fields);
+
+ $fields
+ .removeClass('edit-processed');
+
+ $editables
+ .removeClass('edit-candidate edit-editable edit-highlighted edit-editing edit-belowoverlay')
+ .unbind('mouseenter.edit mouseleave.edit click.edit edit-content-changed.edit')
+ .removeAttr('contenteditable')
+ .removeData(['edit-content-original', 'edit-content-changed']);
+};
+
+Drupal.edit.clickOverlay = function(e) {
+ console.log('clicked overlay');
+
+ if (Drupal.edit.modal.get().length == 0) {
+ Drupal.edit.toolbar.get(Drupal.edit.state.fieldBeingEdited)
+ .find('a.close').trigger('click.edit');
+ }
+};
+
+/*
+2. Each field MAY (if it is editable by the user) contain exactly one Editable,
+ in which the editing itself occurs, this can be either:
+ a. type=direct, here some child element of the Field element is marked as editable
+ b. type=form, here the field itself is marked as editable, upon edit, a form is used
+ */
+
+// Field editables.
+Drupal.edit.editables = {
+ startHighlight: function($editable) {
+ console.log('editables.startHighlight');
+ if (Drupal.edit.toolbar.create($editable)) {
+ var label = $editable.filter('.edit-type-form').data('edit-field-label')
+ || $editable.closest('.edit-type-direct').data('edit-field-label');
+
+ Drupal.edit.toolbar.get($editable)
+ .find('.edit-toolbar:not(:has(.edit-toolgroup.info))')
+ .append(Drupal.theme('editToolgroup', {
+ classes: 'info',
+ buttons: [
+ { url: '#', label: label, classes: 'blank-button label', hasButtonRole: false },
+ ]
+ }))
+ .delegate('a.label', 'click.edit', function(e) {
+ // Clicking the label equals clicking the editable itself.
+ $editable.trigger('click.edit');
+ return false;
+ });
+ }
+
+ // Animations.
+ setTimeout(function() {
+ $editable.addClass('edit-highlighted');
+ Drupal.edit.toolbar.show($editable, 'info');
+ }, 0);
+
+ Drupal.edit.state.fieldBeingHighlighted = $editable;
+ Drupal.edit.state.higlightedEditable = Drupal.edit.getID(Drupal.edit.findFieldForEditable($editable));
+ },
+
+ stopHighlight: function($editable) {
+ console.log('editables.stopHighlight');
+ if ($editable.length == 0) {
+ return;
+ }
+
+ // Animations.
+ Drupal.edit.toolbar.remove($editable);
+ $editable.removeClass('edit-highlighted');
+
+ Drupal.edit.state.fieldBeingHighlighted = [];
+ Drupal.edit.state.highlightedEditable = null;
+ },
+
+ startEdit: function($editable) {
+ if ($editable.hasClass('edit-editing')) {
+ return;
+ }
+
+ console.log('editables.startEdit: ', $editable);
+ var self = this;
+ var $field = Drupal.edit.findFieldForEditable($editable);
+
+ // Highlight if not already highlighted.
+ if (Drupal.edit.state.fieldBeingHighlighted[0] != $editable[0]) {
+ Drupal.edit.editables.startHighlight($editable);
+ }
+
+ $editable
+ .addClass('edit-editing')
+ .bind('edit-content-changed.edit', function(e) {
+ self._buttonFieldSaveToBlue(e, $editable, $field);
+ })
+ // Some transformations are editable-specific.
+ .map(function() {
+ $(this).css('background-color', $(this).data('edit-background-color'));
+ });
+
+ // While editing, don't show *any* other field as editable.
+ $('.edit-candidate').not('.edit-editing').removeClass('edit-editable');
+
+ // Toolbar (already created in the highlight).
+ Drupal.edit.toolbar.get($editable)
+ .addClass('edit-editing')
+ .find('.edit-toolbar:not(:has(.edit-toolgroup.ops))')
+ .append(Drupal.theme('editToolgroup', {
+ classes: 'ops',
+ buttons: [
+ { url: '#', label: Drupal.t('Save'), classes: 'field-save save gray-button' },
+ { url: '#', title: 'Undo changes', label: '', classes: 'field-close close gray-button' }
+ ]
+ }))
+ .delegate('a.field-save', 'click.edit', function(e) {
+ return self._buttonFieldSaveClicked(e, $editable, $field);
+ })
+ .delegate('a.field-close', 'click.edit', function(e) {
+ return self._buttonFieldCloseClicked(e, $editable, $field);
+ });
+
+ // Changes to $editable based on the type.
+ var callback = ($field.hasClass('edit-type-direct'))
+ ? self._updateDirectEditable
+ : self._updateFormEditable;
+ callback($editable);
+
+ // Regardless of the type, load the form for this field. We always use forms
+ // to submit the changes.
+ self._loadForm($editable, $field);
+
+ Drupal.edit.state.fieldBeingEdited = $editable;
+ Drupal.edit.state.editedEditable = Drupal.edit.getID($field);
+ },
+
+ stopEdit: function($editable) {
+ console.log('editables.stopEdit: ', $editable);
+ var self = this;
+ var $field = Drupal.edit.findFieldForEditable($editable);
+ if ($editable.length == 0) {
+ return;
+ }
+
+ $editable
+ .removeClass('edit-highlighted edit-editing edit-belowoverlay')
+ // Some transformations are editable-specific.
+ .map(function() {
+ $(this).css('background-color', '');
+ });
+
+ // Make the other fields and entities editable again.
+ $('.edit-candidate').addClass('edit-editable');
+
+ // Changes to $editable based on the type.
+ var callback = ($field.hasClass('edit-type-direct'))
+ ? self._restoreDirectEditable
+ : self._restoreFormEditable;
+ callback($editable);
+
+ Drupal.edit.toolbar.remove($editable);
+ Drupal.edit.form.remove($editable);
+
+ Drupal.edit.state.fieldBeingEdited = [];
+ Drupal.edit.state.editedEditable = null;
+ },
+
+ _loadRerenderedProcessedText: function($editable, $field) {
+ // Indicate in the 'info' toolgroup that the form is loading.
+ Drupal.edit.toolbar.addClass($editable, 'info', 'loading');
+
+ var edit_id = Drupal.edit.getID($field);
+ var element_settings = {
+ url : Drupal.edit.util.calcRerenderProcessedTextURL(edit_id),
+ event : 'edit-internal-load-rerender.edit',
+ $field : $field,
+ $editable: $editable,
+ submit : { nocssjs : true },
+ progress : { type : null }, // No progress indicator.
+ };
+ if (Drupal.ajax.hasOwnProperty(edit_id)) {
+ delete Drupal.ajax[edit_id];
+ $editable.unbind('edit-internal-load-rerender.edit');
+ }
+ Drupal.ajax[edit_id] = new Drupal.ajax(edit_id, $editable, element_settings);
+ $editable.trigger('edit-internal-load-rerender.edit');
+ },
+
+ // Attach, activate and show the WYSIWYG editor.
+ _wysiwygify: function($editable) {
+ var $field = Drupal.edit.findFieldForEditable($editable);
+ $editable.addClass('edit-wysiwyg-attached');
+ var formatID = $field.attr('data-edit-text-format');
+ var format = Drupal.settings.aloha.formats[formatID];
+ Drupal.edit.wysiwyg[Drupal.settings.edit.wysiwyg].attach($editable, format);
+ Drupal.edit.wysiwyg[Drupal.settings.edit.wysiwyg].activate($editable);
+ Drupal.edit.toolbar.show($editable, 'wysiwyg-tabs');
+ Drupal.edit.toolbar.show($editable, 'wysiwyg');
+ },
+
+ _updateDirectEditable: function($editable) {
+ var $field = Drupal.edit.findFieldForEditable($editable);
+
+ Drupal.edit.editables._padEditable($editable, $field);
+
+ if ($field.hasClass('edit-type-direct-with-wysiwyg')) {
+ Drupal.edit.toolbar.get($editable)
+ .find('.edit-toolbar:not(:has(.edit-toolgroup.wysiwyg-tabs))')
+ .append(Drupal.theme('editToolgroup', {
+ classes: 'wysiwyg-tabs',
+ buttons: []
+ }))
+ .end()
+ .find('.edit-toolbar:not(:has(.edit-toolgroup.wysiwyg))')
+ .append(Drupal.theme('editToolgroup', {
+ classes: 'wysiwyg',
+ buttons: []
+ }));
+
+ // When transformation filters have been been applied to the processed
+ // text of this field, then we'll need to load a re-rendered version of
+ // it without the transformation filters.
+ if ($field.hasClass('edit-text-with-transformation-filters')) {
+ Drupal.edit.editables._loadRerenderedProcessedText($editable, $field);
+ // Also store the "real" original content, i.e. the transformed one.
+ $editable.data('edit-content-original-transformed', $editable.html())
+ }
+ // When no transformation filters have been applied: start WYSIWYG editing
+ // immediately!
+ else {
+ setTimeout(function() {
+ Drupal.edit.editables._wysiwygify($editable);
+ }, 0);
+ }
+ }
+ else {
+ $editable.attr('contenteditable', true);
+ }
+
+ $editable
+ .data('edit-content-original', $editable.html())
+ .data('edit-content-changed', false);
+
+ // Detect content changes ourselves only when not using a WYSIWYG editor.
+ var markContentChanged = function() {
+ $editable.data('edit-content-changed', true);
+ $editable.trigger('edit-content-changed.edit');
+ };
+ if (!$field.hasClass('edit-type-direct-with-wysiwyg')) {
+ // We cannot use Drupal.behaviors.formUpdated here because we're not dealing
+ // with a form!
+ $editable
+ .bind('blur.edit keyup.edit paste.edit', function() {
+ if ($editable.html() != $editable.data('edit-content-original')) {
+ markContentChanged();
+ }
+ })
+ // Disallow return/enter key when editing titles.
+ .bind('keypress.edit', function(event) {
+ if (event.keyCode == 13) {
+ return false;
+ }
+ });
+ }
+ else {
+ $editable.bind('edit-wysiwyg-content-changed.edit', function() {
+ markContentChanged();
+ });
+ }
+ },
+
+ _restoreDirectEditable: function($editable) {
+ var $field = Drupal.edit.findFieldForEditable($editable);
+
+ Drupal.edit.editables._padEditable($editable, $field);
+
+ if ($field.hasClass('edit-type-direct-with-wysiwyg') && $editable.hasClass('edit-wysiwyg-attached')) {
+ $editable.removeClass('edit-wysiwyg-attached');
+ Drupal.edit.wysiwyg[Drupal.settings.edit.wysiwyg].detach($editable);
+
+ // Work-around for major AE bug. See:
+ // - http://drupal.org/node/1725032
+ // - https://github.com/alohaeditor/Aloha-Editor/issues/693.
+ // Also unbind to make sure this doesn't break anything when using
+ // this version of edit.js with a fixed version of Aloha Editor.
+ $editable
+ .unbind('click.edit')
+ .bind('click.edit', function() {
+ Drupal.edit.editables.startEdit($(this)); return false;
+ });
+ }
+ else {
+ $editable
+ .removeAttr('contenteditable')
+ .unbind('keypress.edit');
+ }
+
+ Drupal.edit.editables._unpadEditable($editable, $field);
+
+ $editable
+ .removeData(['edit-content-original', 'edit-content-changed', 'edit-content-original-transformed'])
+ .unbind('blur.edit keyup.edit paste.edit edit-content-changed.edit');
+
+ // Not only clean up the changes to $editable, but also clean up the
+ // backstage area, where we hid the form that we used to send the changes.
+ $('#edit_backstage form').remove();
+ },
+
+ _padEditable: function($editable, $field) {
+ // Add 5px padding for readability. This means we'll freeze the current
+ // width and *then* add 5px padding, hence ensuring the padding is added "on
+ // the outside".
+ // 1) Freeze the width (if it's not already set); don't use animations.
+ if ($editable[0].style.width === "") {
+ $editable
+ .data('edit-width-empty', true)
+ .addClass('edit-animate-disable-width')
+ .css('width', $editable.width());
+ }
+ // 2) Add padding; use animations.
+ var posProp = Drupal.edit.util.getPositionProperties($editable);
+ var $toolbar = Drupal.edit.toolbar.get($editable);
+ setTimeout(function() {
+ // Re-enable width animations (padding changes affect width too!).
+ $editable.removeClass('edit-animate-disable-width');
+
+ // The toolbar must move to the top and the left.
+ var $hf = $toolbar.find('.edit-toolbar-heightfaker');
+ $hf.css({ bottom: '6px', left: '-5px' });
+ // When using a WYSIWYG editor, the width of the toolbar must match the
+ // width of the editable.
+ if ($field.hasClass('edit-type-direct-with-wysiwyg')) {
+ $hf.css({ width: $editable.width() + 10 });
+ }
+
+ // Pad the editable.
+ $editable
+ .css({
+ 'position': 'relative',
+ 'top': posProp['top'] - 5 + 'px',
+ 'left': posProp['left'] - 5 + 'px',
+ 'padding-top' : posProp['padding-top'] + 5 + 'px',
+ 'padding-left' : posProp['padding-left'] + 5 + 'px',
+ 'padding-right' : posProp['padding-right'] + 5 + 'px',
+ 'padding-bottom': posProp['padding-bottom'] + 5 + 'px',
+ 'margin-bottom': posProp['margin-bottom'] - 10 + 'px',
+ });
+ }, 0);
+ },
+
+ _unpadEditable: function($editable, $field) {
+ // 1) Set the empty width again.
+ if ($editable.data('edit-width-empty') === true) {
+ console.log('restoring width');
+ $editable
+ .addClass('edit-animate-disable-width')
+ .css('width', '');
+ }
+ // 2) Remove padding; use animations (these will run simultaneously with)
+ // the fading out of the toolbar as its gets removed).
+ var posProp = Drupal.edit.util.getPositionProperties($editable);
+ var $toolbar = Drupal.edit.toolbar.get($editable);
+ setTimeout(function() {
+ // Re-enable width animations (padding changes affect width too!).
+ $editable.removeClass('edit-animate-disable-width');
+
+ // Move the toolbar back to its original position.
+ var $hf = $toolbar.find('.edit-toolbar-heightfaker');
+ $hf.css({ bottom: '1px', left: '' });
+ // When using a WYSIWYG editor, restore the width of the toolbar.
+ if ($field.hasClass('edit-type-direct-with-wysiwyg')) {
+ $hf.css({ width: '' });
+ }
+
+ // Unpad the editable.
+ $editable
+ .css({
+ 'position': 'relative',
+ 'top': posProp['top'] + 5 + 'px',
+ 'left': posProp['left'] + 5 + 'px',
+ 'padding-top' : posProp['padding-top'] - 5 + 'px',
+ 'padding-left' : posProp['padding-left'] - 5 + 'px',
+ 'padding-right' : posProp['padding-right'] - 5 + 'px',
+ 'padding-bottom': posProp['padding-bottom'] - 5 + 'px',
+ 'margin-bottom': posProp['margin-bottom'] + 10 + 'px'
+ });
+ }, 0);
+ },
+
+ // Creates a form container; when the $editable is inline, it will inherit CSS
+ // properties from the toolbar container, so the toolbar must already exist.
+ _updateFormEditable: function($editable) {
+ if (Drupal.edit.form.create($editable)) {
+ $editable
+ .addClass('edit-belowoverlay')
+ .removeClass('edit-highlighted edit-editable');
+
+ Drupal.edit.form.get($editable)
+ .find('.edit-form')
+ .addClass('edit-editable edit-highlighted edit-editing')
+ .css('background-color', $editable.data('edit-background-color'));
+ }
+ },
+
+ _restoreFormEditable: function($editable) {
+ // No need to do anything here; all of the field HTML will be overwritten
+ // with the freshly rendered version from the server anyway!
+ },
+
+ _loadForm: function($editable, $field) {
+ var edit_id = Drupal.edit.getID($field);
+ var element_settings = {
+ url : Drupal.edit.util.calcFormURLForField(edit_id),
+ event : 'edit-internal.edit',
+ $field : $field,
+ $editable: $editable,
+ submit : { nocssjs : ($field.hasClass('edit-type-direct')) },
+ progress : { type : null }, // No progress indicator.
+ };
+ if (Drupal.ajax.hasOwnProperty(edit_id)) {
+ delete Drupal.ajax[edit_id];
+ $editable.unbind('edit-internal.edit');
+ }
+ Drupal.ajax[edit_id] = new Drupal.ajax(edit_id, $editable, element_settings);
+ $editable.trigger('edit-internal.edit');
+ },
+
+ _buttonFieldSaveToBlue: function(e, $editable, $field) {
+ Drupal.edit.toolbar.get($editable)
+ .find('a.save').addClass('blue-button').removeClass('gray-button');
+ },
+
+ _buttonFieldSaveClicked: function(e, $editable, $field) {
+ // type = form
+ if ($field.hasClass('edit-type-form')) {
+ Drupal.edit.form.get($field).find('form')
+ .find('.edit-form-submit').trigger('click.edit').end();
+ }
+ // type = direct
+ else if ($field.hasClass('edit-type-direct')) {
+ $editable.blur();
+
+ var wysiwyg = $field.hasClass('edit-type-direct-with-wysiwyg')
+ && $editable.hasClass('edit-wysiwyg-attached');
+
+ // When using WYSIWYG editing, first detach the WYSIWYG editor to ensure
+ // the content has been cleaned up before saving it. (Otherwise,
+ // annotations and infrastructure created by the WYSIWYG editor could also
+ // get saved).
+ if (wysiwyg) {
+ $editable.removeClass('edit-wysiwyg-attached');
+ Drupal.edit.wysiwyg[Drupal.settings.edit.wysiwyg].detach($editable);
+ }
+
+ // We trim the title because otherwise whitespace in the raw HTML ends
+ // up in the title as well.
+ // TRICKY: Drupal core does not trim the title, so in theory this is
+ // out of line with Drupal core's behavior.
+ var value = (wysiwyg)
+ ? $.trim($editable.html())
+ : $.trim($editable.text());
+ var selector = (wysiwyg)
+ ? 'textarea'
+ : ':input[type!="hidden"][type!="submit"]';
+ $('#edit_backstage form')
+ .find(selector).val(value).end()
+ .find('.edit-form-submit').trigger('click.edit');
+ }
+ return false;
+ },
+
+ _buttonFieldCloseClicked: function(e, $editable, $field) {
+ // Content not changed: stop editing field.
+ if (!$editable.data('edit-content-changed')) {
+ // Restore to original content. When dealing with processed text, it's
+ // possible that one or more transformation filters are used. Then, the
+ // "real" original content (i.e. the transformed one) is stored separately
+ // from the "original content" that we use to detect changes.
+ if (typeof $editable.data('edit-content-original-transformed') !== 'undefined') {
+ $editable.html($editable.data('edit-content-original-transformed'));
+ }
+
+ Drupal.edit.editables.stopEdit($editable);
+ }
+ // Content changed: show modal.
+ else {
+ Drupal.edit.modal.create(
+ Drupal.t('You have unsaved changes'),
+ Drupal.theme('editButtons', { 'buttons' : [
+ { url: '#', classes: 'gray-button discard', label: Drupal.t('Discard changes') },
+ { url: '#', classes: 'blue-button save', label: Drupal.t('Save') }
+ ]}),
+ $editable
+ );
+ setTimeout(Drupal.edit.modal.show, 0);
+ };
+ return false;
+ }
+};
+
+})(jQuery);
diff --git a/core/modules/edit/js/theme.js b/core/modules/edit/js/theme.js
new file mode 100644
index 0000000..5b2b655
--- /dev/null
+++ b/core/modules/edit/js/theme.js
@@ -0,0 +1,154 @@
+(function($) {
+
+/**
+ * Theme function for the overlay of the Edit module.
+ *
+ * @param settings
+ * An object with the following keys:
+ * - None.
+ * @return
+ * The corresponding HTML.
+ */
+Drupal.theme.editOverlay = function(settings) {
+ var html = '';
+ html += '';
+ return html;
+};
+
+/**
+ * Theme function for a "backstage" for the Edit module.
+ *
+ * @param settings
+ * An object with the following keys:
+ * - None.
+ * @return
+ * The corresponding HTML.
+ */
+Drupal.theme.editBackstage = function(settings) {
+ var html = '';
+ html += '';
+ return html;
+};
+
+/**
+ * Theme function for a modal of the Edit module.
+ *
+ * @param settings
+ * An object with the following keys:
+ * - None.
+ * @return
+ * The corresponding HTML.
+ */
+Drupal.theme.editModal = function(settings) {
+ var classes = 'edit-animate-slow edit-animate-invisible edit-animate-delay-veryfast';
+ var html = '';
+ html += '';
+ html += '
';
+ html += '
';
+ html += '
';
+ html += Drupal.theme('editButtons', { buttons: settings.buttons });
+ html += '
';
+ return html;
+};
+
+/**
+ * Theme function for buttons of the Edit module.
+ *
+ * Can be used for the buttons both in the toolbar toolgroups and in the modal.
+ *
+ * @param settings
+ * An object with the following keys:
+ * - buttons: an array of objects with the following keys:
+ * - url: the URL the button should point to
+ * - classes: the classes of the button (optional)
+ * - label: the label of the button (optional)
+ * - title: the title of the button (optional)
+ * - hasButtonRole: whether this button should have its "role" attribute set
+ * to "button"
+ * @return
+ * The corresponding HTML.
+ */
+Drupal.theme.editButtons = function(settings) {
+ var html = '';
+ for (var i = 0; i < settings.buttons.length; i++) {
+ var button = settings.buttons[i];
+ if (!button.hasOwnProperty('hasButtonRole')) {
+ button.hasButtonRole = true;
+ }
+
+ html += '';
+ html += ' ';
+ html += '';
+ return html;
+};
+
+})(jQuery);
diff --git a/core/modules/edit/js/ui-editables.js b/core/modules/edit/js/ui-editables.js
new file mode 100644
index 0000000..874a224
--- /dev/null
+++ b/core/modules/edit/js/ui-editables.js
@@ -0,0 +1,179 @@
+(function($) {
+
+/**
+ * @file ui-editables.js
+ *
+ * UI components for editables: toolbar, form.
+ */
+
+Drupal.edit = Drupal.edit || {};
+
+
+Drupal.edit.toolbar = {
+ create: function($editable) {
+ if (Drupal.edit.toolbar.get($editable).length > 0) {
+ return false;
+ }
+ else {
+ // Render toolbar.
+ var $toolbar = $(Drupal.theme('editToolbarContainer', {
+ id: this._id($editable)
+ }));
+
+ // Insert in DOM.
+ if ($editable.css('display') == 'inline') {
+ $toolbar.prependTo($editable.offsetParent());
+
+ var pos = $editable.position();
+ Drupal.edit.toolbar.get($editable)
+ .css('left', pos.left).css('top', pos.top);
+ }
+ else {
+ $toolbar.insertBefore($editable);
+ }
+
+ // Animate the toolbar into visibility.
+ setTimeout(function() {
+ $toolbar.removeClass('edit-animate-invisible');
+ }, 0);
+
+ // Remove any and all existing toolbars, except for any that are for a
+ // currently being edited field.
+ $('.edit-toolbar-container:not(:has(.edit-editing))')
+ .trigger('edit-toolbar-remove.edit');
+
+ // Event bindings.
+ $toolbar
+ .bind('mouseenter.edit', function(e) {
+ // Prevent triggering the entity's mouse enter event.
+ e.stopPropagation();
+ })
+ .bind('mouseleave.edit', function(e) {
+ var el = $editable[0];
+ if (e.relatedTarget != el && !jQuery.contains(el, e.relatedTarget)) {
+ console.log('triggering mouseleave on ', $editable);
+ $editable.trigger('mouseleave.edit');
+ }
+ // Prevent triggering the entity's mouse leave event.
+ e.stopPropagation();
+ })
+ // Immediate removal whenever requested.
+ // (This is necessary when showing many toolbars in rapid succession: we
+ // don't want all of them to show up!)
+ .bind('edit-toolbar-remove.edit', function(e) {
+ $toolbar.remove();
+ })
+ .delegate('.edit-toolbar, .edit-toolgroup', 'click.edit mousedown.edit', function(e) {
+ if (!$(e.target).is(':input')) {
+ return false;
+ }
+ });
+
+ return true;
+ }
+ },
+
+ get: function($editable) {
+ return ($editable.length == 0)
+ ? $([])
+ : $('#' + this._id($editable));
+ },
+
+ remove: function($editable) {
+ var $toolbar = Drupal.edit.toolbar.get($editable);
+
+ // Remove after animation.
+ $toolbar
+ .addClass('edit-animate-invisible')
+ // Prevent this toolbar from being detected *while* it is being removed.
+ .removeAttr('id')
+ .find('.edit-toolbar .edit-toolgroup')
+ .addClass('edit-animate-invisible')
+ .bind(Drupal.edit.const.transitionEnd, function(e) {
+ $toolbar.remove();
+ });
+ },
+
+ // Animate into view.
+ show: function($editable, toolgroup) {
+ this._find($editable, toolgroup).removeClass('edit-animate-invisible');
+ },
+
+ addClass: function($editable, toolgroup, classes) {
+ this._find($editable, toolgroup).addClass(classes);
+ },
+
+ removeClass: function($editable, toolgroup, classes) {
+ this._find($editable, toolgroup).removeClass(classes);
+ },
+
+ _find: function($editable, toolgroup) {
+ return Drupal.edit.toolbar.get($editable)
+ .find('.edit-toolbar .edit-toolgroup.' + toolgroup);
+ },
+
+ _id: function($editable) {
+ var edit_id = Drupal.edit.getID(Drupal.edit.findFieldForEditable($editable));
+ return 'edit-toolbar-for-' + edit_id.split(':').join('_');
+ }
+};
+
+
+Drupal.edit.form = {
+ create: function($editable) {
+ if (Drupal.edit.form.get($editable).length > 0) {
+ return false;
+ }
+ else {
+ // Indicate in the 'info' toolgroup that the form is loading. Animated.
+ setTimeout(function() {
+ Drupal.edit.toolbar.addClass($editable, 'info', 'loading');
+ }, 0);
+
+ // Render form container.
+ var $form = $(Drupal.theme('editFormContainer', {
+ id: this._id($editable),
+ loadingMsg: Drupal.t('Loading…')}
+ ));
+
+ // Insert in DOM.
+ if ($editable.css('display') == 'inline') {
+ $form.prependTo($editable.offsetParent());
+
+ var pos = $editable.position();
+ $form.css('left', pos.left).css('top', pos.top);
+ // Reset the toolbar's positioning because it'll be moved inside the
+ // form container.
+ Drupal.edit.toolbar.get($editable).css('left', '').css('top', '');
+ }
+ else {
+ $form.insertBefore($editable);
+ }
+
+ // Move toolbar inside .edit-form-container, to let it snap to the width
+ // of the form instead of the field formatter.
+ Drupal.edit.toolbar.get($editable).detach().prependTo('.edit-form')
+
+ return true;
+ }
+ },
+
+ get: function($editable) {
+ return ($editable.length == 0)
+ ? $([])
+ : $('#' + this._id($editable));
+ },
+
+ remove: function($editable) {
+ Drupal.edit.form.get($editable).remove();
+ },
+
+ _id: function($editable) {
+ var edit_id = ($editable.hasClass('edit-entity'))
+ ? Drupal.edit.getID($editable)
+ : Drupal.edit.getID(Drupal.edit.findFieldForEditable($editable));
+ return 'edit-form-for-' + edit_id.split(':').join('_');
+ }
+};
+
+})(jQuery);
diff --git a/core/modules/edit/js/ui.js b/core/modules/edit/js/ui.js
new file mode 100644
index 0000000..f881527
--- /dev/null
+++ b/core/modules/edit/js/ui.js
@@ -0,0 +1,82 @@
+(function($) {
+
+/**
+ * @file ui.js
+ *
+ * "Global" UI components: toggle, modal.
+ */
+
+Drupal.edit = Drupal.edit || {};
+
+
+Drupal.edit.toggle = {
+ render: function() {
+ // TODO: fancy, "physical toggle" to switch from view to edit mode and back.
+ }
+};
+
+
+Drupal.edit.modal = {
+ create: function(message, actions, $editable) {
+ // The modal should be the only interaction element now.
+ $editable
+ .add(Drupal.edit.toolbar.get($editable))
+ .addClass('edit-belowoverlay');
+
+ $(Drupal.theme('editModal', {}))
+ .appendTo('body')
+ .find('.main p').text(message).end()
+ .find('.actions').append($(actions))
+ .delegate('a.discard', 'click.edit', function() {
+ // Restore to original content. When dealing with processed text, it's
+ // possible that one or more transformation filters are used. Then, the
+ // "real" original content (i.e. the transformed one) is stored separately
+ // from the "original content" that we use to detect changes.
+ if (typeof $editable.data('edit-content-original-transformed') !== 'undefined') {
+ $editable.html($editable.data('edit-content-original-transformed'));
+ }
+ else {
+ $editable.html($editable.data('edit-content-original'));
+ }
+
+ $editable.data('edit-content-changed', false);
+
+ Drupal.edit.modal.remove();
+ Drupal.edit.toolbar.get($editable).find('a.close').trigger('click.edit');
+ return false;
+ })
+ .delegate('a.save', 'click.edit', function() {
+ Drupal.edit.modal.remove();
+ Drupal.edit.toolbar.get($editable).find('a.save').trigger('click.edit');
+ return false;
+ });
+ },
+
+ get: function() {
+ return $('#edit_modal');
+ },
+
+ remove: function() {
+ var $modal = Drupal.edit.modal.get();
+
+ // Remove after animation.
+ $modal
+ .addClass('edit-animate-invisible')
+ .bind(Drupal.edit.const.transitionEnd, function(e) {
+ $modal.remove();
+
+ // The modal's HTML was removed, hence no need to undelegate it.
+ });
+
+ // Make the other interaction elements available again.
+ $('.edit-belowoverlay').removeClass('edit-belowoverlay');
+ },
+
+ // Animate into view.
+ show: function() {
+ Drupal.edit.modal.get()
+ .removeClass('edit-animate-invisible');
+ }
+};
+
+})(jQuery);
diff --git a/core/modules/edit/js/util.js b/core/modules/edit/js/util.js
new file mode 100644
index 0000000..577448a
--- /dev/null
+++ b/core/modules/edit/js/util.js
@@ -0,0 +1,98 @@
+(function($) {
+
+/**
+ * @file util.js
+ *
+ * Utilities for Edit module.
+ */
+
+Drupal.edit = Drupal.edit || {};
+Drupal.edit.util = Drupal.edit.util || {};
+
+Drupal.edit.util.calcFormURLForField = function(id) {
+ var parts = id.split(':');
+ var urlFormat = decodeURIComponent(Drupal.settings.edit.fieldFormURL);
+ return Drupal.formatString(urlFormat, {
+ '!entity_type': parts[0],
+ '!id' : parts[1],
+ '!field_name' : parts[2],
+ '!langcode' : parts[3],
+ '!view_mode' : parts[4]
+ });
+};
+
+Drupal.edit.util.calcRerenderProcessedTextURL = function(id) {
+ var parts = id.split(':');
+ var urlFormat = decodeURIComponent(Drupal.settings.edit.rerenderProcessedTextURL);
+ return Drupal.formatString(urlFormat, {
+ '!entity_type': parts[0],
+ '!id' : parts[1],
+ '!field_name' : parts[2],
+ '!langcode' : parts[3],
+ '!view_mode' : parts[4]
+ });
+}
+
+/**
+ * Get the background color of an element (or the inherited one).
+ */
+Drupal.edit.util.getBgColor = function($e) {
+ var c;
+
+ if ($e == null || $e[0].nodeName == 'HTML') {
+ // Fallback to white.
+ return 'rgb(255, 255, 255)';
+ }
+ c = $e.css('background-color');
+ // TRICKY: edge case for Firefox' "transparent" here; this is a
+ // browser bug: https://bugzilla.mozilla.org/show_bug.cgi?id=635724
+ if (c == 'rgba(0, 0, 0, 0)' || c == 'transparent') {
+ return Drupal.edit.util.getBgColor($e.parent());
+ }
+ return c;
+};
+
+/**
+ * Ignore hovering to/from the given closest element, but as soon as a hover
+ * occurs to/from *another* element, then call the given callback.
+ */
+Drupal.edit.util.ignoreHoveringVia = function(e, closest, callback) {
+ if ($(e.relatedTarget).closest(closest).length > 0) {
+ e.stopPropagation();
+ }
+ else {
+ callback();
+ }
+};
+
+/**
+ * If no position properties defined, replace value with zero.
+ */
+Drupal.edit.util.replaceBlankPosition = function(pos) {
+ if (pos == 'auto' || pos == NaN) {
+ pos = '0px';
+ }
+ return pos;
+};
+
+/**
+ * Get the top and left properties of an element and convert extraneous
+ * values and information into numbers ready for subtraction.
+ */
+Drupal.edit.util.getPositionProperties = function($e) {
+ var p,
+ r = {},
+ props = [
+ 'top', 'left', 'bottom', 'right',
+ 'padding-top', 'padding-left', 'padding-right', 'padding-bottom',
+ 'margin-bottom'
+ ];
+
+ for (var i = 0; i < props.length; i++) {
+ p = props[i];
+ r[p] = parseFloat(this.replaceBlankPosition($e.css(p)));
+ }
+ return r;
+};
+
+})(jQuery);
diff --git a/core/modules/field/modules/text/lib/Drupal/text/Plugin/field/formatter/TextDefaultFormatter.php b/core/modules/field/modules/text/lib/Drupal/text/Plugin/field/formatter/TextDefaultFormatter.php
index 6b34ba9..85d2878 100644
--- a/core/modules/field/modules/text/lib/Drupal/text/Plugin/field/formatter/TextDefaultFormatter.php
+++ b/core/modules/field/modules/text/lib/Drupal/text/Plugin/field/formatter/TextDefaultFormatter.php
@@ -23,6 +23,9 @@
* "text",
* "text_long",
* "text_with_summary"
+ * },
+ * edit = {
+ * "editability" = "direct"
* }
* )
*/
diff --git a/core/modules/field/modules/text/lib/Drupal/text/Plugin/field/formatter/TextPlainFormatter.php b/core/modules/field/modules/text/lib/Drupal/text/Plugin/field/formatter/TextPlainFormatter.php
index 0f7b615..8dc4bf1 100644
--- a/core/modules/field/modules/text/lib/Drupal/text/Plugin/field/formatter/TextPlainFormatter.php
+++ b/core/modules/field/modules/text/lib/Drupal/text/Plugin/field/formatter/TextPlainFormatter.php
@@ -23,6 +23,9 @@
* "text",
* "text_long",
* "text_with_summary"
+ * },
+ * edit = {
+ * "editability" = "direct"
* }
* )
*/
diff --git a/core/modules/field/modules/text/lib/Drupal/text/Plugin/field/formatter/TextSummaryOrTrimmedFormatter.php b/core/modules/field/modules/text/lib/Drupal/text/Plugin/field/formatter/TextSummaryOrTrimmedFormatter.php
index 11f0c14..c69e5e0 100644
--- a/core/modules/field/modules/text/lib/Drupal/text/Plugin/field/formatter/TextSummaryOrTrimmedFormatter.php
+++ b/core/modules/field/modules/text/lib/Drupal/text/Plugin/field/formatter/TextSummaryOrTrimmedFormatter.php
@@ -22,6 +22,9 @@
* },
* settings = {
* "trim_length" = "600"
+ * },
+ * edit = {
+ * "editability" = "form"
* }
* )
*/
diff --git a/core/modules/field/modules/text/lib/Drupal/text/Plugin/field/formatter/TextTrimmedFormatter.php b/core/modules/field/modules/text/lib/Drupal/text/Plugin/field/formatter/TextTrimmedFormatter.php
index 349cf63..add5d55 100644
--- a/core/modules/field/modules/text/lib/Drupal/text/Plugin/field/formatter/TextTrimmedFormatter.php
+++ b/core/modules/field/modules/text/lib/Drupal/text/Plugin/field/formatter/TextTrimmedFormatter.php
@@ -31,6 +31,9 @@
* },
* settings = {
* "trim_length" = "600"
+ * },
+ * edit = {
+ * "editability" = "form"
* }
* )
*/