ThemePlugin.inc.php

<?php
 
import('lib.pkp.classes.plugins.LazyLoadPlugin');
 
define('LESS_FILENAME_SUFFIX', '.less');
define('THEME_OPTION_PREFIX', 'themeOption_');
 
abstract class ThemePlugin extends LazyLoadPlugin {
   public $styles = array();
 
   public $scripts = array();
 
   public $options = array();
 
   public $menuAreas = array();
 
   public $parent;
 
   protected $_optionValues = null;
 
   function register($category, $path, $mainContextId = null) {
      if (!parent::register($category, $path, $mainContextId)) return false;
 
      // Don't perform any futher operations if theme is not currently active
      if (!$this->isActive()) {
         return true;
      }
 
      // Themes must initialize their functionality after all theme plugins
      // have been loaded in order to make use of parent/child theme
      // relationships
      HookRegistry::register('PluginRegistry::categoryLoaded::themes', array($this, 'themeRegistered'));
      HookRegistry::register('PluginRegistry::categoryLoaded::themes', array($this, 'initAfter'));
 
      // Allow themes to override plugin template files
      HookRegistry::register('TemplateResource::getFilename', array($this, '_overridePluginTemplates'));
 
      return true;
   }
 
   public function themeRegistered($themes) {
 
      // Don't fully initialize the theme until OJS is installed, so that
      // there are no requests to the database before it exists
      if (defined('SESSION_DISABLE_INIT')) {
         return;
      }
 
      $this->init();
   }
 
   public abstract function init();
 
   public function initAfter() {
      $this->_registerTemplates();
      $this->_registerStyles();
      $this->_registerScripts();
   }
 
   public function isActive() {
      if (defined('SESSION_DISABLE_INIT')) return false;
      $request = Application::get()->getRequest();
      $context = $request->getContext();
      if (is_a($context, 'Context')) {
         $activeTheme = $context->getData('themePluginPath');
      } else {
         $site = $request->getSite();
         $activeTheme = $site->getData('themePluginPath');
      }
 
      return $activeTheme == basename($this->getPluginPath());
   }
 
   public function addStyle($name, $style, $args = array()) {
 
      // Pass a file path for LESS files
      if (substr($style, (strlen(LESS_FILENAME_SUFFIX) * -1)) === LESS_FILENAME_SUFFIX) {
         $args['style'] = $this->_getBaseDir($style);
 
      // Pass a URL for other files
      } elseif (empty($args['inline'])) {
         if (isset($args['baseUrl'])) {
            $args['style'] = $args['baseUrl'] . $style;
         } else {
            $args['style'] = $this->_getBaseUrl($style);
         }
 
      // Leave inlined styles alone
      } else {
         $args['style'] = $style;
      }
 
      // Generate file paths for any additional LESS files to compile with
      // this style
      if (isset($args['addLess'])) {
         foreach ($args['addLess'] as &$file) {
            $file = $this->_getBaseDir($file);
         }
      }
 
      $this->styles[$name] = $args;
   }
 
   public function modifyStyle($name, $args = array()) {
 
      $style = &$this->getStyle($name);
 
      if (empty($style)) {
         return;
      }
 
      if (isset($args['addLess'])) {
         foreach ($args['addLess'] as &$file) {
            $file = $this->_getBaseDir($file);
         }
      }
 
      if (isset($args['style']) && !isset($args['inline'])) {
         $args['style'] = substr($args['style'], (strlen(LESS_FILENAME_SUFFIX) * -1)) == LESS_FILENAME_SUFFIX ? $this->_getBaseDir($args['style']) : $this->_getBaseUrl($args['style']);
      }
 
      $style = array_merge_recursive($style, $args);
   }
 
   public function removeStyle($name) {
 
      if (isset($this->styles[$name])) {
         unset($this->styles[$name]);
         return true;
      }
 
      return $this->parent ? $this->parent->removeStyle($name) : false;
   }
 
   public function &getStyle($name) {
 
      // Search this theme
      if (isset($this->styles[$name])) {
         $style = &$this->styles[$name];
         return $style;
      }
 
      // If no parent theme, no style was found
      if (!isset($this->parent)) {
         $style = null;
         return $style;
      }
 
      return $this->parent->getStyle($name);
   }
 
   public function addScript($name, $script, $args = array()) {
 
      if (!empty($args['inline'])) {
         $args['script'] = $script;
      } elseif (isset($args['baseUrl'])) {
         $args['script'] = $args['baseUrl'] . $script;
      } else {
         $args['script'] = $this->_getBaseUrl($script);
      }
 
      $this->scripts[$name] = $args;
   }
 
   public function modifyScript($name, $args = array()) {
 
      $script = &$this->getScript($name);
 
      if (empty($script)) {
         return;
      }
 
      if (isset($args['path'])) {
         $args['path'] = $this->_getBaseUrl($args['path']);
      }
 
      $script = array_merge( $script, $args );
   }
 
