Club Drupal

<?php

/**

 * @file

 * Administation settings for Adminimal Admin Menu.

 */

/**

 * Settings page form.

 */

function adminimal_admin_menu_settings($form, &$form_state) {

  // Create the shortcut category.

  $form['shortcut'] = array(

    '#type' => 'fieldset',

    '#title' => t('Shortcut options'),

  );

  if (module_exists('shortcut')) {

    // Create the select list.

    $form['shortcut']['adminimal_admin_menu_render'] = array(

      '#type' => 'radios',

      '#title' => t('Rendering method'),

      '#default_value' => variable_get('adminimal_admin_menu_render', 'collapsed'),

      '#options' => array(

        'hidden' => t('Hidden'),

        'inline' => t('Inline'),

        'collapsed' => t('Collapsed'),

        'newline' => t('Newline'),

        'dropdown' => t('Dropdown'),

        'exclusive' => t('Exclusive'),

      ),

      '#required' => TRUE,

    );

    $descriptions = &$form['shortcut']['adminimal_admin_menu_render'];

    $descriptions['hidden']['#description'] = t('Shortcuts will not be rendered inside the admin menu.');

    $descriptions['inline']['#description'] = t('Shortcuts will be rendered on the same line with the root menu links.');

    $descriptions['collapsed']['#description'] = t('Shortcuts will be collapsed like a normal menu.');

    $descriptions['newline']['#description'] = t('<b>(Default)</b>') . ' ' . t('Shortcuts will be rendered on a new line, below the root menu links.');

    $descriptions['dropdown']['#description'] = t('Shortcuts will be rendered inside a dropdown using the select html tag.');

    $descriptions['exclusive']['#description'] = t('Only the shortcuts will be rendered; the normal menu will be hidden.');

  }

  else {

    $form['shortcut']['#description'] = t('Module Shortcut is supported, but not required by Adminimal Admin Menu.');

  }

  // Create the advanced settings category.

  $form['advanced_settings'] = array(

    '#type' => 'fieldset',

    '#title' => t('Advanced settings'),

    '#description' => t('Do not change any of the advanced setting unless you know what you are doing!'),

    '#collapsible' => TRUE,

    '#collapsed' => TRUE,

  );

  $form['advanced_settings']['adminimal_admin_menu_slicknav'] = array(

    '#type' => 'checkbox',

    '#default_value' => variable_get('adminimal_admin_menu_slicknav', TRUE),

    '#title' => t('Enable Responsive Menu.'),

    '#description' => t('Enable this option if you want to have responsive menu and mobile device support. While disabling this option could save you few kilobytes (around 3KB), it will completely disable the responsive menu functionality.'),

  );

  $form['advanced_settings']['adminimal_admin_menu_jquery'] = array(

    '#type' => 'checkbox',

    '#default_value' => variable_get('adminimal_admin_menu_jquery', TRUE),

    '#title' => t('Load the required jQuery 1.7 library automagically.'),

    '#description' => t('This will load the newer jQuery version 1.7 using the no-conflict method so it won\'t interfere with any existing jQuery or other JavaScript libraries. The only reason to un-check this if you are already using a newer version of jQuery site-wide and its globally accessible by the "$" variable. Un-cheking this option could save you 33KB, but it may also break your JavaScript if not used correctly.'),

    '#states' => array(

      // Hide the settings when the cancel notify checkbox is disabled.

      'visible' => array(

        ':input[name="adminimal_admin_menu_slicknav"]' => array('checked' => TRUE),

      ),

    ),

  );

  $form['advanced_settings']['adminimal_admin_menu_viewport'] = array(

    '#type' => 'checkbox',

    '#default_value' => variable_get('adminimal_admin_menu_viewport', TRUE),

    '#title' => t('Set the metatag viewport <em>\'width=device-width, initial-scale=1\'</em> for devices.'),

    '#description' => t('This is needed for the responsive menu, if no other theme or module sets the viewport.'),

    '#states' => array(

      // Hide the settings when the cancel notify checkbox is disabled.

      'visible' => array(

        ':input[name="adminimal_admin_menu_slicknav"]' => array('checked' => TRUE),

      ),

    ),

  );

  $form = system_settings_form($form);

  $form['#submit'][] = 'adminimal_admin_menu_settings_submit';

  return $form;

}

