Club Drupal

    }

    if (!empty($items) && isset($items[$delta]['value'])) {

    }

  }

  return ctools_context_create_empty('entity:field_collection_item', NULL);

 * @see template_process()

 */

?>

  <div class="content"<?php print $content_attributes; ?>>

    <?php

      print render($content);

    ->execute();

}

/**

 * Act on a field collection item that is being assembled before rendering.

 *

  public function translatedInstanceLabel($langcode = NULL) {

    if ($info = $this->instanceInfo()) {

      if (module_exists('i18n_field')) {

      }

      return $info['label'];

    }

          $query->entityCondition('entity_type', $entity_type);

          $query->entityCondition('entity_id', $hostEntity->{$key});

          $query->entityCondition('bundle', $bundle);

          }

        }

        $query->addTag('DANGEROUS_ACCESS_CHECK_OPT_OUT');

          ->fields(array('archived' => 1, 'revision_id' => $row['revision_id']))

          ->condition('item_id', $this->item_id)

          ->execute();

        entity_get_controller('field_collection_item')->resetCache(array($this->item_id));

        entity_revision_delete('field_collection_item', $this->revision_id);

      }

   */

  public function __sleep() {

    $vars = get_object_vars($this);

    // Also do not serialize the host entity, but only if it has already an id.

    if ($this->hostEntity && ($this->hostEntityId || $this->hostEntityRevisionId)) {

      unset($vars['hostEntity']);

configure = admin/structure/field-collections

package = Fields

core = "7.x"

project = "field_collection"

      foreach ($bundles as $bundle => $fields) {

        if (array_intersect_key($fields, $field_collection_fields)) {

          $args = array('@type' => $entity_types[$entity_type]['label']);

            'label' => t('Host entity (@type)', $args),

            'type' => $entity_type,

            'description' => t('The @type containing the field collection field (empty if this field collection is attached to an item of a different type).', $args),

    ->fields('t', array("{$sandbox['field_name']}_revision_id"))

    ->range($sandbox['current_field_collection_item'], $items_per_pass)

    ->groupBy("t.{$sandbox['field_name']}_revision_id");

  $vids = $query->execute()->fetchCol();

  // Each revision ID that occurs more than once.

        ->condition('delta', $row_to_replace->delta)

        ->condition('language', $row_to_replace->language)

        ->execute();

    }

    foreach ($modern_revisions as $each_modern_revision) {

      $new_revision_id = _field_collection_update_7009_new_revision($field_collection_item_id, $each_modern_revision, $sandbox['inner_fields'], $sandbox['field_name']);

        ->execute();

      if ($field_collection_item_current_revision == $each_modern_revision->{"{$sandbox['field_name']}_revision_id"}) {

        // Update the current field collection item data in its host.

        db_update("field_data_{$sandbox['field_name']}")

          ->condition('entity_type', $each_modern_revision->entity_type)

          ->execute();

      }

   */

  protected $hostEntityType;

    return array(

      'item_id' => array(

        'type' => 'int',

 * Implements migrate hook_migrate_api().

 */

function field_collection_migrate_api() {

    'api' => 2,

  );

}

      if (!isset($field['type']['#title'])) {

        continue;

      }

        $form['fields'][$fieldname]['field_name']['#markup'] =

          l($form['fields'][$fieldname]['field_name']['#markup'], 'admin/structure/field-collections/' . str_replace('_', '-', $fieldname) . '/fields');

      }

 * Implements hook_ctools_plugin_directory().

 */

function field_collection_ctools_plugin_directory($module, $plugin) {

    return 'ctools/' . $plugin;

  }

}

 */

function field_collection_field_name_load($arg) {

  $field_name = strtr($arg, array('-' => '_'));

    return $field_name;

  }

}

  // Add menu paths for viewing/editing/deleting field collection items.

  foreach (field_info_fields() as $field) {

      $path = field_collection_field_get_path($field);

      $count = substr_count($path, '/') + 1;

}

/**

 */

function field_collection_menu_alter(&$items) {

  if (isset($items['admin/structure/field-collections/%field_collection_field_name/fields']) && module_exists('field_ui')) {

  // We do not support editing field collection revisions that are not used at

  // the hosts default revision as saving the host might result in a new default

  // revision.

    return FALSE;

  }

  if (user_access('edit field collections', $account)) {

  if (!isset($item)) {

    return FALSE;

  }

  // Access is determined by the entity and field containing the reference.

  $field = field_info_field($item->field_name);

  $hostEntity = $item->hostEntity() !== FALSE ? $item->hostEntity() : NULL;

  return $entity_access && field_access($op, $field, $item->hostEntityType(), $hostEntity, $account);

}

        'value' => $entity->item_id,

        'revision_id' => $entity->revision_id,

      );

    }

  }

}

        if (!empty($host_entity->revision) || !empty($host_entity->is_new_revision)) {

          $entity->revision = TRUE;

          // Without this cache clear entity_revision_is_default will

          if (!isset($cleared_host_entity_cache)) {

            list($entity_id) = entity_extract_ids($host_entity_type, $host_entity);

            entity_get_controller($host_entity_type)->resetCache(array($entity_id));

          'value' => $entity->item_id,

          'revision_id' => $entity->revision_id,

        );

      }

    }

        ->fields(array('archived' => 1))

        ->condition('item_id', $ids, 'IN')

        ->execute();

    }

    else {

      // Load items from the original entity from all languages checking which

      foreach (field_collection_item_load_multiple($items_to_remove) as $un_item) {

        $un_item->updateHostEntity($host_entity, $host_entity_type);

        $un_item->deleteRevision(TRUE);

      }

    }

  }

          $hostEntity->field_collection_deleting = TRUE;

        }

      }

    }

    entity_delete_multiple('field_collection_item', $ids);

}

