wysiwyg.module in Wysiwyg 6.2

Same filename and directory in other branches
Integrates client-side editors with Drupal.
File

wysiwyg.module
View source
<?php

/**
 * @file
 * Integrates client-side editors with Drupal.
 */

/**
 * Implementation of hook_menu().
 */
function wysiwyg_menu() {
  $items['admin/settings/wysiwyg'] = array(
    'title' => 'Wysiwyg profiles',
    'page callback' => 'drupal_get_form',
    'page arguments' => array(
      'wysiwyg_profile_overview',
    ),
    'description' => 'Configure client-side editors.',
    'access arguments' => array(
      'administer filters',
    ),
    'file' => 'wysiwyg.admin.inc',
  );
  $items['admin/settings/wysiwyg/profile/list'] = array(
    'title' => 'List',
    'type' => MENU_DEFAULT_LOCAL_TASK,
    'weight' => -10,
  );
  $items['admin/settings/wysiwyg/profile/%wysiwyg_ui_profile_cache'] = array(
    'title callback' => 'wysiwyg_admin_profile_title',
    'title arguments' => array(
      4,
    ),
    'page callback' => 'drupal_get_form',
    'page arguments' => array(
      'wysiwyg_profile_form',
      4,
    ),
    'access arguments' => array(
      'administer filters',
    ),
    'file' => 'wysiwyg.admin.inc',
  );
  $items['admin/settings/wysiwyg/profile/%wysiwyg_ui_profile_cache/edit'] = array(
    'title' => 'Edit',
    'type' => MENU_DEFAULT_LOCAL_TASK,
  );
  $items['admin/settings/wysiwyg/profile/%wysiwyg_ui_profile_cache/delete'] = array(
    'title' => 'Remove',
    'page callback' => 'drupal_get_form',
    'page arguments' => array(
      'wysiwyg_profile_delete_confirm',
      4,
    ),
    'access arguments' => array(
      'administer filters',
    ),
    'file' => 'wysiwyg.admin.inc',
    'type' => MENU_LOCAL_TASK,
    'weight' => 10,
  );
  $items['admin/settings/wysiwyg/profile/%wysiwyg_ui_profile_cache/break-lock'] = array(
    'title' => 'Break lock',
    'page callback' => 'drupal_get_form',
    'page arguments' => array(
      'wysiwyg_profile_break_lock_confirm',
      4,
    ),
    'access arguments' => array(
      'administer filters',
    ),
    'file' => 'wysiwyg.admin.inc',
    'type' => MENU_VISIBLE_IN_BREADCRUMB,
  );

  // @see wysiwyg_dialog()
  $items['wysiwyg/%'] = array(
    'page callback' => 'wysiwyg_dialog',
    'page arguments' => array(
      1,
    ),
    'access arguments' => array(
      'access content',
    ),
    'type' => MENU_CALLBACK,
    'file' => 'wysiwyg.dialog.inc',
  );
  return $items;
}

/**
 * Display an editor profile title.
 *
 * @param $profile
 *   An editor profile object.
 *
 * @return
 *   The unfiltered name of an editor profile.
 *   Currently the same as the input format name.
 */
function wysiwyg_admin_profile_title($profile) {
  $format = filter_format_load($profile->format);
  return $format->name;
}

/**
 * Implementation of hook_theme().
 *
 * @see drupal_common_theme(), common.inc
 * @see template_preprocess_page(), theme.inc
 */
function wysiwyg_theme() {
  return array(
    'wysiwyg_profile_overview' => array(
      'arguments' => array(
        'form' => NULL,
      ),
    ),
    'wysiwyg_admin_button_table' => array(
      'arguments' => array(
        'form' => NULL,
      ),
    ),
    'wysiwyg_dialog_page' => array(
      'arguments' => array(
        'content' => NULL,
        'show_messages' => TRUE,
      ),
      'file' => 'wysiwyg.dialog.inc',
      'template' => 'wysiwyg-dialog-page',
    ),
  );
}

/**
 * Implementation of hook_help().
 */
function wysiwyg_help($path, $arg) {
  switch ($path) {
    case 'admin/settings/wysiwyg':
      $output = '<p>' . t('A Wysiwyg profile is associated with an input format. A Wysiwyg profile defines which client-side editor is loaded with a particular input format, what buttons or themes are enabled for the editor, how the editor is displayed, and a few other editor-specific functions.') . '</p>';
      return $output;
  }
}

/**
 * Implementation of hook_form_alter().
 *
 * Before Drupal 7, there is no way to easily identify form fields that are
 * input format enabled. As a workaround, we assign a form #after_build
 * processing callback that is executed on all forms after they have been
 * completely built, so form elements are in their effective order
 * and position already.
 *
 * @see wysiwyg_process_form()
 */
function wysiwyg_form_alter(&$form, &$form_state) {
  $form['#after_build'][] = 'wysiwyg_process_form';

  // Teaser splitter is unconditionally removed and NOT supported.
  if (isset($form['body_field'])) {
    unset($form['body_field']['teaser_js']);
  }
}

/**
 * Process a textarea for Wysiwyg Editor.
 *
 * This way, we can recurse into the form and search for certain, hard-coded
 * elements that have been added by filter_form(). If an input format selector
 * or input format guidelines element is found, we assume that the preceding
 * element is the corresponding textarea and use it's #id for attaching
 * client-side editors.
 *
 * @see wysiwyg_elements(), filter_form()
 */
