modules/translatable/translatable.module

<?php
// $Id: translatable.module,v 1.7 2008/09/12 17:01:11 smk Exp $

/**
 * @file
 * Core functions for #translatable support.
 * 
 * @see README.txt
 */

// Include database functions.
require_once drupal_get_path('module', 'translatable') .'/translatable.database.inc';
// Include custom drupal_get_form() implementation for Drupal 5 which allows to
// merge in translations.
require_once drupal_get_path('module', 'translatable') .'/includes/form.inc';
// Include menu translation functions.
require_once drupal_get_path('module', 'translatable') .'/includes/menu.inc';

// Load module components.
require_once drupal_get_path('module', 'translatable') .'/translatable.block.inc';
require_once drupal_get_path('module', 'translatable') .'/translatable.node.inc';
require_once drupal_get_path('module', 'translatable') .'/translatable.object.inc';
require_once drupal_get_path('module', 'translatable') .'/translatable.page-translations.inc';
require_once drupal_get_path('module', 'translatable') .'/includes/language.inc';

// Enable built-in support for certain contrib modules.
if (module_exists('views')) {
  include_once 'contrib/views.inc';
}
if (module_exists('category')) {
  include_once 'contrib/category.inc';
}

/**
 * Implementation of hook_perm().
 */
function translatable_perm() {
  return array('access translatable');
}

/**
 * Implementation of hook_menu() for adding translatable menu items.
 * 
 * Translates also all user menu items.
 */
function translatable_menu($may_cache) {
  $items = array();

  // Change locale based on methods configured in Translatable settings.
  translatable_change_uilocale();
  
  if ($may_cache) {
    $items = array_merge(translatable_node_menu($may_cache), translatable_object_menu($may_cache));
    $items[] = array(
      'path' => 'admin/settings/translatable',
      'title' => t('Translatable'),
      'description' => t('Configure multilingual support'),
      'callback' => 'drupal_get_form',
      'callback arguments' => 'translatable_settings_form',
      'access' => user_access('administer site configuration'),
      'type' => MENU_NORMAL_ITEM,
    );
  }
  else {
    $items = array_merge(translatable_node_menu($may_cache), translatable_object_menu($may_cache));
    // @todo Turn this into a cacheable item.
    $items[] = array(
      'path' => 'switchuilocale',
      'callback' => 'translatable_set_locale',
      'callback arguments' => array(arg(1), TRUE),
      'access' => TRUE,
      'type' => MENU_CALLBACK,
    );
    $items[] = array(
      'path' => 'switchadminlocale',
      'callback' => 'translatable_set_adminlocale',
      'access' => user_access('access translatable'),
      'type' => MENU_CALLBACK,
    );
  }
  
  return $items;
}

/**
 * Translatable module settings form.
 */
function translatable_settings_form() {
  translatable_language_negotiation_settings($form);

  $form['content_types'] = array(
    '#type' => 'fieldset',
    '#title' => t('Translation support'),
  );
  $form['content_types']['translatable_content_types'] = array(
    '#type' => 'checkboxes',
    '#title' => t('Translatable content types'),
    '#default_value' => translatable_content_type_enabled(),
    '#options' => node_get_types('names'),
    '#description' => t('Only enabled content types can be translated.'),
  );

  $form['translation'] = array(
    '#type' => 'fieldset',
    '#title' => t('Translation options'),
  );
  $form['translation']['translatable_default_content_any'] = array(
    '#type' => 'checkbox',
    '#title' => t("Create new contents in 'Any language'"),
    '#default_value' => variable_get('translatable_default_content_any', FALSE),
    '#description' => t('If this is enabled, the option "Any" is always pre-selected for new contents. If this is disabled, the current locale is pre-selected.'),
  );
  
  return system_settings_form($form);
}

