Smarty.php

<?php
require_once('Smarty/Smarty.class.php');

class Dsao_View_Smarty extends Smarty
{
  const CONTENT = 'content';

  const POST_CONTENT = 'postContent';

  const PRE_CONTENT = 'preContent';

  protected $_addDefaultTemplate = true;

  protected $_ajaxResponse = null;

  protected static $_debug = array();

  protected $_initialised = false;

  protected $_isXmlHttpRequest = null;

  protected $_layouts = null;

  protected $_layoutsDefault = array();

  protected $_jsFiles = false;

  protected $_jsMessages = array();

  protected $_request = null;

  protected $_scriptaculous = null;

  protected $_templateDirController = null;

  protected $_templates = null;

  protected $_translate = null;

  public function __construct($isXmlHttpRequest = false)
  {
    $this->_messages  = new ArrayObject();

    $this->_translate = Dsao_Registry::get('translate');

    $config = Dsao_Registry::get('config');

    // Falls Ajax-Anfrage vorliegt, an dieser Stelle abbrechen
    if ($this->_isXmlHttpRequest = $isXmlHttpRequest)
    {
      $this->_ajaxResponse = new Dsao_Ajax_Response();

      return;
    }

    $this->_request   = Zend_Controller_Front::getInstance()->getRequest();

    // Standardlayouts
    $this->_layoutsDefault = explode(',', $config->smarty->layoutsDefault);

    // Templateobjekt initialisieren
    $this->_templates  = new stdClass();
    // Inhaltstemplates
    $this->_templates->content = new ArrayObject();
    // Haupttemplate
    $this->_templates->main = null;
    // Nach dem Inhalt anzuzeigende Templates
    $this->_templates->postContent = new ArrayObject();
    // Vor dem Inhalt anzuzeigende Templates
    $this->_templates->preContent = new ArrayObject();

    // Smartyverzeichnisse aus Konfiguration holen
    $this->template_dir = $config->smarty->templateDir;

    $this->compile_dir  = $config->smarty->compileDir;

    // Templateordner
    $this->_templateDirController = $this->_request->getModuleName().'/'.
      $this->_request->getControllerName().'/';

    // Falls Debug-Konsole angezeigt werden soll
    if ($config->smarty->debug->console)
    {
      $this->debugging = true;
    }
  }

  protected function _getTemplatePath($template, $prefix = null)
  {
    // string, Pfad des Templates relativ zum Templateordner
    $templatePath = $prefix.$template.'.tpl';

    // Layouts durchgehen und passenden Pfad zurueckgeben
    foreach ($this->_layoutsDefault as $layout)
    {
      // string, Resultierender, korrekter Pfad des Templates
      $resultPath = $layout.'/'.$templatePath;

      // Falls Template vorhanden, dieses zurueckgeben
      if (is_file($this->template_dir.$resultPath))
      {
        return $resultPath;
      }
    }

    return false;
  }

  protected function _init()
  {
    // Falls bereits initialisiert
    if ($this->_initialised)
    {
      return;
    }

    // Layouts initialisieren

    // Falls Benutzer ein Layout gewaehlt hat, dieses zu Array hinzufuegen
    if (Dsao_Registry::get('user')->layout)
    {
      $this->_layoutsDefault[] = Dsao_Registry::get('user')->layout;
    }

    // Reihenfolge der Layouts umkehren
    $this->_layoutsDefault   = array_reverse($this->_layoutsDefault);

    // Haupttemplate setzen
    $this->_templates->main = $this->_getTemplatePath('index');

    // Ggf. modulspefische CSS-Datei / JS-Datei uebergeben
    $this->_setModuleCssFile();

    // Ausgabefilter
    if (Dsao_Registry::get('config')->smarty->stripOutput)
    {
      $this->load_filter('output','trimwhitespace');
    }

    // Templatesystem ist initialisiert
    $this->_initialised = true;
  }

  protected function _setModuleCssFile()
  {
    // Layouts durchgehen
    foreach ($this->_layoutsDefault as $layout)
    {
      $cssFileSystemPath = 'htdocs/css/'.$layout.'/'.
        $this->_request->getModuleName().'.css';

      // Falls CSS-Datei in aktuellem Layout vorhanden, diese uebergeben
      if (is_file(BASE_DIR.$cssFileSystemPath))
      {
        $cssFilePath = '/css/'.$layout.'/'.$this->_request->getModuleName();

        $this->assign('moduleCssFile', $cssFilePath);

        return true;
      }
    }

    return false;
  }

  public function addConfirmationTemplate($question, $uri)
  {
    // Falls Array übergeben wurde, diesen an sprintf übergeben
    if (is_array($question))
    {
      $question = call_user_func_array('Dsao_View_Smarty::sprintf', $question);
    }
    // Ansonsten einfach Frage übersetzen lassen
    else
    {
      $question = self::sprintf($question);
    }

    if (!is_object($uri))
    {
      $uri = new Dsao_Uri_Http($uri);
    }

    // Informationen fuer das Abfragentemplate
    $globalConfirm = array
      (
        'question'  => $question,
        'uri'       => $uri,
      );

    $this->addTemplate('/global/confirm')
    ->assign_by_ref('globalConfirm', $globalConfirm);
  }

