[moodle.git] / lib / php-css-parser / RuleSet / DeclarationBlock.php

<?php

namespace Sabberworm\CSS\RuleSet;

use Sabberworm\CSS\Parsing\ParserState;
use Sabberworm\CSS\Parsing\OutputException;
use Sabberworm\CSS\Property\Selector;
use Sabberworm\CSS\Rule\Rule;
use Sabberworm\CSS\Value\RuleValueList;
use Sabberworm\CSS\Value\Value;
use Sabberworm\CSS\Value\Size;
use Sabberworm\CSS\Value\Color;
use Sabberworm\CSS\Value\URL;

/**
 * Declaration blocks are the parts of a css file which denote the rules belonging to a selector.
 * Declaration blocks usually appear directly inside a Document or another CSSList (mostly a MediaQuery).
 */
class DeclarationBlock extends RuleSet {

	private $aSelectors;

	public function __construct($iLineNo = 0) {
		parent::__construct($iLineNo);
		$this->aSelectors = array();
	}

	public static function parse(ParserState $oParserState) {
		$aComments = array();
		$oResult = new DeclarationBlock($oParserState->currentLine());
		$oResult->setSelector($oParserState->consumeUntil('{', false, true, $aComments));
		$oResult->setComments($aComments);
		RuleSet::parseRuleSet($oParserState, $oResult);
		return $oResult;
	}


	public function setSelectors($mSelector) {
		if (is_array($mSelector)) {
			$this->aSelectors = $mSelector;
		} else {
			$this->aSelectors = explode(',', $mSelector);
		}
		foreach ($this->aSelectors as $iKey => $mSelector) {
			if (!($mSelector instanceof Selector)) {
				$this->aSelectors[$iKey] = new Selector($mSelector);
			}
		}
	}

	// remove one of the selector of the block
	public function removeSelector($mSelector) {
		if($mSelector instanceof Selector) {
			$mSelector = $mSelector->getSelector();
		}
		foreach($this->aSelectors as $iKey => $oSelector) {
			if($oSelector->getSelector() === $mSelector) {
				unset($this->aSelectors[$iKey]);
				return true;
			}
		}
		return false;
	}

	/**
	 * @deprecated use getSelectors()
	 */
	public function getSelector() {
		return $this->getSelectors();
	}

	/**
	 * @deprecated use setSelectors()
	 */
	public function setSelector($mSelector) {
		$this->setSelectors($mSelector);
	}

	/**
	 * Get selectors.
	 *
	 * @return Selector[] Selectors.
	 */
	public function getSelectors() {
		return $this->aSelectors;
	}

	/**
	 * Split shorthand declarations (e.g. +margin+ or +font+) into their constituent parts.
	 * */
	public function expandShorthands() {
		// border must be expanded before dimensions
		$this->expandBorderShorthand();
		$this->expandDimensionsShorthand();
		$this->expandFontShorthand();
		$this->expandBackgroundShorthand();
		$this->expandListStyleShorthand();
	}

	/**
	 * Create shorthand declarations (e.g. +margin+ or +font+) whenever possible.
	 * */
	public function createShorthands() {
		$this->createBackgroundShorthand();
		$this->createDimensionsShorthand();
		// border must be shortened after dimensions 
		$this->createBorderShorthand();
		$this->createFontShorthand();
		$this->createListStyleShorthand();
	}

	/**
	 * Split shorthand border declarations (e.g. <tt>border: 1px red;</tt>)
	 * Additional splitting happens in expandDimensionsShorthand
	 * Multiple borders are not yet supported as of 3
	 * */
	public function expandBorderShorthand() {
		$aBorderRules = array(
			'border', 'border-left', 'border-right', 'border-top', 'border-bottom'
		);
		$aBorderSizes = array(
			'thin', 'medium', 'thick'
		);
		$aRules = $this->getRulesAssoc();
		foreach ($aBorderRules as $sBorderRule) {
			if (!isset($aRules[$sBorderRule]))
				continue;
			$oRule = $aRules[$sBorderRule];
			$mRuleValue = $oRule->getValue();
			$aValues = array();
			if (!$mRuleValue instanceof RuleValueList) {
				$aValues[] = $mRuleValue;
			} else {
				$aValues = $mRuleValue->getListComponents();
			}
			foreach ($aValues as $mValue) {
				if ($mValue instanceof Value) {
					$mNewValue = clone $mValue;
				} else {
					$mNewValue = $mValue;
				}
				if ($mValue instanceof Size) {
					$sNewRuleName = $sBorderRule . "-width";
				} else if ($mValue instanceof Color) {
					$sNewRuleName = $sBorderRule . "-color";
				} else {
					if (in_array($mValue, $aBorderSizes)) {
						$sNewRuleName = $sBorderRule . "-width";
					} else/* if(in_array($mValue, $aBorderStyles)) */ {
						$sNewRuleName = $sBorderRule . "-style";
					}
				}
				$oNewRule = new Rule($sNewRuleName, $this->iLineNo);
				$oNewRule->setIsImportant($oRule->getIsImportant());
				$oNewRule->addValue(array($mNewValue));
				$this->addRule($oNewRule);
			}
			$this->removeRule($sBorderRule);
		}
	}

