2009-05-10 10:50:39 +03:00
|
|
|
|
<?php
|
2008-09-21 09:36:57 +03:00
|
|
|
|
/*-------------------------------------------------------
|
|
|
|
|
*
|
|
|
|
|
* LiveStreet Engine Social Networking
|
|
|
|
|
* Copyright © 2008 Mzhelskiy Maxim
|
|
|
|
|
*
|
|
|
|
|
*--------------------------------------------------------
|
|
|
|
|
*
|
|
|
|
|
* Official site: www.livestreet.ru
|
|
|
|
|
* Contact e-mail: rus.engine@gmail.com
|
|
|
|
|
*
|
|
|
|
|
* GNU General Public License, version 2:
|
|
|
|
|
* http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
|
|
|
|
|
*
|
|
|
|
|
---------------------------------------------------------
|
|
|
|
|
*/
|
|
|
|
|
|
2011-04-27 18:45:28 +03:00
|
|
|
|
require_once(Config::Get('path.root.engine').'/lib/external/Smarty-3.0.7/libs/Smarty.class.php');
|
2010-03-14 23:03:33 +02:00
|
|
|
|
require_once(Config::Get('path.root.engine').'/modules/viewer/lsSmarty.class.php');
|
2009-10-06 21:36:25 +03:00
|
|
|
|
require_once(Config::Get('path.root.engine').'/lib/external/CSSTidy-1.3/class.csstidy.php');
|
|
|
|
|
require_once(Config::Get('path.root.engine').'/lib/external/JSMin-1.1.1/jsmin.php');
|
2008-09-21 09:36:57 +03:00
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* Модуль обработки шаблонов используя шаблонизатор Smarty
|
|
|
|
|
*
|
|
|
|
|
*/
|
2010-05-27 17:02:43 +03:00
|
|
|
|
class ModuleViewer extends Module {
|
2008-09-21 09:36:57 +03:00
|
|
|
|
/**
|
|
|
|
|
* Объект Smarty
|
|
|
|
|
*
|
|
|
|
|
* @var Smarty
|
|
|
|
|
*/
|
2008-10-16 18:15:19 +03:00
|
|
|
|
protected $oSmarty;
|
2008-09-21 09:36:57 +03:00
|
|
|
|
/**
|
2008-10-16 18:15:19 +03:00
|
|
|
|
* Коллекция(массив) блоков
|
2008-09-21 09:36:57 +03:00
|
|
|
|
*
|
|
|
|
|
* @var array
|
|
|
|
|
*/
|
2008-10-16 18:15:19 +03:00
|
|
|
|
protected $aBlocks=array();
|
2009-10-02 23:45:30 +03:00
|
|
|
|
/**
|
|
|
|
|
* Массив правил организации блоков
|
|
|
|
|
*
|
|
|
|
|
* @var array
|
|
|
|
|
*/
|
2009-10-03 21:58:07 +03:00
|
|
|
|
protected $aBlockRules = array();
|
2009-10-06 21:36:25 +03:00
|
|
|
|
/**
|
|
|
|
|
* Стандартные настройки вывода js, css файлов
|
|
|
|
|
*
|
|
|
|
|
* @var array
|
|
|
|
|
*/
|
|
|
|
|
protected $aFilesDefault=array(
|
|
|
|
|
'js' => array(),
|
|
|
|
|
'css' => array()
|
2009-10-07 11:01:19 +03:00
|
|
|
|
);
|
|
|
|
|
/**
|
|
|
|
|
* Параметры отображения js, css файлов
|
|
|
|
|
*
|
|
|
|
|
* @var array
|
|
|
|
|
*/
|
|
|
|
|
protected $aFilesParams=array(
|
|
|
|
|
'js' => array(),
|
|
|
|
|
'css' => array()
|
|
|
|
|
);
|
2009-10-06 21:36:25 +03:00
|
|
|
|
/**
|
|
|
|
|
* Правила переопределение массивов js и css
|
|
|
|
|
*
|
|
|
|
|
* @var array
|
|
|
|
|
*/
|
|
|
|
|
protected $aFileRules=array();
|
|
|
|
|
/**
|
|
|
|
|
* Список JS, которые нужно добавить в начало и в конец
|
|
|
|
|
*
|
|
|
|
|
* @var array
|
|
|
|
|
*/
|
|
|
|
|
protected $aJsInclude = array(
|
|
|
|
|
'append' => array(),
|
2009-10-10 22:58:24 +03:00
|
|
|
|
'prepend' => array()
|
2009-10-06 21:36:25 +03:00
|
|
|
|
);
|
|
|
|
|
/**
|
|
|
|
|
* Список CSS, которые нужно добавить в начало и в конец
|
|
|
|
|
*
|
|
|
|
|
* @var array
|
|
|
|
|
*/
|
|
|
|
|
protected $aCssInclude = array(
|
|
|
|
|
'append' => array(),
|
2009-10-10 22:58:24 +03:00
|
|
|
|
'prepend' => array()
|
2009-10-06 21:36:25 +03:00
|
|
|
|
);
|
|
|
|
|
/**
|
|
|
|
|
* Каталог для кешировния js,css файлов
|
|
|
|
|
*
|
|
|
|
|
* @var string
|
|
|
|
|
*/
|
|
|
|
|
protected $sCacheDir='';
|
|
|
|
|
/**
|
|
|
|
|
* Объект CSSTidy для компрессии css-файлов
|
|
|
|
|
*
|
|
|
|
|
* @var csstidy
|
|
|
|
|
*/
|
|
|
|
|
protected $oCssCompressor = null;
|
2008-09-21 09:36:57 +03:00
|
|
|
|
/**
|
|
|
|
|
* Заголовок HTML страницы
|
|
|
|
|
*
|
|
|
|
|
* @var unknown_type
|
|
|
|
|
*/
|
2009-08-19 16:15:47 +03:00
|
|
|
|
protected $sHtmlTitle;
|
2008-10-24 08:23:13 +03:00
|
|
|
|
/**
|
|
|
|
|
* SEO ключевые слова страницы
|
|
|
|
|
*
|
|
|
|
|
* @var unknown_type
|
|
|
|
|
*/
|
2009-08-19 16:15:47 +03:00
|
|
|
|
protected $sHtmlKeywords;
|
2008-10-24 08:23:13 +03:00
|
|
|
|
/**
|
|
|
|
|
* SEO описание страницы
|
|
|
|
|
*
|
|
|
|
|
* @var unknown_type
|
|
|
|
|
*/
|
2009-08-19 16:15:47 +03:00
|
|
|
|
protected $sHtmlDescription;
|
2008-10-24 08:23:13 +03:00
|
|
|
|
|
2008-09-21 09:36:57 +03:00
|
|
|
|
/**
|
|
|
|
|
* Разделитель заголовка HTML страницы
|
|
|
|
|
*
|
|
|
|
|
* @var unknown_type
|
|
|
|
|
*/
|
|
|
|
|
protected $sHtmlTitleSeparation=' / ';
|
|
|
|
|
|
2009-04-25 14:22:57 +03:00
|
|
|
|
/**
|
|
|
|
|
* Альтернативный адрес страницы по RSS
|
|
|
|
|
*
|
|
|
|
|
* @var array
|
|
|
|
|
*/
|
|
|
|
|
protected $aHtmlRssAlternate=null;
|
2009-10-06 21:36:25 +03:00
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* Html код для подключения js,css
|
|
|
|
|
*
|
|
|
|
|
* @var string
|
|
|
|
|
*/
|
2009-10-07 14:30:06 +03:00
|
|
|
|
protected $aHtmlHeadFiles='';
|
2009-04-25 14:22:57 +03:00
|
|
|
|
|
2009-06-24 19:58:21 +03:00
|
|
|
|
/**
|
|
|
|
|
* Переменные для отдачи при ajax запросе
|
|
|
|
|
*
|
|
|
|
|
* @var unknown_type
|
|
|
|
|
*/
|
|
|
|
|
protected $aVarsAjax=array();
|
|
|
|
|
/**
|
|
|
|
|
* Определяет тип ответа при ajax запросе
|
|
|
|
|
*
|
|
|
|
|
* @var unknown_type
|
|
|
|
|
*/
|
|
|
|
|
protected $sResponseAjax=null;
|
2011-05-04 19:11:54 +03:00
|
|
|
|
/**
|
|
|
|
|
* Отправляет специфичный для ответа header
|
|
|
|
|
*
|
|
|
|
|
* @var unknown_type
|
|
|
|
|
*/
|
|
|
|
|
protected $bResponseSpecificHeader=true;
|
2010-01-19 19:38:04 +02:00
|
|
|
|
/**
|
|
|
|
|
* Список меню для рендеринга
|
|
|
|
|
*
|
|
|
|
|
* @var array
|
|
|
|
|
*/
|
|
|
|
|
protected $aMenu=array();
|
|
|
|
|
/**
|
|
|
|
|
* Скомпилированные меню
|
|
|
|
|
*
|
|
|
|
|
* @var array
|
|
|
|
|
*/
|
|
|
|
|
protected $aMenuFetch=array();
|
2008-09-21 09:36:57 +03:00
|
|
|
|
/**
|
|
|
|
|
* Инициализация модуля
|
|
|
|
|
*
|
|
|
|
|
*/
|
2010-08-05 12:44:08 +03:00
|
|
|
|
public function Init($bLocal=false) {
|
|
|
|
|
$this->Hook_Run('viewer_init_start',compact('bLocal'));
|
2010-08-16 15:49:12 +03:00
|
|
|
|
/**
|
|
|
|
|
* Load template config
|
|
|
|
|
*/
|
|
|
|
|
if (!$bLocal) {
|
|
|
|
|
if(file_exists(Config::Get('path.smarty.template').'/settings/config/config.php')) {
|
|
|
|
|
Config::LoadFromFile(Config::Get('path.smarty.template').'/settings/config/config.php',false);
|
|
|
|
|
}
|
|
|
|
|
}
|
2009-08-19 16:15:47 +03:00
|
|
|
|
/**
|
|
|
|
|
* Заголовок HTML страницы
|
|
|
|
|
*/
|
|
|
|
|
$this->sHtmlTitle=Config::Get('view.name');
|
|
|
|
|
/**
|
|
|
|
|
* SEO ключевые слова страницы
|
|
|
|
|
*/
|
|
|
|
|
$this->sHtmlKeywords=Config::Get('view.keywords');
|
|
|
|
|
/**
|
|
|
|
|
* SEO описание страницы
|
|
|
|
|
*/
|
|
|
|
|
$this->sHtmlDescription=Config::Get('view.description');
|
|
|
|
|
|
2008-09-21 09:36:57 +03:00
|
|
|
|
/**
|
|
|
|
|
* Создаём объект Smarty и устанавливаем необходиму параметры
|
|
|
|
|
*/
|
2011-04-25 19:00:40 +03:00
|
|
|
|
$this->oSmarty = new lsSmarty();
|
2011-04-27 18:45:28 +03:00
|
|
|
|
$this->oSmarty->error_reporting=E_ALL^E_NOTICE; // подавляем NOTICE ошибки - в этом вся прелесть смарти )
|
2011-04-25 19:00:40 +03:00
|
|
|
|
$this->oSmarty->template_dir=(array)Config::Get('path.smarty.template');
|
|
|
|
|
$this->oSmarty->template_dir[]=Config::Get('path.root.server').'/plugins/';
|
2009-11-06 02:24:02 +02:00
|
|
|
|
/**
|
|
|
|
|
* Для каждого скина устанавливаем свою директорию компиляции шаблонов
|
|
|
|
|
*/
|
|
|
|
|
$sCompilePath = Config::Get('path.smarty.compiled').'/'.Config::Get('view.skin');
|
|
|
|
|
if(!is_dir($sCompilePath)) @mkdir($sCompilePath);
|
|
|
|
|
$this->oSmarty->compile_dir=$sCompilePath;
|
|
|
|
|
|
2009-08-19 16:15:47 +03:00
|
|
|
|
$this->oSmarty->cache_dir=Config::Get('path.smarty.cache');
|
2011-04-27 18:45:28 +03:00
|
|
|
|
$this->oSmarty->plugins_dir=array_merge(array(Config::Get('path.smarty.plug'),'plugins'),$this->oSmarty->plugins_dir);
|
2009-10-02 23:45:30 +03:00
|
|
|
|
/**
|
2010-04-03 19:44:12 +03:00
|
|
|
|
* Получаем настройки блоков из конфигов
|
2009-10-02 23:45:30 +03:00
|
|
|
|
*/
|
2009-10-03 21:58:07 +03:00
|
|
|
|
$this->InitBlockParams();
|
2010-04-03 19:44:12 +03:00
|
|
|
|
/**
|
|
|
|
|
* Добавляем блоки по предзагруженным правилам из конфигов
|
|
|
|
|
*/
|
|
|
|
|
$this->BuildBlocks();
|
2009-10-06 21:36:25 +03:00
|
|
|
|
/**
|
|
|
|
|
* Получаем настройки JS, CSS файлов
|
|
|
|
|
*/
|
|
|
|
|
$this->InitFileParams();
|
2010-02-04 21:17:03 +02:00
|
|
|
|
$this->sCacheDir = Config::Get('path.smarty.cache');
|
2008-09-21 09:36:57 +03:00
|
|
|
|
}
|
|
|
|
|
|
2009-12-14 22:25:30 +02:00
|
|
|
|
/**
|
|
|
|
|
* Получает локальную копию модуля
|
|
|
|
|
*
|
2010-05-27 17:02:43 +03:00
|
|
|
|
* return ModuleViewer
|
2009-12-14 22:25:30 +02:00
|
|
|
|
*/
|
|
|
|
|
public function GetLocalViewer() {
|
2010-05-27 17:02:43 +03:00
|
|
|
|
$oViewerLocal=new ModuleViewer(Engine::getInstance());
|
2010-08-05 12:44:08 +03:00
|
|
|
|
$oViewerLocal->Init(true);
|
2009-12-14 22:25:30 +02:00
|
|
|
|
$oViewerLocal->VarAssign();
|
|
|
|
|
$oViewerLocal->Assign('aLang',$this->Lang_GetLangMsg());
|
|
|
|
|
|
|
|
|
|
return $oViewerLocal;
|
|
|
|
|
}
|
|
|
|
|
|
2008-09-21 09:36:57 +03:00
|
|
|
|
/**
|
|
|
|
|
* Выполняет загрузку необходимый(возможно даже системный :)) переменных в шалон
|
|
|
|
|
*
|
|
|
|
|
*/
|
|
|
|
|
public function VarAssign() {
|
|
|
|
|
/**
|
|
|
|
|
* Загружаем весь $_REQUEST, предварительно обработав его функцией func_htmlspecialchars()
|
|
|
|
|
*/
|
|
|
|
|
$aRequest=$_REQUEST;
|
|
|
|
|
func_htmlspecialchars($aRequest);
|
|
|
|
|
$this->Assign("_aRequest",$aRequest);
|
|
|
|
|
/**
|
|
|
|
|
* Параметры стандартной сессии
|
|
|
|
|
*/
|
|
|
|
|
$this->Assign("_sPhpSessionName",session_name());
|
|
|
|
|
$this->Assign("_sPhpSessionId",session_id());
|
2010-11-13 07:44:45 +02:00
|
|
|
|
/**
|
|
|
|
|
* Short Engine aliases
|
|
|
|
|
*/
|
|
|
|
|
$this->Assign("LS",LS::getInstance());
|
2009-12-04 18:11:07 +02:00
|
|
|
|
/**
|
2009-12-06 19:46:03 +02:00
|
|
|
|
* Загружаем объект доступа к конфигурации
|
2009-12-04 18:11:07 +02:00
|
|
|
|
*/
|
2009-12-06 19:46:03 +02:00
|
|
|
|
$this->Assign("oConfig",Config::getInstance());
|
2009-08-29 13:01:16 +03:00
|
|
|
|
/**
|
|
|
|
|
* Загружаем роутинг с учетом правил rewrite
|
|
|
|
|
*/
|
|
|
|
|
$aRouter=array();
|
2009-11-29 18:50:37 +02:00
|
|
|
|
$aPages=Config::Get('router.page');
|
|
|
|
|
|
|
|
|
|
if(!$aPages or !is_array($aPages)) throw new Exception('Router rules is underfined.');
|
|
|
|
|
foreach ($aPages as $sPage=>$aAction) {
|
2009-08-29 13:01:16 +03:00
|
|
|
|
$aRouter[$sPage]=Router::GetPath($sPage);
|
|
|
|
|
}
|
|
|
|
|
$this->Assign("aRouter",$aRouter);
|
2009-10-06 21:36:25 +03:00
|
|
|
|
/**
|
|
|
|
|
* Загружаем в шаблон блоки
|
|
|
|
|
*/
|
2008-10-16 18:15:19 +03:00
|
|
|
|
$this->Assign("aBlocks",$this->aBlocks);
|
2008-09-21 09:36:57 +03:00
|
|
|
|
/**
|
|
|
|
|
* Загружаем HTML заголовки
|
|
|
|
|
*/
|
|
|
|
|
$this->Assign("sHtmlTitle",htmlspecialchars($this->sHtmlTitle));
|
2008-10-24 08:23:13 +03:00
|
|
|
|
$this->Assign("sHtmlKeywords",htmlspecialchars($this->sHtmlKeywords));
|
|
|
|
|
$this->Assign("sHtmlDescription",htmlspecialchars($this->sHtmlDescription));
|
2009-10-07 14:30:06 +03:00
|
|
|
|
$this->Assign("aHtmlHeadFiles",$this->aHtmlHeadFiles);
|
2009-04-25 14:22:57 +03:00
|
|
|
|
$this->Assign("aHtmlRssAlternate",$this->aHtmlRssAlternate);
|
2010-05-04 13:08:49 +03:00
|
|
|
|
/**
|
|
|
|
|
* Загружаем список активных плагинов
|
|
|
|
|
*/
|
|
|
|
|
$aPlugins=$this->oEngine->GetPlugins();
|
2010-08-21 10:07:51 +03:00
|
|
|
|
$this->Assign("aPluginActive",array_fill_keys(array_keys($aPlugins),true));
|
|
|
|
|
/**
|
|
|
|
|
* Загружаем пути до шаблонов плагинов
|
|
|
|
|
*/
|
|
|
|
|
$aTemplateWebPathPlugin=array();
|
2011-04-10 19:10:13 +03:00
|
|
|
|
$aTemplatePathPlugin=array();
|
2010-08-21 10:07:51 +03:00
|
|
|
|
foreach ($aPlugins as $k=>$oPlugin) {
|
|
|
|
|
$aTemplateWebPathPlugin[$k]=Plugin::GetTemplateWebPath(get_class($oPlugin));
|
2011-04-10 19:10:13 +03:00
|
|
|
|
$aTemplatePathPlugin[$k]=Plugin::GetTemplatePath(get_class($oPlugin));
|
2010-08-21 10:07:51 +03:00
|
|
|
|
}
|
|
|
|
|
$this->Assign("aTemplateWebPathPlugin",$aTemplateWebPathPlugin);
|
2011-04-10 19:10:13 +03:00
|
|
|
|
$this->Assign("aTemplatePathPlugin",$aTemplatePathPlugin);
|
2008-09-21 09:36:57 +03:00
|
|
|
|
}
|
|
|
|
|
|
2010-01-23 21:01:54 +02:00
|
|
|
|
/**
|
|
|
|
|
* Загружаем содержимое menu-контейнеров
|
|
|
|
|
*/
|
|
|
|
|
protected function MenuVarAssign() {
|
|
|
|
|
$this->Assign("aMenuFetch",$this->aMenuFetch);
|
|
|
|
|
$this->Assign("aMenuContainers",array_keys($this->aMenu));
|
|
|
|
|
}
|
|
|
|
|
|
2008-09-21 09:36:57 +03:00
|
|
|
|
/**
|
|
|
|
|
* Выводит на экран(браузер) обработанный шаблон
|
|
|
|
|
*
|
|
|
|
|
* @param string $sTemplate
|
|
|
|
|
*/
|
|
|
|
|
public function Display($sTemplate) {
|
2009-06-24 19:58:21 +03:00
|
|
|
|
if ($this->sResponseAjax) {
|
|
|
|
|
$this->DisplayAjax($this->sResponseAjax);
|
|
|
|
|
}
|
2008-09-21 09:36:57 +03:00
|
|
|
|
/**
|
|
|
|
|
* Если шаблон найден то выводим, иначе ошибка
|
2010-01-11 15:22:29 +02:00
|
|
|
|
* Предварительно проверяем наличие делегата
|
2008-09-21 09:36:57 +03:00
|
|
|
|
*/
|
2011-04-26 14:38:48 +03:00
|
|
|
|
if ($sTemplate) {
|
|
|
|
|
$sTemplate=$this->Plugin_GetDelegate('template',$sTemplate);
|
|
|
|
|
if ($this->TemplateExists($sTemplate)) {
|
|
|
|
|
$this->oSmarty->display($sTemplate);
|
|
|
|
|
} else {
|
|
|
|
|
throw new Exception('Can not find the template: '.$sTemplate);
|
|
|
|
|
}
|
2008-09-21 09:36:57 +03:00
|
|
|
|
}
|
|
|
|
|
}
|
2010-09-24 17:32:00 +03:00
|
|
|
|
/**
|
|
|
|
|
* Возвращает объект Smarty
|
|
|
|
|
*
|
|
|
|
|
* @return unknown
|
|
|
|
|
*/
|
|
|
|
|
public function GetSmartyObject() {
|
|
|
|
|
return $this->oSmarty;
|
|
|
|
|
}
|
2009-06-24 19:58:21 +03:00
|
|
|
|
/**
|
|
|
|
|
* Ответ на ajax запрос
|
|
|
|
|
*
|
|
|
|
|
* @param unknown_type $sType - jsHttpRequest или json
|
|
|
|
|
*/
|
|
|
|
|
public function DisplayAjax($sType='jsHttpRequest') {
|
|
|
|
|
/**
|
|
|
|
|
* Загружаем статус ответа и сообщение
|
|
|
|
|
*/
|
|
|
|
|
$bStateError=false;
|
|
|
|
|
$sMsgTitle='';
|
|
|
|
|
$sMsg='';
|
|
|
|
|
$aMsgError=$this->Message_GetError();
|
|
|
|
|
$aMsgNotice=$this->Message_GetNotice();
|
2010-09-24 17:45:53 +03:00
|
|
|
|
if (count($aMsgError)>0) {
|
|
|
|
|
$bStateError=true;
|
|
|
|
|
$sMsgTitle=$aMsgError[0]['title'];
|
|
|
|
|
$sMsg=$aMsgError[0]['msg'];
|
2010-09-24 17:47:38 +03:00
|
|
|
|
} elseif (count($aMsgNotice)>0) {
|
|
|
|
|
$sMsgTitle=$aMsgNotice[0]['title'];
|
|
|
|
|
$sMsg=$aMsgNotice[0]['msg'];
|
|
|
|
|
}
|
2009-09-20 21:47:25 +03:00
|
|
|
|
$this->AssignAjax('sMsgTitle',$sMsgTitle);
|
|
|
|
|
$this->AssignAjax('sMsg',$sMsg);
|
|
|
|
|
$this->AssignAjax('bStateError',$bStateError);
|
2009-07-05 00:41:42 +03:00
|
|
|
|
if ($sType=='jsHttpRequest') {
|
2009-06-24 19:58:21 +03:00
|
|
|
|
foreach ($this->aVarsAjax as $key => $value) {
|
|
|
|
|
$GLOBALS['_RESULT'][$key]=$value;
|
|
|
|
|
}
|
|
|
|
|
} elseif ($sType=='json') {
|
2011-05-04 19:11:54 +03:00
|
|
|
|
if ($this->bResponseSpecificHeader and !headers_sent()) {
|
2009-06-24 19:58:21 +03:00
|
|
|
|
header('Content-type: application/json');
|
|
|
|
|
}
|
|
|
|
|
echo json_encode($this->aVarsAjax);
|
2011-05-04 19:11:54 +03:00
|
|
|
|
} elseif ($sType=='jsonIframe') {
|
|
|
|
|
// Оборачивает json в тег <textarea>, это не дает браузеру выполнить HTML, который вернул iframe
|
|
|
|
|
if ($this->bResponseSpecificHeader and !headers_sent()) {
|
|
|
|
|
header('Content-type: application/json');
|
|
|
|
|
}
|
|
|
|
|
echo '<textarea>'.json_encode($this->aVarsAjax).'</textarea>';
|
2010-11-13 08:02:53 +02:00
|
|
|
|
} elseif ($sType=='jsonp') {
|
2011-05-04 19:11:54 +03:00
|
|
|
|
if ($this->bResponseSpecificHeader and !headers_sent()) {
|
2010-11-13 08:02:53 +02:00
|
|
|
|
header('Content-type: application/json');
|
|
|
|
|
}
|
|
|
|
|
echo getRequest('jsonpCallback','callback').'('.json_encode($this->aVarsAjax).');';
|
2009-06-24 19:58:21 +03:00
|
|
|
|
}
|
|
|
|
|
exit();
|
|
|
|
|
}
|
2011-03-23 13:31:06 +02:00
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* Возвращает тип отдачи контекта
|
|
|
|
|
*
|
|
|
|
|
* @return unknown
|
|
|
|
|
*/
|
|
|
|
|
public function GetResponseAjax() {
|
|
|
|
|
return $this->sResponseAjax;
|
|
|
|
|
}
|
2009-06-24 19:58:21 +03:00
|
|
|
|
/**
|
|
|
|
|
* Устанавливает тип отдачи при ajax запросе, если null то выполняется обычный вывод шаблона в браузер
|
|
|
|
|
*
|
|
|
|
|
* @param unknown_type $sResponseAjax
|
|
|
|
|
*/
|
2011-05-04 19:11:54 +03:00
|
|
|
|
public function SetResponseAjax($sResponseAjax='jsHttpRequest',$bResponseSpecificHeader=true) {
|
2009-06-24 19:58:21 +03:00
|
|
|
|
/**
|
|
|
|
|
* Проверка на безопасную обработку ajax запроса
|
|
|
|
|
*/
|
2009-07-05 00:41:42 +03:00
|
|
|
|
if ($sResponseAjax) {
|
|
|
|
|
if ($sResponseAjax=='jsHttpRequest') {
|
2009-08-19 16:15:47 +03:00
|
|
|
|
require_once(Config::Get('path.root.engine')."/lib/external/JsHttpRequest/JsHttpRequest.php");
|
2009-07-05 00:41:42 +03:00
|
|
|
|
$JsHttpRequest = new JsHttpRequest("UTF-8");
|
|
|
|
|
}
|
2009-10-21 01:32:58 +03:00
|
|
|
|
}
|
2010-11-13 08:02:53 +02:00
|
|
|
|
// Для возможности кросс-доменных запросов
|
|
|
|
|
if ($sResponseAjax!='jsonp') {
|
|
|
|
|
$this->Security_ValidateSendForm();
|
|
|
|
|
}
|
2009-06-24 19:58:21 +03:00
|
|
|
|
$this->sResponseAjax=$sResponseAjax;
|
2011-05-04 19:11:54 +03:00
|
|
|
|
$this->bResponseSpecificHeader=$bResponseSpecificHeader;
|
2009-06-24 19:58:21 +03:00
|
|
|
|
}
|
2008-09-21 09:36:57 +03:00
|
|
|
|
/**
|
|
|
|
|
* Загружает переменную в шаблон
|
|
|
|
|
*
|
|
|
|
|
* @param string $sName
|
|
|
|
|
* @param unknown_type $value
|
|
|
|
|
*/
|
|
|
|
|
public function Assign($sName,$value) {
|
|
|
|
|
$this->oSmarty->assign($sName, $value);
|
|
|
|
|
}
|
2009-06-24 19:58:21 +03:00
|
|
|
|
/**
|
|
|
|
|
* Загружаем переменную в ajax ответ
|
|
|
|
|
*
|
|
|
|
|
* @param unknown_type $sName
|
|
|
|
|
* @param unknown_type $value
|
|
|
|
|
*/
|
2009-09-20 21:47:25 +03:00
|
|
|
|
public function AssignAjax($sName,$value) {
|
2009-06-24 19:58:21 +03:00
|
|
|
|
$this->aVarsAjax[$sName]=$value;
|
|
|
|
|
}
|
2008-09-21 09:36:57 +03:00
|
|
|
|
/**
|
|
|
|
|
* Возвращает обработанный шаблон
|
|
|
|
|
*
|
|
|
|
|
* @param string $sTemplate
|
|
|
|
|
* @return string
|
|
|
|
|
*/
|
2010-01-01 17:31:04 +02:00
|
|
|
|
public function Fetch($sTemplate) {
|
2010-01-11 15:22:29 +02:00
|
|
|
|
/**
|
|
|
|
|
* Проверяем наличие делегата
|
|
|
|
|
*/
|
|
|
|
|
$sTemplate=$this->Plugin_GetDelegate('template',$sTemplate);
|
2009-12-28 13:43:56 +02:00
|
|
|
|
return $this->oSmarty->fetch($sTemplate);
|
2008-09-21 09:36:57 +03:00
|
|
|
|
}
|
|
|
|
|
/**
|
|
|
|
|
* Проверяет существование шаблона
|
|
|
|
|
*
|
|
|
|
|
* @param string $sTemplate
|
|
|
|
|
* @return bool
|
|
|
|
|
*/
|
|
|
|
|
public function TemplateExists($sTemplate) {
|
2011-04-27 18:45:28 +03:00
|
|
|
|
return $this->oSmarty->templateExists($sTemplate);
|
2008-09-21 09:36:57 +03:00
|
|
|
|
}
|
2009-10-02 23:45:30 +03:00
|
|
|
|
/**
|
|
|
|
|
* Инициализируем параметры отображения блоков
|
2009-11-23 16:01:48 +02:00
|
|
|
|
*/
|
2009-10-03 21:58:07 +03:00
|
|
|
|
protected function InitBlockParams() {
|
2009-11-23 16:01:48 +02:00
|
|
|
|
if($aRules=Config::Get('block')) {
|
|
|
|
|
$this->aBlockRules=$aRules;
|
|
|
|
|
}
|
2009-10-02 23:45:30 +03:00
|
|
|
|
}
|
2008-09-21 09:36:57 +03:00
|
|
|
|
/**
|
|
|
|
|
* Добавляет блок для отображения
|
|
|
|
|
*
|
2009-10-03 21:58:07 +03:00
|
|
|
|
* @param string $sGroup
|
2008-09-21 09:36:57 +03:00
|
|
|
|
* @param string $sName
|
2009-10-03 21:58:07 +03:00
|
|
|
|
* @param array $aParams - параметры блока, которые будут переданы обработчику блока
|
|
|
|
|
* @param int $iPriority
|
|
|
|
|
* @return bool
|
2008-09-21 09:36:57 +03:00
|
|
|
|
*/
|
2009-10-03 21:58:07 +03:00
|
|
|
|
public function AddBlock($sGroup,$sName,$aParams=array(),$iPriority=5) {
|
2010-03-09 00:41:58 +02:00
|
|
|
|
/**
|
|
|
|
|
* Если не указана директория шаблона, но указана приналежность к плагину,
|
|
|
|
|
* то "вычисляем" правильную директорию
|
|
|
|
|
*/
|
|
|
|
|
if(!isset($aParams['dir']) and isset($aParams['plugin'])) {
|
|
|
|
|
$aParams['dir'] = Plugin::GetTemplatePath($aParams['plugin']);
|
|
|
|
|
}
|
2008-09-21 09:36:57 +03:00
|
|
|
|
/**
|
|
|
|
|
* Если смогли определить тип блока то добавляем его
|
|
|
|
|
*/
|
2010-01-01 17:31:04 +02:00
|
|
|
|
$sType=$this->DefineTypeBlock($sName,isset($aParams['dir'])?$aParams['dir']:null);
|
2008-09-21 09:36:57 +03:00
|
|
|
|
if ($sType=='undefined') {
|
|
|
|
|
return false;
|
|
|
|
|
}
|
2010-01-13 20:10:05 +02:00
|
|
|
|
$this->aBlocks[$sGroup][]=array(
|
2009-10-03 21:58:07 +03:00
|
|
|
|
'type' => $sType,
|
2010-01-01 17:31:04 +02:00
|
|
|
|
'name' => $sName,
|
2009-10-03 21:58:07 +03:00
|
|
|
|
'params' => $aParams,
|
|
|
|
|
'priority' => $iPriority,
|
2008-09-21 09:36:57 +03:00
|
|
|
|
);
|
|
|
|
|
return true;
|
|
|
|
|
}
|
2010-03-09 00:41:58 +02:00
|
|
|
|
|
2008-09-21 09:36:57 +03:00
|
|
|
|
/**
|
|
|
|
|
* Добавляет список блоков
|
|
|
|
|
*
|
|
|
|
|
* @param array $aBlocks
|
|
|
|
|
*/
|
2010-01-06 22:53:38 +02:00
|
|
|
|
public function AddBlocks($sGroup,$aBlocks,$ClearBlocks=true) {
|
2008-09-21 09:36:57 +03:00
|
|
|
|
/**
|
|
|
|
|
* Удаляем ранее добавленые блоки
|
|
|
|
|
*/
|
2010-01-06 22:53:38 +02:00
|
|
|
|
if ($ClearBlocks) {
|
|
|
|
|
$this->ClearBlocks($sGroup);
|
|
|
|
|
}
|
2008-09-21 09:36:57 +03:00
|
|
|
|
foreach ($aBlocks as $sBlock) {
|
2010-07-07 13:01:52 +03:00
|
|
|
|
if (is_array($sBlock)) {
|
|
|
|
|
$this->AddBlock(
|
|
|
|
|
$sGroup,
|
|
|
|
|
$sBlock['block'],
|
|
|
|
|
isset($sBlock['params']) ? $sBlock['params'] : array(),
|
|
|
|
|
isset($sBlock['priority']) ? $sBlock['priority'] : 5
|
|
|
|
|
);
|
|
|
|
|
} else {
|
|
|
|
|
$this->AddBlock($sGroup,$sBlock);
|
|
|
|
|
}
|
2008-09-21 09:36:57 +03:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
2008-10-16 18:15:19 +03:00
|
|
|
|
* Удаляет блоки группы
|
|
|
|
|
*
|
|
|
|
|
*/
|
|
|
|
|
public function ClearBlocks($sGroup) {
|
|
|
|
|
$this->aBlocks[$sGroup]=array();
|
|
|
|
|
}
|
|
|
|
|
/**
|
|
|
|
|
* Удаляет блоки всех групп
|
2008-09-21 09:36:57 +03:00
|
|
|
|
*
|
2008-10-16 18:15:19 +03:00
|
|
|
|
* @param unknown_type $sGroup
|
2008-09-21 09:36:57 +03:00
|
|
|
|
*/
|
2008-10-16 18:15:19 +03:00
|
|
|
|
public function ClearBlocksAll() {
|
|
|
|
|
foreach ($this->aBlocks as $sGroup => $aBlock) {
|
|
|
|
|
$this->aBlocks[$sGroup]=array();
|
|
|
|
|
}
|
2008-09-21 09:36:57 +03:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* Определяет тип блока
|
|
|
|
|
*
|
|
|
|
|
* @param string $sName
|
|
|
|
|
* @return string('block','template','undefined')
|
|
|
|
|
*/
|
2010-01-01 17:31:04 +02:00
|
|
|
|
protected function DefineTypeBlock($sName,$sDir=null) {
|
|
|
|
|
if ($this->TemplateExists(is_null($sDir)?'block.'.$sName.'.tpl':rtrim($sDir,'/').'/block.'.$sName.'.tpl')) {
|
2008-09-21 09:36:57 +03:00
|
|
|
|
/**
|
|
|
|
|
* Если найден шаблон вида block.name.tpl то считаем что тип 'block'
|
|
|
|
|
*/
|
|
|
|
|
return 'block';
|
2010-01-01 17:31:04 +02:00
|
|
|
|
} elseif ($this->TemplateExists($sName)) {
|
2008-09-21 09:36:57 +03:00
|
|
|
|
/**
|
|
|
|
|
* Если найден шаблон по имени блока то считаем его простым шаблоном
|
|
|
|
|
*/
|
|
|
|
|
return 'template';
|
|
|
|
|
} else {
|
|
|
|
|
/**
|
|
|
|
|
* Считаем что тип не определен
|
|
|
|
|
*/
|
2010-01-05 12:38:22 +02:00
|
|
|
|
throw new Exception('Can not find the block`s template: '.$sName);
|
2008-09-21 09:36:57 +03:00
|
|
|
|
return 'undefined';
|
|
|
|
|
}
|
|
|
|
|
}
|
2009-10-02 23:45:30 +03:00
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* Анализируем правила и наборы массивов
|
|
|
|
|
* получаем окончательные списки блоков
|
|
|
|
|
*/
|
2009-10-03 21:58:07 +03:00
|
|
|
|
protected function BuildBlocks() {
|
2009-10-02 23:45:30 +03:00
|
|
|
|
$sAction = strtolower(Router::GetAction());
|
2010-04-03 19:44:12 +03:00
|
|
|
|
$sEvent = strtolower(Router::GetActionEvent());
|
2009-10-03 21:58:07 +03:00
|
|
|
|
foreach($this->aBlockRules as $sName=>$aRule) {
|
2009-10-02 23:45:30 +03:00
|
|
|
|
$bUse=false;
|
|
|
|
|
/**
|
|
|
|
|
* Если в правиле не указан список блоков, нам такое не нужно
|
|
|
|
|
*/
|
|
|
|
|
if(!array_key_exists('blocks',$aRule)) continue;
|
|
|
|
|
/**
|
2009-10-16 01:13:16 +03:00
|
|
|
|
* Если не задан action для исполнения и нет ни одного шаблона path,
|
2009-10-02 23:45:30 +03:00
|
|
|
|
* или текущий не входит в перечисленные в правиле
|
|
|
|
|
* то выбираем следующее правило
|
|
|
|
|
*/
|
2009-11-06 02:24:02 +02:00
|
|
|
|
if(!array_key_exists('action',$aRule) && !array_key_exists('path',$aRule)) continue;
|
2010-04-03 19:44:12 +03:00
|
|
|
|
if(in_array($sAction, (array)$aRule['action'])) $bUse=true;
|
2009-10-02 23:45:30 +03:00
|
|
|
|
if(array_key_exists($sAction,(array)$aRule['action'])) {
|
|
|
|
|
/**
|
|
|
|
|
* Если задан список event`ов и текущий в него не входит,
|
2010-04-03 22:09:21 +03:00
|
|
|
|
* переходи к следующему действию.
|
2009-10-02 23:45:30 +03:00
|
|
|
|
*/
|
2010-04-03 22:09:21 +03:00
|
|
|
|
foreach ((array)$aRule['action'][$sAction] as $sEventPreg) {
|
|
|
|
|
if(substr($sEventPreg,0,1)!='/') {
|
|
|
|
|
/**
|
|
|
|
|
* значит это название event`a
|
|
|
|
|
*/
|
|
|
|
|
if($sEvent==$sEventPreg) { $bUse=true; break; }
|
|
|
|
|
} else {
|
|
|
|
|
/**
|
|
|
|
|
* это регулярное выражение
|
|
|
|
|
*/
|
|
|
|
|
if(preg_match($sEventPreg,$sEvent)) { $bUse=true; break; }
|
2009-10-03 21:58:07 +03:00
|
|
|
|
}
|
2010-04-03 22:09:21 +03:00
|
|
|
|
}
|
2009-10-02 23:45:30 +03:00
|
|
|
|
}
|
2009-10-16 01:13:16 +03:00
|
|
|
|
/**
|
|
|
|
|
* Если не найдено совпадение по паре Action/Event,
|
|
|
|
|
* переходим к поиску по regexp путей.
|
|
|
|
|
*/
|
2009-11-23 16:01:48 +02:00
|
|
|
|
if(!$bUse && isset($aRule['path'])) {
|
2009-10-16 01:13:16 +03:00
|
|
|
|
$sPath = rtrim(Router::GetPathWebCurrent(),"/");
|
|
|
|
|
/**
|
|
|
|
|
* Проверяем последовательно каждый regexp
|
|
|
|
|
*/
|
|
|
|
|
foreach((array)$aRule['path'] as $sRulePath) {
|
2010-04-17 18:28:42 +03:00
|
|
|
|
$sPattern = "~".str_replace(array('/','*'),array('\/','[\w\-]+'), $sRulePath)."~";
|
2009-10-16 01:13:16 +03:00
|
|
|
|
if(preg_match($sPattern, $sPath)) {
|
|
|
|
|
$bUse=true;
|
|
|
|
|
break 1;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
}
|
2009-10-02 23:45:30 +03:00
|
|
|
|
|
|
|
|
|
if($bUse){
|
2009-11-23 16:01:48 +02:00
|
|
|
|
/**
|
|
|
|
|
* Если задан режим очистки блоков, сначала чистим старые блоки
|
|
|
|
|
*/
|
|
|
|
|
if(isset($aRule['clear'])) {
|
|
|
|
|
switch (true) {
|
|
|
|
|
/**
|
|
|
|
|
* Если установлен в true, значит очищаем все
|
|
|
|
|
*/
|
|
|
|
|
case ($aRule['clear']===true):
|
|
|
|
|
$this->ClearBlocksAll();
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case is_string($aRule['clear']):
|
|
|
|
|
$this->ClearBlocks($aRule['clear']);
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case is_array($aRule['clear']):
|
|
|
|
|
foreach ($aRule['clear'] as $sGroup) {
|
|
|
|
|
$this->ClearBlocks($sGroup);
|
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
2009-10-02 23:45:30 +03:00
|
|
|
|
/**
|
|
|
|
|
* Добавляем все блоки, указанные в параметре blocks
|
|
|
|
|
*/
|
|
|
|
|
foreach ($aRule['blocks'] as $sGroup => $aBlocks) {
|
|
|
|
|
foreach ((array)$aBlocks as $sName=>$aParams) {
|
2010-07-07 13:01:52 +03:00
|
|
|
|
/**
|
|
|
|
|
* Если название блока указывается в параметрах
|
|
|
|
|
*/
|
|
|
|
|
if (is_int($sName)) {
|
|
|
|
|
if (is_array($aParams)) {
|
|
|
|
|
$sName=$aParams['block'];
|
|
|
|
|
}
|
|
|
|
|
}
|
2009-10-02 23:45:30 +03:00
|
|
|
|
/**
|
|
|
|
|
* Если $aParams не являются массивом, значит передано только имя блока
|
|
|
|
|
*/
|
|
|
|
|
if(!is_array($aParams)) {
|
|
|
|
|
$this->AddBlock($sGroup,$aParams);
|
|
|
|
|
} else {
|
2009-10-03 21:58:07 +03:00
|
|
|
|
$this->AddBlock(
|
|
|
|
|
$sGroup,$sName,
|
|
|
|
|
isset($aParams['params']) ? $aParams['params'] : array(),
|
|
|
|
|
isset($aParams['priority']) ? $aParams['priority'] : 5
|
|
|
|
|
);
|
2009-10-02 23:45:30 +03:00
|
|
|
|
}
|
|
|
|
|
}
|
2009-10-03 21:58:07 +03:00
|
|
|
|
}
|
2009-10-02 23:45:30 +03:00
|
|
|
|
}
|
2010-04-03 19:44:12 +03:00
|
|
|
|
}
|
2009-10-02 23:45:30 +03:00
|
|
|
|
return true;
|
2009-10-03 21:58:07 +03:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* Вспомагательная функция для сортировки блоков по приоритетности
|
|
|
|
|
*
|
|
|
|
|
* @param array $a
|
|
|
|
|
* @param array $b
|
|
|
|
|
* @return int
|
|
|
|
|
*/
|
2010-04-03 19:44:12 +03:00
|
|
|
|
protected function _SortBlocks($a,$b) {
|
2009-10-03 21:58:07 +03:00
|
|
|
|
return ($a["priority"]-$b["priority"]);
|
|
|
|
|
}
|
2010-04-03 19:44:12 +03:00
|
|
|
|
/**
|
|
|
|
|
* Сортируем блоки
|
|
|
|
|
*
|
|
|
|
|
*/
|
|
|
|
|
protected function SortBlocks() {
|
|
|
|
|
/**
|
|
|
|
|
* Сортируем блоки по приоритетности
|
|
|
|
|
*/
|
|
|
|
|
foreach($this->aBlocks as $sGroup=>$aBlocks) {
|
|
|
|
|
uasort($aBlocks,array(&$this,'_SortBlocks'));
|
|
|
|
|
$this->aBlocks[$sGroup] = array_reverse($aBlocks);
|
|
|
|
|
}
|
|
|
|
|
}
|
2009-10-06 21:36:25 +03:00
|
|
|
|
/**
|
|
|
|
|
* Инициализирует параметры вывода js- и css- файлов
|
|
|
|
|
*/
|
|
|
|
|
protected function InitFileParams() {
|
2009-10-07 11:01:19 +03:00
|
|
|
|
foreach (array('js','css') as $sType) {
|
2009-11-23 16:01:48 +02:00
|
|
|
|
/**
|
|
|
|
|
* Проверяем наличие списка файлов данного типа
|
|
|
|
|
*/
|
|
|
|
|
$aFiles = Config::Get('head.default.'.$sType);
|
|
|
|
|
if(is_array($aFiles) and count($aFiles)) {
|
|
|
|
|
foreach ($aFiles as $sFile=>$aParams) {
|
|
|
|
|
if(!is_array($aParams)) {
|
|
|
|
|
/**
|
|
|
|
|
* Параметры не определены
|
|
|
|
|
*/
|
|
|
|
|
$this->aFilesDefault[$sType][] = $aParams;
|
|
|
|
|
} else {
|
|
|
|
|
/**
|
|
|
|
|
* Добавляем файл и параметры
|
|
|
|
|
*/
|
|
|
|
|
$this->aFilesDefault[$sType][] = $sFile;
|
|
|
|
|
$this->aFilesParams[$sType][$sFile] = $aParams;
|
|
|
|
|
}
|
|
|
|
|
}
|
2009-10-07 11:01:19 +03:00
|
|
|
|
}
|
|
|
|
|
}
|
2009-10-06 21:36:25 +03:00
|
|
|
|
}
|
|
|
|
|
/**
|
|
|
|
|
* Создает css-компрессор и инициализирует его конфигурацию
|
|
|
|
|
*
|
|
|
|
|
* @return bool
|
|
|
|
|
*/
|
|
|
|
|
protected function InitCssCompressor() {
|
|
|
|
|
/**
|
|
|
|
|
* Получаем параметры из конфигурации
|
|
|
|
|
*/
|
|
|
|
|
$aParams = Config::Get('compress.css');
|
|
|
|
|
$this->oCssCompressor =($aParams['use']) ? new csstidy() : null;
|
|
|
|
|
/**
|
|
|
|
|
* Если компрессор не создан, завершаем работу инициализатора
|
|
|
|
|
*/
|
|
|
|
|
if(!$this->oCssCompressor) return false;
|
|
|
|
|
/**
|
|
|
|
|
* Устанавливаем параметры
|
|
|
|
|
*/
|
|
|
|
|
$this->oCssCompressor->set_cfg('case_properties', $aParams['case_properties']);
|
|
|
|
|
$this->oCssCompressor->set_cfg('merge_selectors', $aParams['merge_selectors']);
|
|
|
|
|
$this->oCssCompressor->set_cfg('optimise_shorthands', $aParams['optimise_shorthands']);
|
|
|
|
|
$this->oCssCompressor->set_cfg('remove_last_;', $aParams['remove_last_;']);
|
|
|
|
|
$this->oCssCompressor->set_cfg('css_level', $aParams['css_level']);
|
|
|
|
|
$this->oCssCompressor->load_template($aParams['template']);
|
|
|
|
|
|
|
|
|
|
return true;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* Функции добавления js-скриптов и css-каскадов
|
|
|
|
|
*/
|
2009-10-07 11:01:19 +03:00
|
|
|
|
public function AppendScript($sJs,$aParams=array()) {
|
2009-10-06 21:36:25 +03:00
|
|
|
|
$this->aJsInclude['append'][] = $sJs;
|
2009-10-07 11:01:19 +03:00
|
|
|
|
$this->aFilesParams['js'][$sJs] = $aParams;
|
2009-10-06 21:36:25 +03:00
|
|
|
|
}
|
2009-10-10 22:58:24 +03:00
|
|
|
|
public function PrependScript($sJs,$aParams=array()) {
|
2009-10-07 11:01:19 +03:00
|
|
|
|
$this->aJsInclude['prepend'][] = $sJs;
|
|
|
|
|
$this->aFilesParams['js'][$sJs] = $aParams;
|
2009-10-06 21:36:25 +03:00
|
|
|
|
}
|
2009-10-07 11:01:19 +03:00
|
|
|
|
public function AppendStyle($sCss,$aParams=array()) {
|
2009-10-06 21:36:25 +03:00
|
|
|
|
$this->aCssInclude['append'][] = $sCss;
|
2009-10-07 11:01:19 +03:00
|
|
|
|
$this->aFilesParams['css'][$sCss] = $aParams;
|
2009-10-06 21:36:25 +03:00
|
|
|
|
}
|
2009-10-10 22:58:24 +03:00
|
|
|
|
public function PrependStyle($sCss,$aParams=array()) {
|
2009-10-06 21:36:25 +03:00
|
|
|
|
$this->aCssInclude['prepend'][] = $sCss;
|
2009-10-07 11:01:19 +03:00
|
|
|
|
$this->aFilesParams['css'][$sCss] = $aParams;
|
2009-10-06 21:36:25 +03:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* Строит массив для подключения css и js,
|
|
|
|
|
* преобразовывает их в строку для HTML
|
|
|
|
|
*
|
|
|
|
|
* @return bool
|
|
|
|
|
*/
|
|
|
|
|
protected function BuildHeadFiles() {
|
2009-10-16 01:13:16 +03:00
|
|
|
|
$sPath = Router::GetPathWebCurrent();
|
2009-10-06 21:36:25 +03:00
|
|
|
|
/**
|
|
|
|
|
* По умолчанию имеем дефаултовые настройки
|
|
|
|
|
*/
|
|
|
|
|
$aResult = $this->aFilesDefault;
|
|
|
|
|
|
2010-06-02 19:29:09 +03:00
|
|
|
|
$this->aFileRules = Config::Get('head.rules');
|
2009-10-06 21:36:25 +03:00
|
|
|
|
foreach((array)$this->aFileRules as $sName => $aRule) {
|
|
|
|
|
if(!$aRule['path']) continue;
|
|
|
|
|
|
|
|
|
|
foreach((array)$aRule['path'] as $sRulePath) {
|
2009-10-16 01:13:16 +03:00
|
|
|
|
$sPattern = "~".str_replace(array('/','*'),array('\/','\w+'), $sRulePath)."~";
|
|
|
|
|
if(preg_match($sPattern, $sPath)) {
|
2009-10-06 21:36:25 +03:00
|
|
|
|
/**
|
|
|
|
|
* Преобразование JS
|
|
|
|
|
*/
|
|
|
|
|
if(isset($aRule['js']['empty']) && $aRule['js']['empty']) $aResult['js']=array();
|
|
|
|
|
if(isset($aRule['js']['exclude']) && is_array($aRule['js']['exclude'])) $aResult['js']=array_diff($aResult['js'],$aRule['js']['exclude']);
|
|
|
|
|
if(isset($aRule['js']['include']) && is_array($aRule['js']['include'])) $aResult['js']=array_merge($aResult['js'],$aRule['js']['include']);
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* Преобразование CSS
|
|
|
|
|
*/
|
|
|
|
|
if(isset($aRule['css']['empty']) && $aRule['css']['empty']) $aResult['css']=array();
|
|
|
|
|
if(isset($aRule['css']['exclude']) && is_array($aRule['css']['exclude'])) $aResult['css']=array_diff($aResult['css'],$aRule['css']['exclude']);
|
|
|
|
|
if(isset($aRule['css']['include']) && is_array($aRule['css']['include'])) $aResult['css']=array_merge($aResult['css'],$aRule['css']['include']);
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* Продолжаем поиск
|
|
|
|
|
*/
|
|
|
|
|
if(isset($aRule['stop'])) {
|
|
|
|
|
break(2);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* Добавляем скрипты и css из массивов
|
|
|
|
|
*/
|
|
|
|
|
$aResult['js'] = array_values(
|
|
|
|
|
array_merge(
|
2010-02-01 12:32:40 +02:00
|
|
|
|
(array)$this->aJsInclude['prepend'],
|
2009-10-06 21:36:25 +03:00
|
|
|
|
(array)$aResult['js'],
|
2010-02-01 12:32:40 +02:00
|
|
|
|
(array)$this->aJsInclude['append']
|
2009-10-06 21:36:25 +03:00
|
|
|
|
)
|
|
|
|
|
);
|
|
|
|
|
$aResult['css'] = array_values(
|
|
|
|
|
array_merge(
|
2010-02-01 12:32:40 +02:00
|
|
|
|
(array)$this->aCssInclude['prepend'],
|
2009-10-06 21:36:25 +03:00
|
|
|
|
(array)$aResult['css'],
|
2010-02-01 12:32:40 +02:00
|
|
|
|
(array)$this->aCssInclude['append']
|
2009-10-06 21:36:25 +03:00
|
|
|
|
)
|
|
|
|
|
);
|
|
|
|
|
|
|
|
|
|
/**
|
2009-10-07 11:01:19 +03:00
|
|
|
|
* Получаем список блоков
|
2009-10-06 21:36:25 +03:00
|
|
|
|
*/
|
2009-10-07 11:01:19 +03:00
|
|
|
|
$aBlocks['js'] = array_unique(
|
|
|
|
|
array_map(
|
|
|
|
|
create_function('$sJs','return isset($sJs["block"]) ? $sJs["block"] : null;'),
|
|
|
|
|
$this->aFilesParams['js']
|
|
|
|
|
)
|
|
|
|
|
);
|
|
|
|
|
$aBlocks['css'] = array_unique(
|
|
|
|
|
array_map(
|
|
|
|
|
create_function('$sCss','return isset($sCss["block"]) ? $sCss["block"] : null;'),
|
|
|
|
|
$this->aFilesParams['css']
|
|
|
|
|
)
|
|
|
|
|
);
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* Сливаем файлы в один, используя блочное разделение
|
|
|
|
|
*/
|
|
|
|
|
$aHeadFiles = array('js'=>array(),'css'=>array());
|
|
|
|
|
|
|
|
|
|
foreach (array('js','css') as $sType) {
|
|
|
|
|
/**
|
|
|
|
|
* Отдельно выделяем файлы, для которых указано отображение,
|
|
|
|
|
* привязанное к браузеру (ex. IE6, IE7)
|
|
|
|
|
*/
|
|
|
|
|
$aFilesHack = array_filter(
|
|
|
|
|
$this->aFilesParams[$sType],
|
|
|
|
|
create_function(
|
|
|
|
|
'$aParams',
|
|
|
|
|
'return array_key_exists("browser",(array)$aParams);'
|
|
|
|
|
)
|
|
|
|
|
);
|
|
|
|
|
$aFilesHack = array_intersect(array_keys($aFilesHack),$aResult[$sType]);
|
|
|
|
|
/**
|
|
|
|
|
* Исключаем эти файлы из основной выдачи
|
|
|
|
|
*/
|
|
|
|
|
$aResult[$sType] = array_diff($aResult[$sType],$aFilesHack);
|
2011-04-25 12:46:29 +03:00
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* Аналогично выделяем файлы, которые не нужно объединять со всеми
|
|
|
|
|
* TODO: объединить в один цикл с $aFilesHack
|
|
|
|
|
*/
|
|
|
|
|
$aFilesNoMerge = array_filter(
|
|
|
|
|
$this->aFilesParams[$sType],
|
|
|
|
|
create_function(
|
|
|
|
|
'$aParams',
|
|
|
|
|
'return array_key_exists("merge",(array)$aParams) and !$aParams["merge"];'
|
|
|
|
|
)
|
|
|
|
|
);
|
|
|
|
|
$aFilesNoMerge = array_intersect(array_keys($aFilesNoMerge),$aResult[$sType]);
|
|
|
|
|
$aResult[$sType] = array_diff($aResult[$sType],$aFilesNoMerge);
|
|
|
|
|
|
2009-10-07 11:01:19 +03:00
|
|
|
|
/**
|
|
|
|
|
* Добавляем файлы поблочно
|
|
|
|
|
*/
|
|
|
|
|
if($aBlocks[$sType] && count($aBlocks[$sType])) {
|
|
|
|
|
foreach ($aBlocks[$sType] as $sBlock) {
|
|
|
|
|
if(!$sBlock) continue;
|
|
|
|
|
/**
|
|
|
|
|
* Выбираем все файлы, входящие в данный блок
|
|
|
|
|
*/
|
|
|
|
|
$aFiles = array_filter($this->aFilesParams[$sType],create_function('$aParams','return (isset($aParams)&&($aParams["block"]=="'.$sBlock.'"));'));
|
|
|
|
|
$aFiles = array_intersect(array_keys($aFiles),$aResult[$sType]);
|
|
|
|
|
if($aFiles && count($aFiles)) {
|
|
|
|
|
$aHeadFiles[$sType][] = $this->Compress($aFiles,$sType);
|
|
|
|
|
/**
|
|
|
|
|
* Удаляем эти файлы из
|
|
|
|
|
*/
|
2009-11-23 14:53:06 +02:00
|
|
|
|
$aResult[$sType] = array_diff($aResult[$sType],$aFiles);
|
2009-10-07 11:01:19 +03:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
/**
|
|
|
|
|
* Обрабатываем "последние" оставшиеся
|
|
|
|
|
*/
|
2009-11-23 14:53:06 +02:00
|
|
|
|
if(Config::Get("compress.{$sType}.merge")) {
|
|
|
|
|
$aHeadFiles[$sType][] = $this->Compress($aResult[$sType],$sType);
|
|
|
|
|
} else {
|
2010-04-10 03:04:03 +03:00
|
|
|
|
$aHeadFiles[$sType] = array_map(array($this,'GetWebPath'),array_merge($aHeadFiles[$sType],$aResult[$sType]));
|
2009-11-23 14:53:06 +02:00
|
|
|
|
}
|
2009-10-07 11:01:19 +03:00
|
|
|
|
/**
|
|
|
|
|
* Добавляем файлы хаков
|
|
|
|
|
*/
|
|
|
|
|
if(is_array($aFilesHack) && count($aFilesHack)) $aHeadFiles[$sType] = array_merge($aHeadFiles[$sType],$aFilesHack);
|
2011-04-25 12:46:29 +03:00
|
|
|
|
if(is_array($aFilesNoMerge) && count($aFilesNoMerge)) $aHeadFiles[$sType] = array_merge($aHeadFiles[$sType],$aFilesNoMerge);
|
2009-10-07 11:01:19 +03:00
|
|
|
|
}
|
|
|
|
|
|
2009-10-06 21:36:25 +03:00
|
|
|
|
/**
|
|
|
|
|
* Получаем HTML код
|
|
|
|
|
*/
|
2009-10-07 14:30:06 +03:00
|
|
|
|
$aHtmlHeadFiles = $this->BuildHtmlHeadFiles($aHeadFiles);
|
|
|
|
|
$this->SetHtmlHeadFiles($aHtmlHeadFiles);
|
2009-10-06 21:36:25 +03:00
|
|
|
|
return true;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* Сжимает все переданные файлы в один,
|
|
|
|
|
* использует файловое кеширование
|
|
|
|
|
*
|
|
|
|
|
* @param array $aFiles
|
|
|
|
|
* @param string $sType
|
|
|
|
|
* @return array
|
|
|
|
|
*/
|
|
|
|
|
protected function Compress($aFiles,$sType) {
|
2009-11-15 19:52:11 +02:00
|
|
|
|
$sCacheDir = $this->sCacheDir."/".Config::Get('view.skin');
|
|
|
|
|
$sCacheName = $sCacheDir."/".md5(serialize($aFiles).'_head').".{$sType}";
|
2009-10-06 21:36:25 +03:00
|
|
|
|
$sPathServer = Config::Get('path.root.server');
|
|
|
|
|
$sPathWeb = Config::Get('path.root.web');
|
|
|
|
|
/**
|
|
|
|
|
* Если кеш существует, то берем из кеша
|
|
|
|
|
*/
|
|
|
|
|
if(!file_exists($sCacheName)) {
|
2009-11-15 19:52:11 +02:00
|
|
|
|
/**
|
|
|
|
|
* Создаем директорию для кеша текущего скина,
|
|
|
|
|
* если таковая отсутствует
|
|
|
|
|
*/
|
|
|
|
|
if(!is_dir($sCacheDir)){
|
|
|
|
|
@mkdir($sCacheDir);
|
|
|
|
|
}
|
2009-10-06 21:36:25 +03:00
|
|
|
|
/**
|
|
|
|
|
* Считываем содержимое
|
|
|
|
|
*/
|
|
|
|
|
ob_start();
|
2009-11-15 19:52:11 +02:00
|
|
|
|
foreach ($aFiles as $sFile) {
|
2011-04-25 12:46:29 +03:00
|
|
|
|
// если файл локальный
|
|
|
|
|
if (strpos($sFile,Config::Get('path.root.web'))!==false) {
|
|
|
|
|
$sFile=$this->GetServerPath($sFile);
|
|
|
|
|
}
|
2009-10-06 21:36:25 +03:00
|
|
|
|
list($sFile,)=explode('?',$sFile,2);
|
|
|
|
|
/**
|
|
|
|
|
* Если файл существует, обрабатываем
|
|
|
|
|
*/
|
2011-04-25 15:28:26 +03:00
|
|
|
|
if($sFileContent = @file_get_contents($sFile)) {
|
2009-10-06 21:36:25 +03:00
|
|
|
|
if($sType=='css'){
|
|
|
|
|
$sFileContent = $this->ConvertPathInCss($sFileContent,$sFile);
|
|
|
|
|
$sFileContent = $this->CompressCss($sFileContent);
|
|
|
|
|
} elseif($sType=='js') {
|
|
|
|
|
$sFileContent = $this->CompressJs($sFileContent);
|
|
|
|
|
}
|
|
|
|
|
print $sFileContent;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
$sContent = ob_get_contents();
|
|
|
|
|
ob_end_clean();
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* Создаем новый файл и сливаем туда содержимое
|
|
|
|
|
*/
|
|
|
|
|
file_put_contents($sCacheName,$sContent);
|
2009-12-01 01:47:41 +02:00
|
|
|
|
@chmod($sCacheName, 0766);
|
2009-10-06 21:36:25 +03:00
|
|
|
|
}
|
|
|
|
|
/**
|
|
|
|
|
* Возвращаем имя файла, заменяя адрес сервера на веб-адрес
|
|
|
|
|
*/
|
2009-10-07 11:01:19 +03:00
|
|
|
|
return $this->GetWebPath($sCacheName);
|
2009-10-06 21:36:25 +03:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* Выполняет преобразование CSS файлов
|
|
|
|
|
*
|
|
|
|
|
* @param string $sContent
|
|
|
|
|
* @return string
|
|
|
|
|
*/
|
|
|
|
|
protected function CompressCss($sContent) {
|
|
|
|
|
$this->InitCssCompressor();
|
|
|
|
|
if(!$this->oCssCompressor) return $sContent;
|
|
|
|
|
/**
|
|
|
|
|
* Парсим css и отдаем обработанный результат
|
|
|
|
|
*/
|
|
|
|
|
$this->oCssCompressor->parse($sContent);
|
2009-10-07 11:01:19 +03:00
|
|
|
|
return $this->oCssCompressor->print->plain();
|
2009-10-06 21:36:25 +03:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* Конвертирует относительные пути в css файлах в абсолютные
|
|
|
|
|
*
|
|
|
|
|
* @param string $content
|
|
|
|
|
* @param string $path
|
|
|
|
|
* @return string
|
|
|
|
|
*/
|
|
|
|
|
protected function ConvertPathInCss($sContent,$sPath) {
|
|
|
|
|
preg_match_all( "/url\((.*?)\)/is",$sContent,$aMatches);
|
|
|
|
|
if(count($aMatches[1])==0) return $sContent;
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* Обрабатываем список файлов
|
|
|
|
|
*/
|
|
|
|
|
$aFiles = array_unique($aMatches[1]);
|
|
|
|
|
$sDir = dirname($sPath)."/";
|
|
|
|
|
|
|
|
|
|
foreach($aFiles as $sFilePath) {
|
|
|
|
|
/**
|
|
|
|
|
* Don't touch data URIs
|
|
|
|
|
*/
|
|
|
|
|
if(strstr($sFilePath,"data:")) {
|
|
|
|
|
continue;
|
|
|
|
|
}
|
|
|
|
|
$sFilePathAbsolute = preg_replace("@'|\"@","",trim($sFilePath));
|
|
|
|
|
/**
|
|
|
|
|
* Если путь является абсолютным, необрабатываем
|
|
|
|
|
*/
|
|
|
|
|
if(substr($sFilePathAbsolute,0,1) == "/" || substr($sFilePathAbsolute,0,5) == "http:") {
|
|
|
|
|
continue;
|
|
|
|
|
}
|
|
|
|
|
/**
|
|
|
|
|
* Обрабатываем относительный путь
|
|
|
|
|
*/
|
2011-04-25 15:28:26 +03:00
|
|
|
|
$sFilePathAbsolute = $this->GetWebPath($this->GetRealpath($sDir.$sFilePathAbsolute));
|
2009-10-06 21:36:25 +03:00
|
|
|
|
/**
|
|
|
|
|
* Заменяем относительные пути в файле на абсолютные
|
|
|
|
|
*/
|
|
|
|
|
$sContent = str_replace($sFilePath,$sFilePathAbsolute,$sContent);
|
|
|
|
|
}
|
|
|
|
|
return $sContent;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* Выполняет преобразование JS файла
|
|
|
|
|
*
|
|
|
|
|
* @param string $sContent
|
|
|
|
|
* @return string
|
|
|
|
|
*/
|
|
|
|
|
protected function CompressJs($sContent) {
|
|
|
|
|
$sContent = (Config::Get('compress.js.use'))
|
|
|
|
|
? JSMin::minify($sContent)
|
|
|
|
|
: $sContent;
|
|
|
|
|
/**
|
|
|
|
|
* Добавляем разделитель в конце файла
|
|
|
|
|
* с расчетом на возможное их слияние в будущем
|
|
|
|
|
*/
|
|
|
|
|
return rtrim($sContent,";").";".PHP_EOL;
|
|
|
|
|
}
|
|
|
|
|
|
2011-04-25 15:28:26 +03:00
|
|
|
|
/**
|
|
|
|
|
* Аналог realpath + обработка URL
|
|
|
|
|
*
|
|
|
|
|
* @param unknown_type $sPath
|
|
|
|
|
* @return unknown
|
|
|
|
|
*/
|
|
|
|
|
protected function GetRealpath($sPath) {
|
|
|
|
|
if (preg_match("@^(http|https):@",$sPath)) {
|
|
|
|
|
$aUrl=parse_url($sPath);
|
|
|
|
|
$sPath=$aUrl['path'];
|
|
|
|
|
|
|
|
|
|
$aParts = array();
|
|
|
|
|
$sPath = preg_replace('~/\./~', '/', $sPath);
|
|
|
|
|
foreach (explode('/', preg_replace('~/+~', '/', $sPath)) as $sPart ) {
|
|
|
|
|
if ($sPart === "..") {
|
|
|
|
|
array_pop($aParts);
|
|
|
|
|
} elseif ($sPart!="") {
|
|
|
|
|
$aParts[] = $sPart;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
return ( (array_key_exists('scheme', $aUrl)) ? $aUrl['scheme'] . '://' . $aUrl['host'] : "" ) . "/" . implode("/", $aParts);
|
|
|
|
|
} else {
|
|
|
|
|
return realpath($sPath);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2009-10-06 21:36:25 +03:00
|
|
|
|
/**
|
|
|
|
|
* Преобразует абсолютный путь к файлу в WEB-вариант
|
|
|
|
|
*
|
|
|
|
|
* @param string $sFile
|
|
|
|
|
* @return string
|
|
|
|
|
*/
|
|
|
|
|
protected function GetWebPath($sFile) {
|
2010-02-09 17:16:17 +02:00
|
|
|
|
return str_replace(
|
|
|
|
|
str_replace(DIRECTORY_SEPARATOR,'/',Config::Get('path.root.server')),
|
|
|
|
|
Config::Get('path.root.web'),
|
|
|
|
|
str_replace(DIRECTORY_SEPARATOR,'/',$sFile)
|
|
|
|
|
);
|
2009-10-06 21:36:25 +03:00
|
|
|
|
}
|
2009-11-15 19:52:11 +02:00
|
|
|
|
/**
|
|
|
|
|
* Преобразует WEB-путь файла в серверный вариант
|
|
|
|
|
*
|
|
|
|
|
* @param string $sFile
|
|
|
|
|
* @return string
|
|
|
|
|
*/
|
|
|
|
|
protected function GetServerPath($sFile) {
|
|
|
|
|
/**
|
|
|
|
|
* Убираем из путей www
|
|
|
|
|
*/
|
|
|
|
|
$sFile = str_replace('//www.','//',$sFile);
|
|
|
|
|
$sPathWeb = str_replace('//www.','//',Config::Get('path.root.web'));
|
|
|
|
|
/**
|
|
|
|
|
* Производим замену
|
|
|
|
|
*/
|
|
|
|
|
$sFile=str_replace($sPathWeb,Config::Get('path.root.server'),$sFile);
|
|
|
|
|
return str_replace('/',DIRECTORY_SEPARATOR,$sFile);
|
|
|
|
|
}
|
|
|
|
|
|
2009-10-06 21:36:25 +03:00
|
|
|
|
/**
|
|
|
|
|
* Строит HTML код по переданному массиву файлов
|
|
|
|
|
*
|
|
|
|
|
* @param array $aFileList
|
|
|
|
|
* @return string
|
|
|
|
|
*/
|
|
|
|
|
protected function BuildHtmlHeadFiles($aFileList) {
|
2009-10-07 14:30:06 +03:00
|
|
|
|
$aHeader=array('js'=>'','css'=>'');
|
2009-10-06 21:36:25 +03:00
|
|
|
|
|
|
|
|
|
foreach ((array)$aFileList['css'] as $sCss) {
|
2009-10-07 14:30:06 +03:00
|
|
|
|
$aHeader['css'].=$this->WrapHtmlHack("<link rel='stylesheet' type='text/css' href='{$sCss}' />", $sCss, 'css').PHP_EOL;
|
2009-10-06 21:36:25 +03:00
|
|
|
|
}
|
|
|
|
|
foreach((array)$aFileList['js'] as $sJs) {
|
2009-10-07 14:30:06 +03:00
|
|
|
|
$aHeader['js'].=$this->WrapHtmlHack("<script type='text/javascript' src='{$sJs}'></script>",$sJs,'js').PHP_EOL;
|
2009-10-06 21:36:25 +03:00
|
|
|
|
}
|
|
|
|
|
|
2009-10-07 14:30:06 +03:00
|
|
|
|
return $aHeader;
|
2009-10-06 21:36:25 +03:00
|
|
|
|
}
|
|
|
|
|
|
2009-10-07 11:01:19 +03:00
|
|
|
|
/**
|
|
|
|
|
* Обрамляет HTML код в браузер-хак (ex., [if IE 6])
|
|
|
|
|
*
|
|
|
|
|
* @param string $sHtml
|
|
|
|
|
* @param string $sFile
|
|
|
|
|
* @param string $sType (js|css)
|
|
|
|
|
*
|
|
|
|
|
* @return string
|
|
|
|
|
*/
|
|
|
|
|
protected function WrapHtmlHack($sHtml,$sFile,$sType) {
|
|
|
|
|
if(!isset($this->aFilesParams[$sType][$sFile]['browser'])) return $sHtml;
|
|
|
|
|
return "<!--[if {$this->aFilesParams[$sType][$sFile]['browser']}]>$sHtml<![endif]-->";
|
|
|
|
|
}
|
|
|
|
|
|
2009-10-07 14:30:06 +03:00
|
|
|
|
public function SetHtmlHeadFiles($aText) {
|
|
|
|
|
$this->aHtmlHeadFiles=$aText;
|
2009-10-06 21:36:25 +03:00
|
|
|
|
}
|
2009-10-02 23:45:30 +03:00
|
|
|
|
|
2008-09-21 09:36:57 +03:00
|
|
|
|
/**
|
|
|
|
|
* Устанавливаем заголовок страницы(тег <title>)
|
|
|
|
|
*
|
|
|
|
|
* @param string $sText
|
|
|
|
|
*/
|
|
|
|
|
public function SetHtmlTitle($sText) {
|
|
|
|
|
$this->sHtmlTitle=$sText;
|
|
|
|
|
}
|
|
|
|
|
/**
|
|
|
|
|
* Добавляет часть заголовка страницы через разделитель
|
|
|
|
|
*
|
|
|
|
|
* @param string $sText
|
|
|
|
|
*/
|
|
|
|
|
public function AddHtmlTitle($sText) {
|
|
|
|
|
$this->sHtmlTitle=$sText.$this->sHtmlTitleSeparation.$this->sHtmlTitle;
|
|
|
|
|
}
|
|
|
|
|
/**
|
|
|
|
|
* Возвращает текущий заголовок страницы
|
|
|
|
|
*
|
|
|
|
|
* @return unknown
|
|
|
|
|
*/
|
|
|
|
|
public function GetHtmlTitle() {
|
|
|
|
|
return $this->sHtmlTitle;
|
2008-10-24 08:23:13 +03:00
|
|
|
|
}
|
|
|
|
|
/**
|
|
|
|
|
* Устанавливает ключевые слова keywords
|
|
|
|
|
*
|
|
|
|
|
* @param string $sText
|
|
|
|
|
*/
|
|
|
|
|
public function SetHtmlKeywords($sText) {
|
|
|
|
|
$this->sHtmlKeywords=$sText;
|
|
|
|
|
}
|
|
|
|
|
/**
|
|
|
|
|
* Устанавливает описание страницы desciption
|
|
|
|
|
*
|
|
|
|
|
* @param string $sText
|
|
|
|
|
*/
|
|
|
|
|
public function SetHtmlDescription($sText) {
|
|
|
|
|
$this->sHtmlDescription=$sText;
|
2008-09-21 09:36:57 +03:00
|
|
|
|
}
|
2009-04-25 14:22:57 +03:00
|
|
|
|
/**
|
|
|
|
|
* Устанавливает альтернативный адрес страницы по RSS
|
|
|
|
|
*
|
|
|
|
|
* @param string $sText
|
|
|
|
|
*/
|
|
|
|
|
public function SetHtmlRssAlternate($sUrl,$sTitle) {
|
|
|
|
|
$this->aHtmlRssAlternate['title']=htmlspecialchars($sTitle);
|
|
|
|
|
$this->aHtmlRssAlternate['url']=htmlspecialchars($sUrl);
|
|
|
|
|
}
|
2008-09-21 09:36:57 +03:00
|
|
|
|
/**
|
|
|
|
|
* Формирует постраничный вывод
|
|
|
|
|
*
|
|
|
|
|
* @param int $iCount
|
|
|
|
|
* @param int $iCurrentPage
|
|
|
|
|
* @param int $iCountPerPage
|
|
|
|
|
* @param int $iCountPageLine
|
|
|
|
|
* @param string $sBaseUrl
|
2008-11-12 22:04:21 +02:00
|
|
|
|
* @param array(name=>value) $aGetParamsList
|
2008-09-21 09:36:57 +03:00
|
|
|
|
* @return array()
|
|
|
|
|
*/
|
2008-11-12 22:04:21 +02:00
|
|
|
|
public function MakePaging($iCount,$iCurrentPage,$iCountPerPage,$iCountPageLine,$sBaseUrl,$aGetParamsList=array()) {
|
2008-09-21 09:36:57 +03:00
|
|
|
|
if ($iCount==0) {
|
|
|
|
|
return false;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
$iCountPage=ceil($iCount/$iCountPerPage);
|
|
|
|
|
if (!preg_match("/^[1-9]\d*$/i",$iCurrentPage)) {
|
|
|
|
|
$iCurrentPage=1;
|
|
|
|
|
}
|
|
|
|
|
if ($iCurrentPage>$iCountPage) {
|
|
|
|
|
$iCurrentPage=$iCountPage;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
$aPagesLeft=array();
|
|
|
|
|
$iTemp=$iCurrentPage-$iCountPageLine;
|
|
|
|
|
$iTemp = $iTemp<1 ? 1 : $iTemp;
|
|
|
|
|
for ($i=$iTemp;$i<$iCurrentPage;$i++) {
|
|
|
|
|
$aPagesLeft[]=$i;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
$aPagesRight=array();
|
|
|
|
|
for ($i=$iCurrentPage+1;$i<=$iCurrentPage+$iCountPageLine and $i<=$iCountPage;$i++) {
|
|
|
|
|
$aPagesRight[]=$i;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
$iNextPage = $iCurrentPage<$iCountPage ? $iCurrentPage+1 : false;
|
|
|
|
|
$iPrevPage = $iCurrentPage>1 ? $iCurrentPage-1 : false;
|
|
|
|
|
|
2008-11-12 22:04:21 +02:00
|
|
|
|
$sGetParams='';
|
2011-04-26 22:55:22 +03:00
|
|
|
|
if (is_string($aGetParamsList) or count($aGetParamsList)){
|
|
|
|
|
$sGetParams='?'.(is_array($aGetParamsList) ? http_build_query($aGetParamsList,'','&') : $aGetParamsList);
|
2008-11-12 22:04:21 +02:00
|
|
|
|
}
|
2008-09-21 09:36:57 +03:00
|
|
|
|
$aPaging=array(
|
|
|
|
|
'aPagesLeft' => $aPagesLeft,
|
|
|
|
|
'aPagesRight' => $aPagesRight,
|
|
|
|
|
'iCountPage' => $iCountPage,
|
|
|
|
|
'iCurrentPage' => $iCurrentPage,
|
|
|
|
|
'iNextPage' => $iNextPage,
|
|
|
|
|
'iPrevPage' => $iPrevPage,
|
2009-11-13 11:11:12 +02:00
|
|
|
|
'sBaseUrl' => rtrim($sBaseUrl,'/'),
|
2008-11-12 22:04:21 +02:00
|
|
|
|
'sGetParams' => $sGetParams,
|
2008-09-21 09:36:57 +03:00
|
|
|
|
);
|
|
|
|
|
return $aPaging;
|
|
|
|
|
}
|
2010-01-19 19:38:04 +02:00
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* Добавить меню в контейнер
|
|
|
|
|
*
|
|
|
|
|
* @param string $sContainer
|
|
|
|
|
* @param string $sTemplatePath
|
|
|
|
|
*/
|
|
|
|
|
public function AddMenu($sContainer, $sTemplate) {
|
|
|
|
|
$this->aMenu[strtolower($sContainer)]=$sTemplate;
|
|
|
|
|
}
|
|
|
|
|
/**
|
|
|
|
|
* Компилирует меню по контейнерам
|
|
|
|
|
*
|
|
|
|
|
* @return null
|
|
|
|
|
*/
|
|
|
|
|
protected function BuildMenu() {
|
|
|
|
|
foreach ($this->aMenu as $sContainer=>$sTemplate) {
|
|
|
|
|
$this->aMenuFetch[$sContainer]=$this->Fetch($sTemplate);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2009-07-26 16:43:16 +03:00
|
|
|
|
/**
|
|
|
|
|
* Загружаем переменные в шаблон при завершении модуля
|
|
|
|
|
*
|
|
|
|
|
*/
|
2010-04-03 19:44:12 +03:00
|
|
|
|
public function Shutdown() {
|
|
|
|
|
$this->SortBlocks();
|
2009-10-06 21:36:25 +03:00
|
|
|
|
/**
|
|
|
|
|
* Добавляем JS и CSS по предписанным правилам
|
|
|
|
|
*/
|
|
|
|
|
$this->BuildHeadFiles();
|
2009-07-26 16:43:16 +03:00
|
|
|
|
$this->VarAssign();
|
2010-01-23 21:01:54 +02:00
|
|
|
|
/**
|
|
|
|
|
* Рендерим меню для шаблонов и передаем контейнеры в шаблон
|
|
|
|
|
*/
|
|
|
|
|
$this->BuildMenu();
|
|
|
|
|
$this->MenuVarAssign();
|
2009-07-26 16:43:16 +03:00
|
|
|
|
}
|
2008-09-21 09:36:57 +03:00
|
|
|
|
}
|
|
|
|
|
?>
|