function wysiwyg_process_form(&$form) {
  static $triggered_fields = array();

  // Iterate over element children; resetting array keys to access last index.
  if ($children = array_values(element_children($form))) {
    foreach ($children as $index => $item) {
      $element =& $form[$item];

      // filter_form() always uses the key 'format'. We need a type-agnostic
      // match to prevent false positives. Also, there must have been at least
      // one element on this level.
      if (($item === 'format' || $item === 'signature_format') && $index > 0) {

        // Make sure we either match a input format selector or input format
        // guidelines (displayed if user has access to one input format only).
        if (isset($element['#type']) && $element['#type'] == 'fieldset' || isset($element['format']['guidelines'])) {

          // The element before this element is the target form field.
          $field =& $form[$children[$index - 1]];

          // Allow modules to programmatically enforce no client-side editor by
          // setting the #wysiwyg property to FALSE.
          if (isset($field['#wysiwyg']) && !$field['#wysiwyg']) {

            // A 'format' element should not have any child elements that may
            // need processing, so it should be safe to skip the recursion that
            // happens at the end of this function, and move on to the next
            // element on the same level.
            continue;
          }
          $settings = array(
            'field' => $field['#id'],
          );

          // If this textarea is #resizable the 'none' editor will attach/detach
          // it to avoid hi-jacking the UI.
          if (!empty($field['#resizable'])) {
            $settings['resizable'] = 1;
          }

          // Determine the available input formats. The last child element is a
          // link to "More information about formatting options". When only one
          // input format is displayed, we also have to remove formatting
          // guidelines, stored in the child 'format'.
          $formats = element_children($element);
          array_pop($formats);
          if (($key = array_search('format', $formats)) !== FALSE) {
            unset($formats[$key]);
          }
          if (count($formats) > 1) {

            // Let the client check the radio buttons for the active format.
            $settings['select'] = $element[reset($formats)]['#name'];
          }
          else {

            // Directly specify which the single available format is.
            $settings['activeFormat'] = reset($formats);
          }
          foreach ($formats as $format_id) {
            $format = 'format' . $format_id;

            // Initialize default settings, defaulting to 'none' editor.
            $settings[$format] = array(
              'editor' => 'none',
              'status' => 1,
              'toggle' => 1,
            );

            // Fetch the profile associated to this input format.
            $profile = wysiwyg_get_profile($format_id);
            if ($profile) {
              $settings[$format]['editor'] = $profile->editor;
              $settings[$format]['status'] = (int) wysiwyg_user_get_status($profile);
              if (isset($profile->preferences['show_toggle'])) {
                $settings[$format]['toggle'] = (int) $profile->preferences['show_toggle'];
              }

              // Check editor theme (and reset it if not/no longer available).
              $theme = wysiwyg_get_editor_themes($profile, isset($profile->settings['theme']) ? $profile->settings['theme'] : '');

              // Add plugin settings (first) for this input format.
              wysiwyg_add_plugin_settings($profile);

              // Add profile settings for this input format.
              wysiwyg_add_editor_settings($profile, $theme);
            }
          }

          // Store the unaltered content so it can be restored if no changes
          // intentionally made by the user were detected, such as those caused by
          // WYSIWYG editors when initially parsing and loading content.
          if (!empty($field['#value'])) {
            $original = $field['#value'];
            $field['#attributes']['data-wysiwyg-value-original'] = $original;
            $field['#attributes']['data-wysiwyg-value-is-changed'] = 'false';
          }

          // Tag this field to make it easier to find on the client.
          if (empty($field['#attributes']['class'])) {
            $field['#attributes']['class'] = 'wysiwyg';
          }
          else {
            if (!isset($field['#attributes']['class'])) {
              $field['#attributes']['class'] = '';
            }
            $field['#attributes']['class'] .= ' wysiwyg';
          }
          if (!isset($triggered_fields[$field['#id']])) {
            drupal_add_js(array(
              'wysiwyg' => array(
                'triggers' => array(
                  $field['#id'] => $settings,
                ),
              ),
            ), 'setting');
            $triggered_fields[$field['#id']] = TRUE;
          }
        }

        // If this element is 'format', do not recurse further.
        continue;
      }

      // Recurse into children.
      wysiwyg_process_form($element);
    }
  }
  return $form;
}

/**
 * Implementation of hook_js_alter().
 *
 * Applies overrides to CTools' scripts command or it will execute editor
 * scripts twice, causing instances/state to be lost (YUI Editor).
 *
 * Needs the jsalter module for this to be called in D6.
 */
function wysiwyg_js_alter(&$scripts, $scope, &$queryString) {
  if (module_exists('ctools')) {
    $path = drupal_get_path('module', 'ctools') . '/js/ajax-responder.js';
    if (isset($scripts['module'][$path])) {

      // Add this directly to the scripts.
      $scripts['module'][drupal_get_path('module', 'wysiwyg') . '/override-ctools-ajax.js'] = array(
        'cache' => TRUE,
        'defer' => FALSE,
        'preprocess' => TRUE,
      );

      // Modules like jquery_update call drupal_get_js() again after this.
      drupal_add_js(drupal_get_path('module', 'wysiwyg') . '/override-ctools-ajax.js');
    }
  }
}

/**
 * Determine the profile to use for a given input format id.
 *
 * This function also performs sanity checks for the configured editor in a
 * profile to ensure that we do not load a malformed editor.
 *
 * @param $format
 *   The internal id of an input format.
 *
 * @return
 *   A wysiwyg profile.
 *
 * @see wysiwyg_load_editor(), wysiwyg_get_editor()
 */
function wysiwyg_get_profile($format) {
  if ($profile = wysiwyg_profile_load($format)) {
    if (wysiwyg_load_editor($profile)) {
      return $profile;
    }
  }
  return FALSE;
}

/**
 * Load an editor library and initialize basic Wysiwyg settings.
 *
 * @param $profile
 *   A wysiwyg editor profile.
 *
 * @return
 *   TRUE if the editor has been loaded, FALSE if not.
 *
 * @see wysiwyg_get_profile()
 */