   public function removeScript($name) {
 
      if (isset($this->scripts[$name])) {
         unset($this->scripts[$name]);
         return true;
      }
 
      return $this->parent ? $this->parent->removeScript($name) : false;
   }
 
   public function &getScript($name) {
 
      // Search this theme
      if (isset($this->scripts[$name])) {
         $style = &$this->scripts[$name];
         return $style;
      }
 
      // If no parent theme, no script was found
      if (!isset($this->parent)) {
         return;
      }
 
      return $this->parent->getScript($name);
   }
 
   public function addOption($name, $type, $args = array()) {
 
      if (!empty($this->options[$name])) {
         return;
      }
 
      // Convert theme option types from before v3.2
      if (in_array($type, ['text', 'colour', 'radio'])) {
         if (isset($args['label'])) {
            $args['label'] = __($args['label']);
         }
         if (isset($args['description'])) {
            $args['description'] = __($args['description']);
         }
         switch ($type) {
            case 'text':
               $type = 'FieldText';
               break;
            case 'colour':
               $type = 'FieldColor';
               break;
            case 'radio':
               $type = 'FieldOptions';
               $args['type'] = 'radio';
               if (!empty($args['options'])) {
                  $options = [];
                  foreach ($args['options'] as $optionValue => $optionLabel) {
                     $options[] = ['value' => $optionValue, 'label' => __($optionLabel)];
                  }
                  $args['options'] = $options;
               }
               break;
         }
      }
 
      $class = 'PKP\components\forms\\' . $type;
      try {
         $this->options[$name] = new $class($name, $args);
      } catch (Exception $e) {
         $class = 'APP\components\forms\\' . $type;
         try {
            $this->options[$name] = new $class($name, $args);
         } catch (Exception $e) {
            throw new Exception(sprintf(
               'The %s class was not found for the theme option, %s,  defined by %s or one of its parent themes.',
               $type,
               $name,
               $this->getDisplayName()
            ));
         }
      }
   }
 
   public function getOption($name) {
 
      // Check if this is a valid option
      if (!isset($this->options[$name])) {
         return $this->parent ? $this->parent->getOption($name) : false;
      }
 
      // Retrieve option values if they haven't been loaded yet
      if (is_null($this->_optionValues)) {
         $context = Application::get()->getRequest()->getContext();
         $contextId = $context ? $context->getId() : CONTEXT_ID_NONE;
         $this->_optionValues = $this->getOptionValues($contextId);
      }
 
      if (isset($this->_optionValues[$name])) {
         return $this->_optionValues[$name];
      }
 
      // Return a default if no value is set
      if (isset($this->options[$name])) {
         $option = $this->options[$name];
      } elseif ($this->parent) {
         $option = $this->parent->getOption($name);
      }
      return isset($option->default) ? $option->default : null;
   }
 
   public function getOptionConfig($name) {
 
      if (isset($this->options[$name])) {
         return $this->options[$name];
      }
 
      return $this->parent ? $this->parent->getOptionConfig($name) : false;
   }
 
   public function getOptionsConfig() {
 
      if (!$this->parent) {
         return $this->options;
      }
 
      return array_merge(
         $this->parent->getOptionsConfig(),
         $this->options
      );
   }
 
   public function modifyOptionsConfig($name, $args = array()) {
      $option = $this->getOption($name);
      foreach ($args as $key => $value) {
         if (property_exists($option, $key)) {
            $option->{$key} = $value;
         }
      }
   }
 
   public function removeOption($name) {
 
      if (isset($this->options[$name])) {
         unset($this->options[$name]);
         return true;
      }
 
      return $this->parent ? $this->parent->removeOption($name) : false;
   }
 
   public function getOptionValues($contextId) {
 
      $pluginSettingsDAO = DAORegistry::getDAO('PluginSettingsDAO');
 
      $return = [];
      $values = $pluginSettingsDAO->getPluginSettings($contextId, $this->getName());
      foreach ($this->options as $optionName => $optionConfig) {
         $value = isset($values[$optionName]) ? $values[$optionName] : null;
         // Convert values stored in the db to the type of the default value
         if (!is_null($optionConfig->default)) {
            switch (gettype($optionConfig->default)) {
               case 'boolean':
                  $value = !$value || $value === 'false' ? false : true;
                  break;
               case 'integer':
                  $value = (int) $value;
                  break;
               case 'array':
                  $value = $value === null ? [] : unserialize($value);
                  break;
            }
         }
         $return[$optionName] = $value;
      }
 
      if (!$this->parent) {
         return $return;
      }
 
      return array_merge(
         $this->parent->getOptionValues($contextId),
         $return
      );
   }
 