/**

 */

function field_collection_item_is_empty(FieldCollectionItemEntity $item) {

  $instances = field_info_instances('field_collection_item', $item->field_name);

    // Boolean fields as those are always considered non-empty, thus their

    // information is not useful and can be skipped by default.

      continue;

    }

 */

function _field_collection_field_is_not_boolean($instance) {

  $field = field_info_field($instance['field_name']);

}

/**

  $settings = $display['settings'];

  $elements = array();

    $elements['add'] = array(

      '#type' => 'textfield',

      '#title' => t('Add link title'),

    );

  }

  if ($display['type'] !== 'field_collection_list') {

    $entity_type = entity_get_info('field_collection_item');

  static $local_entity_cache = array();

  $fc_ids = array();

  // Collect every possible term attached to any of the fieldable entities.

  foreach ($entities as $id => $entity) {

    foreach ($items[$id] as $delta => $item) {

      if (isset($local_entity_cache[$item['value']])) {

        $items[$id][$delta]['field_collection'] = $local_entity_cache[$item['value']];

        continue;

  if ($fc_ids) {

    $new_entities = array();

    $terms = field_collection_item_load_multiple($fc_ids);

    // Iterate through the fieldable entities again to attach the loaded

    // field collection data.

      $rekey = FALSE;

      foreach ($items[$id] as $delta => $item) {

        if (isset($terms[$item['value']])) {

          // Replace the instance value with the term data.

          $e = $terms[$item['value']];

          $local_entity_cache[$item['value']] = $e;

          $items[$id][$delta]['field_collection'] = $e;

            if (isset($e->$field_name)) {

              $field_data = $e->$field_name;

              if (isset($field_data[$langcode])) {

                $new_entities[$e->item_id] = $e->item_id;

              }

            }

          }

        }

        else {

          $rekey = TRUE;

        }

      }

      if ($rekey) {

        // Rekey the items array.

      }

    }

  }

}

          $output = l($field_collection->label(), $field_collection->path());

          $links = array();

          foreach (field_collection_get_operations($settings) as $op => $label) {

              $title = entity_i18n_string("field:{$field['field_name']}:{$instance['bundle']}:setting_$op", $settings[$op]);

              $links[] = l($title, $field_collection->path() . '/' . $op, array('query' => drupal_get_destination()));

            }

          );

          $links['#attributes']['class'][] = 'field-collection-view-links';

          foreach (field_collection_get_operations($settings) as $op => $label) {

              $links['#links'][$op] = array(

                'title' => entity_i18n_string("field:{$field['field_name']}:{$instance['bundle']}:setting_$op", $settings[$op]),

                'href' => $field_collection->path() . '/' . $op,

      $path = field_collection_field_get_path($field);

      list($id) = entity_extract_ids($entity_type, $entity);

      $element['#suffix'] = '';

        $element['#suffix'] .= '<div class="description field-collection-description">' . field_filter_xss($instance['description']) . '</div>';

      }

      $title = entity_i18n_string("field:{$field['field_name']}:{$instance['bundle']}:setting_add", $settings['add']);

      $add_path = $path . '/add/' . $entity_type . '/' . $id;

    }

  }

  // If there is no add link, add a special class to the last item.

        if (!isset($field_collection_item->entity_translation_handler_id)) {

          list($id, $revision_id) = entity_extract_ids('field_collection_item', $field_collection_item);

          $revision_id = isset($revision_id) ? $revision_id : 0;

        }

        $element['#field_collection_item'] = $field_collection_item;

        field_collection_add_child_translation_handler($element);

        }

      }

      field_form_set_state($field_parents, $field_name, $language, $form_state, $field_state);

      // Set the language to to parent entity language, because

      // field_content_languages() will always set $language to LANGUAGE_NONE.

        $item_id = isset($items[$delta]['value']) ? $items[$delta]['value'] : NULL;

        $revision_id = isset($items[$delta]['revision_id']) ? $items[$delta]['revision_id'] : NULL;

        $element['label'] = array();

        if ($item_id) {

          $item = field_collection_item_load($item_id);

          $element['label']['#markup'] = $item ? $item->label() : $item_id;

        }

        $element['value'] = array(

          '#type' => 'hidden',

          '#default_value' => $item_id,

          '#title' => check_plain($instance['label']),

          '#required' => FALSE,

          '#description' => field_filter_xss($instance['description']),

        );

      }

}

/**

 */