function wysiwyg_load_editor($profile) {
  static $settings_added;
  static $loaded = array();
  $path = drupal_get_path('module', 'wysiwyg');
  $name = $profile->editor;

  // Library files must be loaded only once.
  if (!isset($loaded[$name])) {

    // Load editor.
    $editor = wysiwyg_get_editor($name);
    if ($editor) {

      // Determine library files to load.
      // @todo Allow to configure the library/execMode to use.
      if (isset($profile->preferences['library']) && isset($editor['libraries'][$profile->preferences['library']])) {
        $library = $profile->preferences['library'];
        $files = $editor['libraries'][$library]['files'];
      }
      else {

        // Fallback to the first defined library by default (external libraries can change).
        $library = key($editor['libraries']);
        $files = array_shift($editor['libraries']);
        $files = $files['files'];
      }

      // Check whether the editor requires an initialization script.
      if (!empty($editor['init callback'])) {
        $init = $editor['init callback']($editor, $library, $profile);
        if (!empty($init)) {

          // Build a file for each of the editors to hold the init scripts.
          // @todo Aggregate all initialization scripts into one file.
          $js_path = file_create_path('js');
          file_check_directory($js_path, FILE_CREATE_DIRECTORY | FILE_MODIFY_PERMISSIONS);
          $js_path .= '/';
          $hash = base64_encode(hash('sha256', $init, TRUE));

          // Modify the hash so it's safe to use in URLs.
          $hash = strtr($hash, array(
            '+' => '-',
            '/' => '_',
            '=' => '',
          ));
          $filename = 'wysiwyg_' . $name . '_' . $hash . '.js';
          $init_exists = file_exists($js_path . $filename);

          // Attempt to create the file, or fall back to an inline script (which
          // will not work in Ajax calls).
          if (!$init_exists && !file_save_data($init, $js_path . $filename, FILE_EXISTS_REPLACE)) {
            drupal_add_js($init, 'inline', 'header', FALSE, TRUE, TRUE);
          }
          else {
            $path_prefix = variable_get('file_downloads', FILE_DOWNLOADS_PUBLIC) == FILE_DOWNLOADS_PRIVATE ? 'system/files/js/' : $js_path;
            drupal_add_js($path_prefix . $filename, 'core', 'header', FALSE, TRUE, TRUE);
          }
        }
      }
      foreach ($files as $file => $options) {
        if (is_array($options)) {
          $options += array(
            'type' => 'module',
            'scope' => 'header',
            'defer' => FALSE,
            'cache' => TRUE,
            'preprocess' => TRUE,
          );
          drupal_add_js($editor['library path'] . '/' . $file, $options['type'], $options['scope'], $options['defer'], $options['cache'], $options['preprocess']);
        }
        else {
          drupal_add_js($editor['library path'] . '/' . $options);
        }
      }

      // If editor defines an additional load callback, invoke it.
      // @todo Isn't the settings callback sufficient?
      if (isset($editor['load callback']) && function_exists($editor['load callback'])) {
        $editor['load callback']($editor, $library);
      }

      // Load JavaScript integration files for this editor.
      $files = array();
      if (isset($editor['js files'])) {
        $files = $editor['js files'];
      }
      foreach ($files as $file) {
        drupal_add_js($editor['js path'] . '/' . $file, 'module', 'footer');
      }

      // Load CSS stylesheets for this editor.
      $files = array();
      if (isset($editor['css files'])) {
        $files = $editor['css files'];
      }
      foreach ($files as $file) {
        drupal_add_css($editor['css path'] . '/' . $file);
      }
      $loaded[$name] = TRUE;
    }
    else {
      $loaded[$name] = FALSE;
    }
  }

  // Add basic Wysiwyg settings if any editor has been added.
  if (!isset($settings_added) && $loaded[$name]) {
    drupal_add_js(array(
      'wysiwyg' => array(
        'configs' => array(),
        'plugins' => array(),
        'disable' => t('Disable rich-text'),
        'enable' => t('Enable rich-text'),
      ),
    ), 'setting');

    // Initialize our namespaces in the *header* to do not force editor
    // integration scripts to check and define Drupal.wysiwyg on its own.
    drupal_add_js($path . '/wysiwyg.init.js', 'core');

    // The 'none' editor is a special editor implementation, allowing us to
    // attach and detach regular Drupal behaviors just like any other editor.
    drupal_add_js($path . '/editors/js/none.js');

    // Add wysiwyg.js to the footer to ensure it's executed after the
    // Drupal.settings array has been rendered and populated. Also, since editor
    // library initialization functions must be loaded first by the browser,
    // and Drupal.wysiwygInit() must be executed AFTER editors registered
    // their callbacks and BEFORE Drupal.behaviors are applied, this must come
    // last.
    drupal_add_js($path . '/wysiwyg.js', 'module', 'footer');
    $settings_added = TRUE;
  }
  return $loaded[$name];
}

/**
 * Add editor settings for a given input format.
 */
function wysiwyg_add_editor_settings($profile, $theme) {
  static $formats = array();
  if (!isset($formats[$profile->format])) {
    $config = wysiwyg_get_editor_config($profile, $theme);

    // drupal_to_js() does not properly convert numeric array keys, so we need
    // to use a string instead of the format id.
    if ($config) {
      drupal_add_js(array(
        'wysiwyg' => array(
          'configs' => array(
            $profile->editor => array(
              'format' . $profile->format => $config,
            ),
          ),
        ),
      ), 'setting');
    }
    $formats[$profile->format] = TRUE;
  }
}

/**
 * Add settings for external plugins.
 *
 * Plugins can be used in multiple profiles, but not necessarily in all. Because
 * of that, we need to process plugins for each profile, even if most of their
 * settings are not stored per profile.
 *
 * Implementations of hook_wysiwyg_plugin() may execute different code for each
 * editor. Therefore, we have to invoke those implementations for each editor,
 * but process the resulting plugins separately for each profile.
 *
 * Drupal plugins differ to native plugins in that they have plugin-specific
 * definitions and settings, which need to be processed only once. But they are
 * also passed to the editor to prepare settings specific to the editor.
 * Therefore, we load and process the Drupal plugins only once, and hand off the
 * effective definitions for each profile to the editor.
 *
 * @param $profile
 *   A wysiwyg editor profile.
 *
 * @todo Rewrite wysiwyg_process_form() to build a registry of effective
 *   profiles in use, so we can process plugins in multiple profiles in one shot
 *   and simplify this entire function.
 */