	/**
	 * Split shorthand dimensional declarations (e.g. <tt>margin: 0px auto;</tt>)
	 * into their constituent parts.
	 * Handles margin, padding, border-color, border-style and border-width.
	 * */
	public function expandDimensionsShorthand() {
		$aExpansions = array(
			'margin' => 'margin-%s',
			'padding' => 'padding-%s',
			'border-color' => 'border-%s-color',
			'border-style' => 'border-%s-style',
			'border-width' => 'border-%s-width'
		);
		$aRules = $this->getRulesAssoc();
		foreach ($aExpansions as $sProperty => $sExpanded) {
			if (!isset($aRules[$sProperty]))
				continue;
			$oRule = $aRules[$sProperty];
			$mRuleValue = $oRule->getValue();
			$aValues = array();
			if (!$mRuleValue instanceof RuleValueList) {
				$aValues[] = $mRuleValue;
			} else {
				$aValues = $mRuleValue->getListComponents();
			}
			$top = $right = $bottom = $left = null;
			switch (count($aValues)) {
				case 1:
					$top = $right = $bottom = $left = $aValues[0];
					break;
				case 2:
					$top = $bottom = $aValues[0];
					$left = $right = $aValues[1];
					break;
				case 3:
					$top = $aValues[0];
					$left = $right = $aValues[1];
					$bottom = $aValues[2];
					break;
				case 4:
					$top = $aValues[0];
					$right = $aValues[1];
					$bottom = $aValues[2];
					$left = $aValues[3];
					break;
			}
			foreach (array('top', 'right', 'bottom', 'left') as $sPosition) {
				$oNewRule = new Rule(sprintf($sExpanded, $sPosition), $this->iLineNo);
				$oNewRule->setIsImportant($oRule->getIsImportant());
				$oNewRule->addValue(${$sPosition});
				$this->addRule($oNewRule);
			}
			$this->removeRule($sProperty);
		}
	}

	/**
	 * Convert shorthand font declarations
	 * (e.g. <tt>font: 300 italic 11px/14px verdana, helvetica, sans-serif;</tt>)
	 * into their constituent parts.
	 * */
	public function expandFontShorthand() {
		$aRules = $this->getRulesAssoc();
		if (!isset($aRules['font']))
			return;
		$oRule = $aRules['font'];
		// reset properties to 'normal' per http://www.w3.org/TR/21/fonts.html#font-shorthand
		$aFontProperties = array(
			'font-style' => 'normal',
			'font-variant' => 'normal',
			'font-weight' => 'normal',
			'font-size' => 'normal',
			'line-height' => 'normal'
		);
		$mRuleValue = $oRule->getValue();
		$aValues = array();
		if (!$mRuleValue instanceof RuleValueList) {
			$aValues[] = $mRuleValue;
		} else {
			$aValues = $mRuleValue->getListComponents();
		}
		foreach ($aValues as $mValue) {
			if (!$mValue instanceof Value) {
				$mValue = mb_strtolower($mValue);
			}
			if (in_array($mValue, array('normal', 'inherit'))) {
				foreach (array('font-style', 'font-weight', 'font-variant') as $sProperty) {
					if (!isset($aFontProperties[$sProperty])) {
						$aFontProperties[$sProperty] = $mValue;
					}
				}
			} else if (in_array($mValue, array('italic', 'oblique'))) {
				$aFontProperties['font-style'] = $mValue;
			} else if ($mValue == 'small-caps') {
				$aFontProperties['font-variant'] = $mValue;
			} else if (
					in_array($mValue, array('bold', 'bolder', 'lighter'))
					|| ($mValue instanceof Size
					&& in_array($mValue->getSize(), range(100, 900, 100)))
			) {
				$aFontProperties['font-weight'] = $mValue;
			} else if ($mValue instanceof RuleValueList && $mValue->getListSeparator() == '/') {
				list($oSize, $oHeight) = $mValue->getListComponents();
				$aFontProperties['font-size'] = $oSize;
				$aFontProperties['line-height'] = $oHeight;
			} else if ($mValue instanceof Size && $mValue->getUnit() !== null) {
				$aFontProperties['font-size'] = $mValue;
			} else {
				$aFontProperties['font-family'] = $mValue;
			}
		}
		foreach ($aFontProperties as $sProperty => $mValue) {
			$oNewRule = new Rule($sProperty, $this->iLineNo);
			$oNewRule->addValue($mValue);
			$oNewRule->setIsImportant($oRule->getIsImportant());
			$this->addRule($oNewRule);
		}
		$this->removeRule('font');
	}

	/*
	 * Convert shorthand background declarations
	 * (e.g. <tt>background: url("chess.png") gray 50% repeat fixed;</tt>)
	 * into their constituent parts.
	 * @see http://www.w3.org/TR/21/colors.html#propdef-background
	 * */

	public function expandBackgroundShorthand() {
		$aRules = $this->getRulesAssoc();
		if (!isset($aRules['background']))
			return;
		$oRule = $aRules['background'];
		$aBgProperties = array(
			'background-color' => array('transparent'), 'background-image' => array('none'),
			'background-repeat' => array('repeat'), 'background-attachment' => array('scroll'),
			'background-position' => array(new Size(0, '%', null, false, $this->iLineNo), new Size(0, '%', null, false, $this->iLineNo))
		);
		$mRuleValue = $oRule->getValue();
		$aValues = array();
		if (!$mRuleValue instanceof RuleValueList) {
			$aValues[] = $mRuleValue;
		} else {
			$aValues = $mRuleValue->getListComponents();
		}
		if (count($aValues) == 1 && $aValues[0] == 'inherit') {
			foreach ($aBgProperties as $sProperty => $mValue) {
				$oNewRule = new Rule($sProperty, $this->iLineNo);
				$oNewRule->addValue('inherit');
				$oNewRule->setIsImportant($oRule->getIsImportant());
				$this->addRule($oNewRule);
			}
			$this->removeRule('background');
			return;
		}
		$iNumBgPos = 0;
		foreach ($aValues as $mValue) {
			if (!$mValue instanceof Value) {
				$mValue = mb_strtolower($mValue);
			}
			if ($mValue instanceof URL) {
				$aBgProperties['background-image'] = $mValue;
			} else if ($mValue instanceof Color) {
				$aBgProperties['background-color'] = $mValue;
			} else if (in_array($mValue, array('scroll', 'fixed'))) {
				$aBgProperties['background-attachment'] = $mValue;
			} else if (in_array($mValue, array('repeat', 'no-repeat', 'repeat-x', 'repeat-y'))) {
				$aBgProperties['background-repeat'] = $mValue;
			} else if (in_array($mValue, array('left', 'center', 'right', 'top', 'bottom'))
					|| $mValue instanceof Size
			) {
				if ($iNumBgPos == 0) {
					$aBgProperties['background-position'][0] = $mValue;
					$aBgProperties['background-position'][1] = 'center';
				} else {
					$aBgProperties['background-position'][$iNumBgPos] = $mValue;
				}
				$iNumBgPos++;
			}
		}
		foreach ($aBgProperties as $sProperty => $mValue) {
			$oNewRule = new Rule($sProperty, $this->iLineNo);
			$oNewRule->setIsImportant($oRule->getIsImportant());
			$oNewRule->addValue($mValue);
			$this->addRule($oNewRule);
		}
		$this->removeRule('background');
	}

