menu

Adianti Solutions

API

Adianti, Framework, PHP, MVC, Active record, Front controller, IDE, RAD, Web, multiplataforma, geração de código, desenvolvimento rápido, relatórios, formulários, listagens, datagrids, gráficos, banco de dados, padrões de projeto, design patterns API do Adianti Framework.
API Docs
code
Selecione a classe

Source for file TElement.php

Documentation is available at TElement.php

  1. <?php
  2. namespace Adianti\Widget\Base;
  3.  
  4. /**
  5.  * Base class for all HTML Elements
  6.  *
  7.  * @version    5.6
  8.  * @package    widget
  9.  * @subpackage base
  10.  * @author     Pablo Dall'Oglio
  11.  * @copyright  Copyright (c) 2006 Adianti Solutions Ltd. (http://www.adianti.com.br)
  12.  * @license    http://www.adianti.com.br/framework-license
  13.  */
  14. class TElement
  15. {
  16.     private $tagname;     // tag name
  17.     private $properties;  // tag properties
  18.     private $wrapped;
  19.     private $useLineBreaks;
  20.     private $useSingleQuotes;
  21.     protected $children;
  22.     private $voidelements;
  23.     
  24.     /**
  25.      * Class Constructor
  26.      * @param $tagname  tag name
  27.      */
  28.     public function __construct($tagname)
  29.     {
  30.         // define the element name
  31.         $this->tagname $tagname;
  32.         $this->useLineBreaks TRUE;
  33.         $this->useSingleQuotes FALSE;
  34.         $this->wrapped FALSE;
  35.         $this->properties [];
  36.         $this->voidelements array('area''base''br''col''command''embed''hr',
  37.                                     'img''input''keygen''link''meta''param''source''track''wbr');
  38.     }
  39.     
  40.     /**
  41.      * Create an element
  42.      * @param $tagname Element name
  43.      * @param $value Element value
  44.      * @param $attributes Element attributes
  45.      */
  46.     public static function tag($tagname$value$attributes NULL)
  47.     {
  48.         $object new TElement($tagname);
  49.         
  50.         if (is_array($value))
  51.         {
  52.             foreach ($value as $element)
  53.             {
  54.                 $object->add($element);
  55.             }
  56.         }
  57.         else
  58.         {
  59.             $object->add($value);
  60.         }
  61.         
  62.         if ($attributes)
  63.         {
  64.             foreach ($attributes as $att_name => $att_value)
  65.             {
  66.                 $object->$att_name $att_value;
  67.             }
  68.         }
  69.         
  70.         return $object;
  71.     }
  72.     
  73.     /**
  74.      * Change the element name
  75.      * @param $tagname Element name
  76.      */
  77.     public function setName($tagname)
  78.     {
  79.         $this->tagname $tagname;
  80.     }
  81.     
  82.     /**
  83.      * Returns tag name
  84.      */
  85.     public function getName()
  86.     {
  87.         return $this->tagname;
  88.     }
  89.     
  90.     /**
  91.      * Define if the element is wrapped inside another one
  92.      * @param @bool Boolean TRUE if is wrapped
  93.      */
  94.     protected function setIsWrapped($bool)
  95.     {
  96.         $this->wrapped $bool;
  97.     }
  98.     
  99.     /**
  100.      * Return if the element is wrapped inside another one
  101.      */
  102.     public function getIsWrapped()
  103.     {
  104.         return $this->wrapped;
  105.     }
  106.     
  107.     /**
  108.      * Set tag property
  109.      * @param $name     Property Name
  110.      * @param $value    Property Value
  111.      */
  112.     public function setProperty($name$value)
  113.     {
  114.         // objects and arrays are not set as properties
  115.         if (is_scalar($value))
  116.         {
  117.             // store the property's value
  118.             $this->properties[$name$value;
  119.         }
  120.     }
  121.     
  122.     /**
  123.      * Return a property
  124.      * @param $name property name
  125.      */
  126.     public function getProperty($name)
  127.     {
  128.         return isset($this->properties[$name]$this->properties[$namenull;
  129.     }
  130.     
  131.     /**
  132.      * Return element properties
  133.      */
  134.     public function getProperties()
  135.     {
  136.         return $this->properties;
  137.     }
  138.     
  139.     /**
  140.      * Intercepts whenever someones assign a new property's value
  141.      * @param $name     Property Name
  142.      * @param $value    Property Value
  143.      */
  144.     public function __set($name$value)
  145.     {
  146.         // objects and arrays are not set as properties
  147.         if (is_scalar($value))
  148.         {
  149.             // store the property's value
  150.             $this->properties[$name$value;
  151.         }
  152.     }
  153.     
  154.     /**
  155.      * Intercepts whenever someones unset a property's value
  156.      * @param $name     Property Name
  157.      */
  158.     public function __unset($name)
  159.     {
  160.         unset($this->properties[$name]);
  161.     }
  162.     
  163.     /**
  164.      * Returns a property's value
  165.      * @param $name     Property Name
  166.      */
  167.     public function __get($name)
  168.     {
  169.         if (isset($this->properties[$name]))
  170.         {              
  171.             return $this->properties[$name];
  172.         }
  173.     }
  174.     
  175.     /**
  176.      * Returns is a property's is set
  177.      * @param $name     Property Name
  178.      */
  179.     public function __isset($name)
  180.     {
  181.         return isset($this->properties[$name]);
  182.     }
  183.     
  184.     /**
  185.      * Clone the object
  186.      */
  187.     public function __clone()
  188.     {
  189.         // verify if the tag has child elements
  190.         if ($this->children)
  191.         {
  192.             // iterate all child elements
  193.             foreach ($this->children as $key => $child)
  194.             {
  195.                 if (is_object($child))
  196.                 {
  197.                     $this->children[$keyclone $child;
  198.                 }
  199.                 else
  200.                 {
  201.                     $this->children[$key$child;
  202.                 }
  203.             }
  204.         }
  205.     }
  206.     
  207.     /**
  208.      * Add an child element
  209.      * @param $child Any object that implements the show() method
  210.      */
  211.     public function add($child)
  212.     {
  213.         $this->children[$child;
  214.         if ($child instanceof TElement)
  215.         {
  216.             $child->setIsWrappedTRUE );
  217.         }
  218.     }
  219.     
  220.     /**
  221.      * Insert an child element
  222.      * @param $position Element position
  223.      * @param $child Any object that implements the show() method
  224.      */
  225.     public function insert($position$child)
  226.     {
  227.         array_splice$this->children$position0array($child) );
  228.         if ($child instanceof TElement)
  229.         {
  230.             $child->setIsWrappedTRUE );
  231.         }
  232.     }
  233.     
  234.     /**
  235.      * Set the use of linebreaks
  236.      * @param $linebreaks boolean
  237.      */
  238.     public function setUseLineBreaks($linebreaks)
  239.     {
  240.         $this->useLineBreaks $linebreaks;
  241.     }
  242.     
  243.     /**
  244.      * Set the use of single quotes
  245.      * @param $singlequotes boolean
  246.      */
  247.     public function setUseSingleQuotes($singlequotes)
  248.     {
  249.         $this->useSingleQuotes $singlequotes;
  250.     }
  251.     
  252.     /**
  253.      * Del an child element
  254.      * @param $child Any object that implements the show() method
  255.      */
  256.     public function del($object)
  257.     {
  258.         foreach ($this->children as $key => $child)
  259.         {
  260.             if ($child === $object// same instance
  261.             {
  262.                 unset($this->children[$key]);
  263.             }
  264.         }
  265.     }
  266.  
  267.     /**
  268.      * get children
  269.      */
  270.     public function getChildren()
  271.     {
  272.         return $this->children;
  273.     }
  274.     
  275.     /**
  276.      * Get an child element
  277.      * @param $position Element position
  278.      */
  279.     public function get($position)
  280.     {
  281.         return $this->children[$position];
  282.     }
  283.     
  284.     /**
  285.      * Opens the tag
  286.      */
  287.     public function open()
  288.     {
  289.         // exibe a tag de abertura
  290.         echo "<{$this->tagname}";
  291.         if ($this->properties)
  292.         {
  293.             // percorre as propriedades
  294.             foreach ($this->properties as $name=>$value)
  295.             {
  296.                 if ($this->useSingleQuotes)
  297.                 {
  298.                     $value = str_replace("'", '&#039;', $value);
  299.                     echo " {$name}='{$value}'";
  300.                 }
  301.                 else
  302.                 {
  303.                     $value = str_replace('"', '&quot;', $value);
  304.                     echo " {$name}=\"{$value}\"";
  305.                 }
  306.             }
  307.         }
  308.         
  309.         if (in_array($this->tagname$this->voidelements))
  310.         {
  311.             echo '/>';
  312.         }
  313.         else
  314.         {
  315.             echo '>';
  316.         }
  317.     }
  318.     
  319.     /**
  320.      * Shows the tag
  321.      */
  322.     public function show()
  323.     {
  324.         // open the tag
  325.         $this->open();
  326.         
  327.         // verify if the tag has child elements
  328.         if ($this->children)
  329.         {
  330.             if (count($this->children)>1)
  331.             {
  332.                 if ($this->useLineBreaks)
  333.                 {
  334.                     echo "\n";
  335.                 }
  336.             }
  337.             // iterate all child elements
  338.             foreach ($this->children as $child)
  339.             {
  340.                 // verify if the child is an object
  341.                 if (is_object($child))
  342.                 {
  343.                     $child->show();
  344.                 }
  345.                 // otherwise, the child is a scalar
  346.                 else if ((is_string($child)) or (is_numeric($child)))
  347.                 {
  348.                     echo $child;
  349.                 }
  350.             }
  351.         }
  352.         
  353.         if (!in_array($this->tagname$this->voidelements))
  354.         {
  355.             // closes the tag
  356.             $this->close();
  357.         }
  358.     }
  359.     
  360.     /**
  361.      * Closes the tag
  362.      */
  363.     public function close()
  364.     {
  365.         echo "</{$this->tagname}>";
  366.         if ($this->useLineBreaks)
  367.         {
  368.             echo "\n";
  369.         }
  370.     }
  371.     
  372.     /**
  373.      * Converts the object into a string
  374.      */
  375.     public function __toString()
  376.     {
  377.         return $this->getContents();
  378.     }
  379.     
  380.     /**
  381.      * Returns the element content as a string
  382.      */
  383.     public function getContents()
  384.     {
  385.         ob_start();
  386.         $this->show();
  387.         $content ob_get_contents();
  388.         ob_end_clean();
  389.         return $content;
  390.     }
  391.     
  392.     /**
  393.      * Clear element children
  394.      */
  395.     public function clearChildren()
  396.     {
  397.         $this->children = array();
  398.     }