function wysiwyg_add_plugin_settings($profile) {
  static $plugins = array();
  static $processed_plugins = array();
  static $processed_formats = array();

  // Each input format must only processed once.
  // @todo ...as long as we do not have multiple profiles per format.
  if (isset($processed_formats[$profile->format])) {
    return;
  }
  $processed_formats[$profile->format] = TRUE;
  $editor = wysiwyg_get_editor($profile->editor);

  // Collect native plugins for this editor provided via hook_wysiwyg_plugin()
  // and Drupal plugins provided via hook_wysiwyg_include_directory().
  if (!array_key_exists($editor['name'], $plugins)) {
    $plugins[$editor['name']] = wysiwyg_get_plugins($editor['name']);
  }

  // Nothing to do, if there are no plugins.
  if (empty($plugins[$editor['name']])) {
    return;
  }

  // Determine name of proxy plugin for Drupal plugins.
  $proxy = isset($editor['proxy plugin']) ? key($editor['proxy plugin']) : '';

  // Process native editor plugins.
  $profile_plugins_native = array();
  foreach ($plugins[$editor['name']] as $plugin => $meta) {

    // Skip Drupal plugins (handled below) and 'core' functionality.
    if ($plugin === $proxy || $plugin === 'default') {
      continue;
    }

    // Only keep native plugins that are enabled in this profile.
    if (isset($profile->settings['buttons'][$plugin])) {
      $profile_plugins_native[$plugin] = $meta;
      if (!isset($processed_plugins[$editor['name']][$plugin])) {
        if (isset($editor['plugin meta callback'])) {

          // Invoke the editor's plugin meta callback, so it can populate the
          // global metadata for native plugins with required values.
          $meta['name'] = $plugin;
          if ($native_meta = call_user_func($editor['plugin meta callback'], $editor, $meta)) {
            drupal_add_js(array(
              'wysiwyg' => array(
                'plugins' => array(
                  'native' => array(
                    $editor['name'] => array(
                      $plugin => $native_meta,
                    ),
                  ),
                ),
              ),
            ), 'setting');
          }
        }
        $processed_plugins[$editor['name']][$plugin] = $meta;
      }
    }
  }
  if (!empty($profile_plugins_native) && isset($editor['plugin settings callback'])) {

    // Invoke the editor's plugin settings callback, so it can populate the
    // format specific settings for native plugins with required values.
    if ($settings_native = call_user_func($editor['plugin settings callback'], $editor, $profile, $profile_plugins_native)) {
      drupal_add_js(array(
        'wysiwyg' => array(
          'plugins' => array(
            'format' . $profile->format => array(
              'native' => $settings_native,
            ),
          ),
        ),
      ), 'setting');
    }
  }

  // Process Drupal plugins.
  if ($proxy && isset($editor['proxy plugin settings callback'])) {
    $profile_plugins_drupal = array();
    foreach (wysiwyg_get_all_plugins() as $plugin => $meta) {
      if (isset($profile->settings['buttons'][$proxy][$plugin])) {

        // JavaScript and plugin-specific settings for Drupal plugins must be
        // loaded and processed only once. Plugin information is cached
        // statically to pass it to the editor's proxy plugin settings callback.
        if (!isset($processed_plugins[$proxy][$plugin])) {
          $profile_plugins_drupal[$plugin] = $processed_plugins[$proxy][$plugin] = $meta;

          // Load the Drupal plugin's JavaScript.
          drupal_add_js($meta['js path'] . '/' . $meta['js file']);

          // Add plugin-specific settings.
          $settings = isset($meta['settings']) ? $meta['settings'] : array();
          $settings['title'] = $meta['title'];
          $settings['icon'] = base_path() . $meta['icon path'] . '/' . $meta['icon file'];
          if (!empty($meta['css path']) && !empty($meta['css file'])) {
            $settings['css'] = base_path() . $meta['css path'] . '/' . $meta['css file'];
          }
          drupal_add_js(array(
            'wysiwyg' => array(
              'plugins' => array(
                'drupal' => array(
                  $plugin => $settings,
                ),
              ),
            ),
          ), 'setting');
        }
        else {
          $profile_plugins_drupal[$plugin] = $processed_plugins[$proxy][$plugin];
        }
      }
    }

    // Invoke the editor's proxy plugin settings callback, so it can populate
    // the settings for Drupal plugins with custom, required values.
    $settings_drupal = call_user_func($editor['proxy plugin settings callback'], $editor, $profile, $profile_plugins_drupal);
    if ($settings_drupal) {
      drupal_add_js(array(
        'wysiwyg' => array(
          'plugins' => array(
            'format' . $profile->format => array(
              'drupal' => $settings_drupal,
            ),
          ),
        ),
      ), 'setting');
    }
  }
}

/**
 * Retrieve available themes for an editor.
 *
 * Editor themes control the visual presentation of an editor.
 *
 * @param $profile
 *   A wysiwyg editor profile; passed/altered by reference.
 * @param $selected_theme
 *   An optional theme name that ought to be used.
 *
 * @return
 *   An array of theme names, or a single, checked theme name if $selected_theme
 *   was given.
 */
function wysiwyg_get_editor_themes(&$profile, $selected_theme = NULL) {
  static $themes = array();
  if (!isset($themes[$profile->editor])) {
    $editor = wysiwyg_get_editor($profile->editor);
    if (isset($editor['themes callback']) && function_exists($editor['themes callback'])) {
      $themes[$editor['name']] = $editor['themes callback']($editor, $profile);
    }
    else {
      $themes[$editor['name']] = array(
        'default',
      );
    }
  }

  // Check optional $selected_theme argument, if given.
  if (isset($selected_theme)) {

    // If the passed theme name does not exist, use the first available.
    if (!in_array($selected_theme, $themes[$profile->editor])) {
      $selected_theme = $profile->settings['theme'] = $themes[$profile->editor][0];
    }
  }
  return isset($selected_theme) ? $selected_theme : $themes[$profile->editor];
}

/**
 * Return plugin metadata from the plugin registry.
 *
 * @param $editor_name
 *   The internal name of an editor to return plugins for.
 *
 * @return
 *   An array for each plugin.
 */
function wysiwyg_get_plugins($editor_name) {
  $plugins = array();
  if (!empty($editor_name)) {
    $editor = wysiwyg_get_editor($editor_name);

    // Add internal editor plugins.
    if (isset($editor['plugin callback']) && function_exists($editor['plugin callback'])) {
      $plugins = $editor['plugin callback']($editor);
    }

    // Add editor plugins provided via hook_wysiwyg_plugin().
    $plugins = array_merge($plugins, module_invoke_all('wysiwyg_plugin', $editor['name'], $editor['installed version']));

    // Add API plugins provided by Drupal modules.
    // @todo We need to pass the filepath to the plugin icon for Drupal plugins.
    if (isset($editor['proxy plugin'])) {
      $plugins += $editor['proxy plugin'];
      $proxy = key($editor['proxy plugin']);
      foreach (wysiwyg_get_all_plugins() as $plugin_name => $info) {
        $plugins[$proxy]['buttons'][$plugin_name] = $info['title'];
      }
    }
  }
  return $plugins;
}

