Project

General

Profile

Download (66 KB) Statistics
| Branch: | Tag: | Revision:
1
<?php
2

    
3
/**
4
 * Returns the localized representations of the modifiers hold by the
5
 * supplied cdm instance concatenated into one string.
6
 *
7
 * @param object $iModifieable
8
 *   cdm instance of an class implementing the interface IModifieable:
9
 *   DescriptionElementBase, StateDate, State
10
 *
11
 * @return String
12
 *   localized representations of the modifiers hold by the
13
 *   supplied cdm instance concatenated into one string
14
 */
15
function cdm_modifers_representations($iModifieable, $glue = ', ') {
16
  $modifiers_strings = array();
17
  if (isset($iModifieable->modifiers)) {
18
    foreach ($iModifieable->modifiers as $modifier) {
19
      $modifiers_strings[] = cdm_term_representation($modifier);
20
    }
21
  }
22
  return implode(', ', $modifiers_strings);
23
}
24

    
25
/**
26
 * Filters the given set of description elements and prefers computed elements over others.
27
 *
28
 * Computed description elements
29
 * are identified by the MarkerType.COMPUTED()
30
 *
31
 * If the given set contains at least one computed element only
32
 * the computed elements are returned.
33
 *
34
 * @param array $description_elements
35
 *   An array of CDM DescriptionElementBase instances
36
 *
37
 * @return array
38
 *   only the computed description elements otherwise all others.
39
 *
40
 * @deprecated this is replaced by the cdmlib DistributionUtil class!!!
41
 */
42
function cdm_description_elements_prefer_computed($description_elements){
43

    
44
  $computed_elements = array();
45
  $other_elements = array();
46

    
47
  if (!empty($description_elements)) {
48
    foreach ($description_elements as $element) {
49
      if (cdm_entity_has_marker($element, UUID_MARKERTYPE_COMPUTED)) {
50
        $computed_elements[] = $element;
51
      }
52
      else {
53
        $other_elements[] = $element;
54
      }
55
    }
56
  }
57

    
58
  if (count($computed_elements) > 0) {
59
    return $computed_elements;
60
  }
61
  else {
62
    return $other_elements;
63
  }
64
}
65

    
66
/**
67
 * Creates a query parameter array based on the setting stored in the drupal variable CDM_DISTRIBUTION_FILTER.
68
 *
69
 * @return array
70
 *   An array with distribution filter query parameters
71
 */
72
function cdm_distribution_filter_query() {
73
  $cdm_distribution_filter = get_array_variable_merged(CDM_DISTRIBUTION_FILTER, CDM_DISTRIBUTION_FILTER_DEFAULT);
74
  $query = array();
75

    
76
  $feature_block_settings = get_feature_block_settings(UUID_DISTRIBUTION);
77
  if($feature_block_settings['sort_elements'] == SORT_HIERARCHICAL){
78
    $query['distributionOrder'] = 'AREA_ORDER';
79
  }
80

    
81
  $query['recipe'] = variable_get(DISTRIBUTION_CONDENSED_RECIPE, DISTRIBUTION_CONDENSED_RECIPE_DEFAULT);
82

    
83

    
84

    
85
  if ($cdm_distribution_filter['filter_rules']['statusOrderPreference']) {
86
    $query['statusOrderPreference'] = 1;
87
  }
88
  if ($cdm_distribution_filter['filter_rules']['subAreaPreference']) {
89
    $query['subAreaPreference'] = 1;
90
  }
91
  if (is_array($cdm_distribution_filter['hiddenAreaMarkerType']) && count($cdm_distribution_filter['hiddenAreaMarkerType']) > 0) {
92
    $query['hiddenAreaMarkerType'] = '';
93
    foreach ($cdm_distribution_filter['hiddenAreaMarkerType'] as $marker_type => $enabled) {
94
      if ($enabled) {
95
        $query['hiddenAreaMarkerType'] .= ($query['hiddenAreaMarkerType'] ? ',' : '') . $marker_type;
96
      }
97
    }
98
  }
99

    
100
  return $query;
101
}
102

    
103
/**
104
 * Merge the fields 'annotations', 'markers', 'sources', 'media' from the source CDM DescriptionElement into  the target.
105
 *
106
 * @param object $target
107
 *   The source CDM DescriptionElement
108
 * @param object $source
109
 *   The target CDM DescriptionElement
110
 */
111
function cdm_merge_description_elements(&$target, &$source) {
112
  static $fields_to_merge = array('annotations', 'markers', 'sources', 'media');
113

    
114
  foreach ($fields_to_merge as $field) {
115
    if (is_array($source->$field)) {
116
      if (!is_array($target->$field)) {
117
        $target->$field = $source->$field;
118
      }
119
      else {
120
        $target->$field = array_merge($target->$field, $source->$field);
121
      }
122
    }
123
  }
124
}
125

    
126
/**
127
 * Adds an entry to the end of the table of content items list
128
 *
129
 * The  table of content items are crated internally by calling
130
 * toc_list_item() the resulting item is added to the statically cached
131
 * list of toc elements
132
 *
133
 * @param string $label
134
 *   The label of toc entry
135
 * @param $class_attribute_suffix
136
 *   The suffix to be appended to the class attribute prefix: "feature-toc-item-"
137
 * @param string $fragment
138
 *   Optional parameter to define a url fragment different from the $label,
139
 *   if the $fragment is not defined the $label will be used
140
 */
141
function cdm_toc_list_add_item($label, $class_attribute_suffix, $fragment = NULL, $as_first_element = FALSE) {
142
  $toc_list_items = &cdm_toc_list();
143

    
144
  if (!$fragment) {
145
    $fragment = $label;
146
  }
147
  $fragment = generalizeString($fragment);
148

    
149
  $class_attributes = 'feature-toc-item-' . $class_attribute_suffix;
150

    
151
  $new_item = toc_list_item(
152
    theme(
153
      'cdm_feature_name',
154
      array('feature_name' => $label)),
155
      array('class' => $class_attributes),
156
      $fragment
157
    );
158

    
159
  if ($as_first_element) {
160
    array_unshift($toc_list_items, $new_item);
161
  }
162
  else {
163
    $toc_list_items[] = $new_item;
164
  }
165

    
166
}
167

    
168
/**
169
 * Returns the statically cached table of content items as render array.
170
 *
171
 * @see cdm_toc_list_add_item()
172
 *
173
 * @return array
174
 *   a render array of table of content items suitable for theme_item_list()
175
 */
176
function &cdm_toc_list(){
177
  $toc_list_items = &drupal_static('toc_list_items', array());
178

    
179
  return $toc_list_items;
180
}
181

    
182
/**
183
 * Prepares an empty Drupal block for displaying description elements of a specific CDM Feature.
184
 *
185
 * The block can also be used for pseudo Features like a bibliography. Pseudo features are
186
 * derived from other data on the fly and so not exist as such in the cdm data. In case
187
 * of pseudo features the $feature is left empty
188
 *
189
 * @param $feature_name
190
 *   A label describing the feature, usually the localized feature representation.
191
 * @param object $feature
192
 *   The CDM Feature for which the block is created. (optional)
193
 * @return object
194
 *   A Drupal block object
195
 */
196
function feature_block($feature_name, $feature = NULL) {
197
  $block = new stdclass(); // Empty object.
198
  $block->module = 'cdm_dataportal';
199
  $block->delta = generalizeString($feature_name);
200
  $block->region = NULL;
201
  $block->subject = '<a name="' . $block->delta . '"></a><span class="' . html_class_attribute_ref($feature) . '">'
202
    . theme('cdm_feature_name', array('feature_name' => $feature_name))
203
    . '</span>';
204
  $block->module = "cdm_dataportal-feature";
205
  $block->content = '';
206
  return $block;
207
}
208

    
209

    
210
/**
211
 * Returns a list of a specific type of IdentificationKeys.
212
 *
213
 * The list can be restricted by a taxon.
214
 *
215
 * @param string $type
216
 *   The simple name of the cdm class implementing the interface
217
 *   IdentificationKey, valid values are:
218
 *   PolytomousKey, MediaKey, MultiAccessKey.
219
 * @param string $taxonUuid
220
 *   If given this parameter restrict the listed keys to those which have
221
 *   the taxon identified be this uuid in scope.
222
 *
223
 * @return array
224
 *   List with identification keys.
225
 */
226
function _list_IdentificationKeys($type, $taxonUuid = NULL, $pageSize = NULL, $pageNumber = NULL) {
227
  if (!$type) {
228
    drupal_set_message(t('Type parameter is missing'), 'error');
229
    return;
230
  }
231
  $cdm_ws_pasepath = NULL;
232
  switch ($type) {
233
    case "PolytomousKey":
234
      $cdm_ws_pasepath = CDM_WS_POLYTOMOUSKEY;
235
      break;
236

    
237
    case "MediaKey":
238
      $cdm_ws_pasepath = CDM_WS_MEDIAKEY;
239
      break;
240

    
241
    case "MultiAccessKey":
242
      $cdm_ws_pasepath = CDM_WS_MULTIACCESSKEY;
243
      break;
244

    
245
  }
246

    
247
  if (!$cdm_ws_pasepath) {
248
    drupal_set_message(t('Type parameter is not valid: ') . $type, 'error');
249
  }
250

    
251
  $queryParameters = '';
252
  if (is_numeric($pageSize)) {
253
    $queryParameters = "pageSize=" . $pageSize;
254
  }
255
  else {
256
    $queryParameters = "pageSize=0";
257
  }
258

    
259
  if (is_numeric($pageNumber)) {
260
    $queryParameters = "pageNumber=" . $pageNumber;
261
  }
262
  else {
263
    $queryParameters = "pageNumber=0";
264
  }
265
  $queryParameters = NULL;
266
  if ($taxonUuid) {
267
    $queryParameters = "findByTaxonomicScope=$taxonUuid";
268
  }
269
  $pager = cdm_ws_get($cdm_ws_pasepath, NULL, $queryParameters);
270

    
271
  if (!$pager || $pager->count == 0) {
272
    return array();
273
  }
274
  return $pager->records;
275
}
276

    
277

    
278
/**
279
 * Creates a list item for a table of content, suitable as data element for a themed list
280
 *
281
 * @see theme_list()
282
 *
283
 * @param $label
284
 * @param $http_request_params
285
 * @param $attributes
286
 * @return array
287
 */