/**
 * Inject translation languages into translation language block.
 * 
 * This is a tricky one:
 * To conditionally display a block to select the translation language, we
 * only generate the selection list on translation forms and inject it to
 * our block by invoking hook_block('view') afterwards.
 * 
 * @param string $form_id
 *   The id of the form the block is based on.
 * @param array $form
 *   The form the block is based on.
 *
 * @see translatable_block(), translatablenode_form_alter(), translatablevariable_form_alter()
 */
function translatable_adminlocale_formselect($form_id, $form) {
  static $languages;
  
  if (!isset($languages) && !empty($form)) {
    drupal_add_js(drupal_get_path('module', 'translatable') .'/jquery.block.js');
    $languages = theme('translatable_languages', 'translation', $form);
  }
  return $languages;
}

/**
 * Implementation of hook_form_alter().
 *
 * Provides proxy functionality for our module components.
 */
function translatable_form_alter($form_id, &$form) {
  translatable_node_form_alter($form_id, $form);
  translatable_object_form_alter($form_id, $form);
}

/**
 * Implementation of hook_user().
 */
function translatable_user($op, &$edit, &$account, $category = NULL) {
  global $user;
  
  switch ($op) {
    case 'after_update':
    case 'login':
      // Switch language after logging in or updating the user account.
      if ($user->uid == $account->uid) {
        $languages = translatable_available_languages();
        if (isset($languages[$account->language])) {
          translatable_set_locale($account->language);
        }
      }
      break;

    case 'load':
      // Apply default setting for switch_adminlocale if not defined.
      if (empty($account->switch_adminlocale)) {
        $account->switch_adminlocale = 0;
      }
      break;

    case 'form':
      $languages = translatable_available_languages();
      if (count($languages) < 2 || !user_access('access translatable') || $category != 'account') {
        return;
      }
      $form['locale']['switch_adminlocale'] = array(
        '#type' => 'radios',
        '#title' => t('Translation language'),
        '#options' => array(t('Always equivalent to interface language'), t('Separate translation language')),
        '#default_value' => $account->switch_adminlocale,
        '#weight' => 1,
        '#description' => t('Please choose, whether the translation language should always match the interface language or if it should be kept separated, when switching one of both languages.'),
      );
      return $form;
  }
}

/**
 * Check whether a specific content type is translation-enabled, or return
 * a list of translation-enabled content types.
 *
 * @param $type
 *   Content type to check, can be omitted.
 *
 * @return
 *   Either a boolean result, or an array of enabled content types.
 */
function translatable_content_type_enabled($type = NULL) {
  static $enabled_types;
  if (!isset($enabled_types)) {
    $enabled_types = variable_get('translatable_content_types', drupal_map_assoc(array('page', 'story')));
  }
  return isset($type) ? !empty($enabled_types[$type]) : $enabled_types;
}

/**
 * Returns a list of translatable fields for a given form id.
 *
 * @param array $form
 *   The form to search for #translatable fields.
 */
function translatable_get_translatable_fields($form) {
  $fields = array();
  if (is_string($form)) {
    $args = func_get_args();
    $form = call_user_func_array('translatable_retrieve_form', $args);
  }
  return _translatable_get_translatable_fields($fields, $form);
}

function _translatable_get_translatable_fields(&$fields, $element) {
  foreach (element_children($element) as $key) {
    $item = &$element[$key];

    // Catch all fields that are not explicitly set to FALSE.
    if (!isset($item['#translatable']) || $item['#translatable'] !== FALSE) {
      // Check whether this item is basically translatable.
      if (_translatable_is_translatable_field($item)) {
        // If #parents is set, the last element will hold the form value after
        // submit, otherwise use the element's key.
        $field = isset($item['#parents']) ? end($item['#parents']) : $key;
        $fields[$field] = $field;
      }
    }
    if ($item['#translatable'] !== FALSE && element_children($item)) {
      _translatable_get_translatable_fields($fields, $item);
    }
  }
  return $fields;
}

function _translatable_is_translatable_field($element) {
  return isset($element['#type']) && !in_array($element['#type'], array('fieldset', 'button', 'form', 'hidden', 'markup', 'item', 'submit', 'value', 'token'));
}