/**
 * Return an array of initial editor settings for a Wysiwyg profile.
 */
function wysiwyg_get_editor_config($profile, $theme) {
  $editor = wysiwyg_get_editor($profile->editor);
  $settings = array();
  $installed_version = $editor['installed version'];
  $settings = $profile->settings;
  if (!empty($editor['settings callback']) && function_exists($editor['settings callback'])) {
    if (!empty($profile->preferences['version']) && !empty($installed_version)) {
      $profile_version = $profile->preferences['version'];
      $version_status = version_compare($profile_version, $installed_version);
      if ($version_status !== 0) {

        // Installed version is different from profile version. Silently migrate
        // the stored editor settings to the installed version if possible.
        $migrated = FALSE;
        if (!empty($editor['migrate settings callback']) && function_exists($editor['migrate settings callback'])) {
          $migrated = $editor['migrate settings callback']($settings, $editor, $profile_version, $installed_version);
        }
      }
    }
    $settings = $editor['settings callback']($editor, $settings, $theme);

    // Allow other modules to alter the editor settings for this format.
    $context = array(
      'editor' => $editor,
      'profile' => $profile,
      'theme' => $theme,
    );
    drupal_alter('wysiwyg_editor_settings', $settings, $context);
  }
  return $settings;
}

/**
 * Retrieve stylesheets for HTML/IFRAME-based editors.
 *
 * This assumes that the content editing area only needs stylesheets defined
 * for the scope 'theme'.
 *
 * @return
 *   An array containing CSS files, including proper base path.
 */
function wysiwyg_get_css() {
  static $files;
  if (isset($files)) {
    return $files;
  }

  // In node form previews, the theme has not been initialized yet.
  if (!empty($_POST)) {
    init_theme();
  }
  $files = array();
  $query = ($string = variable_get('css_js_query_string', NULL)) ? '?' . $string : '';
  foreach (drupal_add_css() as $media => $css) {
    if ($media != 'print') {
      foreach ($css['theme'] as $filepath => $preprocess) {
        if (file_exists($filepath)) {
          $files[] = base_path() . $filepath . $query;
        }
      }
    }
  }
  return $files;
}

/**
 * Load profile for a given input format.
 *
 * @param $reset
 *   If true, resets the load cache.
 *
 * @return
 *   A profile if found, else FALSE.
 */
function wysiwyg_profile_load($format, $reset = FALSE) {
  static $profiles;
  if ($reset) {
    $profiles = NULL;
  }
  if (!isset($profiles) || !array_key_exists($format, $profiles)) {
    $result = db_query('SELECT format, editor, settings FROM {wysiwyg} WHERE format = %d', $format);
    while ($profile = db_fetch_object($result)) {
      $profile->settings = unserialize($profile->settings);
      $profile->preferences = $profile->settings['_profile_preferences'];
      unset($profile->settings['_profile_preferences']);
      $profile->name = 'format' . $profile->format;
      $profiles[$profile->format] = $profile;
    }
  }
  return isset($profiles[$format]) ? $profiles[$format] : FALSE;
}

/**
 * Load all profiles.
 *
 * @return
 *   An array of profiles keyed by format name.
 */
function wysiwyg_profile_load_all($reset = FALSE) {
  static $profiles;
  if ($reset) {
    $profiles = NULL;
  }
  if (!isset($profiles)) {
    $profiles = array();
    $result = db_query('SELECT format, editor, settings FROM {wysiwyg}');
    while ($profile = db_fetch_object($result)) {
      $profile->settings = unserialize($profile->settings);
      $profile->preferences = $profile->settings['_profile_preferences'];
      unset($profile->settings['_profile_preferences']);
      $profile->name = 'format' . $profile->format;
      $profiles[$profile->format] = $profile;
    }
  }
  return $profiles;
}

/**
 * Remove a profile from the database.
 */
function wysiwyg_profile_delete($format) {
  db_query("DELETE FROM {wysiwyg} WHERE format = %d", $format);

  // Clear the editing caches.
  if (module_exists('ctools')) {
    ctools_include('object-cache');
    ctools_object_cache_clear_all('wysiwyg_profile', $format);
  }
  else {
    cache_clear_all('wysiwyg_profile:' . $format, 'cache');
  }
  wysiwyg_profile_cache_clear();
}

/**
 * Specialized menu callback to load a profile and check its locked status.
 *
 * @param $name
 *   The machine id of the profile.
 *
 * @return
 *   The profile object, with a "locked" property indicating whether or not
 *   someone else is already editing the profile.
 */
function wysiwyg_ui_profile_cache_load($format) {
  $original_profile = wysiwyg_profile_load($format);
  $profile = FALSE;
  $name = $original_profile ? $original_profile->name : 'format' . $format;
  $profile = wysiwyg_ui_profile_cache_get($name);
  if (empty($profile)) {
    $profile = $original_profile;
  }
  if (!empty($profile)) {
    $profile->editing = TRUE;
    return $profile;
  }
  return FALSE;
}

/**
 * Specialized cache function to load a profile from the editing cache.
 *
 * @param $name
 *   The name of a profile to load. Currently the format id prefixed by
 *   'format'.
 * @return
 *  The profile object, with a "locked" property indicating whether or not
 *  someone else is already editing the profile, or FALSE if not cached.
 */
function wysiwyg_ui_profile_cache_get($name) {
  $profile = FALSE;
  if (module_exists('ctools')) {
    ctools_include('object-cache');
    $profile = ctools_object_cache_get('wysiwyg_profile', $name);
    if ($profile) {
      $profile->locked = ctools_object_cache_test('wysiwyg_profile', $name);
    }
  }
  else {

    // Fall back on simple caching in its own bin without locking.
    $cached = cache_get('wysiwyg_profile:' . $name);
    if ($cached) {
      $profile = $cached->data;
      $profile->locked = FALSE;
    }
  }
  return $profile;
}

/**
 * Specialized cache function to add a profile to the editing cache.
 */