288
function toc_list_item($label, $attributes = array(), $fragment = null) {
289

    
290
  // we better cache here since drupal_get_query_parameters has no internal static cache variable
291
  $http_request_params = drupal_static('http_request_params', drupal_get_query_parameters());
292

    
293
  $item =  array(
294
    'data' => l(
295
      $label,
296
      $_GET['q'],
297
      array(
298
        'attributes' => array('class' => array('toc')),
299
        'fragment' => generalizeString($label),
300
        'query' => $http_request_params,
301
      )
302
    ),
303
  );
304
  $item['attributes'] = $attributes;
305
  return $item;
306
}
307

    
308
/**
309
 * Creates the footnotes for the given CDM DescriptionElement instance.
310
 *
311
 * Footnotes are created for annotations and original sources,
312
 * optionally the sources are put into a separate bibliography.
313
 *
314
 * @param $descriptionElement
315
 *   A CDM DescriptionElement instance
316
 * @param $separator
317
 *   Optional parameter. The separator string to concatenate the footnote ids, default is ','
318
 * @param $footnote_list_key_suggestion
319
 *   will be overridden for original sources if the bibliography block is enabled
320
 *
321
 * @return String
322
 *   The foot note keys
323
 */
324
function cdm_create_description_element_footnotes($description_element, $separator = ',',
325
          $footnote_list_key_suggestion = null, $do_link_to_reference = FALSE,
326
          $do_link_to_name_used_in_source = FALSE
327
    ){
328

    
329

    
330
  // Annotations as footnotes.
331
  $footNoteKeys = cdm_annotations_as_footnotekeys($description_element, $footnote_list_key_suggestion);
332

    
333
  // Source references as footnotes.
334
  $bibliography_settings = get_bibliography_settings();
335
  $original_source_footnote_tag = $bibliography_settings['enabled'] == 1 ? 'div' : null; // null will cause original_source_footnote_list_key to use the default
336

    
337
  usort($description_element->sources, 'compare_original_sources');
338
  foreach ($description_element->sources as $source) {
339
    if (_is_original_source_type($source)) {
340
      $fn_key = FootnoteManager::addNewFootnote(
341
        original_source_footnote_list_key($footnote_list_key_suggestion),
342
        theme('cdm_OriginalSource', array(
343
          'source' => $source,
344
          'doLink' => $do_link_to_reference,
345
          'do_link_to_name_used_in_source' => $do_link_to_name_used_in_source
346

    
347
        )),
348
        $original_source_footnote_tag
349
      );
350
      // Ensure uniqueness of the footnote keys.
351
      cdm_add_footnote_to_array($footNoteKeys, $fn_key);
352
    }
353
  }
354
  // Sort and render footnote keys.
355
  $footnoteKeyListStr = '';
356
  asort($footNoteKeys);
357
  foreach ($footNoteKeys as $footNoteKey) {
358
    $footnoteKeyListStr .= theme('cdm_footnote_key',
359
      array(
360
        'footnoteKey' => $footNoteKey,
361
        'separator' => ($footnoteKeyListStr ? $separator : '')));
362
  }
363
  return $footnoteKeyListStr;
364
}
365

    
366

    
367
/**
368
 * Compare callback to be used in usort() to sort render arrays produced by compose_description_element().
369
 *
370
 * @param $a
371
 * @param $b
372
 */
373
function compare_description_element_render_arrays($a, $b){
374
  if ($a['#value'].$a['#value-suffix'] == $b['#value'].$b['#value-suffix']) {
375
    return 0;
376
  }
377
  return ($a['#value'].$a['#value-suffix'] < $b['#value'].$b['#value-suffix']) ? -1 : 1;
378

    
379
}
380

    
381

    
382
/**
383
 * @param $render_array
384
 * @param $element
385
 * @param $feature_block_settings
386
 * @param $element_markup
387
 * @param $footnote_list_key_suggestion
388
 */
389
function compose_description_element($element, $feature_block_settings, $element_markup, $footnote_list_key_suggestion, $prepend_feature_label = FALSE)
390
{
391

    
392
  $render_array = array(
393
    '#type' => 'html_tag',
394
    '#tag' => cdm_feature_block_element_tag_name($feature_block_settings),
395

    
396
    '#attributes' => array(
397
      'class' => array(
398
        'DescriptionElement',
399
        'DescriptionElement-' . $element->class,
400
        html_class_attribute_ref($element)
401
      )
402
    ),
403

    
404
    '#value' => '',
405
    '#value_suffix' => NULL
406

    
407
  );
408

    
409
  $annotations_and_sources = handle_annotations_and_sources($element, $feature_block_settings, $element_markup, $footnote_list_key_suggestion);
410

    
411
  // handle the special case were the TextData is used as container for original source with name
412
  // used in source information without any text stored in it.
413
  $names_used_in_source_markup = '';
414
  if (!empty($annotations_and_sources['names_used_in_source']) && empty($element_markup)) {
415
    $names_used_in_source_markup = join(', ', $annotations_and_sources['names_used_in_source']) . ': ';
416
    // remove all <span class="nameUsedInSource">...</span> from all source_references
417
    // these are expected to be at the end of the strings
418
    $pattern = '/ <span class="nameUsedInSource">.*$/';
419
    foreach( $annotations_and_sources['source_references'] as &$source_reference){
420
      $source_reference = preg_replace($pattern , '', $source_reference);
421
    }
422
  }
423

    
424

    
425
  $source_references_markup = '';
426
  if (!empty($annotations_and_sources['source_references'])) {
427
    $source_references_markup = '<span class="sources">' . join(' ', $annotations_and_sources['source_references']) . '<span>';
428
  }
429

    
430
  $feature_label = '';
431
  if ($prepend_feature_label) {
432
    $feature_label = '<span class="nested-feature-tree-feature-label">' . $element->feature->representation_L10n . ':</span> ';
433
  }
434
  $content_markup = $names_used_in_source_markup . $element_markup . $source_references_markup;
435

    
436
  if(!$content_markup && $feature_block_settings['sources_as_content'] !== 1 || $feature_block_settings['sources_as_content_to_bibliography'] == 1){
437
    // no textual content, so skip this element completely, even if there could be an footnote key
438
    // see #4379
439
    return null;
440
  }
441

    
442
    $render_array['#value'] = $feature_label . $content_markup;
443
    $render_array['#value_suffix'] = $annotations_and_sources['foot_note_keys'];
444
  return $render_array;
445
}
446

    
447

    
448
  /**
449
   * @param $element
450
   * @param $feature_block_settings
451
   * @param $element_text
452
   *   used to decide if the source references should be enclosed in brackets or not
453
   * @param $footnote_list_key_suggestion
454
   * @return array
455
   *   an associative array with the following elements:
456
   *   - foot_note_keys: all footnote keys as markup
457
   *   - source_references: an array of the source references citations
458
   *   - names used in source: an associative array of the names in source,
459
   *        the name in source strings are de-duplicated
460
   *        !!!NOTE!!!!: this field will most probably be removed soon (TODO)
461
   *
462
   *
463
   */
464
  function handle_annotations_and_sources($element, $feature_block_settings, $element_text, $footnote_list_key_suggestion) {
465
    $annotations_and_sources = array(
466
      'foot_note_keys' => NULL,
467
      'source_references' => array(),
468
      'names_used_in_source' => array()
469
    );
470

    
471
    usort($element->sources, 'compare_original_sources');
472

    
473
    if ($feature_block_settings['sources_as_content'] == 1) {
474
      foreach ($element->sources as $source) {
475

    
476
        $referenceCitation = theme('cdm_OriginalSource',
477
          array(
478
            'source' => $source,
479
            'doLink' => $feature_block_settings['link_to_reference'] == 1,
480
            'do_link_to_name_used_in_source' => $feature_block_settings['link_to_name_used_in_source'] == 1,
481
          )
482
        );
483

    
484
        if ($referenceCitation) {
485
          if (empty($element_text)) {
486
            $annotations_and_sources['source_references'][] = $referenceCitation;
487
          }
488
          else {
489
            $annotations_and_sources['source_references'][] = ' (' . $referenceCitation . ')';
490
          }
491
        }
492

    
493
        $name_in_source_render_array = compose_name_in_source(
494
          $source,
495
          $feature_block_settings['link_to_name_used_in_source'] == 1
496
        );
497

    
498
        if(!empty($name_in_source_render_array)){
499
          $annotations_and_sources['names_used_in_source'][$name_in_source_render_array['#_plaintext']] = drupal_render($name_in_source_render_array);
500
        }
501
      } // END of loop over sources
502

    
503
      // annotations footnotes separate.
504
      $annotations_and_sources['foot_note_keys'] = theme('cdm_annotations_as_footnotekeys',
505
        array(
506
          'cdmBase_list' => $element,
507
          'footnote_list_key' => $footnote_list_key_suggestion,
508
        )
509
      );
510

    
511
    } // END of references inline
512

    
513
    // put sources into bibliography if requested ...
514
    if ($feature_block_settings['sources_as_content'] !== 1 || $feature_block_settings['sources_as_content_to_bibliography'] == 1) {
515
      $annotations_and_sources['foot_note_keys'] = cdm_create_description_element_footnotes(
516
        $element, ',',
517
        $footnote_list_key_suggestion,
518
        $feature_block_settings['link_to_reference'] == 1,
519
        $feature_block_settings['link_to_name_used_in_source'] == 1
520
      );
521
    }
522

    
523
    return $annotations_and_sources;
524
  }
