Subversion Repositories web.active

<?php namespace ProcessWire;

/**
 * AdminThemeUikit
 * 
 * @property bool $isSuperuser Is current user a superuser?
 * @property bool $isEditor Does current user have page-edit permission?
 * @property bool $isLoggedIn Is current user logged in?
 * @property bool $useOffset Use offset/margin for all Inputfields?
 * @property array $noBorderTypes Inputfield class names that should always use the noBorder option (when 100% width).
 * @property array $cardTypes Inputfield class names that should always use the card option.
 * @property array $offsetTypes Inputfield class names that should always use the offset option.
 * @property string $logoURL URL to custom logo, relative to PW installation root. 
 * @property string $cssURL URL to custom CSS file, relative to PW installation root. 
 * @property string $layout Layout type (blank=default, sidenav=multi-pane, sidenav-tree=left-tree, sidenav-tree-alt=right-tree)
 * @property int $logoAction Logo click action (0=admin root page list, 1=offcanvas nav)
 * @property string $userLabel Text containing user {vars} to use for user label in masthead (default="{Name}")
 * @property int $maxWidth Maximum layout width in pixels, or 0 for no max (default=1600).
 * @property bool|int $groupNotices Whether or not notices should be grouped by type
 * @property string $inputSize Size for input/select elements. One of "s" for small, "m" for medium (default), or "l" for large. 
 * @property bool|int $ukGrid When true, use uk-width classes for Inputfields (rather than CSS percentages). 
 * @property int $toggleBehavior (0=Standard, 1=Consistent)
 * @property string $configPhpHash Hash used internally to detect changes to $config->AdminThemeUikit settings.
 * @property int $cssVersion Current version number of core CSS/LESS files
 * 
 * @method string renderBreadcrumbs()
 * @method string getUikitCSS()
 * 
 * 
 */
class AdminThemeUikit extends AdminThemeFramework implements Module, ConfigurableModule {

  public static function getModuleInfo() {
    return array(
      'title' => 'Uikit',
      'version' => 33,
      'summary' => 'Uikit v3 admin theme',
      'autoload' => 'template=admin', 
    ); 
  }

  /**
   * Development mode, to be used when developing this module’s code
   * 
   * Makes it use runtime/temporary compiled CSS files rather than the final ones. 
   *
   */
  const dev = false;

  /**
   * Set to true when upgrading Uikit version
   * 
   */
  const upgrade = false;

  /**
   * Required CSS/LESS files version 
   * 
   * Increment on core less file changes that will also require a recompile of /site/assets/admin.css
   * 
   */
  const requireCssVersion = 1;

  /**
   * Default logo image file (relative to this dir)
   * 
   */
  const logo = 'uikit-pw/images/pw-mark.png';

  /**
   * sidenavType: primary navigation on left sidebar
   * 
   */
  const sidenavTypePrimary = 0;

  /**
   * sidenavType: tree navigation on left sidebar
   * 
   */
  const sidenavTypeTree = 1;

  /**
   * Construct and establish default module config settings
   * 
   */
  public function __construct() {
    
    parent::__construct();
    
    $this->set('useOffset', false);
    $this->set('cardTypes', array());
    $this->set('offsetTypes', array());
    $this->set('logoURL', '');
    $this->set('cssURL', '');
    $this->set('layout', '');
    $this->set('noBorderTypes', array()); // 'InputfieldCKEditor' is a good one for this
    $this->set('logoAction', 0); 
    $this->set('toggleBehavior', 0);
    $this->set('userLabel', '{Name}'); 
    $this->set('userAvatar', 'icon.user-circle'); 
    $this->set('maxWidth', 1600); 
    $this->set('groupNotices', true);
    $this->set('inputSize', 'm'); // m=medium (default), s=small, l=large
    $this->set('ukGrid', false); 
    $this->set('configPhpHash', '');
    $this->set('cssVersion', 0);
    $this->setClasses(array(
      'input' => 'uk-input',
      'input-small' => 'uk-input uk-form-small',
      'input-checkbox' => 'uk-checkbox',
      'input-radio' => 'uk-radio',
      'input-password' => 'uk-input uk-form-width-medium',
      'select' => 'uk-select',
      'select-asm' => 'uk-select uk-form-small',
      'select-small' => 'uk-select uk-form-small',
      'textarea' => 'uk-textarea',
      'table' => 'uk-table uk-table-divider uk-table-justify uk-table-small',
      'dl' => 'uk-description-list uk-description-list-divider',
    ));
    
  }
  
  public function wired() {
    parent::wired();
    $this->addHookAfter('InputfieldSelector::ajaxReady', $this, 'hookInputfieldSelectorAjax');
  }
  