  public function addJsFile($file)
  {
    // Falls Ajax-Anfrage, abbrechen
    if ($this->_isXmlHttpRequest)
    {
      return $this;
    }

    // string, Relativer Pfad zur JS-Datei auf Dateisystemebene
    $jsFileSystemPath = 'htdocs/js'.$file.'.js';

    // Falls JS-Datei vorhanden, diese uebergeben
    if (is_file(BASE_DIR.$jsFileSystemPath))
    {
      // Falls noch keine JavaScript-Dateien hinzugefügt wurden
      if (false === $this->_jsFiles)
      {
        $this->_jsFiles = array();
      }

      $this->_jsFiles[] = '/js'.$file;
    }

    return $this;
  }

  public function addJsTexts($messageIds)
  {
    // Ggf. in Array umwandeln
    $messageIds = (array) $messageIds;

    foreach ($messageIds as $messageId)
    {
      // Falls keine Uebersetzung existiert, gueltigen Index erstellen
      if (($translation = $this->_translate->_($messageId)) == $messageId)
      {
        $messageId = preg_replace('/\W/', '_', $messageId);
      }

      $this->_jsMessages[$messageId] = $translation;
    }

    return $this;
  }

  public function addScriptaculousFiles(array $files = array())
  {
    // Falls Objekt noch nicht initialisiert wurde
    if (null === $this->_scriptaculous)
    {
      $this->_scriptaculous = new stdClass();

      $this->_scriptaculous->files = array
      (
        'builder'   => true,
        'effects'   => true,
        'dragdrop'  => true,
        'controls'  => true,
        'slider'    => true,
      );

      $this->_scriptaculous->loadScriptaculous = false;
      $this->_scriptaculous->queryString = null;
    }

    // Falls nichts übergeben wurde, alle Dateien übernehmen
    if (empty($files))
    {
      $files = $this->_scriptaculous->files;
    }

    foreach ($files as $file)
    {
      // Falls Schluessel vorhanden
      if (array_key_exists($file, $this->_scriptaculous->files))
      {
        unset($this->_scriptaculous->files[$file]);

        // Falls Query-String noch leer ist
        if (null === $this->_scriptaculous->queryString)
        {
          $this->_scriptaculous->queryString = '?load='.$file;
          $this->_scriptaculous->loadScriptaculous = true;
        }
        else
        {
          $this->_scriptaculous->queryString .= ','.$file;
        }
      }
    }

    // Falls bereits alle Dateien zum Laden ausgewählt wurden
    if (empty($this->_scriptaculous->files))
    {
      $this->_scriptaculous->loadScriptaculous = true;
      $this->_scriptaculous->queryString = null;
    }
  }

  public function addTemplate($template = null, $templatePosition = self::CONTENT)
  {
    // Falls kein Standardtemplate hinzugefuegt werden soll oder Ajax-Anfrage
    // vorliegt, abbrechen
    if (false === $template || $this->_isXmlHttpRequest)
    {
       $this->_addDefaultTemplate = false;

       return $this;
    }

    // Falls noch nicht geschehen, initialisieren
    $this->_init();

    // Falls $_templates->{$templatePosition} nicht existiert oder kein Objekt
    // ist, abbrechen
    if (!isset($this->_templates->$templatePosition)
        || !is_object($this->_templates->$templatePosition))
    {
      return $this;
    }

    // Falls Template nicht uebergeben, Aktionnamen nehmen
    if (!$template)
    {
      $template = $this->_request->getActionName();
    }

    // string, bei relativen Angaben wird als Praefix der Pfad zum Verzeichnis
    // des Controllers uebergeben
    $prefix = null;

    // Falls absolute Angabe
    if (substr($template, 0, 1) == '/')
    {
      // Slash entfernen
      $template = substr($template, 1);
    }
    // Ansonsten Praefix setzen
    else
    {
      $prefix = $this->_templateDirController;
    }

    // bool|string, der Pfad zum Template, relativ zum /templates-Ordner oder
    // false
    $templateFile = $this->_getTemplatePath($template, $prefix);

    // Falls Template existiert
    if ($templateFile)
    {
      // Vor oder nach Inhalt
      $this->_templates->$templatePosition->append($templateFile);
    }

    return $this;
  }

  public static function debug($debugVariable, $value = null, $metaInfo = null)
  {
    // Falls Array uebergeben wurde, Methode rekursiv aufrufen
    if (is_array($debugVariable))
    {
      foreach ($debugVariable as $variable => $value)
      {
        self::debug($variable, $value, $metaInfo);
      }

      return;
    }

        // Falls Debug-Array noch nicht initialisiert wurde
    if (null === Dsao_View_Smarty::$_debug)
    {
      self::$_debug = array();
      self::$_debug['metaInfo'] = array();
    }

    self::$_debug[$debugVariable] = print_r($value, true);

    // Falls Meta-Informationen übergeben wurden
    if ($metaInfo)
    {
      self::$_debug[$debugVariable.':metaInfo'] = print_r($metaInfo, true);
    }
  }