525

    
526

    
527
  /**
528
   *
529
   *
530
   * @return string
531
   *  the footnote_list_key
532
   */
533
  function original_source_footnote_list_key($key_suggestion = null) {
534
    if(!$key_suggestion){
535
      $key_suggestion = RenderHints::getFootnoteListKey();
536
    }
537
    $bibliography_settings = get_bibliography_settings();
538
    $footnote_list_key = $bibliography_settings['enabled'] == 1 ? 'BIBLIOGRAPHY' : 'BIBLIOGRAPHY-' . $key_suggestion;
539
    return $footnote_list_key;
540
  }
541

    
542
  /**
543
   * Provides the according tag name for the description element markup which fits the  $feature_block_settings['as_list'] value
544
   *
545
   * @param $feature_block_settings
546
   *   A feature_block_settings array, for details, please see get_feature_block_settings($feature_uuid = 'DEFAULT')
547
   */
548
  function cdm_feature_block_element_tag_name($feature_block_settings){
549
    switch ($feature_block_settings['as_list']){
550
      case 'ul':
551
      case 'ol':
552
        return 'li';
553
      case 'div':
554
        if(isset($feature_block_settings['element_tag'])){
555
          return $feature_block_settings['element_tag'];
556
        }
557
        return 'span';
558
      case 'dl':
559
        return 'dd';
560
      default:
561
        return 'div'; // should never happen, throw error instead?
562
    }
563
  }
564

    
565

    
566
/* ==================== COMPOSE FUNCTIONS =============== */
567

    
568
  /**
569
   * Returns a set of feature blocks for a taxon profile from the $mergedFeatureNodes of a given $taxon.
570
   *
571
   * The taxon profile consists of drupal block elements, one for the description elements
572
   * of a specific feature. The structure is defined by specific FeatureTree.
573
   * The chosen FeatureTree is merged with the list of description elements prior to using this method.
574
   *
575
   * The merged nodes can be obtained by making use of the
576
   * function cdm_ws_descriptions_by_featuretree().
577
   *
578
   * @see cdm_ws_descriptions_by_featuretree()
579
   *
580
   * @param $mergedFeatureNodes
581
   *
582
   * @param $taxon
583
   *
584
   * @return array
585
   *  A Drupal render array containing feature blocks and the table of content
586
   *
587
   * @ingroup compose
588
   */
589
  function compose_feature_blocks($mergedFeatureNodes, $taxon) {
590

    
591
    $block_list = array();
592

    
593
    $gallery_settings = getGallerySettings(CDM_DATAPORTAL_DESCRIPTION_GALLERY_NAME);
594

    
595

    
596
    RenderHints::pushToRenderStack('feature_block');
597
    // Create a drupal block for each feature
598
    foreach ($mergedFeatureNodes as $node) {
599

    
600
      if ((isset($node->descriptionElements['#type']) ||
601
          has_feature_node_description_elements($node)) && $node->feature->uuid != UUID_IMAGE) { // skip empty or suppressed features
602

    
603
        RenderHints::pushToRenderStack($node->feature->uuid);
604
          
605
        $feature_name = cdm_term_representation($node->feature, 'Unnamed Feature');
606
        $feature_block_settings = get_feature_block_settings($node->feature->uuid);
607
        
608

    
609
        $block = feature_block($feature_name, $node->feature);
610
        $block->content = array();
611
        $block_content_is_empty = TRUE;
612

    
613
        /*
614
         * Content/DISTRIBUTION.
615
         */
616
        if ($node->feature->uuid == UUID_DISTRIBUTION) {
617
          $block = compose_feature_block_distribution($taxon, $node->descriptionElements, $node->feature);
618
          $block_content_is_empty = FALSE;
619
        }
620
        /*
621
         * Content/COMMON_NAME.
622
         */
623
        else if ($node->feature->uuid == UUID_COMMON_NAME) {
624
          $common_names_render_array = compose_feature_block_items_feature_common_name($node->descriptionElements, $node->feature);
625
          $block->content[] = $common_names_render_array;
626
          $block_content_is_empty = FALSE;
627
        }
628

    
629
        else if ($node->feature->uuid == UUID_USE_RECORD) {
630
          $block_uses_content_html = theme('cdm_block_Uses', array('taxonUuid' => $taxon->uuid));
631
          $block->content[] = markup_to_render_array($block_uses_content_html);
632
          $block_content_is_empty = FALSE;
633
        }
634

    
635
        /*
636
         * Content/ALL OTHER FEATURES.
637
         */
638
        else {
639

    
640
          $media_list = array();
641
          $elements_render_array = array();
642
          $child_elements_render_array = null;
643

    
644
          if (isset($node->descriptionElements[0])) {
645
            $elements_render_array = compose_feature_block_items_generic($node->descriptionElements, $node->feature);
646
          }
647

    
648
          // Content/ALL OTHER FEATURES/Subordinate Features
649
          // subordinate features are printed inline in one floating text,
650
          // it is expected hat subordinate features can "contain" TextData,
651
          // Qualitative- and Qualitative- DescriptionElements
652
          if (isset($node->childNodes[0])) {
653
            $child_elements_render_array = compose_feature_block_items_nested($node, $media_list, $feature_block_settings);
654
            $elements_render_array = array_merge($elements_render_array, $child_elements_render_array);
655
          }
656
          $block_content_is_empty = $block_content_is_empty && empty($media_list) && empty($elements_render_array);
657
          if(!$block_content_is_empty){
658
            $block->content[] = compose_feature_block_wrap_elements($elements_render_array, $node->feature);
659
            $block->content[] = compose_feature_media_gallery($node, $media_list, $gallery_settings);
660
            /*
661
             * Footnotes for the feature block
662
             */
663
            $block->content[] = markup_to_render_array(theme('cdm_footnotes', array('footnoteListKey' => 'BIBLIOGRAPHY-' . $node->feature->uuid)));
664
            $block->content[] = markup_to_render_array(theme('cdm_footnotes', array('footnoteListKey' => $node->feature->uuid)));
665
            $block->content[] = markup_to_render_array(theme('cdm_annotation_footnotes', array('footnoteListKey' => $node->feature->uuid)));
666
          }
667
        } // END all other features
668

    
669
        // allows modifying the block contents via a the hook_cdm_feature_node_block_content_alter
670
        drupal_alter('cdm_feature_node_block_content', $block->content, $node->feature, $node->descriptionElements);
671

    
672
        if(!$block_content_is_empty){ // skip empty block content
673
          $block_list[] = $block;
674
          cdm_toc_list_add_item(cdm_term_representation($node->feature), $node->feature->uuid);
675
        } // END: skip empty block content
676
      } // END: skip empty or suppressed features
677
      RenderHints::popFromRenderStack();
678
    } // END: creating a block per feature
679

    
680
    RenderHints::popFromRenderStack();
681

    
682
    drupal_alter('cdm_feature_node_blocks', $block_list, $taxon);
683

    
684
    return _block_get_renderable_array($block_list);
685
  }
686

    
687
/**
688
 * Creates a render array of description elements  held by child nodes of the given feature node.
689
 *
690
 * This function is called recursively!
691
 *
692
 * @param $node
693
 *   The feature node.
694
 * @param array $media_list
695
 *   List of CDM Media entities. All media of subordinate elements should be passed to the main feature.ä
696
 * @param $feature_block_settings
697
 *   The feature block settings.
698
 * @param $main_feature
699
 *  Only used internally in recursive calls.
700
 *
701
 * @return array
702
 *  A Drupal render array
703
 *
704
 * @ingroup compose
705
 */
706
function compose_feature_block_items_nested($node, &$media_list, $feature_block_settings, $main_feature = NULL)
707
{
708

    
709
  if(!$main_feature){
710
    $main_feature = $node->feature;
711
  }
712
  /*
713
   * TODO should be configurable, options; YES, NO, AUTOMATIC
714
   * (automatic will only place the label if the first word of the description element text is not the same)
715
   */
716
  $prepend_feature_label = false;
717

    
718
  $render_arrays = array();
719
  foreach ($node->childNodes as $child_node) {
720
    if (isset($child_node->descriptionElements[0])) {
721
      foreach ($child_node->descriptionElements as $element) {
722

    
723
        if (isset($element->media[0])) {
724
          // Append media of subordinate elements to list of main
725
          // feature.
726
          $media_list = array_merge($media_list, $element->media);
727
        }
728

    
729
        $child_node_element = null;
730
        switch ($element->class) {
731
          case 'TextData':
732
            $child_node_element = compose_description_element_text_data($element, $element->feature->uuid, $feature_block_settings, $prepend_feature_label);
733
            break;
734
          case 'CategoricalData':
735
            $child_node_element = compose_description_element_categorical_data($element, $feature_block_settings, $prepend_feature_label);
736
            break;
737
          case 'QuantitativeData':
738
            $child_node_element = compose_description_element_quantitative_data($element, $feature_block_settings, $prepend_feature_label);
739

    
740
        }
741
        if (is_array($child_node_element)) {
742
          $render_arrays[] = $child_node_element;
743
        }
744
      }
745
    }
746

    
747
    if(isset($child_node->childNodes[0])){
748
      $render_arrays = array_merge($render_arrays, compose_feature_block_items_nested($child_node, $media_list, $feature_block_settings, $main_feature ));
749
    }
750
  }
751

    
752
  return $render_arrays;
753
}
754

    
755
  /**
756
   *
757
   * @param $node
758
   *  The merged feature three node which potentially contains media in its description elements.
759
   * @param $media_list
760
   *    Additional media to be merged witht the media contained in the nodes description elements
761
   * @param $gallery_settings
762
   * @return array
763
   *
764
   * @ingroup compose
765
   */