  /**
   * Initialize and attach hooks
   * 
   */
  public function init() {
    parent::init();

    // if this is not the current admin theme, exit now so no hooks are attached
    if(!$this->isCurrent()) return;
  
    /** @var Page $page */
    $page = $this->wire('page');
    /** @var Modules $modules */
    $modules = $this->wire('modules');
    /** @var Modules $modules */
    $session = $this->wire('session');
    
    $sidenav = strpos($this->layout, 'sidenav') === 0;

    // disable sidebar layout if SystemNotifications is active
    if($sidenav && $modules->isInstalled('SystemNotifications')) {
      /** @var SystemNotifications $systemNotifications */
      $systemNotifications = $modules->get('SystemNotifications');
      if(!$systemNotifications->disabled) {
        $this->layout = '';
        $sidenav = false;
      }
    }
    
    if(!$page || $page->template != 'admin') {
      // front-end
      if($sidenav) {
        // ensure that page edit links on front-end load the sidenav-init 
        $session->setFor('Page', 'appendEditUrl', "&layout=sidenav-init");
      }
      return;
    }
  
    $inputSize = $this->get('inputSize');
    if($inputSize && $inputSize != 'm') {
      $inputClass = $inputSize === 'l' ? 'uk-form-large' : 'uk-form-small';
      foreach(array('input', 'select', 'textarea') as $name) {
        $this->addClass($name, $inputClass); 
      }
    }
    
    if(!$this->ukGrid) {
      $this->addClass('body', 'AdminThemeUikitNoGrid'); 
    }
    
    if($this->className() !== 'AdminThemeUikit') {
      $this->addBodyClass('AdminThemeUikit');
    }
    
    $session->removeFor('Page', 'appendEditUrl');
    /** @var JqueryUI $jqueryUI */
    $jqueryUI = $modules->get('JqueryUI');
    $jqueryUI->use('panel');

    // add rendering hooks
    $this->addHookBefore('Inputfield::render', $this, 'hookBeforeRenderInputfield');
    $this->addHookBefore('Inputfield::renderValue', $this, 'hookBeforeRenderInputfield');
    $this->addHookAfter('Inputfield::getConfigInputfields', $this, 'hookAfterInputfieldGetConfigInputfields');
    $this->addHookAfter('Inputfield::getConfigAllowContext', $this, 'hookAfterInputfieldGetConfigAllowContext');
    $this->addHookAfter('MarkupAdminDataTable::render', $this, 'hookAfterTableRender');
  
    // hooks and settings specific to sidebar layouts
    if($sidenav) {
      $this->addHookAfter('ProcessLogin::afterLoginURL', $this, 'hookAfterLoginURL');
      if(strpos($this->layout, 'sidenav-tree') === 0) {
        // page-edit breadcrumbs go to page editor when page tree is always in sidebar
        $this->wire('config')->pageEdit('editCrumbs', true);
      }
    }
    
    // add cache clearing hooks
    $this->wire('pages')->addHookAfter('saved', $this, 'hookClearCaches');
    $modules->addHookAfter('refresh', $this, 'hookClearCaches');
  }
  
  /**
   * Render an extra markup region
   *
   * @param string $for
   * @return mixed|string
   *
   */
  public function renderExtraMarkup($for) {
    $out = parent::renderExtraMarkup($for);
    if($for === 'notices') {
    }
    return $out;
  }

  /**
   * Test all notice types
   * 
   * @return bool
   *
   */
  public function testNotices() {
    if(parent::testNotices()) {
      $v = $this->wire('input')->get('test_notices');
      if($v === 'group-off') $this->groupNotices = false; 
      if($v === 'group-on') $this->groupNotices = true; 
      return true;
    }
    return false;
  }

  /**
   * Get Uikit uk-width-* class for given column width
   * 
   * @param int $columnWidth
   * @param array $widths
   * @return string
   * 
   */
  protected function getUkWidthClass($columnWidth, array $widths) {
    
    static $minColumnWidth = null;
    
    $ukWidthClass = '1-1';
    
    if($minColumnWidth === null) {
      $widthKeys = array_keys($widths);
      sort($widthKeys, SORT_NATURAL);
      $minColumnWidth = (int) reset($widthKeys);
    }

    if($columnWidth < 10) {
      // use uk-width-1-1
    } else if($columnWidth && $columnWidth < 100) {
      if($columnWidth < $minColumnWidth) $columnWidth = $minColumnWidth;
      // determine column width class
      foreach($widths as $pct => $uk) {
        $pct = (int) $pct;
        if($columnWidth >= $pct) {
          $ukWidthClass = $uk;
          break;
        }
      }
    }
    
    if($ukWidthClass === '1-1') {
      return "uk-width-1-1";
    } else {
      return "uk-width-$ukWidthClass@m";
    }
  }
  
  /*******************************************************************************************
   * HOOKS
   *
   */

