function jollyness_preprocess_html(&$vars)
{
    //Process portfolio color
    if ($portfolio_category = taxonomy_vocabulary_machine_name_load('portfolio_category')) {
        $terms = taxonomy_get_tree($portfolio_category->vid);
        $less = new lessc();
        $css = '';
        $color = '';
        $class = '';
        foreach ($terms as $t) {
            $term = taxonomy_term_load($t->tid);
            $class = drupal_html_class($t->name);
            if (!empty($term->field_color)) {
                foreach ($term->field_color as $v) {
                    $color = $v[0]['value'];
                    break;
                }
            }
            if ($color) {
                $css .= ".dexp-masonry-filter,.dexp-portfolio-filter{.{$class} span:before{background-color: {$color} !important;}}";
                $css .= ".{$class} .portfolio-item-overlay{background-color: rgba(red({$color}), green({$color}), blue({$color}), 0.7) !important;}";
            }
        }
        $css = $less->compile($css);
        drupal_add_css($css, array('type' => 'inline'));
    }
}

 /**
  * @param  \stdClass $config
  * @return array
  */
 protected function getTaxonomyTermsAsSelectOptions($config)
 {
     $answer = [];
     if (isset($config->vocabulary) && isset($config->level)) {
         /** @var \stdClass $vocabulary */
         if ($vocabulary = taxonomy_vocabulary_machine_name_load($config->vocabulary)) {
             $tree = $tree = taxonomy_get_tree($vocabulary->vid, 0, null, true);
             dpm($tree, "FLAT TREE");
             /*
             				if(count($terms) == 1) {
             					$term = array_pop($terms);
             					if(isset($term->description)) {
             						$answer = $term->description;
             						if($stripHtml) {
             							$answer = strip_tags($answer);
             						}
             					}
             				}*/
         } else {
             drupal_set_message("Vocabulary not found by name: " . $config->vocabulary, 'warning');
         }
     } else {
         drupal_set_message("Vocabulary or Level not set in config: " . json_encode($config), 'warning');
     }
     return $answer;
 }

/**
 * Implements hook_draw_chart_alter().
 */
function hook_draw_chart_alter(&$settings)
{
    foreach ($settings as $chart) {
        if (isset($chart['chart']['chartCategory']) && !empty($chart['chart']['chartCategory'])) {
            // Geting the count result by vocabulary machine name.
            $voc = taxonomy_vocabulary_machine_name_load('categories');
            $tree = taxonomy_get_tree($voc->vid);
            $header = array();
            foreach ($tree as $term) {
                // Feeds the header with terms names.
                $header[] = $term->name;
                $query = db_select('taxonomy_index', 'ti');
                $query->condition('ti.tid', $term->tid, '=')->fields('ti', array('nid'));
                // Feeding the terms with the node count.
                $terms[] = $query->countQuery()->execute()->fetchField();
            }
            $columns = array('Content per category');
            $rows = array($terms);
            // Replacing the data of the chart.
            $chart['chart']['chartCategory']['header'] = $header;
            $chart['chart']['chartCategory']['rows'] = $rows;
            $chart['chart']['chartCategory']['columns'] = $columns;
            // Adding a colors attribute to the pie.
            $chart['chart']['chartCategory']['options']['colors'] = array('red', '#004411');
        }
    }
}