function wysiwyg_ui_profile_cache_set(&$profile) {
  if (!empty($profile->locked)) {
    drupal_set_message(t('Changes can not be made to a locked profile.'), 'error');
    return;
  }
  $profile->changed = TRUE;
  if (module_exists('ctools')) {
    ctools_include('object-cache');
    ctools_object_cache_set('wysiwyg_profile', $profile->name, $profile);
  }
  else {
    cache_set('wysiwyg_profile:' . $profile->name, $profile);
  }
}

/**
 * Clear all Wysiwyg profile caches.
 */
function wysiwyg_profile_cache_clear() {
  wysiwyg_profile_load(-1, TRUE);
  wysiwyg_profile_load_all(TRUE);
}

/**
 * Implementation of hook_user().
 */
function wysiwyg_user($op, &$edit, $account, $category = NULL) {
  if ($op == 'form' && $category == 'account') {
    $user_formats = filter_formats();
    $options = array();
    $options_default = array();
    foreach (wysiwyg_profile_load_all() as $format => $profile) {

      // Only show profiles that have user_choose enabled.
      if (!empty($profile->settings['user_choose']) && isset($user_formats[$format])) {
        $options[$format] = check_plain($user_formats[$format]->name);
        if (wysiwyg_user_get_status($profile, $account)) {
          $options_default[] = $format;
        }
      }
    }
    if (!empty($options)) {
      $form['wysiwyg']['wysiwyg_status'] = array(
        '#type' => 'checkboxes',
        '#title' => t('Text formats enabled for rich-text editing'),
        '#options' => $options,
        '#default_value' => $options_default,
      );
      return $form;
    }
  }
  elseif ($op == 'insert' || $op == 'update') {
    if (isset($edit['wysiwyg_status'])) {
      db_query("DELETE FROM {wysiwyg_user} WHERE uid = %d", $account->uid);
      foreach ($edit['wysiwyg_status'] as $format => $status) {
        db_query("INSERT INTO {wysiwyg_user} (uid, format, status) VALUES (%d, %d, %d)", array(
          $account->uid,
          $format,
          (int) (bool) $status,
        ));
      }
    }
  }
}
function wysiwyg_user_get_status($profile, $account = NULL) {
  global $user;
  if (!isset($account)) {
    $account = $user;
  }

  // Default wysiwyg editor status information is only required on forms, so we
  // do not pre-emptively load and attach this information on every user_load().
  if (!isset($account->wysiwyg_status)) {
    $account->wysiwyg_status = array();
    $result = db_query("SELECT format, status FROM {wysiwyg_user} WHERE uid = %d", $account->uid);
    while ($row = db_fetch_object($result)) {
      $account->wysiwyg_status[$row->format] = $row->status;
    }
  }
  if (!empty($profile->preferences['user_choose']) && isset($account->wysiwyg_status[$profile->format])) {
    $status = $account->wysiwyg_status[$profile->format];
  }
  else {
    $status = isset($profile->preferences['default']) ? $profile->preferences['default'] : TRUE;
  }
  return (bool) $status;
}

/**
 * Implements hook_file_download().
 */
function wysiwyg_file_download($file) {
  if (preg_match('/^js\\/wysiwyg_(\\w+)_.+\\.js$/', $file, $matches)) {
    $editor_name = $matches[1];
    if (($editor = wysiwyg_get_editor($editor_name)) && $editor['installed']) {
      return array(
        'Content-type: text/javascript',
      );
    }
  }
}

/**
 * @defgroup wysiwyg_api Wysiwyg API
 * @{
 *
 * @todo Forked from Panels; abstract into a separate API module that allows
 *   contrib modules to define supported include/plugin types.
 */

/**
 * Return library information for a given editor.
 *
 * @param $name
 *   The internal name of an editor.
 *
 * @return
 *   The library information for the editor, or FALSE if $name is unknown or not
 *   installed properly.
 */
function wysiwyg_get_editor($name) {
  $editors = wysiwyg_get_all_editors();
  return isset($editors[$name]) && $editors[$name]['installed'] ? $editors[$name] : FALSE;
}

/**
 * Compile a list holding all supported editors including installed editor version information.
 */
function wysiwyg_get_all_editors() {
  static $editors;
  if (isset($editors)) {
    return $editors;
  }
  $editors = wysiwyg_load_includes('editors', 'editor');
  foreach ($editors as $editor => $properties) {

    // Fill in required properties.
    $editors[$editor] += array(
      'title' => '',
      'vendor url' => '',
      'download url' => '',
      'editor path' => wysiwyg_get_path($editors[$editor]['name']),
      'library path' => wysiwyg_get_path($editors[$editor]['name']),
      'libraries' => array(),
      'installed' => FALSE,
      'version callback' => NULL,
      'themes callback' => NULL,
      'settings form callback' => NULL,
      'settings callback' => NULL,
      'plugin callback' => NULL,
      'plugin settings callback' => NULL,
      'versions' => array(),
      'js path' => $editors[$editor]['path'] . '/js',
      'css path' => $editors[$editor]['path'] . '/css',
    );

    // Check whether library is present.
    if (!$editors[$editor]['installed'] && !($editors[$editor]['installed'] = file_exists($editors[$editor]['library path']))) {

      // Find the latest supported version.
      ksort($editors[$editor]['versions']);
      $version = key($editors[$editor]['versions']);
      foreach ($editors[$editor]['versions'] as $supported_version => $version_properties) {
        if (version_compare($version, $supported_version, '<')) {
          $version = $supported_version;
        }
      }

      // Apply library version specific definitions and overrides.
      // This is to show the newest installation instructions.
      $editors[$editor] = array_merge($editors[$editor], $editors[$editor]['versions'][$version]);
      continue;
    }
    $installed_version = NULL;

    // Detect library version.
    if (function_exists($editors[$editor]['version callback'])) {
      $installed_version = $editors[$editor]['installed version'] = $editors[$editor]['version callback']($editors[$editor]);
    }
    if (empty($installed_version)) {
      $editors[$editor]['error'] = t('The version of %editor could not be detected.', array(
        '%editor' => $properties['title'],
      ));
      $editors[$editor]['installed'] = FALSE;
      continue;
    }
    $editors[$editor]['installed version verified'] = TRUE;
    if (!empty($editors[$editor]['verified version range'])) {
      $version_range = $editors[$editor]['verified version range'];
      if (version_compare($installed_version, $version_range[0], '<') || version_compare($installed_version, $version_range[1], '>')) {
        $editors[$editor]['installed version verified'] = FALSE;
      }
    }

    // Determine to which supported version the installed version maps.
    ksort($editors[$editor]['versions']);
    $version = 0;
    foreach ($editors[$editor]['versions'] as $supported_version => $version_properties) {
      if (version_compare($installed_version, $supported_version, '>=')) {
        $version = $supported_version;
      }
    }
    if (!$version) {
      $editors[$editor]['error'] = t('The installed version %version of %editor is not supported.', array(
        '%version' => $installed_version,
        '%editor' => $editors[$editor]['title'],
      ));
      $editors[$editor]['installed'] = FALSE;
      continue;
    }

    // Apply library version specific definitions and overrides.
    $editors[$editor] = array_merge($editors[$editor], $editors[$editor]['versions'][$version]);
    unset($editors[$editor]['versions']);
  }
  drupal_alter('wysiwyg_editor', $editors);
  return $editors;
}