766
  function compose_feature_media_gallery($node, $media_list, $gallery_settings) {
767

    
768
    if (isset($node->descriptionElements)) {
769
      $media_list = array_merge($media_list, cdm_dataportal_media_from_descriptionElements($node->descriptionElements));
770
    }
771

    
772
    $captionElements = array('title', 'rights');
773

    
774
    if (isset($media_list[0]) && isset($gallery_settings['cdm_dataportal_media_maxextend']) && isset($gallery_settings['cdm_dataportal_media_cols'])) {
775
      $gallery = theme('cdm_media_gallerie', array(
776
        'mediaList' => $media_list,
777
        'galleryName' => CDM_DATAPORTAL_DESCRIPTION_GALLERY_NAME . '_' . $node->feature->uuid,
778
        'maxExtend' => $gallery_settings['cdm_dataportal_media_maxextend'],
779
        'cols' => $gallery_settings['cdm_dataportal_media_cols'],
780
        'captionElements' => $captionElements,
781
      ));
782
      return markup_to_render_array($gallery);
783
    }
784

    
785
    return markup_to_render_array('');
786
  }
787

    
788
  /**
789
   * Composes the distribution feature block for a taxon
790
   *
791
   * @param $taxon
792
   * @param $descriptionElements
793
   *   an associative array with two elements:
794
   *   - '#type': must be 'DTO'
795
   *   - 'DistributionInfoDTO': a CDM DistributionInfoDTO object as returned by the DistributionInfo web service
796
   * @param $feature
797
   *
798
   * @return array
799
   *  A drupal render array
800
   *
801
   * @ingroup compose
802
   */
803
  function compose_feature_block_distribution($taxon, $descriptionElements, $feature) {
804
    $text_data_glue = '';
805
    $text_data_sortOutArray = FALSE;
806
    $text_data_enclosingTag = 'ul';
807
    $text_data_out_array = array();
808

    
809
    $distributionElements = NULL;
810
    $distribution_info_dto = NULL;
811
    $distribution_sortOutArray = FALSE;
812

    
813
    $feature_block_settings = get_feature_block_settings(UUID_DISTRIBUTION);
814

    
815
    // TODO use feature_block_settings instead of DISTRIBUTION_ORDER_MODE
816
    if (variable_get(DISTRIBUTION_ORDER_MODE, DISTRIBUTION_ORDER_MODE_DEFAULT) != 'TREE') {
817
      $distribution_glue = '';
818
      $distribution_enclosingTag = 'dl';
819
    } else {
820
      $distribution_glue = '';
821
      $distribution_enclosingTag = 'ul';
822
    }
823

    
824
    if (!isset($descriptionElements['#type']) || !$descriptionElements['#type'] == 'DTO') {
825
      // skip the DISTRIBUTION section if there is no DTO type element
826
      return array(); // FIXME is it ok to return an empty array?
827
    }
828

    
829
    $block = feature_block(
830
      cdm_term_representation($feature, 'Unnamed Feature'),
831
      $feature
832
    );
833

    
834
    // $$descriptionElements['TextData'] is added to to the feature node in merged_taxon_feature_tree()
835
    if (isset($descriptionElements['TextData'])) {
836
      // --- TextData
837
      foreach ($descriptionElements['TextData'] as $text_data_element) {
838
        $text_data_render_array = compose_description_element_text_data($text_data_element, $text_data_element->feature->uuid, $feature_block_settings);
839
        $repr = drupal_render($text_data_render_array);
840

    
841
        if (!array_search($repr, $text_data_out_array)) { // de-duplication !!
842
          $text_data_out_array[] = $repr;
843
          // TODO HINT: sorting in compose_feature_block_wrap_elements will
844
          // not work since this array contains html attributes with uuids
845
          // and what is about cases like the bibliography where
846
          // any content can be prefixed with some foot-note anchors?
847
          $text_data_sortOutArray = TRUE;
848
          $text_data_glue = '<br/> ';
849
          $text_data_enclosingTag = 'p';
850
        }
851
      }
852
    }
853

    
854

    
855
    if ($text_data_out_array && variable_get(DISTRIBUTION_TEXTDATA_DISPLAY_ON_TOP, 0)) {
856
      $block->content[] = compose_feature_block_wrap_elements(
857
        $text_data_out_array, $feature, $text_data_glue, $text_data_sortOutArray
858
      );
859
    }
860

    
861
    // --- Distribution map
862
    $distribution_map_query_parameters = NULL;
863

    
864
    if(variable_get(DISTRIBUTION_MAP_VISIBILITY) == 'always' ||
865
        variable_get(DISTRIBUTION_MAP_VISIBILITY) == 'automatic' && isset($descriptionElements['DistributionInfoDTO']->mapUriParams)
866
      )
867
    {
868
      $distribution_map_query_parameters = $descriptionElements['DistributionInfoDTO']->mapUriParams;
869
    }
870
    $map_render_element = compose_distribution_map($distribution_map_query_parameters);
871
    $block->content[] = $map_render_element;
872

    
873
    $dto_out_array = array();
874

    
875
    // --- Condensed Distribution
876
    if(variable_get(DISTRIBUTION_CONDENSED) && isset($descriptionElements['DistributionInfoDTO']->condensedDistribution)){
877
      $condensed_distribution_markup = '<p class="condensed_distribution">';
878

    
879
      $isFirst = true;
880
      if(isset($descriptionElements['DistributionInfoDTO']->condensedDistribution->indigenous[0])){
881
        foreach($descriptionElements['DistributionInfoDTO']->condensedDistribution->indigenous as $cdItem){
882
          if(!$isFirst){
883
            $condensed_distribution_markup .= ' ';
884
          }
885
          $condensed_distribution_markup .= '<span class="status_' . $cdItem->status->idInVocabulary . '">'
886
          . $cdItem->areaStatusLabel . '</span>';
887
          $isFirst = false;
888
        }
889
      }
890

    
891
      if(isset($descriptionElements['DistributionInfoDTO']->condensedDistribution->foreign[0])) {
892
        if(!$isFirst){
893
          $condensed_distribution_markup .= ' ';
894
        }
895
        $isFirst = TRUE;
896
        $condensed_distribution_markup .= '[';
897
        foreach ($descriptionElements['DistributionInfoDTO']->condensedDistribution->foreign as $cdItem) {
898
          if (!$isFirst) {
899
            $condensed_distribution_markup .= ' ';
900
          }
901
          $condensed_distribution_markup .= '<span class="status_' . $cdItem->status->titleCache . '">'
902
            . $cdItem->areaStatusLabel . '</span>';
903
          $isFirst = false;
904
        }
905
        $condensed_distribution_markup .= ']';
906
      }
907

    
908
      $condensed_distribution_markup .= '&nbsp;' . l(
909
          font_awesome_icon_markup(
910
            'fa-info-circle',
911
            array(
912
              'alt'=>'help',
913
              'class' => array('superscript')
914
            )
915
          ),
916
          variable_get(DISTRIBUTION_CONDENSED_INFO_PATH, DISTRIBUTION_CONDENSED_INFO_PATH_DEFAULT) ,
917
          array('html' => TRUE));
918
      $condensed_distribution_markup .= '</p>';
919
      $dto_out_array[] = $condensed_distribution_markup;
920
    }
921

    
922
    // --- tree or list
923
    if (isset($descriptionElements['DistributionInfoDTO'])) {
924
      $distribution_info_dto = $descriptionElements['DistributionInfoDTO'];
925

    
926
      // --- tree
927
      if (is_object($distribution_info_dto->tree)) {
928
        $distribution_tree_render_array = compose_distribution_hierarchy($distribution_info_dto->tree, $feature_block_settings);
929
        $dto_out_array[] = $distribution_tree_render_array;
930
      }
931

    
932
      // --- sorted element list
933
      if (is_array($distribution_info_dto->elements) && count($distribution_info_dto->elements) > 0) {
934
        foreach ($distribution_info_dto->elements as $descriptionElement) {
935
          if (is_object($descriptionElement->area)) {
936
            $sortKey = $descriptionElement->area->representation_L10n;
937
            $distributionElements[$sortKey] = $descriptionElement;
938
          }
939
        }
940
        ksort($distributionElements);
941
        $distribution_element_render_array = compose_description_elements_distribution($distributionElements);
942
        $dto_out_array[] = $distribution_element_render_array;
943

    
944
      }
945
      //
946
      $block->content[] = compose_feature_block_wrap_elements(
947
        $dto_out_array, $feature, $distribution_glue, $distribution_sortOutArray
948
      );
949
    }
950

    
951
    // --- TextData at the bottom
952
    if ($text_data_out_array && !variable_get(DISTRIBUTION_TEXTDATA_DISPLAY_ON_TOP, 0)) {
953
      $block->content[] = compose_feature_block_wrap_elements(
954
        $text_data_out_array, $feature, $text_data_glue, $text_data_sortOutArray
955
      );
956
    }
957

    
958
    $block->content[] = markup_to_render_array(theme('cdm_footnotes', array('footnoteListKey' => 'BIBLIOGRAPHY-' . UUID_DISTRIBUTION)));
959
    $block->content[] = markup_to_render_array(theme('cdm_footnotes', array('footnoteListKey' => UUID_DISTRIBUTION)));
960
    $block->content[] = markup_to_render_array(theme('cdm_annotation_footnotes', array('footnoteListKey' => UUID_DISTRIBUTION)));
961

    
962
    return $block;
963
  }