	public function expandListStyleShorthand() {
		$aListProperties = array(
			'list-style-type' => 'disc',
			'list-style-position' => 'outside',
			'list-style-image' => 'none'
		);
		$aListStyleTypes = array(
			'none', 'disc', 'circle', 'square', 'decimal-leading-zero', 'decimal',
			'lower-roman', 'upper-roman', 'lower-greek', 'lower-alpha', 'lower-latin',
			'upper-alpha', 'upper-latin', 'hebrew', 'armenian', 'georgian', 'cjk-ideographic',
			'hiragana', 'hira-gana-iroha', 'katakana-iroha', 'katakana'
		);
		$aListStylePositions = array(
			'inside', 'outside'
		);
		$aRules = $this->getRulesAssoc();
		if (!isset($aRules['list-style']))
			return;
		$oRule = $aRules['list-style'];
		$mRuleValue = $oRule->getValue();
		$aValues = array();
		if (!$mRuleValue instanceof RuleValueList) {
			$aValues[] = $mRuleValue;
		} else {
			$aValues = $mRuleValue->getListComponents();
		}
		if (count($aValues) == 1 && $aValues[0] == 'inherit') {
			foreach ($aListProperties as $sProperty => $mValue) {
				$oNewRule = new Rule($sProperty, $this->iLineNo);
				$oNewRule->addValue('inherit');
				$oNewRule->setIsImportant($oRule->getIsImportant());
				$this->addRule($oNewRule);
			}
			$this->removeRule('list-style');
			return;
		}
		foreach ($aValues as $mValue) {
			if (!$mValue instanceof Value) {
				$mValue = mb_strtolower($mValue);
			}
			if ($mValue instanceof Url) {
				$aListProperties['list-style-image'] = $mValue;
			} else if (in_array($mValue, $aListStyleTypes)) {
				$aListProperties['list-style-types'] = $mValue;
			} else if (in_array($mValue, $aListStylePositions)) {
				$aListProperties['list-style-position'] = $mValue;
			}
		}
		foreach ($aListProperties as $sProperty => $mValue) {
			$oNewRule = new Rule($sProperty, $this->iLineNo);
			$oNewRule->setIsImportant($oRule->getIsImportant());
			$oNewRule->addValue($mValue);
			$this->addRule($oNewRule);
		}
		$this->removeRule('list-style');
	}

	public function createShorthandProperties(array $aProperties, $sShorthand) {
		$aRules = $this->getRulesAssoc();
		$aNewValues = array();
		foreach ($aProperties as $sProperty) {
			if (!isset($aRules[$sProperty]))
				continue;
			$oRule = $aRules[$sProperty];
			if (!$oRule->getIsImportant()) {
				$mRuleValue = $oRule->getValue();
				$aValues = array();
				if (!$mRuleValue instanceof RuleValueList) {
					$aValues[] = $mRuleValue;
				} else {
					$aValues = $mRuleValue->getListComponents();
				}
				foreach ($aValues as $mValue) {
					$aNewValues[] = $mValue;
				}
				$this->removeRule($sProperty);
			}
		}
		if (count($aNewValues)) {
			$oNewRule = new Rule($sShorthand, $this->iLineNo);
			foreach ($aNewValues as $mValue) {
				$oNewRule->addValue($mValue);
			}
			$this->addRule($oNewRule);
		}
	}

	public function createBackgroundShorthand() {
		$aProperties = array(
			'background-color', 'background-image', 'background-repeat',
			'background-position', 'background-attachment'
		);
		$this->createShorthandProperties($aProperties, 'background');
	}

	public function createListStyleShorthand() {
		$aProperties = array(
			'list-style-type', 'list-style-position', 'list-style-image'
		);
		$this->createShorthandProperties($aProperties, 'list-style');
	}

	/**
	 * Combine border-color, border-style and border-width into border
	 * Should be run after create_dimensions_shorthand!
	 * */
	public function createBorderShorthand() {
		$aProperties = array(
			'border-width', 'border-style', 'border-color'
		);
		$this->createShorthandProperties($aProperties, 'border');
	}

	/*
	 * Looks for long format CSS dimensional properties
	 * (margin, padding, border-color, border-style and border-width) 
	 * and converts them into shorthand CSS properties.
	 * */

	public function createDimensionsShorthand() {
		$aPositions = array('top', 'right', 'bottom', 'left');
		$aExpansions = array(
			'margin' => 'margin-%s',
			'padding' => 'padding-%s',
			'border-color' => 'border-%s-color',
			'border-style' => 'border-%s-style',
			'border-width' => 'border-%s-width'
		);
		$aRules = $this->getRulesAssoc();
		foreach ($aExpansions as $sProperty => $sExpanded) {
			$aFoldable = array();
			foreach ($aRules as $sRuleName => $oRule) {
				foreach ($aPositions as $sPosition) {
					if ($sRuleName == sprintf($sExpanded, $sPosition)) {
						$aFoldable[$sRuleName] = $oRule;
					}
				}
			}
			// All four dimensions must be present
			if (count($aFoldable) == 4) {
				$aValues = array();
				foreach ($aPositions as $sPosition) {
					$oRule = $aRules[sprintf($sExpanded, $sPosition)];
					$mRuleValue = $oRule->getValue();
					$aRuleValues = array();
					if (!$mRuleValue instanceof RuleValueList) {
						$aRuleValues[] = $mRuleValue;
					} else {
						$aRuleValues = $mRuleValue->getListComponents();
					}
					$aValues[$sPosition] = $aRuleValues;
				}
				$oNewRule = new Rule($sProperty, $this->iLineNo);
				if ((string) $aValues['left'][0] == (string) $aValues['right'][0]) {
					if ((string) $aValues['top'][0] == (string) $aValues['bottom'][0]) {
						if ((string) $aValues['top'][0] == (string) $aValues['left'][0]) {
							// All 4 sides are equal
							$oNewRule->addValue($aValues['top']);
						} else {
							// Top and bottom are equal, left and right are equal
							$oNewRule->addValue($aValues['top']);
							$oNewRule->addValue($aValues['left']);
						}
					} else {
						// Only left and right are equal
						$oNewRule->addValue($aValues['top']);
						$oNewRule->addValue($aValues['left']);
						$oNewRule->addValue($aValues['bottom']);
					}
				} else {
					// No sides are equal 
					$oNewRule->addValue($aValues['top']);
					$oNewRule->addValue($aValues['left']);
					$oNewRule->addValue($aValues['bottom']);
					$oNewRule->addValue($aValues['right']);
				}
				$this->addRule($oNewRule);
				foreach ($aPositions as $sPosition) {
					$this->removeRule(sprintf($sExpanded, $sPosition));
				}
			}
		}
	}

