472 lines
13 KiB
PHP
472 lines
13 KiB
PHP
<?php
|
|
|
|
/**
|
|
* @copyright Copyright (c) 2009-2022 Ryan Demmer. All rights reserved
|
|
* @license GNU/GPL 2 or later - http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
|
|
* JCE is free software. This version may have been modified pursuant
|
|
* to the GNU General Public License, and as distributed it includes or
|
|
* is derivative of works licensed under the GNU General Public License or
|
|
* other free or open source software licenses
|
|
*/
|
|
defined('JPATH_PLATFORM') or die;
|
|
|
|
require_once JPATH_ADMINISTRATOR . '/components/com_jce/includes/base.php';
|
|
|
|
/**
|
|
* JCE class.
|
|
*
|
|
* @static
|
|
*
|
|
* @since 1.5
|
|
*/
|
|
class WFApplication extends JObject
|
|
{
|
|
// Editor instance
|
|
protected static $instance;
|
|
|
|
// Editor Profile
|
|
protected static $profile = array();
|
|
|
|
// Editor Params
|
|
protected static $params = array();
|
|
|
|
// JInput Reference
|
|
public $input;
|
|
|
|
/**
|
|
* Constructor activating the default information of the class.
|
|
*/
|
|
public function __construct($config = array())
|
|
{
|
|
$this->setProperties($config);
|
|
|
|
// store a reference to the Joomla Application input
|
|
$this->input = JFactory::getApplication()->input;
|
|
}
|
|
|
|
/**
|
|
* Returns a reference to a editor object.
|
|
*
|
|
* This method must be invoked as:
|
|
* <pre> $browser =JContentEditor::getInstance();</pre>
|
|
*
|
|
* @return JCE The editor object
|
|
*/
|
|
public static function getInstance($config = array())
|
|
{
|
|
if (!isset(self::$instance)) {
|
|
self::$instance = new self($config);
|
|
}
|
|
|
|
return self::$instance;
|
|
}
|
|
|
|
/**
|
|
* Get the current version.
|
|
*
|
|
* @return string
|
|
*/
|
|
public function getVersion()
|
|
{
|
|
$manifest = WF_ADMINISTRATOR . '/jce.xml';
|
|
|
|
$version = md5_file($manifest);
|
|
|
|
return $version;
|
|
}
|
|
|
|
protected function getComponent($id = null, $option = null)
|
|
{
|
|
if ($id) {
|
|
$components = JComponentHelper::getComponents();
|
|
|
|
foreach ($components as $option => $component) {
|
|
if ($id == $component->id) {
|
|
return $component;
|
|
}
|
|
}
|
|
}
|
|
|
|
return JComponentHelper::getComponent($option);
|
|
}
|
|
|
|
public function getContext()
|
|
{
|
|
$option = JFactory::getApplication()->input->getCmd('option');
|
|
$component = JComponentHelper::getComponent($option, true);
|
|
|
|
return $component->id;
|
|
}
|
|
|
|
private function getProfileVars()
|
|
{
|
|
$app = JFactory::getApplication();
|
|
$user = JFactory::getUser();
|
|
$option = $this->getComponentOption();
|
|
|
|
$settings = array(
|
|
'option' => $option,
|
|
'area' => 2,
|
|
'device' => 'desktop',
|
|
'groups' => array(),
|
|
);
|
|
|
|
// find the component if this is called from within the JCE component
|
|
if ($option == 'com_jce') {
|
|
$context = $app->input->getInt('context');
|
|
|
|
if ($context) {
|
|
|
|
if ($context === 'mediafield') {
|
|
$settings['option'] = 'mediafield';
|
|
} else {
|
|
$component = $this->getComponent($context);
|
|
$settings['option'] = $component->option;
|
|
}
|
|
}
|
|
|
|
$profile_id = $app->input->getInt('profile_id');
|
|
|
|
if ($profile_id) {
|
|
$settings['profile_id'] = $profile_id;
|
|
}
|
|
}
|
|
|
|
// get the Joomla! area, default to "site"
|
|
$settings['area'] = $app->getClientId() === 0 ? 1 : 2;
|
|
|
|
$mobile = new Wf_Mobile_Detect();
|
|
|
|
// phone
|
|
if ($mobile->isMobile()) {
|
|
$settings['device'] = 'phone';
|
|
}
|
|
|
|
if ($mobile->isTablet()) {
|
|
$settings['device'] = 'tablet';
|
|
}
|
|
|
|
$settings['groups'] = $user->getAuthorisedGroups();
|
|
|
|
return $settings;
|
|
}
|
|
|
|
private function isCorePlugin($plugin)
|
|
{
|
|
return in_array($plugin, array('core', 'autolink', 'cleanup', 'code', 'format', 'importcss', 'colorpicker', 'upload', 'branding', 'inlinepopups', 'figure', 'ui'));
|
|
}
|
|
|
|
/**
|
|
* Get an appropriate editor profile.
|
|
*/
|
|
public function getProfile($plugin = '', $id = 0)
|
|
{
|
|
// reset the value if it is a core plugin
|
|
if ($this->isCorePlugin($plugin)) {
|
|
$plugin = '';
|
|
}
|
|
|
|
// get the profile variables for the current context
|
|
$options = $this->getProfileVars();
|
|
|
|
// add plugin to options array
|
|
$options['plugin'] = $plugin;
|
|
|
|
// assign profile_id to simple variable
|
|
if (isset($options['profile_id'])) {
|
|
$id = (int) $options['profile_id'];
|
|
}
|
|
|
|
// create a signature to store
|
|
$signature = md5(serialize($options));
|
|
|
|
if (!isset(self::$profile[$signature])) {
|
|
$db = JFactory::getDBO();
|
|
$user = JFactory::getUser();
|
|
$app = JFactory::getApplication();
|
|
|
|
$query = $db->getQuery(true);
|
|
$query->select('*')->from('#__wf_profiles')->where('published = 1')->order('ordering ASC');
|
|
|
|
if ($id) {
|
|
$query->where('id = ' . (int) $id);
|
|
}
|
|
|
|
$db->setQuery($query);
|
|
$profiles = $db->loadObjectList();
|
|
|
|
// nothing found...
|
|
if (empty($profiles)) {
|
|
return null;
|
|
}
|
|
|
|
// select and return a specific profile by id
|
|
if ($id) {
|
|
// return
|
|
return (object) $profiles[0];
|
|
}
|
|
|
|
foreach ($profiles as $item) {
|
|
// at least one user group or user must be set
|
|
if (empty($item->types) && empty($item->users)) {
|
|
continue;
|
|
}
|
|
|
|
// check user groups - a value should always be set
|
|
$groups = array_intersect($options['groups'], explode(',', $item->types));
|
|
|
|
// user not in the current group...
|
|
if (empty($groups)) {
|
|
// no additional users set or no user match
|
|
if (empty($item->users) || in_array($user->id, explode(',', $item->users)) === false) {
|
|
continue;
|
|
}
|
|
}
|
|
|
|
// check component
|
|
if (!empty($item->components)) {
|
|
if (in_array($options['option'], explode(',', $item->components)) === false) {
|
|
continue;
|
|
}
|
|
}
|
|
|
|
// set device default as 'desktop,tablet,mobile'
|
|
if (empty($item->device)) {
|
|
$item->device = 'desktop,tablet,phone';
|
|
}
|
|
|
|
// check device
|
|
if (in_array($options['device'], explode(',', $item->device)) === false) {
|
|
continue;
|
|
}
|
|
|
|
// check area
|
|
if (!empty($item->area) && (int) $item->area != $options['area']) {
|
|
continue;
|
|
}
|
|
|
|
// check against passed in plugin value
|
|
if ($plugin && in_array($plugin, explode(',', $item->plugins)) === false) {
|
|
continue;
|
|
}
|
|
|
|
// decrypt params
|
|
if (!empty($item->params)) {
|
|
$item->params = JceEncryptHelper::decrypt($item->params);
|
|
}
|
|
|
|
// assign item to profile
|
|
self::$profile[$signature] = (object) $item;
|
|
|
|
// return
|
|
return self::$profile[$signature];
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
return self::$profile[$signature];
|
|
}
|
|
|
|
/**
|
|
* Get the component option.
|
|
*
|
|
* @return string
|
|
*/
|
|
public function getComponentOption()
|
|
{
|
|
$app = JFactory::getApplication();
|
|
|
|
$option = $app->input->getCmd('option', '');
|
|
|
|
switch ($option) {
|
|
case 'com_section':
|
|
$option = 'com_content';
|
|
break;
|
|
case 'com_categories':
|
|
$section = $app->input->getCmd('section');
|
|
|
|
if ($section) {
|
|
$option = $section;
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
return $option;
|
|
}
|
|
|
|
/**
|
|
* Get editor parameters.
|
|
*
|
|
* @param array $options
|
|
*
|
|
* @return object
|
|
*/
|
|
public function getParams($options = array())
|
|
{
|
|
$app = JFactory::getApplication();
|
|
|
|
if (!isset(self::$params)) {
|
|
self::$params = array();
|
|
}
|
|
|
|
// set blank key if not set
|
|
if (!isset($options['key'])) {
|
|
$options['key'] = '';
|
|
}
|
|
// set blank path if not set
|
|
if (!isset($options['path'])) {
|
|
$options['path'] = '';
|
|
}
|
|
|
|
// get plugin name
|
|
$plugin = $app->input->getCmd('plugin', '');
|
|
|
|
// reset the plugin value if this is not called from within the JCE component
|
|
if ($app->input->getCmd('option') !== 'com_jce') {
|
|
$plugin = '';
|
|
}
|
|
|
|
if ($plugin) {
|
|
// optional caller, eg: Link
|
|
$caller = '';
|
|
|
|
// get name and caller from plugin name
|
|
if (strpos($plugin, '.') !== false) {
|
|
list($plugin, $caller) = explode('.', $plugin);
|
|
|
|
if ($caller) {
|
|
$options['caller'] = $caller;
|
|
}
|
|
}
|
|
|
|
$options['plugin'] = $plugin;
|
|
}
|
|
|
|
$signature = serialize($options);
|
|
|
|
if (empty(self::$params[$signature])) {
|
|
// get plugin
|
|
$editor = JPluginHelper::getPlugin('editors', 'jce');
|
|
|
|
if (empty($editor->params)) {
|
|
$editor->params = '{}';
|
|
}
|
|
|
|
// get editor params as an associative array
|
|
$data1 = json_decode($editor->params, true);
|
|
|
|
// if null or false, revert to array
|
|
if (empty($data1)) {
|
|
$data1 = array();
|
|
}
|
|
|
|
// assign params to "editor" key
|
|
$data1 = array('editor' => $data1);
|
|
|
|
// get params data for this profile
|
|
$profile = $this->getProfile($plugin);
|
|
|
|
// create empty default if no profile or params are set
|
|
$params = empty($profile->params) ? '{}' : $profile->params;
|
|
|
|
// get profile params as an associative array
|
|
$data2 = json_decode($params, true);
|
|
|
|
// if null or false, revert to array
|
|
if (empty($data2)) {
|
|
$data2 = array();
|
|
}
|
|
|
|
// merge params, but ignore empty values
|
|
$data = WFUtility::array_merge_recursive_distinct($data1, $data2, true);
|
|
|
|
// create new registry with params
|
|
$params = new JRegistry($data);
|
|
|
|
self::$params[$signature] = $params;
|
|
}
|
|
|
|
return self::$params[$signature];
|
|
}
|
|
|
|
private function isEmptyValue($value)
|
|
{
|
|
if (is_null($value)) {
|
|
return true;
|
|
}
|
|
|
|
if (is_array($value)) {
|
|
return empty($value);
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Get a parameter by key.
|
|
*
|
|
* @param $key Parameter key eg: editor.width
|
|
* @param $fallback Fallback value
|
|
* @param $default Default value
|
|
*/
|
|
public function getParam($key, $fallback = '', $default = '', $type = 'string')
|
|
{
|
|
// get params for base key
|
|
$params = $this->getParams();
|
|
|
|
// get a parameter
|
|
$value = $params->get($key);
|
|
|
|
// key not present in params or was empty string or empty array (JRegistry returns null), use fallback value
|
|
if (self::isEmptyValue($value)) {
|
|
// set default as empty string
|
|
$value = '';
|
|
|
|
// key does not exist (parameter was not set) - use fallback
|
|
if ($params->exists($key) === false) {
|
|
$value = $fallback;
|
|
|
|
// if fallback is empty, revert to system default if it is non-empty
|
|
if ($fallback == '' && $default != '') {
|
|
$value = $default;
|
|
|
|
// reset $default to prevent clearing
|
|
$default = '';
|
|
}
|
|
// parameter is set, but is empty, but fallback is not (inherited values)
|
|
} else if ($fallback != '') {
|
|
$value = $fallback;
|
|
}
|
|
}
|
|
|
|
// clean string value of whitespace
|
|
if (is_string($value)) {
|
|
$value = trim(preg_replace('#[\n\r\t]+#', '', $value));
|
|
}
|
|
|
|
// cast default to float if numeric
|
|
if (is_numeric($default)) {
|
|
$default = (float) $default;
|
|
}
|
|
|
|
// cast value to float if numeric
|
|
if (is_numeric($value)) {
|
|
$value = (float) $value;
|
|
}
|
|
|
|
// if value is equal to system default, clear $value and return
|
|
if ($value === $default) {
|
|
return '';
|
|
}
|
|
|
|
// cast value to boolean
|
|
if ($type == 'boolean') {
|
|
$value = (bool) $value;
|
|
}
|
|
|
|
return $value;
|
|
}
|
|
}
|