  /**
   * Hook called before each Inputfield::render 
   * 
   * This updates the Inputfield classes and settings for Uikit. 
   * 
   * - themeBorder: none, hide, card, line
   * - themeOffset: s, m, l
   * - themeInputSize: s, m, l
   * - themeInputWidth: xs, s, m, l, f
   * - themeColor: primary, secondary, warning, danger, success, highlight, none
   * - themeBlank: no input borders, true or false
   * 
   * @param HookEvent $event
   * 
   */
  public function hookBeforeRenderInputfield(HookEvent $event) {

    /** @var Inputfield $inputfield */
    $inputfield = $event->object;
    $class = $inputfield->className();
    $formSettings = $event->wire('config')->get('InputfieldForm');
    $widths = $formSettings['ukGridWidths'];
    $columnWidth = (int) $inputfield->getSetting('columnWidth');
    $field = $inputfield->hasField;
    $isFieldset = $inputfield instanceof InputfieldFieldset;
    $isMarkup = $inputfield instanceof InputfieldMarkup; 
    $isWrapper = $inputfield instanceof InputfieldWrapper && !$isFieldset && !$isMarkup;
    $ukWidthClass = 'uk-width-1-1';
    $globalInputSize = $this->get('inputSize');
    $ukGrid = $this->get('ukGrid');
    $themeColor = '';
    $themeBorder = '';
    $themeOffset = '';
    $themeInputSize = '';
    $themeInputWidth = '';
    $themeBlank = false;
    $wrapClasses = array();
    $inputClasses = array();
    $removeInputClasses = array();
    
    if($inputfield instanceof InputfieldForm) {
      if($globalInputSize == 's') {
        $inputfield->addClass('InputfieldFormSmallInputs'); 
      } else if($globalInputSize == 'l') {
        $inputfield->addClass('InputfieldFormLargeInputs'); 
      }
      return;
    } else if($inputfield instanceof InputfieldSubmit) {
      // button
      $inputfield->addClass('uk-width-auto uk-margin-top', 'wrapClass');
      return; // no further settings needed for button
    }

    if($ukGrid) {
      $ukWidthClass = $this->getUkWidthClass($columnWidth, $widths); 
      if($ukWidthClass) $wrapClasses[] = $ukWidthClass;
    }
    
    if($isWrapper) {
      if($ukWidthClass != 'uk-width-1-1') $inputfield->addClass($ukWidthClass, 'wrapClass');
      return;
    } else if($inputfield instanceof InputfieldTextarea) {
      $inputClasses[] = $this->getClass('textarea'); 
    } else if($inputfield instanceof InputfieldPassword) {
      $inputClasses[] = $this->getClass('input-password');
    } else if($inputfield instanceof InputfieldText) {
      $inputClasses[] = $this->getClass('input');
    } else if($inputfield instanceof InputfieldInteger) {
      $inputClasses[] = $this->getClass('input');
    } else if($inputfield instanceof InputfieldDatetime) {
      $inputClasses[] = $this->getClass('input');
    } else if($inputfield instanceof InputfieldCheckboxes || $inputfield instanceof InputfieldCheckbox) {
      $inputClasses[] = $this->getClass('input-checkbox');
      $inputfield->addClass('uk-form-controls-text', 'contentClass');
    } else if($inputfield instanceof InputfieldRadios) {
      $inputClasses[] = $this->getClass('input-radio');
      $inputfield->addClass('uk-form-controls-text', 'contentClass');
    } else if($inputfield instanceof InputfieldAsmSelect) {
      $inputClasses[] = $this->getClass('select-asm');
    } else if($inputfield instanceof InputfieldSelect && !$inputfield instanceof InputfieldHasArrayValue) {
      $inputClasses[] = $this->getClass('select');
    } else if($inputfield instanceof InputfieldFile) {
      $themeColor = 'secondary';
    }
    
    if($field) {
      // pull optional uikit settings from Field object
      $themeBorder = $field->get('themeBorder');
      $themeOffset = $field->get('themeOffset');
      $themeInputSize = $field->get('themeInputSize');
      $themeInputWidth = $field->get('themeInputWidth');
      $themeColor = $field->get('themeColor') ? $field->get('themeColor') : $themeColor;
      $themeBlank = $field->get('themeBlank');
    }
    
    // determine custom settings which may be defined with Inputfield
    if(!$themeBorder) $themeBorder = $inputfield->getSetting('themeBorder');
    if(!$themeOffset) $themeOffset = $inputfield->getSetting('themeOffset'); // || in_array($class, $this->offsetTypes);
    if(!$themeColor) $themeColor = $inputfield->getSetting('themeColor');
    if(!$themeInputSize) $themeInputSize = $inputfield->getSetting('themeInputSize');
    if(!$themeInputWidth) $themeInputWidth = $inputfield->getSetting('themeInputWidth');
    if(!$themeBlank) $themeBlank = $inputfield->getSetting('themeBlank');
    
    if(!$themeBorder) {
      if($formSettings['useBorders'] === false || in_array($class, $this->noBorderTypes)) {
        $themeBorder = (!$columnWidth || $columnWidth == 100) ? 'none' : 'hide';
      } else if(in_array($class, $this->cardTypes)) {
        $themeBorder = 'card';
      } else {
        $themeBorder = 'line';
      }
    }
    
    if($themeInputSize && $globalInputSize != $themeInputSize) {
      if($globalInputSize === 's') {
        $removeInputClasses[] = 'uk-form-small';
      } else if($globalInputSize === 'l') {
        $removeInputClasses[] = 'uk-form-large';
      }
      if($themeInputSize === 'm') {
        $inputClasses[] = 'uk-form-medium';
      } else if($themeInputSize === 's') {
        $inputClasses[] = 'uk-form-small';
      } else if($themeInputSize === 'l') {
        $inputClasses[] = 'uk-form-large';
      }
    }
  
    if($themeInputWidth) {
      $inputWidthClasses = array(
        'xs' => 'uk-form-width-xsmall',
        's' => 'uk-form-width-small',
        'm' => 'uk-form-width-medium',
        'l' => 'uk-form-width-large',
        'f' => 'InputfieldMaxWidth',
      );
      $inputfield->removeClass($inputWidthClasses);
      if(isset($inputWidthClasses[$themeInputWidth])) {
        $inputClasses[] = $inputWidthClasses[$themeInputWidth];
        if($themeInputWidth != 'f') $inputClasses[] = 'InputfieldSetWidth';
      }
    }
    
    if($themeBlank) {
      $inputClasses[] = 'uk-form-blank';
    }

    if($themeColor) {
      $wrapClasses[] = 'InputfieldIsColor';
    }
    
    switch($themeColor) {
      case 'primary': $wrapClasses[] = 'InputfieldIsPrimary'; break;
      case 'secondary': $wrapClasses[] = 'InputfieldIsSecondary'; break;
      case 'warning': $wrapClasses[] = 'InputfieldIsWarning'; break;
      case 'danger': $wrapClasses[] = 'InputfieldIsError'; break;
      case 'success': $wrapClasses[] = 'InputfieldIsSuccess'; break;
      case 'highlight': $wrapClasses[] = 'InputfieldIsHighlight'; break;
      case 'none': break;
    }
    
    switch($themeBorder) {
      case 'none': $wrapClasses[] = 'InputfieldNoBorder'; break;
      case 'hide': $wrapClasses[] = 'InputfieldHideBorder'; break;
      case 'card': $wrapClasses[] = 'uk-card uk-card-default'; break;
    }
    
    if($themeOffset && $themeOffset !== 'none') {
      $wrapClasses[] = 'InputfieldIsOffset';
      if($themeOffset === 's') {
        $wrapClasses[] = 'InputfieldIsOffsetSm';
      } else if($themeOffset === 'l') {
        $wrapClasses[] = 'InputfieldIsOffsetLg';
      }
    }
    
    if(count($inputClasses)) {
      $inputfield->addClass(implode(' ', $inputClasses));
    }
    
    if(count($removeInputClasses)) {
      $inputfield->removeClass($removeInputClasses);
    }
    
    if(count($wrapClasses)) {
      $inputfield->addClass(implode(' ', $wrapClasses), 'wrapClass');
    }
    
  }