	/**
	 * Looks for long format CSS font properties (e.g. <tt>font-weight</tt>) and 
	 * tries to convert them into a shorthand CSS <tt>font</tt> property. 
	 * At least font-size AND font-family must be present in order to create a shorthand declaration.
	 * */
	public function createFontShorthand() {
		$aFontProperties = array(
			'font-style', 'font-variant', 'font-weight', 'font-size', 'line-height', 'font-family'
		);
		$aRules = $this->getRulesAssoc();
		if (!isset($aRules['font-size']) || !isset($aRules['font-family'])) {
			return;
		}
		$oNewRule = new Rule('font', $this->iLineNo);
		foreach (array('font-style', 'font-variant', 'font-weight') as $sProperty) {
			if (isset($aRules[$sProperty])) {
				$oRule = $aRules[$sProperty];
				$mRuleValue = $oRule->getValue();
				$aValues = array();
				if (!$mRuleValue instanceof RuleValueList) {
					$aValues[] = $mRuleValue;
				} else {
					$aValues = $mRuleValue->getListComponents();
				}
				if ($aValues[0] !== 'normal') {
					$oNewRule->addValue($aValues[0]);
				}
			}
		}
		// Get the font-size value
		$oRule = $aRules['font-size'];
		$mRuleValue = $oRule->getValue();
		$aFSValues = array();
		if (!$mRuleValue instanceof RuleValueList) {
			$aFSValues[] = $mRuleValue;
		} else {
			$aFSValues = $mRuleValue->getListComponents();
		}
		// But wait to know if we have line-height to add it
		if (isset($aRules['line-height'])) {
			$oRule = $aRules['line-height'];
			$mRuleValue = $oRule->getValue();
			$aLHValues = array();
			if (!$mRuleValue instanceof RuleValueList) {
				$aLHValues[] = $mRuleValue;
			} else {
				$aLHValues = $mRuleValue->getListComponents();
			}
			if ($aLHValues[0] !== 'normal') {
				$val = new RuleValueList('/', $this->iLineNo);
				$val->addListComponent($aFSValues[0]);
				$val->addListComponent($aLHValues[0]);
				$oNewRule->addValue($val);
			}
		} else {
			$oNewRule->addValue($aFSValues[0]);
		}
		$oRule = $aRules['font-family'];
		$mRuleValue = $oRule->getValue();
		$aFFValues = array();
		if (!$mRuleValue instanceof RuleValueList) {
			$aFFValues[] = $mRuleValue;
		} else {
			$aFFValues = $mRuleValue->getListComponents();
		}
		$oFFValue = new RuleValueList(',', $this->iLineNo);
		$oFFValue->setListComponents($aFFValues);
		$oNewRule->addValue($oFFValue);

		$this->addRule($oNewRule);
		foreach ($aFontProperties as $sProperty) {
			$this->removeRule($sProperty);
		}
	}

	public function __toString() {
		return $this->render(new \Sabberworm\CSS\OutputFormat());
	}

	public function render(\Sabberworm\CSS\OutputFormat $oOutputFormat) {
		if(count($this->aSelectors) === 0) {
			// If all the selectors have been removed, this declaration block becomes invalid
			throw new OutputException("Attempt to print declaration block with missing selector", $this->iLineNo);
		}
		$sResult = $oOutputFormat->sBeforeDeclarationBlock;
		$sResult .= $oOutputFormat->implode($oOutputFormat->spaceBeforeSelectorSeparator() . ',' . $oOutputFormat->spaceAfterSelectorSeparator(), $this->aSelectors);
		$sResult .= $oOutputFormat->sAfterDeclarationBlockSelectors;
		$sResult .= $oOutputFormat->spaceBeforeOpeningBrace() . '{';
		$sResult .= parent::render($oOutputFormat);
		$sResult .= '}';
		$sResult .= $oOutputFormat->sAfterDeclarationBlock;
		return $sResult;
	}

}
Commit	Line	Data
fbe18cc0 FM	1	<?php
	2
	3	namespace Sabberworm\CSS\RuleSet;
	4
376eb156 MM	5	use Sabberworm\CSS\Parsing\ParserState;
376eb156 MM	6	use Sabberworm\CSS\Parsing\OutputException;
fbe18cc0 FM	7	use Sabberworm\CSS\Property\Selector;
	8	use Sabberworm\CSS\Rule\Rule;
	9	use Sabberworm\CSS\Value\RuleValueList;
	10	use Sabberworm\CSS\Value\Value;
	11	use Sabberworm\CSS\Value\Size;
	12	use Sabberworm\CSS\Value\Color;
	13	use Sabberworm\CSS\Value\URL;