function field_collection_entity_translation_source_field_state_alter(&$field_state) {

  if (isset($field_state['entity'])) {

        && field_access('edit', $field, $entity_type)) {

      $element_langcode = $form[$field_name]['#language'];

        $form[$field_name][$element_langcode]['#max_delta']--;

      }

      // Remove blank form elements and force user to explicitly add a field

      // collection if both 'hide_initial_item' and 'hide_blank_items' are TRUE.

      if ($field['settings']['hide_initial_item']

        && $field['settings']['hide_blank_items']

        && $form[$field_name][$element_langcode][0]['#entity'] instanceof FieldCollectionItemEntity

        && field_collection_item_is_empty($form[$field_name][$element_langcode][0]['#entity'])) {

        _field_collection_process_children_attached($form[$field_name][$element_langcode][0]);

      }

    }

  }

  // Replace the deleted entity with an empty one. This helps to ensure that

  // trash bin.

  $count = count($field_state['entity']);

  $field_state['entity'][$count] = entity_create('field_collection_item', array('field_name' => $field_name));

  // the 3, the order of the two 3s now is undefined and may not match what

  // the user had selected.

  $input = drupal_array_get_nested_value($form_state['input'], $values_address);

  uasort($input, '_field_sort_items_helper');

  // Reweight everything in the correct order.

        $is_empty_multiple = $is_countable && (!count($elements['#value']));

        $is_empty_string = (is_string($elements['#value']) && drupal_strlen(trim($elements['#value'])) == 0);

        $is_empty_value = ($elements['#value'] === 0);

        // Validate fields with hook_field_is_empty. This will handle cases when

        // file entity passes validation when it shouldn't.

 * Implements hook_field_create_field().

 */