964

    
965

    
966
  /**
967
   * Composes a drupal render array for single CDM TextData description element.
968
   *
969
   * @param $element
970
   *    The CDM TextData description element.
971
   *  @param $feature_uuid
972
   * @param bool $prepend_feature_label
973
   *   Used in nested feature trees to put the feature as label in front of the description element text representation.
974
   *
975
   * @return array
976
   *   A drupal render array with the following elements being used:
977
   *    - #tag: either 'div', 'li', ...
978
   *    ⁻ #attributes: class attributes
979
   *    - #value_prefix: (optionally) contains footnote anchors
980
   *    - #value: contains the textual content
981
   *    - #value_suffix: (optionally) contains footnote keys
982
   *
983
   * @ingroup compose
984
   */
985
  function compose_description_element_text_data($element, $feature_uuid, $feature_block_settings, $prepend_feature_label = FALSE) {
986

    
987
    $footnote_list_key_suggestion = $feature_uuid;
988

    
989
    $element_markup = '';
990
    if (isset($element->multilanguageText_L10n->text)) {
991
      // TODO replacement of \n by <br> should be configurable
992
      $element_markup = str_replace("\n", "<br/>", $element->multilanguageText_L10n->text);
993
    }
994

    
995
    $render_array = compose_description_element($element, $feature_block_settings, $element_markup, $footnote_list_key_suggestion, $prepend_feature_label);
996

    
997
    return $render_array;
998
  }
999

    
1000

    
1001
/**
1002
 * Theme function to render CDM DescriptionElements of the type TaxonInteraction.
1003
 *
1004
 * @param $element
1005
 *  The CDM TaxonInteraction entity
1006
 *
1007
 * @return
1008
 *  A drupal render array
1009
 *
1010
 * @ingroup compose
1011
 */
1012
function compose_description_element_taxon_interaction($element, $feature_block_settings) {
1013

    
1014
  $out = '';
1015

    
1016

    
1017
  if (isset($element->description_L10n)) {
1018
    $out .=  ' ' . $element->description_L10n;
1019
  }
1020

    
1021
  if(isset($element->taxon2)){
1022
    $out = render_taxon_or_name($element->taxon2, url(path_to_taxon($element->taxon2->uuid)));
1023
  }
1024

    
1025
  $render_array = compose_description_element($element, $feature_block_settings, $out, $element->feature->uuid);
1026

    
1027
  return $render_array;
1028
}
1029

    
1030

    
1031
/**
1032
 * Renders a single instance of the type IndividualsAssociations.
1033
 *
1034
 * @param $element
1035
 *   The CDM IndividualsAssociations entity.
1036
 * @param $feature_block_settings
1037
 *
1038
 * @return array
1039
 *   Drupal render array
1040
 *
1041
 * @ingroup compose
1042
 */
1043
function compose_description_element_individuals_association($element, $feature_block_settings) {
1044

    
1045
  $out = '';
1046

    
1047
  $render_array = compose_cdm_specimenOrObservation($element->associatedSpecimenOrObservation);
1048

    
1049
  if (isset($element->description_L10n)) {
1050
    $out .=  ' ' . $element->description_L10n;
1051
  }
1052

    
1053
  $out .= drupal_render($render_array);
1054

    
1055
  $render_array = compose_description_element($element, $feature_block_settings, $out, $element->feature->uuid);
1056

    
1057
  return $render_array;
1058
}
1059

    
1060
/**
1061
 * Renders a single instance of the type CategoricalData.
1062
 *
1063
 * @param $element
1064
 *  The CDM CategoricalData entity
1065
 *
1066
 * @param $feature_block_settings
1067
 *
1068
 * @param bool $prepend_feature_label
1069
 *   Used in nested feature trees to put the feature as label in front of the description element text representation.
1070
 *
1071
 * @return string
1072
 *   a html representation of the given CategoricalData element
1073
 *
1074
 * @ingroup compose
1075
 */
1076
function compose_description_element_categorical_data($element, $feature_block_settings, $prepend_feature_label = FALSE) {
1077

    
1078
  $enclosing_tag = cdm_feature_block_element_tag_name($feature_block_settings);
1079

    
1080
  $state_data_strings = array();
1081
  if (isset($element->stateData)) {
1082
    foreach ($element->stateData as $state_data) {
1083

    
1084
      $state  = NULL;
1085

    
1086
      if (isset($state_data->state)) {
1087
        $state = cdm_term_representation($state_data->state);
1088
      }
1089

    
1090
      if (isset($state_data->modifyingText_L10n)) {
1091
        $state = ' ' . $state_data->modifyingText_L10n;
1092
      }
1093

    
1094
      $modifiers_strings = cdm_modifers_representations($state_data);
1095

    
1096
      $state_data_strings[] = $state . ($modifiers_strings ? ' ' . $modifiers_strings : '');
1097

    
1098
    }
1099
  }
1100

    
1101
  $out = '<span class="' . html_class_attribute_ref($element) . '">' . implode(', ', $state_data_strings) . '</span>';
1102

    
1103
  $render_array = compose_description_element($element, $feature_block_settings, $out, $element->feature->uuid, $prepend_feature_label);
1104

    
1105
  return $render_array;
1106
}
1107

    
1108

    
1109
/**
1110
 * Theme function to render CDM DescriptionElements of the type QuantitativeData.
1111
 *
1112
 * The function renders the statisticalValues contained in the QuantitativeData
1113
 * entity according to the following scheme:
1114
 *
1115
 * (ExtremeMin)-Min-Average-Max-(ExtremeMax)
1116
 *
1117
 * All modifiers of these values are appended.
1118
 *
1119
 * If the QuantitativeData is containing more statisticalValues with further
1120
 * statisticalValue types, these additional measures will be appended to the
1121
 * above string separated by whitespace.
1122
 *
1123
 * Special cases;
1124
 * 1. Min==Max: this will be interpreted as Average
1125
 *
1126
 * @param $element
1127
 *  The CDM QuantitativeData entity
1128
 *
1129
 * @param $feature_block_settings
1130
 *
1131
 * @param bool $prepend_feature_label
1132
 *   Used in nested feature trees to put the feature as label in front of the description element text representation.
1133
 *
1134
 *
1135
 * @return string
1136
 *   a html representation of the given QuantitativeData element
1137
 *
1138
 * @ingroup themeable
1139
 */
1140
function compose_description_element_quantitative_data($element, $feature_block_settings, $prepend_feature_label = FALSE) {
1141
  /*
1142
   * - statisticalValues
1143
   *   - value
1144
   *   - modifiers
1145
   *   - type
1146
   * - unit->representation_L10n
1147
   * - modifyingText
1148
   * - modifiers
1149
   * - sources
1150
   */
1151

    
1152
  $out = '';
1153
  $type_representation = NULL;
1154
  $min_max = min_max_array();
1155

    
1156

    
1157
  $other_values = array();
1158

    
1159
  if (isset($element->statisticalValues)) {
1160
    $other_values_markup = array();
1161
    foreach ($element->statisticalValues as $statistical_val) {
1162

    
1163
      // compile the full value string which also may contain modifiers
1164
      if (isset($statistical_val->value)) {
1165
        $statistical_val->_value = $statistical_val->value;
1166
      }
1167
      $val_modifiers_strings = cdm_modifers_representations($statistical_val);
1168
      if ($val_modifiers_strings) {
1169
        $statistical_val->_value = ' ' . $val_modifiers_strings . ' ' . $statistical_val->_value;
1170
      }
1171

    
1172
      // either put into min max array or into $other_values
1173
      // for generic output to be appended to 'min-max' string
1174
      if (array_key_exists($statistical_val->type->titleCache, $min_max)) {
1175
        $min_max[$statistical_val->type->titleCache] = $statistical_val;
1176
      }
1177
      else {
1178
        $other_values[] = $statistical_val;
1179
      }
1180
    } // end of loop over statisticalValues
1181

    
1182
    // create markup
1183

    
1184
    $min_max_markup = min_max_markup($min_max);
1185

    
1186

    
1187
    foreach ($other_values as $statistical_val) {
1188
      $statistical_val_type_representation = NULL;
1189
      if (isset($statistical_val->type)) {
1190
        $statistical_val_type_representation = cdm_term_representation($statistical_val->type);
1191
        // $statistical_val->type->termType;
1192
        // $statistical_val->type->userFriendlyTypeName;
1193
      }
1194
      $value_markup = '<span class="' . html_class_attribute_ref($statistical_val) . ' ' . $statistical_val->type->termType . ' ">'
1195
        . $statistical_val->_value . '</span>';
1196
      $value_markup = $value_markup .
1197
        ($statistical_val_type_representation ? ' <span class="type">' . $statistical_val_type_representation . '</span>' : '');
1198
      $other_values_markup[] = $value_markup;
1199
    }
1200

    
1201

    
1202
    $out .= $min_max_markup . ' ' . implode($other_values_markup, ', ');
1203
  }
1204

    
1205
  if (isset($element->unit)) {
1206
    $out .= ' <span class="unit" title="'
1207
      . cdm_term_representation($element->unit) . '">'
1208
      . cdm_term_representation_abbreviated($element->unit)
1209
      . '</span>';
1210
  }
1211

    
1212
  // modifiers of the description element itself
1213
  $modifier_string = cdm_modifers_representations($element);
1214
  $out .= ($modifier_string ? ' ' . $modifier_string : '');
1215
  if (isset($element->modifyingText_L10n)) {
1216
    $out = $element->modifyingText_L10n . ' ' . $out;
1217
  }
1218

    
1219
  $render_array = compose_description_element($element, $feature_block_settings, $out, $element->feature->uuid, $prepend_feature_label);
1220

    
1221
  return $render_array;
1222
}
1223

    
1224

    
1225
/**
1226
 * Wraps the render array for the given feature into an enclosing html tag.
1227
 *
1228
 * Optionally the elements can be sorted and glued together by a separator string.
1229
 *
1230
 * @param array $description_element_render_arrays
1231
 *   An list of render arrays. Which are usually are produced by the compose_description_element()
1232
 *   function. The render arrays should be of #type=html_tag, so that they can understand the #attribute property.
1233
 * @param  $feature :
1234
 *  The feature to which the elements given in $elements are belonging to.
1235
 * @param string $glue :
1236
 *  Defaults to empty string.
1237
 * @param bool $sort
1238
 *   Boolean Whether to sort the $elements alphabetically, default is FALSE
1239
 *
1240
 * @return array
1241
 *    A Drupal render array
1242
 *
1243
 * @ingroup compose
1244
 */