/**
 * Filter out untranslatable elements of a given form.
 *
 * @param &$form
 *   The form tree whose untranslatable fields will be filtered out.
 * @param $parent_form
 *   The parent form tree to synchronize the form with.
 */
function translatable_filter_form(&$form, $parent_form) {
  _translatable_filter_form($form, $parent_form, $form);
}

/**
 * Filter out untranslatable elements of a given form.
 *
 * If #translatable is set and TRUE, we copy the default value from the parent
 * form and allow translation.
 * If set to FALSE, we copy the default value from the parent form and make
 * the field inaccessible.
 * If #translatable is not set at all, we leave a field as is.  For new node
 * forms, this means that default values for new nodes are applied.
 *
 * @param &$form
 *   The form tree whose untranslatable fields will be filtered out; parsed
 *   recursively.
 * @param $parent_form
 *   The parent form tree to synchronize $form with.  This is either an empty
 *   form for new nodes, or the source form for existing nodes and generic
 *   translation objects.
 * @param &$form
 *   Equals first parameter (form tree), but holds always the complete form;
 *   needed to define untranslatable fields and check whether the form is built
 *   to create a new translation (#is_new).
 * @param $parents
 *   An array of parent form item keys we have recursed into.
 * @param $submit_parents
 *   An array of form item keys that build up the parents of a form item in the
 *   resulting $form_values array (@see form_builder()).
 *
 * @return
 *   Whether to hide the parent element after returning from recursion.
 */
function _translatable_filter_form(&$element, $parent_form, &$form, $parents = array(), $submit_parents = array()) {
  $hide_parent = TRUE;

  foreach(element_children($element) as $key) {
    $item = &$element[$key];

    // To access each form item in both forms, we need all parents of an item.
    // @see translatable_get_form_value(), translatable_set_form_value()
    $keys = $parents;
    $keys[] = $key;

    // Handle #tree property for untranslatable fields.
    if (isset($item['#tree']) && $item['#tree']) {
      // Start a new parents tree for $form_values.
      $submit_keys = array($key);
    }
    else if (!empty($submit_parents)) {
      // Append to an existing parents tree for $form_values.
      $submit_keys = $submit_parents;
      $submit_keys[] = $key;
    }
    else {
      // No parent item had #tree assigned; store only current key.
      $submit_keys = array($key);
    }

    // Check #translatable property. 
    if (isset($item['#translatable'])) {
      if ($item['#translatable']) {
        $hide_field = FALSE;
        $hide_parent = FALSE;
      }
      else {
        $hide_field = TRUE;
        // Mark untranslatable fields for synchronization in our submit callback.
        $form['#untranslatable'][] = $submit_keys;
      }
      // If #translatable is TRUE or FALSE, we need to sync all contents.
      // Synchronize field _after_ checking #translatable property;
      // otherwise we would overwrite the property.
      if (isset($form['#is_new']) || $item['#translatable'] === FALSE) {
        translatable_set_form_value($form, $keys, translatable_get_form_value($parent_form, $keys));
      }
    }
    else {
      $item['#translatable'] = '';
      $hide_field = FALSE;
      $hide_parent = FALSE;
    }

    // Display source content for translatable fields.
    if (!$hide_field && $item['#translatable'] !== FALSE && _translatable_is_translatable_field($item) && $key != 'translatable_node_any') {
      $prefix = '';
      if (in_array($item['#type'], array('select', 'radios', 'checkboxes'))) {
        $default = translatable_get_form_value($parent_form, $keys, '#default_value');
        $keys[] = '#options';
        if (is_array($default)) {
          $prefix = array();
          foreach ($default as $option_value) {
            $prefix[] = translatable_get_form_value($parent_form, $keys, $option_value);
          }
          $prefix = implode(', ', $prefix);
        }
        else {
          $prefix = translatable_get_form_value($parent_form, $keys, $default);
        }
      }
      else if ($item['#type'] == 'checkbox') {
        $prefix = translatable_get_form_value($parent_form, $keys, '#default_value') ? t('Enabled') : t('Disabled');
      }
      else if ($item['#type'] == 'radio') {
        $keys[] = translatable_get_form_value($parent_form, $keys, '#default_value');
        $prefix = translatable_get_form_value($parent_form, $keys, '#title');
      }
      else {
        $prefix = translatable_get_form_value($parent_form, $keys, '#default_value');
      }
      if ($prefix) {
        if (!isset($item['#prefix'])) {
          $item['#prefix'] = '';
        }
        $item['#prefix'] .= '<div class="form-item translatable-source"><label>'. t('Source') .':</label>'. filter_xss_admin($prefix) .'</div>';
      }
    }

    // Process child elements of current element
    if (!$hide_field) {
      $has_children = element_children($item);
      if ($has_children) {
        $element_parents = $parents;
        $element_parents[] = $key;
        $element_submit_keys = $submit_keys;
        if (!_translatable_filter_form($item, $parent_form, $form, $element_parents, $element_submit_keys)) {
          // Do not hide this field if a child needs to be displayed.
          $hide_field = FALSE;
          $hide_parent = FALSE;
        }
      }
    }

    // Ensure this form element is not a required (in terms of FAPI functionality)
    if ($hide_field && _translatable_is_hideable_field($item)) {
      $item['#access'] = FALSE;
    }
  }

  return $hide_parent;
}