  /**
   * Hook after Inputfield::getConfigInputfields() to add theme-specific configuration settings
   * 
   * @param HookEvent $event
   * 
   */
  public function hookAfterInputfieldGetConfigInputfields(HookEvent $event) {
    
    /** @var Inputfield $inputfield */
    $inputfield = $event->object;
    if($inputfield instanceof InputfieldWrapper) return;
    /** @var InputfieldWrapper $inputfields */
    $inputfields = $event->return;
    if(!$inputfields instanceof InputfieldWrapper) return;
    include_once(dirname(__FILE__) . '/config.php'); 
    $configHelper = new AdminThemeUikitConfigHelper($this);
    $configHelper->configInputfield($inputfield, $inputfields); 
  }

  /**
   * Get fields allowed for field/template context configuration
   * 
   * @param HookEvent $event
   * 
   */
  public function hookAfterInputfieldGetConfigAllowContext(HookEvent $event) {
    $names = $event->return;
    $names[] = '_adminTheme';
    $names[] = 'themeOffset';
    $names[] = 'themeBorder';
    $names[] = 'themeColor';
    $names[] = 'themeInputSize';
    $names[] = 'themeInputWidth';
    $names[] = 'themeBlank';
    $event->return = $names;
  }

  /**
   * Hook after MarkupAdminDataTable::render
   * 
   * This is primarily to add support for Uikit horizontal scrolling responsive tables,
   * which is used instead of the default MarkupAdminDataTable responsive table.
   * 
   * @param HookEvent $event
   * 
   */
  public function hookAfterTableRender(HookEvent $event) {
    /** @var MarkupAdminDataTable $table */
    $table = $event->object;
    $classes = array();
    if($table->responsive) {
      $classes[] = 'pw-table-responsive';
      if(!wireInstanceOf($this->wire()->process, array('ProcessPageLister', 'ProcessUser'))) {
        $classes[] = 'uk-overflow-auto';
      }
    }
    if($table->sortable) {
      $classes[] = 'pw-table-sortable';
    }
    if($table->resizable) {
      $classes[] = 'pw-table-resizable'; 
    } 
    if(count($classes)) {
      $class = implode(' ', $classes);
      $event->return = "<div class='$class'>$event->return</div>";
    }
  }
  