/**
 * Invoke hook_wysiwyg_plugin() in all modules.
 */
function wysiwyg_get_all_plugins() {
  static $plugins;
  if (isset($plugins)) {
    return $plugins;
  }
  $plugins = wysiwyg_load_includes('plugins', 'plugin');
  foreach ($plugins as $name => $properties) {
    $plugin =& $plugins[$name];

    // Fill in required/default properties.
    $plugin += array(
      'title' => $plugin['name'],
      'vendor url' => '',
      'js path' => $plugin['path'] . '/' . $plugin['name'],
      'js file' => $plugin['name'] . '.js',
      'css path' => $plugin['path'] . '/' . $plugin['name'],
      'css file' => $plugin['name'] . '.css',
      'icon path' => $plugin['path'] . '/' . $plugin['name'] . '/images',
      'icon file' => $plugin['name'] . '.png',
      'dialog path' => $plugin['name'],
      'dialog settings' => array(),
      'settings callback' => NULL,
      'settings form callback' => NULL,
    );

    // Fill in default settings.
    $plugin['settings'] += array(
      'path' => base_path() . $plugin['path'] . '/' . $plugin['name'],
    );

    // Check whether library is present.
    if (!($plugin['installed'] = file_exists($plugin['js path'] . '/' . $plugin['js file']))) {
      continue;
    }
  }
  return $plugins;
}

/**
 * Load include files for wysiwyg implemented by all modules.
 *
 * @param $type
 *   The type of includes to search for, can be 'editors'.
 * @param $hook
 *   The hook name to invoke.
 * @param $file
 *   An optional include file name without .inc extension to limit the search to.
 *
 * @see wysiwyg_get_directories(), _wysiwyg_process_include()
 */
function wysiwyg_load_includes($type = 'editors', $hook = 'editor', $file = NULL) {

  // Determine implementations.
  $directories = wysiwyg_get_directories($type);
  $directories['wysiwyg'] = drupal_get_path('module', 'wysiwyg') . '/' . $type;
  $file_list = array();
  foreach ($directories as $module => $path) {
    $file_list[$module] = drupal_system_listing("{$file}" . '.inc$', $path, 'name', 0);
  }

  // Load implementations.
  $info = array();
  foreach (array_filter($file_list) as $module => $files) {
    foreach ($files as $file) {
      include_once './' . $file->filename;
      $result = _wysiwyg_process_include($module, $module . '_' . $file->name, dirname($file->filename), $hook);
      if (is_array($result)) {
        $info = array_merge($info, $result);
      }
    }
  }
  drupal_alter('wysiwyg_load_includes', $info, $hook);
  return $info;
}

/**
 * Helper function to build paths to libraries.
 *
 * @param $library
 *   The external library name to return the path for.
 * @param $base_path
 *   Whether to prefix the resulting path with base_path().
 *
 * @return
 *   The path to the specified library.
 *
 * @ingroup libraries
 */
function wysiwyg_get_path($library, $base_path = FALSE) {
  static $libraries;
  if (!isset($libraries)) {
    $libraries = wysiwyg_get_libraries();
  }
  if (!isset($libraries[$library])) {

    // Most often, external libraries can be shared across multiple sites.
    return 'sites/all/libraries/' . $library;
  }
  $path = $base_path ? base_path() : '';
  $path .= $libraries[$library];
  return $path;
}

/**
 * Return an array of library directories.
 *
 * Returns an array of library directories from the all-sites directory
 * (i.e. sites/all/libraries/), the profiles directory, and site-specific
 * directory (i.e. sites/somesite/libraries/). The returned array will be keyed
 * by the library name. Site-specific libraries are prioritized over libraries
 * in the default directories. That is, if a library with the same name appears
 * in both the site-wide directory and site-specific directory, only the
 * site-specific version will be listed.
 *
 * @return
 *   A list of library directories.
 *
 * @ingroup libraries
 */
function wysiwyg_get_libraries() {
  if (function_exists('libraries_get_libraries')) {
    $directories = libraries_get_libraries();
  }
  else {
    global $profile;

    // When this function is called during Drupal's initial installation process,
    // the name of the profile that is about to be installed is stored in the
    // global $profile variable. At all other times, the regular system variable
    // contains the name of the current profile, and we can call variable_get()
    // to determine the profile.
    if (!isset($profile)) {
      $profile = variable_get('install_profile', 'default');
    }
    $directory = 'libraries';
    $searchdir = array();
    $config = conf_path();

    // The 'profiles' directory contains pristine collections of modules and
    // themes as organized by a distribution.  It is pristine in the same way
    // that /modules is pristine for core; users should avoid changing anything
    // there in favor of sites/all or sites/<domain> directories.
    if (file_exists("profiles/{$profile}/{$directory}")) {
      $searchdir[] = "profiles/{$profile}/{$directory}";
    }

    // Always search sites/all/*.
    $searchdir[] = 'sites/all/' . $directory;

    // Also search sites/<domain>/*.
    if (file_exists("{$config}/{$directory}")) {
      $searchdir[] = "{$config}/{$directory}";
    }

    // Retrieve list of directories.
    // @todo Core: Allow to scan for directories.
    $directories = array();
    $nomask = array(
      'CVS',
    );
    foreach ($searchdir as $dir) {
      if (is_dir($dir) && ($handle = opendir($dir))) {
        while (FALSE !== ($file = readdir($handle))) {
          if (!in_array($file, $nomask) && $file[0] != '.') {
            if (is_dir("{$dir}/{$file}")) {
              $directories[$file] = "{$dir}/{$file}";
            }
          }
        }
        closedir($handle);
      }
    }
  }
  return $directories;
}