/**

 * Submit callback for adminimal_admin_menu_settings();

 */

function adminimal_admin_menu_settings_submit($form, &$form_state) {

  // Clear the admin menu cache.

  admin_menu_flush_caches();

}

version = "7.x-1.9"

datestamp = "1519862286"

    'file' => 'adminimal_admin_menu.admin.inc',

/**

 * Implements hook_module_implements_alter().

 */

function adminimal_admin_menu_module_implements_alter(&$implementations, $hook) {

  // Put Adminimal Admin Menu's implementation of hook_admin_menu_output_alter()

  // to the end of the list of implementors, assuring that it will be executed

  // at the very end. Other modules may manipulate the menu items in the

  // administration menu (i.e. the excellent Administration Menu Source) and we

  // need to make sure those changes are preserved and respected by the output

  // of Adminimal Admin Menu.

  if ($hook == 'admin_menu_output_alter') {

    $group = $implementations['adminimal_admin_menu'];

    unset($implementations['adminimal_admin_menu']);

    $implementations['adminimal_admin_menu'] = $group;

  }

}

  // @todo Stop-gap fix until cached rendering is resolved (http://drupal.org/node/1567622).

  // Shortcut menu.

  if (module_exists('shortcut') && variable_get('adminimal_admin_menu_render', 'collapsed') != 'hidden') {

  if (module_exists('shortcut') && variable_get('adminimal_admin_menu_render', 'collapsed') == 'exclusive') {

    if (module_exists('shortcut')) {

      $content['responsive']['shortcuts'] = array(

        '#prefix' => '<div id="admin-menu-shortcuts-responsive">',

        '#suffix' => '</div>',

        '#pre_render' => array('shortcut_toolbar_pre_render'),

      );

    }

  if (module_exists('shortcut')) {

    $vars['classes_array'][] = 'menu-render-' . variable_get('adminimal_admin_menu_render', 'collapsed');

  }

  _adminimal_admin_menu_viewport();

}

/**

 * Add viewport for scaling on devices.

 */

function _adminimal_admin_menu_viewport() {

  $use_slicknav = variable_get('adminimal_admin_menu_slicknav', TRUE);

  $use_viewport = variable_get('adminimal_admin_menu_viewport', TRUE);

  // Only needed for slicknav.

  if ($use_slicknav && $use_viewport) {

    $viewport = array(

      '#tag' => 'meta',

      '#attributes' => array(

        'name' => 'viewport',

        'content' => 'width=device-width, initial-scale=1',

      ),

    );

    drupal_add_html_head($viewport, 'viewport');

  }

* Entity reference (https://www.drupal.org/project/entityreference)

  - "Simple hierarchical select" works out of the box with simple entity

    reference fields. In case you use Views as entity selection mode for your

    field there may be some problems, though.

    Your reference view needs at least one filter for the vocabulary. Otherwise

    "Simple hierarchical select" has no chance to retrieve the list of possible

    options to display.

    More complex reference views may cause "Simple hierarchical select" to fail,

    so its best to keep it as simple as possible.

<?php

/**

 * @file

 * Definition of shs_handler_filter_numeric.

 */

/**

 * Extends simple numeric filter with hierarchical selection.

 *

 * @ingroup views_filter_handlers

 */

class shs_handler_filter_entityreference extends views_handler_filter_numeric {

  // Define filter options.

  function option_definition() {

    $options = parent::option_definition();

    $options['shs_enabled'] = array('default' => FALSE);

    $options['use_chosen'] = array('default' => 'never');

    return $options;

  }

  /**

   * Build the options form.

   *

   * @param array $form

   *   Current form structure.

   * @param array $form_state

   *   Current form state.

   */

  function options_form(&$form, &$form_state) {

    parent::options_form($form, $form_state);

    $form['shs_enabled'] = array(

      '#type' => 'checkbox',

      '#title' => t('Output filter as hierarchical select'),

      '#default_value' => $this->options['shs_enabled'],

    );

    if (module_exists('chosen')) {

      $form['use_chosen'] = array(

        '#type' => 'select',

        '#title' => t('Output this field with !chosen', array('!chosen' => l(t('Chosen'), 'http://drupal.org/project/chosen'))),

        '#description' => t('Select in which cases the element will use the !chosen module for the term selection of each level.', array('!chosen' => l(t('Chosen'), 'http://drupal.org/project/chosen'))),

        '#default_value' => empty($this->options['use_chosen']) ? 'never' : $this->options['use_chosen'],

        '#dependency' => array(

          'edit-options-shs-enabled' => array(1),

        ),

        '#options' => array(

          'chosen' => t('let chosen decide'),

          'always' => t('always'),

          'never' => t('never'),

        ),

      );

    }

  }

  /**

   * Provide a simple textfield for equality

   */

  function value_form(&$form, &$form_state) {

    global $language;

    parent::value_form($form, $form_state);

    if (empty($form_state['exposed']) || empty($this->options['shs_enabled'])) {

      return;

    }

    $identifier = $this->options['expose']['identifier'];

    $multiple = $this->options['expose']['multiple'];

    $field = field_info_field($this->definition['field_name']);

    $handler = entityreference_get_selection_handler($field);

    $referencable_entities = $handler->getReferencableEntities();

    $vocabulary_names = array();

    if ('views' === $field['settings']['handler']) {

      $view_settings = $field['settings']['handler_settings']['view'];

      // Try to load vocabularies from view filter.

      $vocabulary_names = _shs_entityreference_views_get_vocabularies($view_settings['view_name'], $view_settings['display_name']);

    }

    else {

      $vocabulary_names = empty($field['settings']['handler_settings']['target_bundles']) ? array() : $field['settings']['handler_settings']['target_bundles'];

    }

    $vocabularies = array();

    foreach ($vocabulary_names as $vocabulary_name) {

      if (($vocabulary = taxonomy_vocabulary_machine_name_load($vocabulary_name)) !== FALSE) {

        $vocabularies[] = $vocabulary;

      }

    }

    if (empty($form_state['input'][$identifier])) {

      $form_state['input'][$identifier] = 'All';

    }

    $default_value = $form_state['input'][$identifier];

    if (!is_array($default_value) && $multiple) {

      $default_value = explode('+', $default_value);

      foreach ($default_value as $delta => $value) {

        $default_value[$delta] = explode(',', $value);

      }

    }

    $parents = array();

    if (!empty($default_value) && $default_value != 'All') {

      if (is_array($default_value) && $default_value[0] != 'All') {

        foreach ($default_value as $delta => $level) {

          $parents[$delta]['tid'] = $level;

        }

      }

      elseif (is_string($default_value)) {

        $term_parents = taxonomy_get_parents_all($default_value);

        // Remove selected term from list.

        array_shift($term_parents);

        foreach (array_reverse($term_parents) as $term) {

          $parents[] = array('tid' => $term->tid);

        }

        // Add current term (name not needed).

        $parents[] = array('tid' => $default_value);

      }

    }

    // Add fake item for next level.

    $parents[] = array('tid' => 0);

    $element_settings = array(

      'create_new_terms' => FALSE,

      'create_new_levels' => FALSE,

      'required' => FALSE,

      'language' => $language,

    );

    if (module_exists('chosen') && !empty($this->options['use_chosen'])) {

      $element_settings['use_chosen'] = $this->options['use_chosen'];

    }

    if (!empty($this->options['exposed']) && !empty($this->options['expose']['required'])) {

      $element_settings['required'] = TRUE;

    }

    // Allowing other modules to add settings for shs.

    if (!empty($this->options['expose']['shs'])) {

      $element_settings = array_merge($element_settings, $this->options['expose']['shs']);

    }

    $vocabulary_identifier = array(

      'field_name' => $field['field_name'],

    );

    if (count($vocabularies) == 1) {

      // Get ID from first (and only) vocabulary.

      $vocabulary_identifier = $vocabularies[0]->vid;

    }

    // Generate a random hash to avoid merging of settings by drupal_add_js.

    // This is necessary until http://drupal.org/node/208611 lands for D7.

    $js_hash = _shs_create_hash();

    // Create settings needed for our js magic.

    $settings_js = array(

      'shs' => array(

        $identifier => array(

          $js_hash => array(

            'vid' => $vocabulary_identifier,

            'settings' => $element_settings,

            'default_value' => $default_value,

            'parents' => $parents,

            'multiple' => $multiple,

            'any_label' => variable_get('views_exposed_filter_any_label', 'new_any') == 'old_any' ? t('<Any>') : t('- Any -'),

            'any_value' => 'All',

          ),

        ),

      ),

    );

    // Add settings.

    drupal_add_js($settings_js, 'setting');

    // Add behavior.

    drupal_add_js(drupal_get_path('module', 'shs') . '/js/shs.js');

    if (is_array($default_value) && $multiple && $default_value[0] != 'All') {

      foreach ($default_value as $delta => $level) {

        if ($delta == 0) {

          $default_value_str = implode(',', $level);

        }

        else {

          $default_value_str .= '+' . implode(',', $level);

        }

      }

    }

    $options = array();

    foreach ($referencable_entities as $terms) {

      $options += $terms;

    }

    // Change type of value element.

    $form['value']['#type'] = 'select';

    $form['value']['#options'] = $options;

    $form['value']['#size'] = 1;

    $form['value']['#default_value'] = empty($default_value) ? 'All' : $default_value;

    $form['value']['#attributes'] = array(

      'class' => array('element-invisible', 'shs-enabled'),

    );

    if (!empty($form_state['exposed']) && isset($identifier) && empty($form_state['input'][$identifier]) || $multiple && isset($form_state['input'][$identifier][0])) {

      $form_state['input'][$identifier] = empty($default_value_str) ? 'All' : $default_value_str;

    }

  }

  /**

   * Function to build the admin summary.

   *

   * @return string

   *   Short summary explaining the settings.

   */

  function admin_summary() {

    $summary = parent::admin_summary();

    // @todo: add "shs".

    return $summary;

  }

}

    global $language;

        if ($multiple && !is_array($default_value)) {

          $default_value = array($default_value);

          if (strpos($default_value[0], ',') !== FALSE || strpos($default_value[0], '+') !== FALSE) {

            $values = array();

            foreach ($default_value as $default) {

              $values += preg_split('/[,\+]+/', $default, -1, PREG_SPLIT_NO_EMPTY);

            $form_state['input'][$identifier] = empty($values) ? 'All' : $values;

            $default_value = $values;

          }

          $parents_multiple = array();

          foreach ($default_value as $delta => $tid) {

            $parents_multiple[] = $tid;

          $parents[] = array('tid' => $parents_multiple);

        'language' => $language,

      // Allowing other modules to add settings for shs.

      if (!empty($this->options['expose']['shs'])) {

        $element_settings = array_merge($element_settings, $this->options['expose']['shs']);

      }

          $identifier . ($multiple ? '[]' : '') => array(

              'any_label' => variable_get('views_exposed_filter_any_label', 'new_any') == 'old_any' ? t('<Any>') : t('- Any -'),

              'any_value' => 'All',

      drupal_alter(array('shs_js_settings', "shs_{$identifier}_js_settings"), $settings_js, $identifier, $vocabulary->vid);

      // Rewrite default select element.

      $form['value'] += array(

    if (module_exists('taxonomy_entity_index')) {

      $subquery = db_select('taxonomy_entity_index', 'tn');

      $subquery->addField('tn', 'entity_id');

    }

    else {

      $subquery = db_select('taxonomy_index', 'tn');

      $subquery->addField('tn', 'nid');

    }

(function ($, Drupal) {

      var settingsDefault = {

        display: {

          animationSpeed: 400,

        }

      };

      $('select.shs-enabled:not([disabled])')

        .hide()

          $field = $(this);

          // Multiform messes up the names of the fields

          // to the format multiform[something][fieldname][...].

          if (fieldName.indexOf('multiform') == 0) {

            var split = fieldName.split('][');

            split.splice(0, 1);

            fieldName = split.splice(0, 1) + '[' + split.join('][');

          }

            fieldSettings = $.extend({}, fieldSettings, settingsDefault, {

              fieldName: fieldName

            });

              // Add label to dropdown.

              $label = shsLabelCreate($field.attr('id'), fieldSettings, level);

              if ($label !== false) {

                $label.appendTo($field.parent());

              }

            if ((level > 1 || parent_id) && ((fieldSettings.settings.create_new_terms && fieldSettings.settings.create_new_levels) || fieldSettings.settings.test_create_new_levels)) {

            if (fieldSettings.default_value && (fieldSettings.default_value === parent_id) && (fieldSettings.default_value !== '')) {

              // Add label to dropdown.

              $label = shsLabelCreate($field.attr('id'), fieldSettings, level);

              if ($label !== false) {

                $label.appendTo($field.parent());

              }

              $select = shsElementCreate($field.attr('id'), fieldSettings, ++level);

      url: Drupal.settings.basePath + '?q=' + Drupal.settings.pathPrefix + 'js/shs/json',

          settings: settings.settings,

          field: settings.fieldName

          if (((data.data.length == 0) || ((data.data.length == 1 && !data.data[0].tid))) && !(settings.settings.create_new_terms && (settings.settings.create_new_levels || (parent_value[0] == settings.any_value && default_value == 0)))) {

            $element.prev('label').remove();

          // Add empty option (if field is not required or this is not the

          // first level.

          if (!settings.settings.required || (settings.settings.required && (default_value === 0 || parent_value !== 0))) {

            options[options.length] = new Option(settings.any_label, settings.any_value);

            if (term.vid && settings.settings.create_new_terms) {

              // Add option to add new item.

              options[options.length] = new Option(Drupal.t('<Add new item>', {}, {context: 'shs'}), '_add_new_');

            }

            else if (term.tid) {

              option = new Option(term.label, term.tid);

              options[options.length] = option;

              if (term.has_children) {

                option.setAttribute("class", "has-children");

              }

            }

          if (0 === default_value) {

            $element.val(settings.any_value);

          }

            $element.fadeIn(settings.display.animationSpeed);

          else {

            $element.trigger('chosen:updated');

          }

          if (data.data.length == 0 && settings.settings.required && settings.settings.create_new_terms && (settings.settings.create_new_levels || (parent_value[0] == settings.any_value && default_value == 0))) {

   * @param settings

   *   Field settings.

  termAddNew = function($triggering_element, $container, term, base_id, level, settings) {

      url: Drupal.settings.basePath + '?q=' + Drupal.settings.pathPrefix + 'js/shs/json',

          name: term.name,

          field: settings.fieldName

          updateFieldValue($triggering_element, base_id, level, settings);

          // Add new child element if adding new levels is allowed.

          if (settings.settings.create_new_levels) {

            $element_new = shsElementCreate(base_id, settings, level + 1);

            $element_new.appendTo($triggering_element.parent());

            if ($element_new.prop) {

              var options_new = $element_new.prop('options');

            }

            else {

              var options_new = $element_new.attr('options');

            }

            // Add "none" option.

            options_new[options_new.length] = new Option(settings.any_label, settings.any_value);

            if (settings.settings.create_new_terms) {

              // Add option to add new item.

              options_new[options_new.length] = new Option(Drupal.t('<Add new item>', {}, {context: 'shs'}), '_add_new_');

            }

            // Try to convert the element to a "Chosen" element.

            if (!elementConvertToChosen($element_new, settings)) {

              // Display original dropdown element.

              $element_new.fadeIn(settings.display.animationSpeed);

              $element_new.css('display','inline-block');

            }

          }

        $container.prev('label').remove();

        $triggering_element.fadeIn(settings.display.animationSpeed);

        $triggering_element.trigger('change');

        $element_chosen = $('#' + elem_id.replace(/-/g, '_') + '_chosen');

        if ($element_chosen) {

          $element_chosen.prev('label').remove();

          $element_chosen.remove();

        }

      $(this).prev('label').remove();

      if (Drupal.settings.chosen) {

        // Remove element created by chosen.

        var elem_id = $triggering_element.attr('id');

        $('#' + elem_id.replace(/-/g, '_') + '_chosen').remove();

      }

          $container.prev('label').remove();

          $triggering_element.val(settings.settings.any_value);

          if (!elementConvertToChosen($triggering_element, settings)) {

            // Display triggering element.

            $triggering_element.fadeIn(settings.display.animationSpeed);

            $triggering_element.css('display','inline-block');

          }

            parent: (level === 1) ? 0 : ($triggering_element.prevAll('.shs-select').val() || 0),

            termAddNew($triggering_element, $container, term, base_id, level, settings);

            $container.prev('label').remove();

            $triggering_element.fadeIn(settings.display.animationSpeed);

            $triggering_element.css('display', 'inline-block');;

    else if ($triggering_element.val() != 0 && $triggering_element.val() != settings.any_value) {

      $label = shsLabelCreate(base_id, settings, level);

      if ($label !== false) {

        $label.appendTo($triggering_element.parent());

      }

    updateFieldValue($triggering_element, base_id, level, settings);

    $element = $('<select>')

      .attr('id', base_id + '-select-' + level)

      .addClass('shs-select')

      // Add core class to apply default styles to the element.

      .addClass('form-select')

      .addClass('shs-select-level-' + level)

      .bind('change', function() {

        updateElements($(this), base_id, settings, level);

      })

      .hide();

      $element.attr('multiple', 'multiple')

    if (settings.settings.hasOwnProperty('required') && settings.settings.required) {

      $element.addClass('required');

  /**

   * Create label for dropdown in hierarchy.

   *

   * @param base_id

   *   ID of original field which is rewritten as "taxonomy_shs".

   * @param settings

   *   Field settings.

   * @param level

   *   Current level in hierarchy.

   *

   * @return

   *   The new <label> element or false if no label should be created.

   */

  shsLabelCreate = function(base_id, settings, level) {

    var labelKey = level - 1;

    if (!settings.hasOwnProperty('labels')) {

      return false;

    }

    if (!settings.labels.hasOwnProperty(labelKey) || settings.labels[labelKey] === false) {

      return false;

    }

    // Create element.

    $element = $('<label>')

      .attr('for', base_id + '-select-' + level)

      .addClass('element-invisible')

      .html(settings.labels[labelKey]);

    // Return the new element.

    return $element;

  }

   * @param settings

   *   Field settings.

  updateFieldValue = function($triggering_element, base_id, level, settings) {

    $field_orig.val(settings.any_value);

    if ($triggering_element.val() === settings.any_value || $triggering_element.val() == '_add_new_') {

      if ($triggering_element.prev('select').length) {

      if (level > 1 && settings.multiple) {

        if ($field_orig.children('option[value="' + new_val + '"]').length > 0) {

          // Value exists.

          $field_orig.val(new_val);

        }

        else {

          // We need to append the new option.

          if ($field_orig.prop) {

            var options = $field_orig.prop('options');

          }

          else {

            var options = $field_orig.attr('options');

          }

          options[options.length] = new Option(new_val, new_val);

          $field_orig.val(new_val);

        }

    // Notify listeners about the change in the original select.

    $field_orig.trigger({

      type: 'change',

      shs: {

        triggeringElement: $triggering_element,

        level: level,

        settings: settings,

        value: $triggering_element.val()

      }

    });

    // Returns false if chosen is not available or its settings are undefined.

    if ($.fn.chosen === void 0 || !Drupal.settings.hasOwnProperty('chosen') || Drupal.settings.chosen === void 0) {

      return false;

    }

    var name = $element.attr('name');

    settings.chosen = settings.chosen || Drupal.settings.chosen;

    var minWidth = settings.chosen.minimum_width;

    var multiple = Drupal.settings.chosen.multiple;

    var maxSelectedOptions = Drupal.settings.chosen.max_selected_options;

    // Define options.

    var options = {

      inherit_select_classes: true

    };

    var minimum = multiple && multiple[name] ? settings.chosen.minimum_multiple : settings.chosen.minimum_single;

    if (maxSelectedOptions && maxSelectedOptions[name]) {

      options.max_selected_options = maxSelectedOptions[name];

    // Merges the user defined settings for chosen.

    options = $.extend(options, settings.chosen);

    // Get element selector from settings (and remove "visible" option since

    // our select element is hidden by default).

    var selector = settings.chosen.selector.replace(/:visible/, '');

    if ((settings.settings.use_chosen === 'always') || ((settings.settings.use_chosen === 'chosen') && $element.is(selector) && ($element.find('option').size() >= minimum || minimum === 'Always Apply'))) {

      options = $.extend(options, {

        width: (($element.width() < minWidth) ? minWidth : $element.width()) + 'px'

      });

      // Apply chosen to the element.

      return $element.chosen(options);

    }

    else if ((settings.settings.use_chosen === 'never') && (!$element.hasClass('chosen-disable'))) {

      // Tell chosen to not process this element.

      $element.addClass('chosen-disable');

    }

})(jQuery, Drupal);

name = Simple hierarchical select: node count

core = 7.x

description = Extends 'Simple hierarchical select' with "node count" functionality.

dependencies[] = shs

; Information added by Drupal.org packaging script on 2018-03-06

version = "7.x-1.7"

core = "7.x"

project = "shs"

datestamp = "1520313188"

<?php

/**

 * @file

 * Installation tasks for "SHS node count".

 */

/**

 * Implements hook_uninstall().

 */

function shs_node_count_uninstall() {

  variable_del('shs_node_count_format');

}

<?php

/**

 * @file

 * Node count functionality for Simple hierarchical select.

 */

/**

 * Implements hook_field_widget_info_alter().

 */

function shs_node_count_field_widget_info_alter(&$info) {

  if (empty($info['taxonomy_shs'])) {

    return;

  }

  // Add "a"node_count" setting to a shs widgets.

  $info['taxonomy_shs']['settings']['shs'] += array(

    'node_count' => FALSE,

  );

}

/**

 * Implements hook_form_FORM_ID_alter().

 */

function shs_node_count_form_field_ui_field_edit_form_alter(&$form, &$form_state, $form_id) {

  if (empty($form['instance']['widget']['settings']['shs'])) {

    return;

  }

  $settings_form = &$form['instance']['widget']['settings']['shs'];

  $settings = &$form['#instance']['widget']['settings']['shs'];

  $settings_form['node_count'] = array(

    '#type' => 'checkbox',

    '#title' => t('Display number of nodes'),

    '#description' => t('Display the number of nodes associated with the term.'),

    '#default_value' => empty($settings['node_count']) ? FALSE : $settings['node_count'],

    '#weight' => -1,

  );

}

/**

 * Implements hook_shs_term_get_children_alter().

 */

function shs_node_count_shs_term_get_children_alter(&$terms, &$alter_options) {

  if (empty($alter_options['settings']['node_count']) || empty($alter_options['settings']['language']) || !isset($alter_options['parent'])) {

    // Nothing to do here.

    return;

  }

  $langcode = $alter_options['settings']['language']->language;

  $term = (object) array(

    'vid' => $alter_options['vid'],

    'tid' => 0,

  );

  $format = variable_get('shs_node_count_format', '%s (%d)');

  foreach ($terms as &$item) {

    array_walk($item[$langcode][$alter_options['parent']], function (&$name, $key) use ($term, $format) {

      $term->tid = $key;

      $count = shs_node_count_term_get_node_count($term, TRUE);

      $name = sprintf($format, $name, $count);

    });

  }

}

/**

 * Helper function to count number of nodes associated to a term.

 *

 * @param object $term

 *   The term object.

 * @param boolean $count_children

 *   If set to TRUE, nodes in child terms are counted also.

 *

 * @return int

 *   Number of nodes within the term.

 */

function shs_node_count_term_get_node_count($term, $count_children = FALSE) {

  $num_nodes = &drupal_static(__FUNCTION__, array());

  // Maybe this needs some more caching and value-updates on node_save()/

  // _update()/delete().

  if (empty($num_nodes["{$term->tid}:{$count_children}"])) {

    $index_table = 'taxonomy_index';

    if (module_exists('taxonomy_entity_index')) {

      $index_table = 'taxonomy_entity_index';

    }

    // Count nodes associated to this term.

    $num_nodes["{$term->tid}:{$count_children}"] = db_select($index_table, 'ti')

            ->fields('ti')

            ->condition('tid', $term->tid)

            ->execute()

            ->rowCount();

    if ($count_children) {

      $tids = array();

      $tree = taxonomy_get_tree($term->vid, $term->tid);

      foreach ($tree as $child_term) {

        $tids[] = $child_term->tid;

      }

      if (count($tids)) {

        $num_nodes["{$term->tid}:{$count_children}"] += db_select($index_table, 'ti')