  /**
   * Event called when a page is saved or modules refreshed to clear caches
   *
   * @param HookEvent $event
   *
   */
  public function hookClearCaches(HookEvent $event) {

    /** @var Page|User|null $page */
    $page = $event->arguments(0); 
    /** @var array $changes */
    $changes = $event->arguments(1);
    /** @var User $user */
    $user = $this->wire('user'); 
    
    if($page !== null && !($page instanceof Page)) return;
    if(!is_array($changes)) $changes = array();
    
    if($page === null || $page->template == 'admin' || ($page->id === $user->id && in_array('language', $changes))) {
      /** @var Session $session */
      $session = $this->wire('session'); 
      $session->removeFor($this, 'prnav');
      $session->removeFor($this, 'sidenav');
      $session->message("Cleared the admin theme navigation cache (primary nav)", Notice::debug);
    }
  }

  /**
   * Hook to ProcessLogin::afterLoginURL()
   * 
   * @param HookEvent $event
   * 
   */
  public function hookAfterLoginURL(HookEvent $event) {
    $layout = $this->layout;
    if(!$layout) return;
    $url = $event->return;
    $url .= (strpos($url, '?') !== false ? '&' : '?') . "layout=$this->layout-init";
    $event->return = $url;
  }

  
  /*******************************************************************************************
   * MARKUP RENDERING METHODS
   *
   */

  /**
   * Render a list of breadcrumbs (list items), excluding the containing <ul>
   *
   * @return string
   *
   */
  public function ___renderBreadcrumbs() {

    if(!$this->isLoggedIn || $this->isModal) return '';
    $process = $this->wire('page')->process;
    if($process == 'ProcessPageList') return '';
    $breadcrumbs = $this->wire('breadcrumbs');
    $out = '';

    // don't show breadcrumbs if only one of them (subjective)
    if(count($breadcrumbs) < 2 && $process != 'ProcessPageEdit') return '';

    if(strpos($this->layout, 'sidenav') === false) {
      $out = "<li>" . $this->renderQuickTreeLink() . "</li>";
    }

    foreach($breadcrumbs as $breadcrumb) {
      $title = $breadcrumb->get('titleMarkup');
      if(!$title) $title = $this->wire('sanitizer')->entities1($this->_($breadcrumb->title));
      $out .= "<li><a href='$breadcrumb->url'>$title</a></li>";
    }

    if($out) $out = "<ul class='uk-breadcrumb'>$out</ul>";

    return $out;
  }

  /**
   * Render the populated “Add New” head button, or blank when not applicable
   *
   * @return string
   *
   */
  public function renderAddNewButton() {

    $items = array();

    foreach($this->getAddNewActions() as $item) {
      $icon = $this->renderNavIcon($item['icon']);
      $items[] = "<li><a href='$item[url]'>$icon$item[label]</a></li>";
    }

    if(!count($items)) return '';

    $out = implode('', $items);
    $label = $this->getAddNewLabel();
    $icon = $this->renderIcon('angle-down');

    $out =
      "<button class='ui-button pw-dropdown-toggle'>$label $icon</button>" .
      "<ul class='pw-dropdown-menu' data-at='right bottom+1'>$out</ul>";

    return $out;
  }

  /**
   * Render runtime notices div#notices
   *
   * @param Notices|bool $notices
   * @param array $options See defaults in method
   * @return string|array
   *
   */
  public function renderNotices($notices, array $options = array()) {

    $defaults = array(
      'groupByType' => $this->groupNotices ? true : false, 
      'messageClass' => 'NoticeMessage uk-alert uk-alert-primary', // class for messages
      'messageIcon' => 'check-square', // default icon to show with notices
      'warningClass' => 'NoticeWarning uk-alert uk-alert-warning', // class for warnings
      'warningIcon' => 'exclamation-circle', // icon for warnings
      'errorClass' => 'NoticeError uk-alert uk-alert-danger', // class for errors
      'errorIcon' => 'exclamation-triangle', // icon for errors
      'debugClass' => 'NoticeDebug uk-alert', // class for debug items (appended)
      'debugIcon' => 'bug', // icon for debug notices
      'closeClass' => 'pw-notice-remove notice-remove', // class for close notices link <a>
      'closeIcon' => 'times', // icon for close notices link
      'listMarkup' => "<ul class='pw-notices' id='notices'>{out}</ul><!--/notices-->",
      'itemMarkup' =>
        "<li class='{class}'>" .
          "<div class='pw-container uk-container uk-container-expand'>{remove}{icon}{text}</div>" .
        "</li>"
    );

    $options = array_merge($defaults, $options);
    
    return parent::renderNotices($notices, $options);
  }

  /**
   * Render a single top navigation item for the given page
   *
   * This function designed primarily to be called by the renderPrimaryNavItems() function.
   *
   * @param array $item
   * @return string
   *
   */
  protected function renderPrimaryNavItem(array $item) {

    $title = $item['title'];
    $out = "<li class='page-$item[id]-'>";

    if(!count($item['children'])) {
      $out .= "<a href='$item[url]'>$title</a></li>";
      return $out;
    }

    $out .=
      "<a href='$item[url]' " .
        "id='prnav-page-$item[id]' " .
        "data-from='prnav-page-$item[parent_id]' " .
        "class='pw-dropdown-toggle'>" .
        "$title</a>";

    $my = 'left-1 top';
    if(in_array($item['name'], array('access', 'page', 'module'))) $my = 'left top';
    $out .=
      "<ul class='pw-dropdown-menu prnav' data-my='$my' data-at='left bottom'>" .
        $this->renderPrimaryNavItemChildren($item['children']) .
      "</ul>" .
      "</li>";

    return $out;
  }