1245
  function compose_feature_block_wrap_elements(array $description_element_render_arrays, $feature, $glue = '', $sort = FALSE)
1246
  {
1247

    
1248
    $feature_block_settings = get_feature_block_settings($feature->uuid);
1249
    $enclosing_tag = $feature_block_settings['as_list'];
1250

    
1251
    if ($sort) { // TODO remove parameter and replace by $feature_block_settings['sort_elements']
1252
      usort($description_element_render_arrays, 'compare_description_element_render_arrays');
1253
    }
1254

    
1255
    $is_first = true;
1256
    foreach($description_element_render_arrays as &$element_render_array){
1257
      if(!is_array($element_render_array)){
1258
        $element_render_array = markup_to_render_array($element_render_array);
1259
      }
1260
      $element_render_array['#attributes']['class'][] = "feature-block-element";
1261

    
1262
      // add the glue!
1263
      if(!$is_first) {
1264
        if (isset($element_render_array['#value'])) {
1265
          $element_render_array['#value'] = $glue . $element_render_array['#value'];
1266
        } elseif (isset($element_render_array['#markup'])) {
1267
          $element_render_array['#markup'] = $glue . $element_render_array['#markup'];
1268
        }
1269
      }
1270
      $is_first = false;
1271
    }
1272

    
1273
    $render_array['elements']['children'] = $description_element_render_arrays;
1274

    
1275
    $render_array['elements']['#prefix'] = '<' . $enclosing_tag . ' class="feature-block-elements" id="' . $feature->representation_L10n . '">';
1276
    $render_array['elements']['#suffix'] = '</' . $enclosing_tag . '>';
1277

    
1278
    return $render_array;
1279
  }
1280

    
1281

    
1282
  /* compose nameInSource or originalNameString as markup
1283
   *
1284
   * @param $source
1285
   * @param $do_link_to_name_used_in_source
1286
   * @param $suppress_for_shown_taxon
1287
   *    the nameInSource will be suppressed when it has the same name as the accepted taxon
1288
   *    for which the taxon page is being created, Defaults to TRUE
1289
   *
1290
   * @return array
1291
   *    A Drupal render array with an additional element, the render array is empty
1292
   *    if the source had no name in source information
1293
   *    - #_plaintext: contains the plaintext version of the name (custom element)
1294
   *
1295
   * @ingroup compose
1296
   */
1297
  function compose_name_in_source($source, $do_link_to_name_used_in_source, $suppress_for_shown_taxon = TRUE) {
1298

    
1299
    $plaintext = NULL;
1300
    $markup = NULL;
1301
    $name_in_source_render_array = array();
1302

    
1303
    static $taxon_page_accepted_name = '';
1304
    $taxon_uuid = get_current_taxon_uuid();
1305
    if($suppress_for_shown_taxon && $taxon_uuid && empty($taxon_page_accepted_name)){
1306

    
1307
      $current_taxon = cdm_ws_get(CDM_WS_PORTAL_TAXON, $taxon_uuid);
1308
      $taxon_page_accepted_name = $current_taxon->name->titleCache;
1309
    }
1310

    
1311
    if (isset($source->nameUsedInSource->uuid) && isset($source->nameUsedInSource->titleCache)) {
1312
      // it is a DescriptionElementSource !
1313
      $plaintext = $source->nameUsedInSource->titleCache;
1314
      if($suppress_for_shown_taxon && $taxon_page_accepted_name == $plaintext){
1315
        return $name_in_source_render_array; // SKIP this name
1316
      }
1317
      $markup = render_taxon_or_name($source->nameUsedInSource);
1318
      if ($do_link_to_name_used_in_source) {
1319
        $markup = l(
1320
          $markup,
1321
          path_to_name($source->nameUsedInSource->uuid),
1322
          array(
1323
            'attributes' => array(),
1324
            'absolute' => TRUE,
1325
            'html' => TRUE,
1326
          ));
1327
      }
1328
    }
1329
    else if (isset($source->originalNameString) && !empty($source->originalNameString)) {
1330
      // the name used in source can not be expressed as valid taxon name,
1331
      // so the editor has chosen to put the freetext name into ReferencedEntityBase.originalNameString
1332
      // field
1333
      // using the originalNameString as key to avoid duplicate entries
1334
      $plaintext = $source->originalNameString;
1335
      if($suppress_for_shown_taxon && $taxon_page_accepted_name == $plaintext){
1336
        return $name_in_source_render_array; // SKIP this name
1337
      }
1338
      $markup = $source->originalNameString;
1339
    }
1340

    
1341
    if ($plaintext) { // checks if we have any content
1342
      $name_in_source_render_array = markup_to_render_array($markup);
1343
      $name_in_source_render_array['#_plaintext'] = $plaintext;
1344
    }
1345

    
1346
    return $name_in_source_render_array;
1347
  }
1348

    
1349

    
1350

    
1351
  /**
1352
   * Return HTML for a list of description elements.
1353
   *
1354
   * Usually these are of a specific feature type.
1355
   *
1356
   * @param $description_elements
1357
   *   array of descriptionElements which belong to the same feature.
1358
   *   These descriptions elements of a Description must be ordered by the chosen feature tree by
1359
   *   calling the function _mergeFeatureTreeDescriptions().
1360
   *   @see _mergeFeatureTreeDescriptions()
1361
   *
1362
   * @param  $feature_uuid
1363
   *
1364
   * @return
1365
   *    A drupal render array for the $descriptionElements, may be an empty array if the textual content was empty.
1366
   *    Footnote key or anchors are not considered to be textual content.
1367
   *
1368
   * @ingroup compose
1369
   */
1370
  function compose_feature_block_items_generic($description_elements, $feature) {
1371

    
1372
    $elements_out_array = array();
1373
    $distribution_tree = null;
1374

    
1375
    /*
1376
     * $feature_block_has_content will be set true if at least one of the
1377
     * $descriptionElements contains some text which makes up some content
1378
     * for the feature block. Footnote keys are not considered
1379
     * to be content in this sense.
1380
     */
1381
    $feature_block_has_content = false;
1382

    
1383
    if (is_array($description_elements)) {
1384
      foreach ($description_elements as $description_element) {
1385
          /* decide based on the description element class
1386
           *
1387
           * Features handled here:
1388
           * all except DISTRIBUTION, COMMON_NAME, USES, IMAGES,
1389
           *
1390
           * TODO provide api_hook as extension point for this?
1391
           */
1392
        $feature_block_settings = get_feature_block_settings($description_element->feature->uuid);
1393
        switch ($description_element->class) {
1394
          case 'TextData':
1395
            $elements_out_array[] = compose_description_element_text_data($description_element, $description_element->feature->uuid, $feature_block_settings);
1396
            break;
1397
          case 'CategoricalData':
1398
            $elements_out_array[] = compose_description_element_categorical_data($description_element, $feature_block_settings);
1399
            break;
1400
          case 'QuantitativeData':
1401
            $elements_out_array[] = compose_description_element_quantitative_data($description_element, $feature_block_settings);
1402
            break;
1403
          case 'IndividualsAssociation':
1404
            $elements_out_array[] = compose_description_element_individuals_association($description_element, $feature_block_settings);
1405
            break;
1406
          case 'TaxonInteraction':
1407
            $elements_out_array[] = compose_description_element_taxon_interaction($description_element, $feature_block_settings);
1408
            break;
1409
          case 'CommonTaxonName':
1410
            $elements_out_array[] = compose_description_element_common_taxon_name($description_element, $feature_block_settings);
1411
            break;
1412
          case 'Uses':
1413
            /* IGNORE Uses classes, these are handled completely in theme_cdm_UseDescription */
1414
            break;
1415
          default:
1416
            $feature_block_has_content = true;
1417
            $elements_out_array[] = markup_to_render_array('<li>No method for rendering unknown description class: ' . $description_element->class . '</li>');
1418
        }
1419
        $elements_out_array_last_item = $elements_out_array[count($elements_out_array) - 1];
1420
        // considering not empty as long as the last item added is a render array
1421
        $feature_block_has_content = $feature_block_has_content || !empty($elements_out_array_last_item['#type']);
1422
      }
1423

    
1424
      // If feature = CITATION sort the list of sources.
1425
      // This is ONLY for FLORA MALESIANA and FLORE d'AFRIQUE CENTRALE.
1426
      if (isset($description_element) && $description_element->feature->uuid == UUID_CITATION) {
1427
        sort($elements_out_array);
1428
      }
1429
    }
1430

    
1431
    // sanitize: remove empty and NULL items from the render array
1432
    $tmp_out_array = $elements_out_array;
1433
    $elements_out_array = array();
1434
    foreach($tmp_out_array as $item){
1435
      if(is_array($item) && count($item) > 0){
1436
        $elements_out_array[] = $item;
1437
      }
1438
    }
1439

    
1440
    return $elements_out_array;
1441
  }