fbe18cc0 FM	14
	15	/**
	16	* Declaration blocks are the parts of a css file which denote the rules belonging to a selector.
	17	* Declaration blocks usually appear directly inside a Document or another CSSList (mostly a MediaQuery).
	18	*/
	19	class DeclarationBlock extends RuleSet {
	20
	21	private $aSelectors;
	22
	23	public function __construct($iLineNo = 0) {
	24	parent::__construct($iLineNo);
	25	$this->aSelectors = array();
	26	}
	27
376eb156 MM	28	public static function parse(ParserState $oParserState) {
	29	$aComments = array();
	30	$oResult = new DeclarationBlock($oParserState->currentLine());
	31	$oResult->setSelector($oParserState->consumeUntil('{', false, true, $aComments));
	32	$oResult->setComments($aComments);
	33	RuleSet::parseRuleSet($oParserState, $oResult);
	34	return $oResult;
	35	}
	36
	37
fbe18cc0 FM	38	public function setSelectors($mSelector) {
	39	if (is_array($mSelector)) {
	40	$this->aSelectors = $mSelector;
	41	} else {
	42	$this->aSelectors = explode(',', $mSelector);
	43	}
	44	foreach ($this->aSelectors as $iKey => $mSelector) {
	45	if (!($mSelector instanceof Selector)) {
	46	$this->aSelectors[$iKey] = new Selector($mSelector);
	47	}
	48	}
	49	}
	50
	51	// remove one of the selector of the block
	52	public function removeSelector($mSelector) {
	53	if($mSelector instanceof Selector) {
	54	$mSelector = $mSelector->getSelector();
	55	}
	56	foreach($this->aSelectors as $iKey => $oSelector) {
	57	if($oSelector->getSelector() === $mSelector) {
	58	unset($this->aSelectors[$iKey]);
	59	return true;
	60	}
	61	}
	62	return false;
	63	}
	64
	65	/**
	66	* @deprecated use getSelectors()
	67	*/
	68	public function getSelector() {
	69	return $this->getSelectors();
	70	}
	71
	72	/**
	73	* @deprecated use setSelectors()
	74	*/
	75	public function setSelector($mSelector) {
	76	$this->setSelectors($mSelector);
	77	}
	78
376eb156 MM	79	/**
	80	* Get selectors.
	81	*
	82	* @return Selector[] Selectors.
	83	*/
fbe18cc0 FM	84	public function getSelectors() {
	85	return $this->aSelectors;
	86	}
	87
	88	/**
	89	* Split shorthand declarations (e.g. +margin+ or +font+) into their constituent parts.
	90	* */
	91	public function expandShorthands() {
	92	// border must be expanded before dimensions
	93	$this->expandBorderShorthand();
	94	$this->expandDimensionsShorthand();
	95	$this->expandFontShorthand();
	96	$this->expandBackgroundShorthand();
	97	$this->expandListStyleShorthand();
	98	}
	99
	100	/**
	101	* Create shorthand declarations (e.g. +margin+ or +font+) whenever possible.
	102	* */
	103	public function createShorthands() {
	104	$this->createBackgroundShorthand();
	105	$this->createDimensionsShorthand();
	106	// border must be shortened after dimensions
	107	$this->createBorderShorthand();
	108	$this->createFontShorthand();
	109	$this->createListStyleShorthand();
	110	}
	111
	112	/**
	113	* Split shorthand border declarations (e.g. <tt>border: 1px red;</tt>)
	114	* Additional splitting happens in expandDimensionsShorthand
	115	* Multiple borders are not yet supported as of 3
	116	* */
	117	public function expandBorderShorthand() {
	118	$aBorderRules = array(
	119	'border', 'border-left', 'border-right', 'border-top', 'border-bottom'
	120	);
	121	$aBorderSizes = array(
	122	'thin', 'medium', 'thick'
	123	);
	124	$aRules = $this->getRulesAssoc();
	125	foreach ($aBorderRules as $sBorderRule) {
	126	if (!isset($aRules[$sBorderRule]))
	127	continue;
	128	$oRule = $aRules[$sBorderRule];
	129	$mRuleValue = $oRule->getValue();
	130	$aValues = array();
	131	if (!$mRuleValue instanceof RuleValueList) {
	132	$aValues[] = $mRuleValue;
	133	} else {
	134	$aValues = $mRuleValue->getListComponents();
	135	}
	136	foreach ($aValues as $mValue) {
	137	if ($mValue instanceof Value) {
	138	$mNewValue = clone $mValue;
	139	} else {
	140	$mNewValue = $mValue;
	141	}
	142	if ($mValue instanceof Size) {
	143	$sNewRuleName = $sBorderRule . "-width";
	144	} else if ($mValue instanceof Color) {
	145	$sNewRuleName = $sBorderRule . "-color";
	146	} else {
	147	if (in_array($mValue, $aBorderSizes)) {
148	$sNewRuleName = $sBorderRule . "-width";
149	} else/* if(in_array($mValue, $aBorderStyles)) */ {
150	$sNewRuleName = $sBorderRule . "-style";
151	}
152	}
153	$oNewRule = new Rule($sNewRuleName, $this->iLineNo);
154	$oNewRule->setIsImportant($oRule->getIsImportant());
155	$oNewRule->addValue(array($mNewValue));
156	$this->addRule($oNewRule);
157	}
158	$this->removeRule($sBorderRule);
159	}
160	}
161
162	/**
163	* Split shorthand dimensional declarations (e.g. <tt>margin: 0px auto;</tt>)
164	* into their constituent parts.
165	* Handles margin, padding, border-color, border-style and border-width.
166	* */
167	public function expandDimensionsShorthand() {
168	$aExpansions = array(
169	'margin' => 'margin-%s',
170	'padding' => 'padding-%s',
171	'border-color' => 'border-%s-color',
172	'border-style' => 'border-%s-style',
173	'border-width' => 'border-%s-width'
174	);
175	$aRules = $this->getRulesAssoc();
176	foreach ($aExpansions as $sProperty => $sExpanded) {
177	if (!isset($aRules[$sProperty]))
178	continue;
179	$oRule = $aRules[$sProperty];
180	$mRuleValue = $oRule->getValue();
181	$aValues = array();
182	if (!$mRuleValue instanceof RuleValueList) {
183	$aValues[] = $mRuleValue;
184	} else {
185	$aValues = $mRuleValue->getListComponents();
186	}
187	$top = $right = $bottom = $left = null;
188	switch (count($aValues)) {
189	case 1:
190	$top = $right = $bottom = $left = $aValues[0];
191	break;
192	case 2:
193	$top = $bottom = $aValues[0];
194	$left = $right = $aValues[1];
195	break;
196	case 3:
197	$top = $aValues[0];
198	$left = $right = $aValues[1];
199	$bottom = $aValues[2];
200	break;
201	case 4:
202	$top = $aValues[0];
203	$right = $aValues[1];
204	$bottom = $aValues[2];
205	$left = $aValues[3];
206	break;
207	}
208	foreach (array('top', 'right', 'bottom', 'left') as $sPosition) {
209	$oNewRule = new Rule(sprintf($sExpanded, $sPosition), $this->iLineNo);
210	$oNewRule->setIsImportant($oRule->getIsImportant());
211	$oNewRule->addValue(${$sPosition});
212	$this->addRule($oNewRule);
213	}
214	$this->removeRule($sProperty);
215	}
216	}
217
218	/**
219	* Convert shorthand font declarations
220	* (e.g. <tt>font: 300 italic 11px/14px verdana, helvetica, sans-serif;</tt>)
221	* into their constituent parts.
222	* */
223	public function expandFontShorthand() {
224	$aRules = $this->getRulesAssoc();
225	if (!isset($aRules['font']))
226	return;
227	$oRule = $aRules['font'];
228	// reset properties to 'normal' per http://www.w3.org/TR/21/fonts.html#font-shorthand
229	$aFontProperties = array(
230	'font-style' => 'normal',
231	'font-variant' => 'normal',
232	'font-weight' => 'normal',
233	'font-size' => 'normal',
234	'line-height' => 'normal'
235	);
236	$mRuleValue = $oRule->getValue();
237	$aValues = array();
238	if (!$mRuleValue instanceof RuleValueList) {
239	$aValues[] = $mRuleValue;
240	} else {
241	$aValues = $mRuleValue->getListComponents();
242	}
243	foreach ($aValues as $mValue) {
244	if (!$mValue instanceof Value) {
245	$mValue = mb_strtolower($mValue);
246	}
247	if (in_array($mValue, array('normal', 'inherit'))) {
248	foreach (array('font-style', 'font-weight', 'font-variant') as $sProperty) {
249	if (!isset($aFontProperties[$sProperty])) {
250	$aFontProperties[$sProperty] = $mValue;
251	}
252	}
253	} else if (in_array($mValue, array('italic', 'oblique'))) {
254	$aFontProperties['font-style'] = $mValue;
255	} else if ($mValue == 'small-caps') {
256	$aFontProperties['font-variant'] = $mValue;
257	} else if (
258	in_array($mValue, array('bold', 'bolder', 'lighter'))
259	\|\| ($mValue instanceof Size
260	&& in_array($mValue->getSize(), range(100, 900, 100)))
261	) {
262	$aFontProperties['font-weight'] = $mValue;
263	} else if ($mValue instanceof RuleValueList && $mValue->getListSeparator() == '/') {
264	list($oSize, $oHeight) = $mValue->getListComponents();
265	$aFontProperties['font-size'] = $oSize;
266	$aFontProperties['line-height'] = $oHeight;
267	} else if ($mValue instanceof Size && $mValue->getUnit() !== null) {
268	$aFontProperties['font-size'] = $mValue;
269	} else {
270	$aFontProperties['font-family'] = $mValue;
271	}
272	}
273	foreach ($aFontProperties as $sProperty => $mValue) {
274	$oNewRule = new Rule($sProperty, $this->iLineNo);
275	$oNewRule->addValue($mValue);
276	$oNewRule->setIsImportant($oRule->getIsImportant());
277	$this->addRule($oNewRule);
278	}
279	$this->removeRule('font');
280	}
281
282	/*
283	* Convert shorthand background declarations
284	* (e.g. <tt>background: url("chess.png") gray 50% repeat fixed;</tt>)
285	* into their constituent parts.
286	* @see http://www.w3.org/TR/21/colors.html#propdef-background
287	* */
288
289	public function expandBackgroundShorthand() {
290	$aRules = $this->getRulesAssoc();
291	if (!isset($aRules['background']))
292	return;
293	$oRule = $aRules['background'];
294	$aBgProperties = array(
295	'background-color' => array('transparent'), 'background-image' => array('none'),
296	'background-repeat' => array('repeat'), 'background-attachment' => array('scroll'),
297	'background-position' => array(new Size(0, '%', null, false, $this->iLineNo), new Size(0, '%', null, false, $this->iLineNo))
298	);
299	$mRuleValue = $oRule->getValue();
300	$aValues = array();
301	if (!$mRuleValue instanceof RuleValueList) {
302	$aValues[] = $mRuleValue;
303	} else {
304	$aValues = $mRuleValue->getListComponents();
305	}
306	if (count($aValues) == 1 && $aValues[0] == 'inherit') {
307	foreach ($aBgProperties as $sProperty => $mValue) {
308	$oNewRule = new Rule($sProperty, $this->iLineNo);
309	$oNewRule->addValue('inherit');
310	$oNewRule->setIsImportant($oRule->getIsImportant());
311	$this->addRule($oNewRule);
312	}
313	$this->removeRule('background');
314	return;
315	}
316	$iNumBgPos = 0;
317	foreach ($aValues as $mValue) {
318	if (!$mValue instanceof Value) {
319	$mValue = mb_strtolower($mValue);
320	}
321	if ($mValue instanceof URL) {
322	$aBgProperties['background-image'] = $mValue;
323	} else if ($mValue instanceof Color) {
324	$aBgProperties['background-color'] = $mValue;
325	} else if (in_array($mValue, array('scroll', 'fixed'))) {
326	$aBgProperties['background-attachment'] = $mValue;
327	} else if (in_array($mValue, array('repeat', 'no-repeat', 'repeat-x', 'repeat-y'))) {
328	$aBgProperties['background-repeat'] = $mValue;
329	} else if (in_array($mValue, array('left', 'center', 'right', 'top', 'bottom'))
330	\|\| $mValue instanceof Size
331	) {
332	if ($iNumBgPos == 0) {
333	$aBgProperties['background-position'][0] = $mValue;
334	$aBgProperties['background-position'][1] = 'center';
335	} else {
336	$aBgProperties['background-position'][$iNumBgPos] = $mValue;
337	}
338	$iNumBgPos++;
339	}
340	}
341	foreach ($aBgProperties as $sProperty => $mValue) {
342	$oNewRule = new Rule($sProperty, $this->iLineNo);
343	$oNewRule->setIsImportant($oRule->getIsImportant());
344	$oNewRule->addValue($mValue);
345	$this->addRule($oNewRule);
346	}
347	$this->removeRule('background');
348	}
349
350	public function expandListStyleShorthand() {
351	$aListProperties = array(
352	'list-style-type' => 'disc',
353	'list-style-position' => 'outside',
354	'list-style-image' => 'none'
355	);
356	$aListStyleTypes = array(
357	'none', 'disc', 'circle', 'square', 'decimal-leading-zero', 'decimal',
358	'lower-roman', 'upper-roman', 'lower-greek', 'lower-alpha', 'lower-latin',
359	'upper-alpha', 'upper-latin', 'hebrew', 'armenian', 'georgian', 'cjk-ideographic',
360	'hiragana', 'hira-gana-iroha', 'katakana-iroha', 'katakana'
361	);
362	$aListStylePositions = array(
363	'inside', 'outside'
364	);
365	$aRules = $this->getRulesAssoc();
366	if (!isset($aRules['list-style']))
367	return;
368	$oRule = $aRules['list-style'];
369	$mRuleValue = $oRule->getValue();
370	$aValues = array();
371	if (!$mRuleValue instanceof RuleValueList) {
372	$aValues[] = $mRuleValue;
373	} else {
374	$aValues = $mRuleValue->getListComponents();
375	}
376	if (count($aValues) == 1 && $aValues[0] == 'inherit') {
377	foreach ($aListProperties as $sProperty => $mValue) {
378	$oNewRule = new Rule($sProperty, $this->iLineNo);
379	$oNewRule->addValue('inherit');
380	$oNewRule->setIsImportant($oRule->getIsImportant());
381	$this->addRule($oNewRule);
382	}
383	$this->removeRule('list-style');
384	return;
385	}
386	foreach ($aValues as $mValue) {
387	if (!$mValue instanceof Value) {
388	$mValue = mb_strtolower($mValue);
389	}
390	if ($mValue instanceof Url) {
391	$aListProperties['list-style-image'] = $mValue;
392	} else if (in_array($mValue, $aListStyleTypes)) {
393	$aListProperties['list-style-types'] = $mValue;
394	} else if (in_array($mValue, $aListStylePositions)) {
395	$aListProperties['list-style-position'] = $mValue;
396	}
397	}
398	foreach ($aListProperties as $sProperty => $mValue) {
399	$oNewRule = new Rule($sProperty, $this->iLineNo);
400	$oNewRule->setIsImportant($oRule->getIsImportant());
401	$oNewRule->addValue($mValue);
402	$this->addRule($oNewRule);
403	}
404	$this->removeRule('list-style');
405	}
406
407	public function createShorthandProperties(array $aProperties, $sShorthand) {
408	$aRules = $this->getRulesAssoc();
409	$aNewValues = array();
410	foreach ($aProperties as $sProperty) {
411	if (!isset($aRules[$sProperty]))
412	continue;
413	$oRule = $aRules[$sProperty];
414	if (!$oRule->getIsImportant()) {
415	$mRuleValue = $oRule->getValue();
416	$aValues = array();
417	if (!$mRuleValue instanceof RuleValueList) {
418	$aValues[] = $mRuleValue;
419	} else {
420	$aValues = $mRuleValue->getListComponents();
421	}
422	foreach ($aValues as $mValue) {
423	$aNewValues[] = $mValue;
424	}
425	$this->removeRule($sProperty);
426	}
427	}
428	if (count($aNewValues)) {
429	$oNewRule = new Rule($sShorthand, $this->iLineNo);
430	foreach ($aNewValues as $mValue) {
431	$oNewRule->addValue($mValue);
432	}
433	$this->addRule($oNewRule);
434	}
435	}
436
437	public function createBackgroundShorthand() {
438	$aProperties = array(
439	'background-color', 'background-image', 'background-repeat',
440	'background-position', 'background-attachment'
441	);
442	$this->createShorthandProperties($aProperties, 'background');
443	}
444
445	public function createListStyleShorthand() {
446	$aProperties = array(
447	'list-style-type', 'list-style-position', 'list-style-image'
448	);
449	$this->createShorthandProperties($aProperties, 'list-style');
450	}
451
452	/**
453	* Combine border-color, border-style and border-width into border
454	* Should be run after create_dimensions_shorthand!
455	* */
456	public function createBorderShorthand() {
457	$aProperties = array(
458	'border-width', 'border-style', 'border-color'
459	);
460	$this->createShorthandProperties($aProperties, 'border');
461	}
462
463	/*
464	* Looks for long format CSS dimensional properties
465	* (margin, padding, border-color, border-style and border-width)
466	* and converts them into shorthand CSS properties.
467	* */
468
469	public function createDimensionsShorthand() {
470	$aPositions = array('top', 'right', 'bottom', 'left');
471	$aExpansions = array(
472	'margin' => 'margin-%s',
473	'padding' => 'padding-%s',
474	'border-color' => 'border-%s-color',
475	'border-style' => 'border-%s-style',
476	'border-width' => 'border-%s-width'
477	);
478	$aRules = $this->getRulesAssoc();
479	foreach ($aExpansions as $sProperty => $sExpanded) {
480	$aFoldable = array();
481	foreach ($aRules as $sRuleName => $oRule) {
482	foreach ($aPositions as $sPosition) {
483	if ($sRuleName == sprintf($sExpanded, $sPosition)) {
484	$aFoldable[$sRuleName] = $oRule;
485	}
486	}
487	}
488	// All four dimensions must be present
489	if (count($aFoldable) == 4) {
490	$aValues = array();
491	foreach ($aPositions as $sPosition) {
492	$oRule = $aRules[sprintf($sExpanded, $sPosition)];
493	$mRuleValue = $oRule->getValue();
494	$aRuleValues = array();
495	if (!$mRuleValue instanceof RuleValueList) {
496	$aRuleValues[] = $mRuleValue;
497	} else {
498	$aRuleValues = $mRuleValue->getListComponents();
499	}
500	$aValues[$sPosition] = $aRuleValues;
501	}
502	$oNewRule = new Rule($sProperty, $this->iLineNo);
503	if ((string) $aValues['left'][0] == (string) $aValues['right'][0]) {
504	if ((string) $aValues['top'][0] == (string) $aValues['bottom'][0]) {
505	if ((string) $aValues['top'][0] == (string) $aValues['left'][0]) {
506	// All 4 sides are equal
507	$oNewRule->addValue($aValues['top']);
508	} else {
509	// Top and bottom are equal, left and right are equal
510	$oNewRule->addValue($aValues['top']);
511	$oNewRule->addValue($aValues['left']);
512	}
513	} else {
514	// Only left and right are equal
515	$oNewRule->addValue($aValues['top']);
516	$oNewRule->addValue($aValues['left']);
517	$oNewRule->addValue($aValues['bottom']);
518	}
519	} else {
520	// No sides are equal
521	$oNewRule->addValue($aValues['top']);
522	$oNewRule->addValue($aValues['left']);
523	$oNewRule->addValue($aValues['bottom']);
524	$oNewRule->addValue($aValues['right']);
525	}
526	$this->addRule($oNewRule);
527	foreach ($aPositions as $sPosition) {
528	$this->removeRule(sprintf($sExpanded, $sPosition));
529	}
530	}
531	}
532	}
533
534	/**
535	* Looks for long format CSS font properties (e.g. <tt>font-weight</tt>) and
536	* tries to convert them into a shorthand CSS <tt>font</tt> property.
537	* At least font-size AND font-family must be present in order to create a shorthand declaration.
538	* */
539	public function createFontShorthand() {
540	$aFontProperties = array(
541	'font-style', 'font-variant', 'font-weight', 'font-size', 'line-height', 'font-family'
542	);
543	$aRules = $this->getRulesAssoc();
544	if (!isset($aRules['font-size']) \|\| !isset($aRules['font-family'])) {
545	return;
546	}
547	$oNewRule = new Rule('font', $this->iLineNo);
548	foreach (array('font-style', 'font-variant', 'font-weight') as $sProperty) {
549	if (isset($aRules[$sProperty])) {
550	$oRule = $aRules[$sProperty];
551	$mRuleValue = $oRule->getValue();
552	$aValues = array();
553	if (!$mRuleValue instanceof RuleValueList) {
554	$aValues[] = $mRuleValue;
555	} else {
556	$aValues = $mRuleValue->getListComponents();
557	}
558	if ($aValues[0] !== 'normal') {
559	$oNewRule->addValue($aValues[0]);
560	}
561	}
562	}
563	// Get the font-size value
564	$oRule = $aRules['font-size'];
565	$mRuleValue = $oRule->getValue();
566	$aFSValues = array();
567	if (!$mRuleValue instanceof RuleValueList) {
568	$aFSValues[] = $mRuleValue;
569	} else {
570	$aFSValues = $mRuleValue->getListComponents();
571	}
572	// But wait to know if we have line-height to add it
573	if (isset($aRules['line-height'])) {
574	$oRule = $aRules['line-height'];
575	$mRuleValue = $oRule->getValue();
576	$aLHValues = array();
577	if (!$mRuleValue instanceof RuleValueList) {
578	$aLHValues[] = $mRuleValue;
579	} else {
580	$aLHValues = $mRuleValue->getListComponents();
581	}
582	if ($aLHValues[0] !== 'normal') {
583	$val = new RuleValueList('/', $this->iLineNo);
584	$val->addListComponent($aFSValues[0]);
585	$val->addListComponent($aLHValues[0]);
586	$oNewRule->addValue($val);
587	}
588	} else {
589	$oNewRule->addValue($aFSValues[0]);
590	}
591	$oRule = $aRules['font-family'];
592	$mRuleValue = $oRule->getValue();
593	$aFFValues = array();
594	if (!$mRuleValue instanceof RuleValueList) {
595	$aFFValues[] = $mRuleValue;
596	} else {
597	$aFFValues = $mRuleValue->getListComponents();
598	}
599	$oFFValue = new RuleValueList(',', $this->iLineNo);
600	$oFFValue->setListComponents($aFFValues);
601	$oNewRule->addValue($oFFValue);
602
603	$this->addRule($oNewRule);
604	foreach ($aFontProperties as $sProperty) {
605	$this->removeRule($sProperty);
606	}
607	}
608
609	public function __toString() {
610	return $this->render(new \Sabberworm\CSS\OutputFormat());
611	}
612
613	public function render(\Sabberworm\CSS\OutputFormat $oOutputFormat) {
614	if(count($this->aSelectors) === 0) {
615	// If all the selectors have been removed, this declaration block becomes invalid
616	throw new OutputException("Attempt to print declaration block with missing selector", $this->iLineNo);
617	}
376eb156 MM	618	$sResult = $oOutputFormat->sBeforeDeclarationBlock;
	619	$sResult .= $oOutputFormat->implode($oOutputFormat->spaceBeforeSelectorSeparator() . ',' . $oOutputFormat->spaceAfterSelectorSeparator(), $this->aSelectors);
	620	$sResult .= $oOutputFormat->sAfterDeclarationBlockSelectors;
	621	$sResult .= $oOutputFormat->spaceBeforeOpeningBrace() . '{';
fbe18cc0 FM	622	$sResult .= parent::render($oOutputFormat);
fbe18cc0 FM	623	$sResult .= '}';
376eb156	624	$sResult .= $oOutputFormat->sAfterDeclarationBlock;
fbe18cc0 FM	625	return $sResult;
	626	}
	627
	628	}