  /**
   * Renders <li> items navigation from given nav array
   *
   * @param array $items
   * @return string
   *
   */
  protected function renderPrimaryNavItemChildren(array $items) {
    $out = '';

    foreach($items as $item) {

      $icon = empty($item['icon']) ? '' : $this->renderNavIcon($item['icon']);
      $title = $item['title'];
      $out .= "<li class='page-$item[id]-'>";

      if(!empty($item['children'])) {
        $out .=
          "<a class='pw-has-items' data-from='prnav-page-$item[parent_id]' href='$item[url]'>$icon$title</a>" .
          "<ul>" . $this->renderPrimaryNavItemChildren($item['children']) . "</ul>";

      } else if(!empty($item['navJSON'])) {
        $item['navJSON'] = $this->wire('sanitizer')->entities($item['navJSON']); 
        $out .=
          "<a class='pw-has-items pw-has-ajax-items' " .
            "data-from='prnav-page-$item[parent_id]' " .
            "data-json='$item[navJSON]' " .
            "href='$item[url]'>$icon$title" .
          "</a>" .
          "<ul></ul>";
      } else {
        $out .= "<a href='$item[url]'>$icon$title</a>";
      }
    }
    $out .= "</li>";

    return $out;
  }

  /**
   * Render all top navigation items, ready to populate in ul#prnav
   *
   * @return string
   *
   */
  public function renderPrimaryNavItems() {

    $cache = self::dev ? '' : $this->wire('session')->getFor($this, 'prnav');
    if($cache) {
      $this->markCurrentNavItems($cache);
      return $cache;
    }

    $out = '';
    $items = $this->getPrimaryNavArray();

    foreach($items as $item) {
      $out .= $this->renderPrimaryNavItem($item);
    }

    if(!self::dev) $this->wire('session')->setFor($this, 'prnav', $out);
    $this->markCurrentNavItems($out);

    return $out;
  }

  /**
   * Render sidebar navigation that uses uk-nav
   *
   * The contents is the same as the Primary nav, except that output is prepared for sidebar.
   * This method uses a session-cached version. To clear the cache, logout then log back in.
   *
   * @return string
   *
   */
  public function renderSidebarNavItems() {

    // see if we can get it from the cache
    $out = self::dev ? '' : $this->wire('session')->getFor($this, 'sidenav');
    
    if(empty($out)) {
      $out = $this->renderSidebarNavCache();
      $this->wire('session')->setFor($this, 'sidenav', $out);
    }
    
    $out = str_replace('<!--pw-user-nav-label-->', $this->renderUserNavLabel(), $out);
    $this->markCurrentNavItems($out);

    return $out;
  }

  /**
   * Re-renders the sidebar nav to be cached
   * 
   * @return string
   * 
   */
  protected function renderSidebarNavCache() {
    
    $out = '';
    $items = $this->getPrimaryNavArray();
    $ulAttrs = "class='uk-nav-sub uk-nav-default uk-nav-parent-icon' data-uk-nav='animation: false; multiple: true;'";

    foreach($items as $item) {

      $class = "page-$item[id]-";
      $subnav = '';

      foreach($item['children'] as $child) {
        $icon = $child['icon'] ? $this->renderNavIcon($child['icon']) : '';
        $childClass = "page-$child[id]-";
        $childAttr = "";
        $childNav = '';
        if(count($child['children'])) {
          $childClass .= ' uk-parent';
          $childNavList = $this->renderPrimaryNavItemChildren($child['children']);
          $childIcon = $this->renderNavIcon('arrow-circle-right');
          $childNav =
            "<ul $ulAttrs>" .
              "<li class='pw-nav-dup'><a href='$child[url]'>$childIcon$child[title]</a></li>" .
              $childNavList .
            "</ul>";
        } else if($child['navJSON']) {
          $child['navJSON'] = $this->wire('sanitizer')->entities($child['navJSON']); 
          $childClass .= ' uk-parent';
          $childAttr = " class='pw-has-items pw-has-ajax-items' data-json='$child[navJSON]'";
          $childNav = "<ul $ulAttrs></ul>";
        }
        $subnav .= "<li class='$childClass'><a$childAttr href='$child[url]'>$icon$child[title]</a>";
        $subnav .= $childNav . "</li>";
      }

      if($subnav) {
        $icon = $this->renderNavIcon($item['icon']);
        $class .= " uk-parent";
        $subnav =
          "<ul $ulAttrs>" .
            "<li class='pw-nav-dup'><a href='$item[url]'>$icon$item[title]</a></li>" .
            $subnav .
          "</ul>";
      }

      $out .=
        "<li class='$class'><a href='$item[url]' id='sidenav-page-$item[id]'>$item[title]</a>" .
          $subnav .
        "</li>";
    }
    
    // render user nav
    $out .=
      "<li class='uk-parent'>" .
        "<a href='#'><!--pw-user-nav-label--></a>" . 
        "<ul $ulAttrs>" . $this->renderUserNavItems() . "</ul>" .
      "</li>";

    return $out;
  }
  