/**
 * Retrieve a form item or property of a form item.
 *
 * @param array $form
 *   The form to recurse into.
 * @param array $keys
 *   An array of parent keys of the form item to retrieve, including the item
 *   itself.  This works similar to FAPI's #parents property and form_set_value()
 *   function.
 * @param string $property
 *   An optional form item property to retrieve.
 *
 * @return
 *   A form item or a form item property.
 *
 * @see translatable_set_form_value(), _translatable_filter_form()
 */
function translatable_get_form_value($form, $keys, $property = NULL) {
  $parent = array_shift($keys);
  if (empty($keys)) {
    if (isset($property)) {
      return isset($form[$parent][$property]) ? $form[$parent][$property] : NULL;
    }
    else {
      return $form[$parent];
    }
  }
  else {
    return isset($form[$parent]) ? translatable_get_form_value($form[$parent], $keys, $property) : NULL;
  }
}

/**
 * Replace a form item or form item property with a given value.
 *
 * @param array $form
 *   The form to recurse into.
 * @param array $keys
 *   An array of parent keys of a form item, including the form item itself,
 *   optionally including a form item property.
 * @param $value
 *   A value to assign.
 *
 * @return
 *   Nothing. $form is altered by reference.
 *
 * @see translatable_get_form_value()
 */
function translatable_set_form_value(&$form, $keys, $value) {
  $parent = array_shift($keys);
  if (empty($keys)) {
    $form[$parent] = $value;
  }
  else {
    if (!isset($form[$parent])) {
      $form[$parent] = array();
    }
    translatable_set_form_value($form[$parent], $keys, $value);
  }
}

/**
 * Reset all untranslatable form values to their original values.
 *
 * @todo This is painful in Drupal 5, so we might leave it as is.
 */
function translatable_filter_form_submit($form_id, &$form_values, $form) {
//  foreach (element_children($untranslatable) as $element) {
//    form_set_value($untranslatable[$element], $untranslatable[$element]['#value']);
//  }
}

/**
 * Determine whether a untranslatable field should be hidden.
 *
 * @param $element
 *    A form element.
 */
function _translatable_is_hideable_field($element) {
  if (isset($element['#type'])) {
    // If #type is set, ensure that this element is not required by FAPI.
    if (!in_array($element['#type'], array('button', 'form', 'hidden', 'item', 'submit', 'value', 'token'))) {
      return TRUE;
    }
    else {
      return FALSE;
    }
  }
  // If no #type is set, assume it's hideable.
  return TRUE;
}