function _bootstrap_theme_category_contents($vocab_name)
{
    global $user;
    //$contents = bootstrap_theme_get_category_contents(NODE_PUBLISHED, $user);
    $output = '';
    $myvoc = taxonomy_vocabulary_machine_name_load($vocab_name);
    $tree = taxonomy_get_tree($myvoc->vid);
    $depth = 0;
    $output .= '<div>Vocabulary terms under <a href="' . base_path() . 'category/' . $vocab_name . '" class="category-title">' . $myvoc->name . '</a>. Click on term you want to search content for.</div>
				<div style="float:right;"><a href="' . base_path() . '" class="btn btn-primary form-submit">Back</a></div><br>';
    $output .= '<ul>';
    foreach ($tree as $term) {
        if ($term->depth > $depth) {
            $output .= '<ul>';
            $depth = $term->depth;
        }
        if ($term->depth < $depth) {
            $output .= '</ul>';
            $depth = $term->depth;
        }
        //$output .= '<li>' . l($term->name, 'taxonomy/term/' . $term->tid) . '</li>';
        $output .= '<li>' . l($term->name, 'taxonomy/term/' . $term->tid) . "<br>";
        $output .= '<div>' . $term->description . '</div></li>';
    }
    $output .= '</ul>';
    return $output;
}

 /**
  * Implements \Drupal\block\BlockBase::blockBuild().
  */
 public function build()
 {
     static $vocabularies, $terms;
     $items = array();
     $faq_settings = \Drupal::config('faq.settings');
     if (!$faq_settings->get('use_categories')) {
         return;
     }
     $moduleHandler = \Drupal::moduleHandler();
     if ($moduleHandler->moduleExists('taxonomy')) {
         if (!isset($terms)) {
             $terms = array();
             $vocabularies = Vocabulary::loadMultiple();
             $vocab_omit = array_flip($faq_settings->get('omit_vocabulary'));
             $vocabularies = array_diff_key($vocabularies, $vocab_omit);
             foreach ($vocabularies as $vocab) {
                 foreach (taxonomy_get_tree($vocab->vid) as $term) {
                     if (FaqHelper::taxonomyTermCountNodes($term->tid)) {
                         $terms[$term->name] = $term->tid;
                     }
                 }
             }
         }
         if (count($terms) > 0) {
             foreach ($terms as $name => $tid) {
                 $items[] = l($name, 'faq-page/' . $tid);
             }
         }
     }
     return array('#theme' => 'item_list', '#items' => $items, '#list_type' => $faq_settings->get('category_listing'));
 }

 /**
  * Deletes all terms of a vocabulary.
  *
  * @param $vid
  *   int a vocabulary vid.
  */
 protected function deleteVocabularyTerms($vid)
 {
     $tids = array();
     foreach (taxonomy_get_tree($vid) as $term) {
         $tids[] = $term->tid;
     }
     entity_delete_multiple('taxonomy_term', $tids);
 }

function bootstrap_theme_get_taxonomy_vocabulary_category_options($taxonomy_vocabulary_id)
{
    $options = array();
    //$options[] = '<none>';
    foreach (taxonomy_get_tree($taxonomy_vocabulary_id) as $category) {
        $options[$category->tid] = $category->name;
    }
    return $options;
}

function mis_theme_get_all_categories_array()
{
    $categories = taxonomy_get_tree(5);
    $catArray = null;
    foreach ($categories as $cat) {
        $catArray[] = taxonomy_term_load($cat->tid);
    }
    return $catArray;
}

function getOptionsfrom($taxonomy)
{
    $terms = array();
    $myvoc = taxonomy_vocabulary_machine_name_load($taxonomy);
    $tree = taxonomy_get_tree($myvoc->vid);
    foreach ($tree as $term) {
        array_push($terms, $term->name);
    }
    return $terms;
}

function _taxonomy_options($machine_name, $default = '')
{
    $vocabulary = taxonomy_vocabulary_machine_name_load($machine_name);
    $tree = taxonomy_get_tree($vocabulary->vid);
    if (!empty($default)) {
        $options[0] = $default;
    } else {
        $options = array();
    }
    foreach ($tree as $item) {
        $options[$item->tid] = str_repeat('-', $item->depth) . $item->name;
    }
    return $options;
}

function exploreworld_preprocess_page(&$vars)
{
    $voc = taxonomy_vocabulary_machine_name_load('travel_destinations');
    $taxonomy = taxonomy_get_tree($voc->vid);
    $items = array();
    foreach ($taxonomy as $row) {
        $items[] = $row->name;
    }
    $vars['custom_item_list'] = theme('custom_item_list', array('items' => $items));
    $obj = menu_get_object();
    if (is_object($obj)) {
        $vars['theme_hook_suggestions'][] = 'page__' . $obj->type;
    }
}

/**
 * Implements hook_analytics_dashboard().
 */