  public function getAjaxResponse()
  {
    return $this->_ajaxResponse;
  }

  public function getLayoutDefault()
  {
    return end($this->_layoutsDefault);
  }

  public function getLayouts()
  {
    // Falls Ajax-Anfrage vorliegt, abbrechen
    if ($this->_isXmlHttpRequest)
    {
      return array();
    }

    // Falls Layouts bereits initialisiert wurden, diese zurueckgeben
    if ($this->_layouts)
    {
      return $this->_layouts;
    }

    // Ansonsten $_layout initialisieren
    $this->_layouts = array();

    // DirectoryIterator, Ordner, der alle Layouts enthaelt (/templates)
    $layoutDir = new DirectoryIterator(Dsao_Registry::get('config')->smarty->templateDir);

    // Eintraege durchlaufen
    while ($layoutDir->valid())
    {
      // Falls Verzeichnis gueltiges Layoutverzeichnis
      if (!$layoutDir->isDot()
          && $layoutDir->isDir()
          // Keine Verzeichnisse, die mit einem Punkt beginnen ('.svn' etc.)
          && substr($layoutDir->getFilename(), 0, 1) != '.'
          // Temporär, um Default-Layout zu 'verstecken'
          && $layoutDir->getFilename() != 'default')
      {
        $this->_layouts[] = $layoutDir->getFilename();
      }

      $layoutDir->next();
    }

    return $this->_layouts;
  }

  public function render()
  {
    $config = Dsao_Registry::get('config');

    // Ggf. Debug-Informationen uebergeben
    if ($config->smarty->debug->output)
    {
      $this->assign('debug', self::$_debug);
    }

    // Falls Ajax-Anfrage vorliegt, nur bis hierhin ausführen
    if ($this->_isXmlHttpRequest)
    {
      // Daten ausgeben (u.U werden Nachrichten und Variablen nicht uebergeben)
      return $this->_ajaxResponse->setData
        ($this->get_template_vars(), Dsao_Ajax_Response::JSON, false);
    }

    // Nachrichten und Templatedateien uebergeben
    $this->assign(array
      (
        'jsFiles'             => $this->_jsFiles,
        'jsMessages'          => $this->_jsMessages,
        'scriptaculous'       => $this->_scriptaculous,
        'templates'           => $this->_templates,
      ));

    // Falls noch kein Inhaltstemplate uebergeben wurde, Standardtemplate
    // hinzufuegen
    if (!count($this->_templates->content) && $this->_addDefaultTemplate)
    {
      $this->addTemplate();
    }

    // Falls Smarty noch nicht initialisiert wurde
    if (!$this->_initialised)
    {
      $this->_init();
    }

    // Profiling
    $profiler = Dsao_Registry::get('db')->getProfiler();

    // Falls Profiler aktiviert
    if ($profiler->getEnabled())
    {
      $this->assign('footerProfiling', self::sprintf('footer_profiling',
        array(
          'count' => $profiler->getTotalNumQueries(),
          'time' => $profiler->getTotalElapsedSecs())
      ));

      // Falls ausführliches Profiling aktiviert wurde
      if ($config->db->profiler == 'verbose'
          && false !== $profiler->getQueryProfiles())
      {
        $queries = '';

        foreach ($profiler->getQueryProfiles() as $queryProfile)
        {
          $queries .= '<br />'.$queryProfile->getQuery();
        }

        $this->assign_by_ref('footerProfilingQueries', $queries);
      }
    }

    // Nun darf Smarty loslegen
    $this->display($this->_templates->main);

    return $this;
  }

  public function setModuleNavigation(array $navigation = array())
  {
    $this->assign('moduleNavigation', $navigation);
  }

  public static function sprintf($string = null, array $variables = array(), $translateVariables = false, $translateString = true)
  {
    // Falls leerer String uebergeben
    if (!$string)
    {
      return '';
    }

    $translate = Dsao_Registry::get('translate');

    if ($translateString)
    {
      $string = $translate->_($string);
    }

    // Zu ersetzende Variablen durchgehen
    if (count($variables) > 0)
    {
      // array, Schluessel, also zu ersetzende Variablen
      $keys = array_keys($variables);

      // Schluessel durchgehen und '%' voranstellen
      foreach ($keys as &$key)
      {
        $key = '%'.$key;
      }

      // array, die einzusetzenden Werte
      $values = array_values($variables);

      // Falls Variablen uebersetzt werden sollen, durchgehen und uebersetzen
      if ($translateVariables)
      {
        foreach ($values as &$value)
        {
            $value = $translate->_($value);
        }
      }

      // Variablen durch Werte ersetzen
      $string = str_replace($keys, $values, $string);
    }

    return $string;
  }
}