/**
 * Recursively replace field values with translated values.
 *
 * Used for translation objects only.
 *
 * @param &$form
 *   The form tree to process.
 * @param $items
 *   The field translations as returned by translatable_find().
 *
 * @see translatable_find(), translatable.object.inc
 */
function translatable_translate_form_values(&$form, $items) {
  if ($items) {
    $fields = array();
    foreach ($items as $item) {
      $fields[$item['object_field']] = $item['translation'];
    }
    _translatable_translate_form_values($form, $fields);
  }
}

function _translatable_translate_form_values(&$form, $fields) {
  foreach(element_children($form) as $key) {
    $item = &$form[$key];
    // If #parents is set, it overrides $key as the element's form value name.
    $field = isset($item['#parents']) ? end($item['#parents']) : $key;
    if (isset($fields[$field]) && _translatable_is_translatable_field($item)) {
      $item['#default_value'] = $fields[$field];
    }
    _translatable_translate_form_values($item, $fields);
  }
}

/**
 * Get the key to use for cache system by adding current locale.
 *
 * @param $key
 *   The original key.
 *
 * @return
 *   The key for cache.
 *
 * @todo Unused.
 */
function cache_key($key = NULL) {
  if ($key == NULL) {
    return NULL;
  }
  if (!$key) {
    return $key;
  }
  $key = $key .'-'. translatable_get_locale() .'-'. translatable_get_enabled_locales(false);
  return $key;
}

/**
 * Translate an object.
 *
 * @param $object_name
 *   The object name (typically the name of the database table).
 * @param $object_key
 *   The object key (typically the id of the database record).
 * @param $object
 *   The object to translate.
 *
 * @return
 *   The translated object.
 * @see translatable_get_object_definition(), translatable.database.inc
 */
function tobject($object_name, $object_key, $object) {
  $items = translatable_find('translation', "object_name='$object_name' AND object_key='$object_key' AND locale='". translatable_get_locale() ."'");
  
  foreach ($items as $key => $item) {
    if (!empty($item['translation'])) {
      $object_field = $item['object_field'];
      $object->$object_field = $item['translation'];
    }
  }
  return $object;
}

// Rewrite of some core functions

/**
 * Translate a string and substitute the arguments.
 *
 * @param $string
 *   The string to translate.
 * @param $args
 *   Array of additional arguments to substitute.
 * @param $locale
 *   The locale to use for the translation.
 *
 * @return
 *   The translated string.
 */
function translatable_t($string, $args = 0, $locale = '') {
  if ($locale == '') {
    $locale = $GLOBALS['locale'];
  }
  
  if ($locale != 'en') {
    $string = translatable_locale($string, $locale);
  }
  
  if (!$args) {
    return $string;
  }
  else {
    return strtr($string, $args);
  }
}

/**
 * Translate a string.
 *
 * @param string $string
 *   A string to translate.
 * @param string $locale
 *   A locale to use for the translation.
 *
 * @return
 *   The translated string.
 */