function hook_analytics_dashboard()
{
    $voc = taxonomy_vocabulary_machine_name_load('categories');
    $tree = taxonomy_get_tree($voc->vid);
    $header = array();
    foreach ($tree as $term) {
        $header[] = $term->name;
        $query = db_select('taxonomy_index', 'ti');
        $query->condition('ti.tid', $term->tid, '=')->fields('ti', array('nid'));
        $terms[] = $query->countQuery()->execute()->fetchField();
    }
    $columns = array('Ideas in category');
    $rows = array($terms);
    $settings = array();
    $settings['chart']['chartCategory'] = array('header' => $header, 'rows' => $rows, 'columns' => $columns, 'weight' => -10, 'chartType' => 'PieChart', 'options' => array('curveType' => "function", 'is3D' => TRUE, 'forceIFrame' => FALSE, 'title' => 'Ideas per category', 'width' => 500, 'height' => 300));
    return draw_chart($settings);
}

 /**
  * Test a taxonomy with terms that have multiple parents of different depths.
  */
 function testTaxonomyVocabularyTree()
 {
     // Create a new vocabulary with 6 terms.
     $vocabulary = $this->createVocabulary();
     $term = array();
     for ($i = 0; $i < 6; $i++) {
         $term[$i] = $this->createTerm($vocabulary);
     }
     // $term[2] is a child of 1 and 5.
     $term[2]->parent = array($term[1]->id(), $term[5]->id());
     $term[2]->save();
     // $term[3] is a child of 2.
     $term[3]->parent = array($term[2]->id());
     $term[3]->save();
     // $term[5] is a child of 4.
     $term[5]->parent = array($term[4]->id());
     $term[5]->save();
     /**
      * Expected tree:
      * term[0] | depth: 0
      * term[1] | depth: 0
      * -- term[2] | depth: 1
      * ---- term[3] | depth: 2
      * term[4] | depth: 0
      * -- term[5] | depth: 1
      * ---- term[2] | depth: 2
      * ------ term[3] | depth: 3
      */
     // Count $term[1] parents with $max_depth = 1.
     $tree = taxonomy_get_tree($vocabulary->id(), $term[1]->id(), 1);
     $this->assertEqual(1, count($tree), 'We have one parent with depth 1.');
     // Count all vocabulary tree elements.
     $tree = taxonomy_get_tree($vocabulary->id());
     $this->assertEqual(8, count($tree), 'We have all vocabulary tree elements.');
     // Count elements in every tree depth.
     foreach ($tree as $element) {
         if (!isset($depth_count[$element->depth])) {
             $depth_count[$element->depth] = 0;
         }
         $depth_count[$element->depth]++;
     }
     $this->assertEqual(3, $depth_count[0], 'Three elements in taxonomy tree depth 0.');
     $this->assertEqual(2, $depth_count[1], 'Two elements in taxonomy tree depth 1.');
     $this->assertEqual(2, $depth_count[2], 'Two elements in taxonomy tree depth 2.');
     $this->assertEqual(1, $depth_count[3], 'One element in taxonomy tree depth 3.');
 }

 /**
  * {@inheritdoc}
  */
 public function getSettableOptions(AccountInterface $account = NULL)
 {
     if ($callback = $this->getSetting('options_list_callback')) {
         return call_user_func_array($callback, array($this->getFieldDefinition(), $this->getEntity()));
     } else {
         $options = array();
         foreach ($this->getSetting('allowed_values') as $tree) {
             if ($vocabulary = entity_load('taxonomy_vocabulary', $tree['vocabulary'])) {
                 if ($terms = taxonomy_get_tree($vocabulary->id(), $tree['parent'], NULL, TRUE)) {
                     foreach ($terms as $term) {
                         $options[$term->id()] = str_repeat('-', $term->depth) . $term->getName();
                     }
                 }
             }
         }
         return $options;
     }
 }

 /**
  * {@inheritdoc}
  */
 public function form(array $form, FormStateInterface $form_state)
 {
     $term = $this->entity;
     $vocab_storage = $this->entityManager->getStorage('taxonomy_vocabulary');
     $vocabulary = $vocab_storage->load($term->bundle());
     $parent = array_keys(taxonomy_term_load_parents($term->id()));
     $form_state['taxonomy']['parent'] = $parent;
     $form_state['taxonomy']['vocabulary'] = $vocabulary;
     $language_configuration = $this->moduleHandler->moduleExists('language') ? language_get_default_configuration('taxonomy_term', $vocabulary->id()) : FALSE;
     $form['langcode'] = array('#type' => 'language_select', '#title' => $this->t('Language'), '#languages' => LanguageInterface::STATE_ALL, '#default_value' => $term->getUntranslated()->language()->id, '#access' => !empty($language_configuration['language_show']));
     $form['relations'] = array('#type' => 'details', '#title' => $this->t('Relations'), '#open' => $vocabulary->hierarchy == TAXONOMY_HIERARCHY_MULTIPLE, '#weight' => 10);
     // taxonomy_get_tree and taxonomy_term_load_parents may contain large
     // numbers of items so we check for taxonomy.settings:override_selector
     // before loading the full vocabulary. Contrib modules can then intercept
     // before hook_form_alter to provide scalable alternatives.
     if (!$this->config('taxonomy.settings')->get('override_selector')) {
         $parent = array_keys(taxonomy_term_load_parents($term->id()));
         $children = taxonomy_get_tree($vocabulary->id(), $term->id());
         // A term can't be the child of itself, nor of its children.
         foreach ($children as $child) {
             $exclude[] = $child->tid;
         }
         $exclude[] = $term->id();
         $tree = taxonomy_get_tree($vocabulary->id());
         $options = array('<' . $this->t('root') . '>');
         if (empty($parent)) {
             $parent = array(0);
         }
         foreach ($tree as $item) {
             if (!in_array($item->tid, $exclude)) {
                 $options[$item->tid] = str_repeat('-', $item->depth) . $item->name;
             }
         }
         $form['relations']['parent'] = array('#type' => 'select', '#title' => $this->t('Parent terms'), '#options' => $options, '#default_value' => $parent, '#multiple' => TRUE);
     }
     $form['relations']['weight'] = array('#type' => 'textfield', '#title' => $this->t('Weight'), '#size' => 6, '#default_value' => $term->getWeight(), '#description' => $this->t('Terms are displayed in ascending order by weight.'), '#required' => TRUE);
     $form['vid'] = array('#type' => 'value', '#value' => $vocabulary->id());
     $form['tid'] = array('#type' => 'value', '#value' => $term->id());
     if ($term->isNew()) {
         $form_state['redirect'] = current_path();
     }
     return parent::form($form, $form_state, $term);
 }

 /**
  * {@inheritdoc}
  */
 public function getReferenceableEntities($match = NULL, $match_operator = 'CONTAINS', $limit = 0)
 {
     if ($match || $limit) {
         return parent::getReferenceableEntities($match, $match_operator, $limit);
     }
     $options = array();
     $bundles = entity_get_bundles('taxonomy_term');
     $bundle_names = !empty($this->instance['settings']['handler_settings']['target_bundles']) ? $this->instance['settings']['handler_settings']['target_bundles'] : array_keys($bundles);
     foreach ($bundle_names as $bundle) {
         if ($vocabulary = entity_load('taxonomy_vocabulary', $bundle)) {
             if ($terms = taxonomy_get_tree($vocabulary->id(), 0, NULL, TRUE)) {
                 foreach ($terms as $term) {
                     $options[$vocabulary->id()][$term->id()] = str_repeat('-', $term->depth) . String::checkPlain($term->getName());
                 }
             }
         }
     }
     return $options;
 }

 /**
  *  Overrides \RestfulEntityBase::getList().
  */
 public function getList()
 {
     $list = parent::getList();
     $return = array();
     // Select vocabulary related.
     $vocabulary = taxonomy_vocabulary_machine_name_load($this->bundle);
     // Order according the taxonomy order.
     $tree = taxonomy_get_tree($vocabulary->vid);
     foreach ($tree as $term) {
         foreach ($list as $item) {
             if ($item['id'] == $term->tid) {
                 // Add extra properties.
                 $item['depth'] = $term->depth;
                 $return[] = $item;
                 break;
             }
         }
     }
     return $return;
 }

 /**
  * Tests the forum node pager for nodes with multiple grants per realm.
  */
 public function testForumPager()
 {
     // Look up the forums vocabulary ID.
     $vid = \Drupal::config('forum.settings')->get('vocabulary');
     $this->assertTrue($vid, 'Forum navigation vocabulary ID is set.');
     // Look up the general discussion term.
     $tree = taxonomy_get_tree($vid, 0, 1);
     $tid = reset($tree)->tid;
     $this->assertTrue($tid, 'General discussion term is found in the forum vocabulary.');
     // Create 30 nodes.
     for ($i = 0; $i < 30; $i++) {
         $this->drupalCreateNode(array('nid' => NULL, 'type' => 'forum', 'taxonomy_forums' => array(array('target_id' => $tid))));
     }
     // View the general discussion forum page. With the default 25 nodes per
     // page there should be two pages for 30 nodes, no more.
     $this->drupalLogin($this->web_user);
     $this->drupalGet('forum/' . $tid);
     $this->assertRaw('page=1');
     $this->assertNoRaw('page=2');
 }