  /**
   * Identify current items in the primary nav and add appropriate classes to them
   *
   * This presumes that navigation items in given $out markup use "page-[id]-" classes,
   * which will be updated consistent with the current $page.
   *
   * @param $out
   *
   */
  protected function markCurrentNavItems(&$out) {
    $page = $this->wire('page');
    foreach($page->parents()->and($page) as $p) {
      $out = str_replace("page-$p-", "page-$p- uk-active", $out);
    }
  }

  /**
   * Render label for user masthead dropdown nav item
   * 
   * @return string
   * 
   */
  public function renderUserNavLabel() {
    /** @var User $user */
    $user = $this->wire('user');
    $userLabel = $this->get('userLabel');
    $userAvatar = $this->get('userAvatar');
    $defaultIcon = 'user-circle';
    
    if(strpos($userLabel, '{') !== false) {
      if(strpos($userLabel, '{Name}') !== false) {
        $userLabel = str_replace('{Name}', ucfirst($user->name), $userLabel);
      } else if(strpos($userLabel, '{name}') !== false) {
        $userLabel = str_replace('{name}', $user->name, $userLabel);
      }
      if(strpos($userLabel, '{') !== false) {
        $userLabel = $user->getText($userLabel, true, true);
      }
    } else {
      $userLabel = $this->wire('sanitizer')->entities($userLabel);
    }
    
    if($userAvatar) {
      if($userAvatar === 'gravatar') {
        if($user->email) {
          $url = "https://www.gravatar.com/avatar/" . md5(strtolower(trim($user->email))) . "?s=80&d=mm&r=g";
          $userAvatar = "<img class='pw-avatar' src='$url' alt='$user->name' />&nbsp;";
        } else {
          $userAvatar = $this->renderNavIcon("$defaultIcon fa-lg"); 
        }
      } else if(strpos($userAvatar, 'icon.') === 0) {
        list(,$icon) = explode('.', $userAvatar); 
        $userAvatar = $this->renderNavIcon("$icon fa-lg"); 
      } else if(strpos($userAvatar, ':')) {
        list($fieldID, $fieldName) = explode(':', $userAvatar); 
        $field = $this->wire('fields')->get($fieldName);
        if(!$field || !$field->type instanceof FieldtypeImage) {
          $field = $this->wire('fields')->get((int) $fieldID); 
        }
        if($field && $field->type instanceof FieldtypeImage) {
          $value = $user->get($field->name); 
          if($value instanceof Pageimages) $value = $value->first();
          if($value instanceof Pageimage) {
            $value = $value->size(60, 60); 
            $userAvatar = "<img class='pw-avatar' src='$value->url' alt='$user->name' />&nbsp;";
          } else {
            $userAvatar = $this->renderNavIcon("$defaultIcon fa-lg"); 
          }
        } else {
          $userAvatar = '';
        }
      }
    }
  
    if($userAvatar) $userLabel = $userAvatar . $userLabel;
    
    return $userLabel;
  }

  /**
   * Render navigation for the “user” menu
   *
   * @return string
   *
   */
  public function renderUserNavItems() {

    $items = $this->getUserNavArray();
    $out = '';

    foreach($items as $item) {
      $label = $this->wire('sanitizer')->entities($item['title']);
      $icon = isset($item['icon']) ? $this->renderNavIcon($item['icon']) : ' ';
      $target = isset($item['target']) ? " target='$item[target]'" : '';
      $out .= "<li><a$target href='$item[url]'>$icon$label</a></li>";
    }

    return $out;
  }


  /**
   * Render link that opens the quick page-tree panel
   *
   * @param string $icon Icon to use for link (default=sitemap)
   * @param string $text Optional text to accompany icon (default=empty)
   * @return string
   *
   */
  public function renderQuickTreeLink($icon = 'tree', $text = '') {
    $tree = $this->_('Tree');
    $url = $this->wire('urls')->admin . 'page/';
    return
      "<a class='pw-panel' href='$url' data-tab-text='$tree' data-tab-icon='$icon' title='$tree'>" .
        $this->renderNavIcon($icon) . $text .
      "</a>";
  }