function translatable_locale($string, $locale) {
  static $locale_t;
  
  // Store database cached translations in a static var.
  $cache = cache_get("locale:$locale");
  
  if ($cache == 0) {
    locale_refresh_cache();
    $cache = cache_get("locale:$locale");
  }
  $locale_t = unserialize($cache->data);
  
  if (isset($locale_t[$string])) {
    // We have the translation cached (if it is TRUE, then there is no
    // translation, so there is no point in checking the database).
    $string = ($locale_t[$string] === TRUE ? $string : $locale_t[$string]);
  }
  else {
    // We do not have this translation cached, so get it from the DB.
    $result = db_query("SELECT s.lid, t.translation FROM {locales_source} s INNER JOIN {locales_target} t ON s.lid = t.lid WHERE s.source = '%s' AND t.locale = '%s'", $string, $locale);
    if ($trans = db_fetch_object($result)) {
      // Translation found
      if (!empty($trans->translation)) {
        $locale_t[$string] = $trans->translation;
        $string = $trans->translation;
      }
    }
    else {
      // Either we have no such source string, or no translation
      $result = db_query("SELECT lid, source FROM {locales_source} WHERE source = '%s'", $string);
      if ($obj = db_fetch_object($result)) {
        // We have no such translation
        if ($locale) {
          db_query("INSERT INTO {locales_target} (lid, locale, translation) VALUES (%d, '%s', '')", $obj->lid, $locale);
        }
      }
      else {
        // We have no such source string
        db_query("INSERT INTO {locales_source} (location, source) VALUES ('%s', '%s')", request_uri(), $string);
        if ($locale) {
          $lid = db_fetch_object(db_query("SELECT lid FROM {locales_source} WHERE source = '%s'", $string));
          db_query("INSERT INTO {locales_target} (lid, locale, translation) VALUES (%d, '%s', '')", $lid->lid, $locale);
        }
      }
      // Clear locale cache in DB
      cache_clear_all("locale:$locale");
    }
  }
  
  return $string;
}

/**
 * Provides generic db_rewrite_sql support for third party support modules.
 *
 * Invokes hook_translatable_rewrite_sql() for all activated support modules,
 * and expects a boolean result whether the current query should be rewritten
 * using the current $primary_table and $primary_field values.
 *
 * @see db_rewrite_sql(), category_translatable_rewrite_sql()
 */
function translatable_db_rewrite_sql($query, $primary_table, $primary_field, $args = array()) {
  $sql = array();
  
  $applytranslatable = ($primary_table == 'n') && !preg_match('/'. $primary_table .'\.nid\s*=\s*\'?(%d|\d+)\'?/', $query);
  
  if (module_exists('views')) {
    $applytranslatable = $applytranslatable || ($primary_table == 'node');
    // Don't rewrite if the view filters by language on its own.
    if ($applytranslatable && preg_match('/\bnode_translatable\b/', $query)) {
      $applytranslatable = FALSE;
    }
  }
  
  foreach (module_implements('translatable_rewrite_sql') as $external) {
    $function = $external .'_translatable_rewrite_sql';
    if ($function($query, $primary_table, $primary_field, $args)) {
      $applytranslatable = TRUE;
    }
  }

  if ($applytranslatable) {
    // Validate that the content type is enabled for translation.
    if (preg_match('/'. $primary_table .'\.type\s*=\s*\'([^\']+)\'/', $query, $matches)) {
      // @todo Missing ! here?
      if (translatable_content_type_enabled($matches[1])) {
        $applytranslatable = FALSE;
      }
    }
  }
  
  if ($applytranslatable) {
    // When adding or editing a node we use the current locale.
    // @doc Why? And what about the translation page (node/%/edit/translation)?
    if (arg(0) == 'node' && (arg(1) == 'add' || arg(2) == 'edit')) {
      $locales = "'". translatable_get_adminlocale() ."'";
    }
    else {
      $locales = translatable_get_enabled_locales();
    }
    $sql['join'] = 'LEFT JOIN {node_translatable} translatable ON translatable.nid = '. $primary_table .'.'. $primary_field;
    $sql['where'] = 'translatable.language IN ('. $locales .') OR translatable.any = 1';
  }

  return $sql;
}

/**
 * Create the HTML for a language flag.
 * 
 * @param $locale
 *   The ISO locale of the flag.
 * @param $language
 *   The language name, used for alt and title.
 * @param $block
 *   The name of the block in which the flag is displayed.
 *
 * @return
 *   HTML for a flag in the given language.
 */
function theme_translatable_flag($locale, $language, $block = 'ui') {
  $path = variable_get('translatable_block_'. $block .'_flagspath', drupal_get_path('module', 'translatable') .'/flags/*.png');
  $src = str_replace('*', $locale, $path);
  $attribs = array('class' => 'translatable-flag');
  return theme('image', $src, $language, $language, $attribs);
}