/**
 * Returns the list of options to be displayed for a field.
 *
 * Field types willing to enable one or several of the widgets defined in
 * options.module (select, radios/checkboxes, on/off checkbox) need to
 * implement this hook to specify the list of options to display in the
 * widgets.
 *
 * @param $field
 *   The field definition.
 * @param $instance
 *   (optional) The instance definition. The hook might be called without an
 *   $instance parameter in contexts where no specific instance can be targeted.
 *   It is recommended to only use instance level properties to filter out
 *   values from a list defined by field level properties.
 * @param $entity_type
 *   The entity type the field is attached to.
 * @param $entity
 *   The entity object the field is attached to, or NULL if no entity
 *   exists (e.g. in field settings page).
 *
 * @return
 *   The array of options for the field. Array keys are the values to be
 *   stored, and should be of the data type (string, number...) expected by
 *   the first 'column' for the field type. Array values are the labels to
 *   display within the widgets. The labels should NOT be sanitized,
 *   options.module takes care of sanitation according to the needs of each
 *   widget. The HTML tags defined in _field_filter_xss_allowed_tags() are
 *   allowed, other tags will be filtered.
 */
function hook_options_list($field, $instance, $entity_type, $entity)
{
    // Sample structure.
    $options = array(0 => t('Zero'), 1 => t('One'), 2 => t('Two'), 3 => t('Three'));
    // Sample structure with groups. Only one level of nesting is allowed. This
    // is only supported by the 'options_select' widget. Other widgets will
    // flatten the array.
    $options = array(t('First group') => array(0 => t('Zero')), t('Second group') => array(1 => t('One'), 2 => t('Two')), 3 => t('Three'));
    // In actual implementations, the array of options will most probably depend
    // on properties of the field. Example from taxonomy.module:
    $options = array();
    foreach ($field['settings']['allowed_values'] as $tree) {
        $terms = taxonomy_get_tree($tree['vid'], $tree['parent']);
        if ($terms) {
            foreach ($terms as $term) {
                $options[$term->tid] = str_repeat('-', $term->depth) . $term->name;
            }
        }
    }
    return $options;
}

 /**
  * Overrides EntityReferenceHandler::getReferencableEntities().
  * @inheritdoc
  */
 public function getReferencableEntities($match = NULL, $match_operator = 'CONTAINS', $limit = 0)
 {
     if ($match || $limit) {
         return parent::getReferencableEntities($match, $match_operator, $limit);
     }
     $options = array();
     $entity_type = $this->field['settings']['target_type'];
     // We imitate core by calling taxonomy_get_tree().
     $entity_info = entity_get_info('taxonomy_term');
     $bundles = !empty($this->field['settings']['handler_settings']['target_bundles']) ? $this->field['settings']['handler_settings']['target_bundles'] : array_keys($entity_info['bundles']);
     foreach ($bundles as $bundle) {
         if ($vocabulary = taxonomy_vocabulary_machine_name_load($bundle)) {
             if ($terms = taxonomy_get_tree($vocabulary->vid, 0)) {
                 foreach ($terms as $term) {
                     $context = array('entity' => $term);
                     od_entity_label_translate_factory::inst()->getTranslator('taxonomy_term', $context)->triggerEvent('pseudo_entity_load');
                     $options[$vocabulary->machine_name][$term->tid] = str_repeat('-', $term->depth) . check_plain($term->name);
                 }
             }
         }
     }
     return $options;
 }