/**
 * Return a list of directories by modules implementing wysiwyg_include_directory().
 *
 * @param $plugintype
 *   The type of a plugin; can be 'editors'.
 *
 * @return
 *   An array containing module names suffixed with '_' and their defined
 *   directory.
 *
 * @see wysiwyg_load_includes(), _wysiwyg_process_include()
 */
function wysiwyg_get_directories($plugintype) {
  $directories = array();
  foreach (module_implements('wysiwyg_include_directory') as $module) {
    $result = module_invoke($module, 'wysiwyg_include_directory', $plugintype);
    if (isset($result) && is_string($result)) {
      $directories[$module] = drupal_get_path('module', $module) . '/' . $result;
    }
  }
  return $directories;
}

/**
 * Create a placeholder structure for JavaScript callbacks.
 *
 * @param $name
 *  A string with the name of the callback, use 'object.subobject.method'
 *  syntax for methods in nested objects.
 * @param $context
 *  An optional string with the name of an object for overriding 'this' inside
 *  the function. Use 'object.subobject' syntax for nested objects. Defaults to
 *  the window object.
 *
 * @return
 *  An array with placeholder information for creating a JavaScript function
 *  reference on the client.
 */
function wysiwyg_wrap_js_callback($name, $context = NULL) {
  $obj = array(
    'drupalWysiwygType' => 'callback',
    'name' => $name,
  );
  if ($context) {
    $obj['context'] = $context;
  }
  return $obj;
}

/**
 * Create a placeholder structure for JavaScript RegExp objects.
 *
 * @param $regexp
 *  A JavaScript Regular Expression as a string, without / wrappers.
 * @param $modifiers
 *  An optional string with modifiers for the RegExp object.
 *
 * @return
 *  An array with placeholder information for creating a JavaScript RegExp
 *  object on the client.
 */
function wysiwyg_wrap_js_regexp($regexp, $modifiers = NULL) {
  $obj = array(
    'drupalWysiwygType' => 'regexp',
    'regexp' => $regexp,
  );
  if ($modifiers) {
    $obj['modifiers'] = $modifiers;
  }
  return $obj;
}

/**
 * Process a single hook implementation of a wysiwyg editor.
 *
 * @param $module
 *   The module that owns the hook.
 * @param $identifier
 *   Either the module or 'wysiwyg_' . $file->name
 * @param $hook
 *   The name of the hook being invoked.
 */
function _wysiwyg_process_include($module, $identifier, $path, $hook) {
  $function = $identifier . '_' . $hook;
  if (!function_exists($function)) {
    return NULL;
  }
  $result = $function();
  if (!isset($result) || !is_array($result)) {
    return NULL;
  }

  // Fill in defaults.
  foreach ($result as $editor => $properties) {
    $result[$editor]['module'] = $module;
    $result[$editor]['name'] = $editor;
    $result[$editor]['path'] = $path;
  }
  return $result;
}

/**
 * @} End of "defgroup wysiwyg_api".
 */
Functions

Name	Description
wysiwyg_add_editor_settings	Add editor settings for a given input format.
wysiwyg_add_plugin_settings	Add settings for external plugins.
wysiwyg_admin_profile_title	Display an editor profile title.
wysiwyg_file_download	Implements hook_file_download().
wysiwyg_form_alter	Implementation of hook_form_alter().
wysiwyg_get_all_editors	Compile a list holding all supported editors including installed editor version information.
wysiwyg_get_all_plugins	Invoke hook_wysiwyg_plugin() in all modules.
wysiwyg_get_css	Retrieve stylesheets for HTML/IFRAME-based editors.
wysiwyg_get_directories	Return a list of directories by modules implementing wysiwyg_include_directory().
wysiwyg_get_editor	Return library information for a given editor.
wysiwyg_get_editor_config	Return an array of initial editor settings for a Wysiwyg profile.
wysiwyg_get_editor_themes	Retrieve available themes for an editor.
wysiwyg_get_libraries	Return an array of library directories.
wysiwyg_get_path	Helper function to build paths to libraries.
wysiwyg_get_plugins	Return plugin metadata from the plugin registry.
wysiwyg_get_profile	Determine the profile to use for a given input format id.
wysiwyg_help	Implementation of hook_help().
wysiwyg_js_alter	Implementation of hook_js_alter().
wysiwyg_load_editor	Load an editor library and initialize basic Wysiwyg settings.
wysiwyg_load_includes	Load include files for wysiwyg implemented by all modules.
wysiwyg_menu	Implementation of hook_menu().
wysiwyg_process_form	Process a textarea for Wysiwyg Editor.
wysiwyg_profile_cache_clear	Clear all Wysiwyg profile caches.
wysiwyg_profile_delete	Remove a profile from the database.
wysiwyg_profile_load	Load profile for a given input format.
wysiwyg_profile_load_all	Load all profiles.
wysiwyg_theme	Implementation of hook_theme().
wysiwyg_ui_profile_cache_get	Specialized cache function to load a profile from the editing cache.
wysiwyg_ui_profile_cache_load	Specialized menu callback to load a profile and check its locked status.
wysiwyg_ui_profile_cache_set	Specialized cache function to add a profile to the editing cache.
wysiwyg_user	Implementation of hook_user().
wysiwyg_user_get_status
wysiwyg_wrap_js_callback	Create a placeholder structure for JavaScript callbacks.
wysiwyg_wrap_js_regexp	Create a placeholder structure for JavaScript RegExp objects.
_wysiwyg_process_include	Process a single hook implementation of a wysiwyg editor.
You are here

wysiwyg.module in Wysiwyg 6.2

File

Functions

API Navigation