  /**
   * Get the URL to the ProcessWire or brand logo (or <img> tag) 
   * 
   * @param array $options
   *  - `getURL` (bool): Return only the URL? (default=false)
   *  - `getNative` (bool): Return only the ProcessWire brand logo? (default=false)
   *  - `alt` (string): Alt attribute for <img> tag (default=auto)
   *  - `height` (string): Height style to use for SVG images (default='')
   * @return string
   * 
   */
  public function getLogo(array $options = array()) {
    
    /** @var Config $config */
    $config = $this->wire('config');
    /** @var Sanitizer $sanitizer */
    $sanitizer = $this->wire('sanitizer');
    
    $defaults = array(
      'getURL' => false, 
      'getNative' => false,
      'alt' => '',
      'height' => '',
    );
  
    $options = array_merge($defaults, $options);
    $logoURL = $this->get('logoURL');
    $logoQS = '';
    $svg = false;
    
    if(empty($logoURL) || $options['getNative'] || strpos($logoURL, '//') !== false) {
      $native = true;
      $logoURL = $this->url() . self::logo;
    } else {
      if(strpos($logoURL, '?')) list($logoURL, $logoQS) = explode('?', $logoURL, 2);
      $logoURL = $config->urls->root . ltrim($logoURL, '/');
      $logoURL = $sanitizer->entities($logoURL);
      $native = false;
      $svg = strtolower(pathinfo($logoURL, PATHINFO_EXTENSION)) === 'svg';
    }
    
    $alt = $options['alt'];
    if(empty($alt) && $this->wire()->user->isLoggedin()) {
      $alt = "ProcessWire $config->version";
    }
    
    $class = 'pw-logo ' . ($native ? 'pw-logo-native' : 'pw-logo-custom');
    $attr = "class='$class' alt='$alt' ";

    if($svg) {
      if($options['height']) $attr .= "style='height:$options[height]' ";
      if(strpos($logoQS, 'uk-svg') === 0) {
        // if logo has "?uk-svg" query string, add uk-svg attribute which makes it styleable via CSS/LESS (PR#77)
        $attr .= 'uk-svg ';
        $logoQS = str_replace(array('uk-svg&', 'uk-svg'), '', $logoQS);
      }
    }
    
    if($logoQS) $logoURL .= '?' . $sanitizer->entities($logoQS);
    
    $img = "<img src='$logoURL' $attr/>";
    
    return $options['getURL'] ? $logoURL : $img;
  }

  /**
   * Get the URL to the ProcessWire or brand logo
   * 
   * @return string
   * 
   */
  public function getLogoURL() {
    return $this->getLogo(array('getURL' => true));
  }
  
  /**
   * Get URL to this admin theme
   *
   * @return string
   * @since 3.0.171
   *
   */
  public function url() {
    return $this->wire()->config->urls->modules . 'AdminTheme/AdminThemeUikit/';
  }
  
  /**
   * Get disk path to this admin theme
   *
   * @return string
   * @since 3.0.171
   *
   */
  public function path() {
    return __DIR__ . '/';
  }

  /**
   * Get the primary Uikit CSS URL to use
   * 
   * @return string
   * @since 3.0.178 Was not hookable in prior versions
   * 
   */
  public function ___getUikitCSS() {

    $config = $this->wire()->config;
    $cssUrl = $this->get('cssURL');
    
    if($cssUrl) { // a custom css URL was set in the theme config
      if(strpos($cssUrl, '//') === false) $cssUrl = $config->urls->root . ltrim($cssUrl, '/');
      return $this->wire()->sanitizer->entities($cssUrl);
    }
    
    require_once(__DIR__ . '/AdminThemeUikitCss.php');
    
    $settings = $config->AdminThemeUikit; 
    if(!is_array($settings)) $settings = array();
    $settings['requireCssVersion'] = self::requireCssVersion;
    
    if(self::upgrade) {
      $settings['upgrade'] = true;
      $settings['replacements'] = array('../pw/images/' => 'images/');
    } else {
      if(empty($settings['customCssFile'])) $settings['customCssFile'] = '/site/assets/admin.css';
      $path = 'wire/modules/AdminTheme/AdminThemeUikit/uikit-pw/images/';
      $back = str_repeat('../', substr_count(trim($settings['customCssFile'], '/'), '/'));
      $settings['replacements'] = array(
        'url(../pw/images/' => "url($back$path",
        'url("../pw/images/' => "url(\"$back$path",
        'url(pw/images/' => "url($back$path",
        'url("pw/images/' => "url(\"$back$path"
      );
    }
    
    $css = new AdminThemeUikitCss($this, $settings);
    
    return $css->getCssFile();
  }
  
  /**
   * Get Javascript that must be present in the document <head>
   *
   * @return string
   *
   */
  public function getHeadJS() {

    $config = $this->wire()->config;
    $data = $config->js('adminTheme');
    if(!is_array($data)) $data = array();
    $data['logoAction'] = (int) $this->logoAction;
    $data['toggleBehavior'] = (int) $this->toggleBehavior; 
    $config->js('adminTheme', $data);
    
    return parent::getHeadJS();
  }

  /**
   * Module configuration
   * 
   * @param InputfieldWrapper $inputfields
   * 
   */
  public function getModuleConfigInputfields(InputfieldWrapper $inputfields) {
    parent::getModuleConfigInputfields($inputfields);
    include_once(__DIR__ . '/config.php');
    $configHelper = new AdminThemeUikitConfigHelper($this);
    $configHelper->configModule($inputfields);
  }
}