1442

    
1443
/**
1444
 * Composes block of common names for the given DescriptionElements $elements which must be of the feature CommonName
1445
 *
1446
 * @parameter $elements
1447
 *  an array of CDM DescriptionElements either of type CommonName or TextData
1448
 * @parameter $feature
1449
 *  the common feature of all $elements, must be CommonName
1450
 *
1451
 * @return
1452
 *   A drupal render array
1453
 *
1454
 * @ingroup compose
1455
 */
1456
function compose_feature_block_items_feature_common_name($elements, $feature, $weight = FALSE) {
1457

    
1458
  $common_name_out = '';
1459
  $common_name_feature_elements = array();
1460
  $textData_commonNames = array();
1461

    
1462
  $footnote_key_suggestion = 'common-names-feature-block';
1463

    
1464
  $feature_block_settings = get_feature_block_settings(UUID_COMMON_NAME);
1465

    
1466
  if (is_array($elements)) {
1467
    foreach ($elements as $element) {
1468

    
1469
      if ($element->class == 'CommonTaxonName') {
1470

    
1471
        // common name without a language or area, should not happen but is possible
1472
        $language_area_key = '';
1473
        if (isset($element->language->representation_L10n)) {
1474
          $language_area_key .= '<span class="language-label">' . $element->language->representation_L10n . '</span>';
1475
        }
1476
        if(isset($element->area->titleCache) && strlen($element->area->titleCache) > 0){
1477
          $language_area_key .= ($language_area_key ? ' '  : '') . '(' . $element->area->titleCache . ')';
1478
        }
1479

    
1480
        if(isset($common_names[$language_area_key][$element->name])) {
1481
          // same name already exists for language and area combination, se we merge the description elements
1482
          cdm_merge_description_elements($common_names[$language_area_key][$element->name], $element);
1483
        } else{
1484
          // otherwise add as new entry
1485
          $common_names[$language_area_key][$element->name] = $element;
1486
        }
1487

    
1488
      }
1489
      elseif ($element->class == 'TextData') {
1490
        $textData_commonNames[] = $element;
1491
      }
1492
    }
1493
  }
1494
  // Handling common names.
1495
  if (isset($common_names) && count($common_names) > 0) {
1496
    // Sorting the array based on the key (language, + area if set).
1497
    // Comment @WA there are common names without a language, so this sorting
1498
    // can give strange results.
1499
    ksort($common_names);
1500

    
1501
    // loop over set of elements per language area
1502
    foreach ($common_names as $language_area_key => $elements) {
1503
      ksort($elements); // sort names alphabetically
1504
      $per_language_area_out = array();
1505

    
1506
      foreach ($elements as $element) {
1507
        $common_name_render_array = compose_description_element_common_taxon_name($element, $feature_block_settings, $footnote_key_suggestion);
1508
        $common_name_markup = drupal_render($common_name_render_array);
1509
        // IMPORTANT!
1510
        // during the above drupal_render the theme_html_tag function is executed, which adds a "\n" character to the end of the markup
1511
        // this is an error and the trailing whitespace needs to be removed
1512
        if(str_endsWith($common_name_markup, "\n")){
1513
          $common_name_markup = substr($common_name_markup, 0, strlen($common_name_markup) - 1);
1514
        }
1515
        $per_language_area_out[] = $common_name_markup;
1516
      }
1517

    
1518
      $common_name_feature_elements[] = ($language_area_key ? $language_area_key . ': ' : '' ) . join(', ', $per_language_area_out);
1519
    } // End of loop over set of elements per language area
1520

    
1521

    
1522
    $common_name_feature_elements_render_array = compose_feature_block_wrap_elements(
1523
      $common_name_feature_elements, $feature, '; ', FALSE
1524
    );
1525
    $common_name_out .= drupal_render($common_name_feature_elements_render_array); // FIXME should this be a render array instead?
1526

    
1527
  }
1528

    
1529
  // Handling commons names as text data.
1530
  $text_data_out = array();
1531

    
1532
  foreach ($textData_commonNames as $text_data_element) {
1533
    /* footnotes are not handled correctly in compose_description_element_text_data,
1534
       need to set 'common-names-feature-block' as $footnote_key_suggestion */
1535
    RenderHints::setFootnoteListKey($footnote_key_suggestion);
1536
    $text_data_render_array = compose_description_element_text_data($text_data_element, $text_data_element->feature->uuid, $feature_block_settings);
1537
    $text_data_out[] = drupal_render($text_data_render_array);
1538
  }
1539

    
1540
  $common_name_out_text_data = compose_feature_block_wrap_elements(
1541
    $text_data_out, $feature
1542
  );
1543

    
1544
  $footnotes = theme('cdm_footnotes', array('footnoteListKey' => 'BIBLIOGRAPHY-' . $footnote_key_suggestion));
1545
  $footnotes .= theme('cdm_footnotes', array('footnoteListKey' => $footnote_key_suggestion)); // FIXME is this needed at all?
1546
  $footnotes .= theme('cdm_annotation_footnotes', array('footnoteListKey' => $footnote_key_suggestion));
1547

    
1548
  return  markup_to_render_array(  // FIXME markup_to_render_array should no longer be needed
1549
    '<div class="common-taxon-name">' . $common_name_out . '</div>'
1550
    .'<div class="text-data">' . drupal_render($common_name_out_text_data) . '</div>'
1551
    .$footnotes,
1552
    $weight
1553
  );
1554
}
1555

    
1556
/**
1557
 * Renders a single instance of the type CommonTaxonName.
1558
 *
1559
 * @param $element
1560
 *   The CDM CommonTaxonName entity.
1561
 * @param $feature_block_settings
1562
 *
1563
 * @param $footnote_key_suggestion
1564
 *
1565
 * @param $element_tag_name
1566
 *
1567
 * @return array
1568
 *   Drupal render array
1569
 *
1570
 * @ingroup compose
1571
 */
1572
function compose_description_element_common_taxon_name($element, $feature_block_settings, $footnote_key_suggestion = NULL)
1573
{
1574

    
1575
  if(!$footnote_key_suggestion) {
1576
    $footnote_key_suggestion = $element->feature->uuid;
1577
  }
1578

    
1579
  $name = '';
1580
  if(isset($element->name)){
1581
    $name = $element->name;
1582
  }
1583

    
1584

    
1585
  return compose_description_element($element, $feature_block_settings, $name, $footnote_key_suggestion);
1586
}
1587

    
1588
/**
1589
 * Composes the render array for a CDM Distribution description element
1590
 *
1591
 * @param array $description_elements
1592
 *   Array of CDM Distribution instances
1593
 * @param $enclosingTag
1594
 *   The html tag to be use for the enclosing element
1595
 *
1596
 * @return array
1597
 *   A Drupal render array
1598
 *
1599
 * @ingroup compose
1600
 */
1601
function compose_description_elements_distribution($description_elements){
1602

    
1603
  $out = '';
1604
  RenderHints::pushToRenderStack('descriptionElementDistribution');
1605
  RenderHints::setFootnoteListKey(UUID_DISTRIBUTION);
1606

    
1607
  $feature_block_settings = get_feature_block_settings(UUID_DISTRIBUTION);
1608
  $enclosingTag = cdm_feature_block_element_tag_name($feature_block_settings);
1609

    
1610
  foreach ($description_elements as $description_element) {
1611
    $annotations_and_sources = handle_annotations_and_sources(
1612
      $description_element,
1613
      $feature_block_settings,
1614
      $description_element->area->representation_L10n,
1615
      UUID_DISTRIBUTION
1616
    );
1617

    
1618

    
1619
    list($status_label, $status_markup) = distribution_status_label_and_markup($description_element);
1620

    
1621
    $out .= '<' . $enclosingTag . ' class="descriptionElement descriptionElement-' . $description_element->uuid
1622
      . ' " title="' . $status_label. '">'
1623
      . $description_element->area->representation_L10n
1624
      . $status_markup;
1625
    if(!empty($annotations_and_sources['source_references'])){
1626
      $out .= ' ' . join(' ', $annotations_and_sources['source_references'] );
1627
    }
1628
    $out .= $annotations_and_sources['foot_note_keys']   . ' </' . $enclosingTag . '>';
1629
  }
1630

    
1631
  RenderHints::popFromRenderStack();
1632
  return markup_to_render_array($out);
1633
}
1634

    
1635
  /**
1636
   * @param $descriptionElement
1637
   * @return array
1638
   */
1639
  function distribution_status_label_and_markup($descriptionElement, $status_glue = '&#8210; ') {
1640
    $status_markup = '';
1641
    $status_label = '';
1642

    
1643
    if (isset($descriptionElement->status)) {
1644
      $status_label = $descriptionElement->status->representation_L10n;
1645
      $status_markup =  '<span class="distributionStatus"> '
1646
        . $status_glue
1647
        . '<span class="distributionStatus-' . $descriptionElement->status->idInVocabulary . '">'
1648
        . $status_label
1649
        . '</span></span>';
1650

    
1651
    };
1652
    return array($status_label, $status_markup);
1653
  }
1654

    
1655

    
1656
  /**
1657
   * Provides the merged feature tree for a taxon profile page.
1658
   *
1659
   * The merging of the profile feature tree is actully done in
1660
   * _mergeFeatureTreeDescriptions(). See this method  for details
1661
   * on the structure of the merged tree.
1662
   *
1663
   * This method provides t hook which can be used to modify the
1664
   * merged feature tree after it has been created, see
1665
   * hook_merged_taxon_feature_tree_alter()
1666
   *
1667
   * @param $taxon
1668
   *   A CDM Taxon instance
1669
   *
1670
   * @return object
1671
   *  The merged feature tree
1672
   *
1673
   */