   public function validateOptions($options, $themePluginPath, $contextId, $request) {
      return [];
   }
 
   public function saveOption($name, $value, $contextId = null) {
 
      $option = !empty($this->options[$name]) ? $this->options[$name] : null;
 
      if (is_null($option)) {
         return $this->parent ? $this->parent->saveOption($name, $value, $contextId) : false;
      }
 
      if (is_null($contextId)) {
         $context = Application::get()->getRequest()->getContext();
         $contextId = $context->getId();
      }
 
      $pluginSettingsDao = DAORegistry::getDAO('PluginSettingsDAO'); /* @var $pluginSettingsDao PluginSettingsDAO */
 
      // Remove setting row for empty string values (but not all falsey values)
      if ($value === '') {
         $pluginSettingsDao->deleteSetting($contextId, $this->getName(), $name);
      } else {
         $type = $pluginSettingsDao->getType($value);
         $value = $pluginSettingsDao->convertToDb($value, $type);
         $this->updateSetting($contextId, $name, $value, $type);
      }
 
   }
 
   public function addMenuArea($menuAreas) {
 
      if (!is_array($menuAreas)) {
         $menuAreas = array($menuAreas);
      }
 
      $this->menuAreas = array_merge($this->menuAreas, $menuAreas);
   }
 
   public function removeMenuArea($menuArea) {
 
      $index = array_search($menuArea, $this->menuAreas);
      if ($index !== false) {
         array_splice($this->menuAreas, $index, 1);
         return true;
      }
 
      return $this->parent ? $this->parent->removeMenuArea($menuArea) : false;
   }
 
   public function getMenuAreas($existingAreas = array()) {
 
      $existingAreas = array_unique(array_merge($this->menuAreas, $existingAreas));
 
      return $this->parent ? $this->parent->getMenuAreas($existingAreas) : $existingAreas;
   }
 
   public function setParent($parent) {
      $parent = PluginRegistry::getPlugin('themes', $parent);
 
      if (!is_a($parent, 'ThemePlugin')) {
         return;
      }
 
      $this->parent = $parent;
      $this->parent->init();
   }
 
   private function _registerTemplates() {
 
      // Register parent theme template directory
      if (isset($this->parent) && is_a($this->parent, 'ThemePlugin')) {
         $this->parent->_registerTemplates();
      }
 
      // Register this theme's template directory
      $request = Application::get()->getRequest();
      $templateManager = TemplateManager::getManager($request);
      $templateManager->addTemplateDir($this->_getBaseDir('templates'));
   }
 
   private function _registerStyles() {
 
      if (isset($this->parent)) {
         $this->parent->_registerStyles();
      }
 
      $request = Application::get()->getRequest();
      $dispatcher = $request->getDispatcher();
      $templateManager = TemplateManager::getManager($request);
 
      foreach($this->styles as $name => $data) {
 
         if (empty($data['style'])) {
            continue;
         }
 
         // Compile LESS files
         if ($dispatcher && substr($data['style'], (strlen(LESS_FILENAME_SUFFIX) * -1)) == LESS_FILENAME_SUFFIX) {
            $styles = $dispatcher->url(
               $request,
               ROUTE_COMPONENT,
               null,
               'page.PageHandler',
               'css',
               null,
               array(
                  'name' => $name,
               )
            );
         } else {
            $styles = $data['style'];
         }
 
         unset($data['style']);
 
         $templateManager->addStylesheet($name, $styles, $data);
      }
   }
 
   public function _registerScripts() {
 
      if (isset($this->parent)) {
         $this->parent->_registerScripts();
      }
 
      $request = Application::get()->getRequest();
      $templateManager = TemplateManager::getManager($request);
 
      foreach($this->scripts as $name => $data) {
         $script = $data['script'];
         unset($data['script']);
         $templateManager->addJavaScript($name, $script, $data);
      }
   }
 
   public function _getBaseUrl($path = '') {
      $request = Application::get()->getRequest();
      $path = empty($path) ? '' : DIRECTORY_SEPARATOR . $path;
      return $request->getBaseUrl() . DIRECTORY_SEPARATOR . $this->getPluginPath() . $path;
   }
 
   public function _getBaseDir($path = '') {
      $path = empty($path) ? '' : DIRECTORY_SEPARATOR . $path;
      return Core::getBaseDir() . DIRECTORY_SEPARATOR . $this->getPluginPath() . $path;
   }
 
   public function isColourDark($color, $limit = 130) {
      $color = str_replace('#', '', $color);
      $r = hexdec(substr($color, 0, 2));
      $g = hexdec(substr($color, 2, 2));
      $b = hexdec(substr($color, 4, 2));
      $contrast = sqrt(
         $r * $r * .241 +
         $g * $g * .691 +
         $b * $b * .068
      );
      return $contrast < $limit;
   }
}