function field_collection_field_create_field($field) {

    field_attach_create_bundle('field_collection_item', $field['field_name']);

    // Clear caches.

 * Implements hook_field_delete_field().

 */

function field_collection_field_delete_field($field) {

    // Notify field.module that field collection was deleted.

    field_attach_delete_bundle('field_collection_item', $field['field_name']);

 * Implements hook_i18n_string_list_{textgroup}_alter().

 */

function field_collection_i18n_string_list_field_alter(&$properties, $type, $instance) {

    $field = field_info_field($instance['field_name']);

      foreach ($instance['display'] as $view_mode => $display) {

          $properties['field'][$instance['field_name']][$instance['bundle']]['setting_edit'] = array(

            'title' => t('Edit link title'),

  if (!function_exists('field_instance_features_export_options')) {

    // Add the fields of the field collection entity to the pipe.

    foreach ($data as $identifier) {

        $fields = field_info_instances('field_collection_item', $field['field_config']['field_name']);

        foreach ($fields as $name => $field) {

          $pipe['field'][] = "{$field['entity_type']}-{$field['bundle']}-{$field['field_name']}";

function field_collection_features_pipe_field_instance_alter(&$pipe, $data, $export) {

  // Add the fields of the field collection entity to the pipe.

  foreach ($data as $identifier) {

      $fields = field_info_instances('field_collection_item', $field['field_config']['field_name']);

      foreach ($fields as $name => $field) {

        $pipe['field_instance'][] = "{$field['entity_type']}-{$field['bundle']}-{$field['field_name']}";

 */

function field_collection_item_get_specific_type_host_entity($item, array $options, $name) {

  // These properties' machine names have the form "host_entity_TYPE".

    return NULL;

  }

  return $item->hostEntityType() === substr($name, 12) ? $item->hostEntity() : NULL;

      $field_name = $instance['field_name'];

      $field = field_info_field($field_name);

        $field_langcode = field_is_translatable($entity_type, $field) ? $langcode : LANGUAGE_NONE;

        if (!empty($entity->{$field_name}[$field_langcode])) {

}

/**

 */

function field_collection_entity_translation_insert($entity_type, $entity, $translation, $values = array()) {

  if (!empty($values)) {

    foreach ($values as $field_name => $value) {

      $field = field_info_field($field_name);

        $language = $translation['language'];

        $source_language = $translation['source'];

        if (!empty($value[$language])) {

          $source_items = !empty($entity->{$field_name}[$source_language]) ? field_collection_field_item_to_ids($entity->{$field_name}[$source_language]) : array();

          foreach ($value[$language] as $delta => $field_value) {

            if (!isset($field_value['entity'])

              && ($fc_entity = field_collection_field_get_entity($field_value))

              $new_fc_entity = clone $fc_entity;

              $new_fc_entity->item_id = NULL;

              $new_fc_entity->revision_id = NULL;

              $new_fc_entity->is_new = TRUE;

              $entity->{$field_name}[$language][$delta]['entity'] = $new_fc_entity;

            }

          }

/**

 */

function field_collection_feeds_processor_targets_alter(&$targets, $entity_type, $bundle_name) {

  foreach (field_info_instances($entity_type, $bundle_name) as $name => $instance) {

    $info = field_info_field($name);

      $sub_type = 'field_collection_item';

      $new_targets = module_invoke_all('feeds_processor_targets', $sub_type, $info['field_name']);

    while (isset($value[$delta])) {

      // Zero out.

      // FC is already set on host entity.

      if (isset($field[LANGUAGE_NONE][$delta]['entity'])) {

        $field_collection_item = field_collection_item_load($field[LANGUAGE_NONE][$delta]['value']);

        // Zero out field so that we don't just keep accumulating values.

      }

      // Host entity does not have any attached FCs yet.

      $config = $source->importer()->getConfig();

      if (!empty($config['processor']['config']['mappings'])) {

        foreach ($config['processor']['config']['mappings'] as $mapping) {

            $sub_mapping = $mapping;

            $sub_mapping['target'] = $sub_target;

            // Needs language or feeds mappers shout php notices.

      if (isset($_sub_targets[$sub_target]['callback']) && function_exists($_sub_targets[$sub_target]['callback'])) {

        $callback = $_sub_targets[$sub_target]['callback'];

        if (!is_array($value[$delta])) {

          $value[$delta] = array($value[$delta]);

        }

        }

        // HiJack the file callback so we can make it work.

          $callback = 'field_collection_file_feeds_set_target';

        }

      watchdog('feeds', check_plain($e->getMessage()));

    }

    if ($file) {

      if ($info['cardinality'] == 1) {

        break;

      }

}

/**

 * Implementation of hook_feeds_presave().

 * Invoked before a feed item is saved.

 *

 * @param FeedsSource $source

        $info = field_info_field($fc_name);

        // If the field is not a field collection, skip it.

          continue;

        }

    }

  }

}

 */

function field_collection_item_delete_confirm_submit($form, &$form_state) {

  $field_collection_item = $form_state['field_collection_item'];

  drupal_set_message(t('%label has been deleted.', array('%label' => drupal_ucfirst($field_collection_item->label()))));

  $form_state['redirect'] = '<front>';

}

  $langcode = !empty($field['translatable']) ? entity_language($entity_type, $entity) : LANGUAGE_NONE;

  if (!($field['cardinality'] == FIELD_CARDINALITY_UNLIMITED || !isset($entity->{$field_name}[$langcode]) || count($entity->{$field_name}[$langcode]) < $field['cardinality'])) {

  }

  $field_collection_item = entity_create('field_collection_item', array('field_name' => $field_name));

  $field_collection_item->setHostEntity($entity_type, $entity, $langcode, FALSE);

  $label = $field_collection_item->translatedInstanceLabel();

  drupal_set_title($title);

  // Make sure the current user has access to create a field collection item.

      'field_name' => $this->field_name,

      'entity_type' => 'node',

      'bundle' => 'article',

      'settings' => array(),

      'widget' => array(

        'type' => 'hidden',

    $this->drupalGet($path);

    $this->assertText(t('Test text field'), 'Add form is shown.');

    $this->drupalPost($path, $edit, t('Save'));

    $this->assertText(t('The changes have been saved.'), 'Field collection saved.');

    $this->assertText($edit['field_text[und][0][value]'], 'Added field value is shown.');

    $this->drupalPost('field-collection/field-test-collection/1/edit', $edit, t('Save'));

    $this->assertText(t('The changes have been saved.'), 'Field collection saved.');

    $this->assertText($edit['field_text[und][0][value]'], 'Field collection has been edited.');

    // Make sure adding doesn't work any more as we have restricted cardinality

    // to 1.

    $this->drupalGet($path);

    $this->drupalPost('field-collection/field-test-collection/1/delete', array(), t('Delete'));

    $this->drupalGet($path);

      'field_name' => $this->field_name,

      'entity_type' => 'node',

      'bundle' => 'article',

      'settings' => array(),

      'widget' => array(

        'type' => 'hidden',

      'field_name' => $this->field_name,

      'entity_type' => 'node',

      'bundle' => 'article',

      'settings' => array(),

      'widget' => array(

        'type' => 'field_collection_embed',

   */

  public function testContentTranslation() {

    // Create "Article" content.

    $edit['language'] = 'en';

    $field_collection_name = 'field_test_collection[' . LANGUAGE_NONE . '][0][field_text][' . LANGUAGE_NONE . '][0][value]';

    $this->drupalPost('node/add/article', $edit, t('Save'));

    $this->assertRaw(t('Article %title has been created.', array('%title' => $edit['title'])), 'Article created.');

      'field_name' => $this->field_name,

      'entity_type' => 'node',

      'bundle' => 'page',

      'settings' => array(),

      'widget' => array(

        'type' => 'field_collection_embed',

      $num_values = self::NUM_VALUES;

    }

    $this->drupalGet('node/add/page');

@charset "UTF-8";

.field-collection-container {

  margin-bottom: 1em;

}

.field-collection-view {

  padding: 1em 0 0.3em 0;

  margin: 0 1em 0 1em;

}

/* If there is no add link, don't show the final border. */

  );

}

/**

 * Implements hook_tokens().

 */

  // Provide a complete set of tokens for type == 'host', and a supplementary

  // token 'host' for type == 'field_collection_item'.

    $collection = $data['field_collection_item'];

    // When saving revisions, only $collection->original has valid state about

    // its host entity.

      $collection = $collection->original;

    }

      if (!empty($tokens['host'])) {

        $replacements[$tokens['host']] = $collection->hostEntityId();

      }

 * @file

 * Provide relationship handler for field collection fields.

 */

class field_collection_handler_relationship extends views_handler_relationship {

  function option_definition() {

    $uri = file_stream_wrapper_uri_normalize('youtube://' . $type . '/' . check_plain($id));

    $external_url = file_create_url($uri);

    $oembed_url = url('https://www.youtube.com/oembed', array('query' => array('url' => $external_url, 'format' => 'json')));

    }

    }

  }

}

files[] = includes/MediaYouTubeStreamWrapper.inc

files[] = includes/MediaInternetYouTubeHandler.inc

core = "7.x"

project = "media_youtube"

files[] = includes/MediaYouTubeTestStreamWrapper.inc

files[] = includes/MediaYouTubeTestHandler.inc

core = "7.x"

project = "media_youtube"