1674
  function merged_taxon_feature_tree($taxon) {
1675

    
1676
    // 1. fetch descriptions_by_featuretree but exclude the distribution feature
1677
    $merged_tree = cdm_ws_descriptions_by_featuretree(get_profile_feature_tree(), $taxon->uuid, array(UUID_DISTRIBUTION));
1678

    
1679

    
1680
    // 2. find the distribution feature node
1681
    $distribution_node =& cdm_feature_tree_find_node($merged_tree->root->childNodes, UUID_DISTRIBUTION);
1682

    
1683
    if ($distribution_node) {
1684
      // 3. get the distributionInfoDTO
1685
      $query_parameters = cdm_distribution_filter_query();
1686
      $query_parameters['part'] = array('mapUriParams');
1687
      if(variable_get(DISTRIBUTION_CONDENSED)){
1688
        $query_parameters['part'][] = 'condensedDistribution';
1689
      }
1690
      if (variable_get(DISTRIBUTION_ORDER_MODE, DISTRIBUTION_ORDER_MODE_DEFAULT) == 'TREE') {
1691
        $query_parameters['part'][] = 'tree';
1692
      }
1693
      else {
1694
        $query_parameters['part'][] = 'elements';
1695
      }
1696
      $query_parameters['omitLevels'] = array();
1697
      foreach(variable_get(DISTRIBUTION_TREE_OMIT_LEVELS, array()) as $uuid){
1698
        if(is_uuid($uuid)){
1699
          $query_parameters['omitLevels'][] = $uuid;
1700
        }
1701
      }
1702
      $customStatusColorsJson = variable_get(DISTRIBUTION_STATUS_COLORS, NULL);
1703
      if ($customStatusColorsJson) {
1704
        $query_parameters['statusColors'] = $customStatusColorsJson;
1705
      }
1706

    
1707
      $distribution_info_dto = cdm_ws_get(CDM_WS_PORTAL_DESCRIPTION_DISTRIBUTION_INFO_FOR, $taxon->uuid, queryString($query_parameters));
1708
      // 4. get distribution TextData is there are any
1709
      $distribution_text_data = cdm_ws_fetch_all(CDM_WS_DESCRIPTIONELEMENT_BY_TAXON,
1710
        array(
1711
          'taxon' => $taxon->uuid,
1712
          'type' => 'TextData',
1713
          'features' => UUID_DISTRIBUTION
1714
        )
1715
      );
1716

    
1717
      // 5. put all distribution data into the distribution feature node
1718
      if ($distribution_text_data //if text data exists
1719
        || ($distribution_info_dto && isset($distribution_info_dto->tree) && $distribution_info_dto->tree->rootElement->numberOfChildren > 0) // OR if tree element has distribution elements
1720
        || ($distribution_info_dto && !empty($distribution_info_dto->elements))
1721
      ) { // OR if DTO has distribution elements
1722
        $distribution_node->descriptionElements = array('#type' => 'DTO');
1723
        if ($distribution_text_data) {
1724
          $distribution_node->descriptionElements['TextData'] = $distribution_text_data;
1725
        }
1726
        if ($distribution_info_dto) {
1727
          $distribution_node->descriptionElements['DistributionInfoDTO'] = $distribution_info_dto;
1728
        }
1729
      }
1730
    }
1731

    
1732
    // allows modifying the merged tree via a the hook_cdm_feature_node_block_content_alter
1733
    drupal_alter('merged_taxon_feature_tree', $taxon, $merged_tree);
1734

    
1735
    return $merged_tree;
1736
  }
1737

    
1738

    
1739
  function compose_distribution_hierarchy($distribution_tree, $feature_block_settings){
1740

    
1741
    static $hierarchy_style;
1742
    // TODO expose $hierarchy_style to administration or provide a hook
1743
    if( !isset($hierarchy_style)){
1744
      $hierarchy_style = get_array_variable_merged(DISTRIBUTION_HIERARCHY_STYLE, DISTRIBUTION_HIERARCHY_STYLE_DEFAULT);
1745
    }
1746

    
1747
    $render_array = array();
1748

    
1749
    RenderHints::pushToRenderStack('descriptionElementDistribution');
1750
    RenderHints::setFootnoteListKey(UUID_DISTRIBUTION);
1751

    
1752
    // Returning NULL if there are no description elements.
1753
    if ($distribution_tree == null) {
1754
      return $render_array;
1755
    }
1756
    // for now we are not using a render array internally to avoid performance problems
1757
    $markup = '';
1758
    if (isset($distribution_tree->rootElement->children)) {
1759
      $tree_nodes = $distribution_tree->rootElement->children;
1760
      _compose_distribution_hierarchy($tree_nodes, $feature_block_settings, $markup, $hierarchy_style);
1761
    }
1762

    
1763
    $render_array['distribution_hierarchy'] = markup_to_render_array(
1764
      $markup,
1765
      0,
1766
      '<div id="distribution_hierarchy" class="distribution_hierarchy">',
1767
      '</div>'
1768
    );
1769

    
1770
    RenderHints::popFromRenderStack();
1771

    
1772
    return $render_array;
1773
  }
1774

    
1775
  /**
1776
   * this function should produce markup as the compose_description_elements_distribution()
1777
   * function.
1778
   *
1779
   * @see compose_description_elements_distribution()
1780
   *
1781
   * @param $distribution_tree
1782
   * @param $feature_block_settings
1783
   * @param $tree_nodes
1784
   * @param $markup
1785
   * @param $hierarchy_style
1786
   */
1787
  function _compose_distribution_hierarchy($tree_nodes, $feature_block_settings, &$markup, $hierarchy_style, $level_index = -1){
1788

    
1789
    $level_index++;
1790
    static $enclosingTag = "span";
1791

    
1792
    $level_style = array_shift($hierarchy_style);
1793
    if(count($hierarchy_style) == 0){
1794
      // lowest defined level style will be reused for all following levels
1795
      $hierarchy_style[] = $level_style;
1796
    }
1797

    
1798
    $node_index = -1;
1799
    $per_node_markup = array();
1800
    foreach ($tree_nodes as $node){
1801

    
1802
      $per_node_markup[++$node_index] = '';
1803

    
1804
      $label = $node->nodeId->representation_L10n;
1805

    
1806
      $distributions = $node->data;
1807
      $distribution_uuids = array();
1808
      $distribution_aggregate = NULL;
1809
        foreach($distributions as $distribution){
1810

    
1811
          $distribution_uuids[] = $distribution->uuid;
1812

    
1813
          // if there is more than one distribution we aggregate the sources and
1814
          // annotations into a synthetic distribution so that the footnote keys
1815
          // can be rendered consistently
1816
          if(!$distribution_aggregate) {
1817
            $distribution_aggregate = $distribution;
1818
            if(!isset($distribution_aggregate->sources[0])){
1819
              $distribution_aggregate->sources = array();
1820
            }
1821
            if(!isset($distribution_aggregate->annotations[0])){
1822
              $distribution_aggregate->annotations = array();
1823
            }
1824
          } else {
1825
            if(isset($distribution->sources[0])) {
1826
              $distribution_aggregate->sources = array_merge($distribution_aggregate->sources,
1827
                $distribution->sources);
1828
            }
1829
            if(isset($distribution->annotations[0])) {
1830
              $distribution_aggregate->annotations = array_merge($distribution_aggregate->annotations,
1831
                $distribution->annotations);
1832
            }
1833
          }
1834
        }
1835

    
1836
      $status_label= '';
1837
      $status_markup = '';
1838
      $annotations_and_sources =  null;
1839
      if($distribution_aggregate) {
1840
        $annotations_and_sources = handle_annotations_and_sources(
1841
          $distribution_aggregate,
1842
          $feature_block_settings,
1843
          $label,
1844
          UUID_DISTRIBUTION
1845
        );
1846

    
1847
        list($status_label, $status_markup) = distribution_status_label_and_markup($distribution, $level_style['status_glue']);
1848
      }
1849

    
1850
      $per_node_markup[$node_index] .= '<' . $enclosingTag . ' class="descriptionElement'
1851
        . join(' descriptionElement-', $distribution_uuids)
1852
        . ' level_index_' . $level_index
1853
        . ' " title="' . $status_label . '">'
1854
        . '<span class="area_label">' . $label
1855
        . $level_style['label_suffix'] . '</span>'
1856
        . $status_markup
1857
      ;
1858

    
1859
      if(isset($annotations_and_sources)){
1860
        if(!empty($annotations_and_sources['source_references'])){
1861
          $per_node_markup[$node_index] .= ' ' . join(', ' , $annotations_and_sources['source_references']);
1862
        }
1863
        if($annotations_and_sources['foot_note_keys']) {
1864
          $per_node_markup[$node_index] .= $annotations_and_sources['foot_note_keys'];
1865
        }
1866
      }
1867

    
1868
      if(isset($node->children[0])){
1869
        _compose_distribution_hierarchy(
1870
          $node->children,
1871
          $feature_block_settings,
1872
          $per_node_markup[$node_index],
1873
          $hierarchy_style,
1874
          $level_index
1875
        );
1876
      }
1877

    
1878
      $per_node_markup[$node_index] .= '</' . $enclosingTag . '>';
1879
    }
1880
    $markup .= $level_style['item_group_prefix']  . join( $level_style['item_glue'], $per_node_markup) . $level_style['item_group_postfix'];
1881
  }
1882

    
1883

    
(2-2/10)