$node->ownerDocument->createElement("dompdf_generated");
}
$new_node->setAttribute($pos, $pos);
$new_frame_id = $tree->insert_node($node, $new_node, $pos);
$node->setAttribute("dompdf_{$pos}_frame_id", $new_frame_id);
}
}
}
}
// Apply all styles in stylesheet
foreach ($this->_styles as $selector => $selector_styles) {
$query = $this->selectorToXpath($selector);
if ($query === null) {
Helpers::record_warnings(E_USER_WARNING, "The CSS selector '$selector' is not valid", __FILE__, __LINE__);
continue;
}
// Retrieve the nodes
$nodes = @$xp->query($query["query"]);
if ($nodes === false) {
Helpers::record_warnings(E_USER_WARNING, "The CSS selector '$selector' is not valid", __FILE__, __LINE__);
continue;
}
foreach ($selector_styles as $style) {
$spec = $this->specificity($selector, $style->get_origin());
foreach ($nodes as $node) {
// Only DOMElements get styles
if (!($node instanceof DOMElement)) {
continue;
}
$id = $node->getAttribute("frame_id");
// Assign the current style to the scratch array
$styles[$id][$spec][] = $style;
}
}
}
// Set the page width, height, and orientation based on the canvas paper size
$canvas = $this->_dompdf->getCanvas();
$paper_width = $canvas->get_width();
$paper_height = $canvas->get_height();
$paper_orientation = ($paper_width > $paper_height ? "landscape" : "portrait");
if ($this->_page_styles["base"] && is_array($this->_page_styles["base"]->size)) {
$paper_width = $this->_page_styles['base']->size[0];
$paper_height = $this->_page_styles['base']->size[1];
$paper_orientation = ($paper_width > $paper_height ? "landscape" : "portrait");
}
// Now create the styles and assign them to the appropriate frames. (We
// iterate over the tree using an implicit FrameTree iterator.)
$root_flg = false;
foreach ($tree as $frame) {
// Helpers::pre_r($frame->get_node()->nodeName . ":");
if (!$root_flg && $this->_page_styles["base"]) {
$style = $this->_page_styles["base"];
} else {
$style = $this->create_style();
}
// Find nearest DOMElement parent
$p = $frame;
while ($p = $p->get_parent()) {
if ($p->get_node()->nodeType === XML_ELEMENT_NODE) {
break;
}
}
// Styles can only be applied directly to DOMElements; anonymous
// frames inherit from their parent
if ($frame->get_node()->nodeType !== XML_ELEMENT_NODE) {
$style->inherit($p ? $p->get_style() : null);
$frame->set_style($style);
continue;
}
$id = $frame->get_id();
// Handle HTML 4.0 attributes
AttributeTranslator::translate_attributes($frame);
if (($str = $frame->get_node()->getAttribute(AttributeTranslator::$_style_attr)) !== "") {
$styles[$id][self::SPEC_NON_CSS][] = $this->_parse_properties($str);
}
// Locate any additional style attributes
if (($str = $frame->get_node()->getAttribute("style")) !== "") {
// Destroy CSS comments
$str = preg_replace("'/\*.*?\*/'si", "", $str);
$spec = $this->specificity("!attr", self::ORIG_AUTHOR);
$styles[$id][$spec][] = $this->_parse_properties($str);
}
// Grab the applicable styles
if (isset($styles[$id])) {
/** @var array[][] $applied_styles */
$applied_styles = $styles[$id];
// Sort by specificity
ksort($applied_styles);
if ($DEBUGCSS) {
$debug_nodename = $frame->get_node()->nodeName;
print "\n$debug_nodename [\n";
foreach ($applied_styles as $spec => $arr) {
printf(" specificity 0x%08x\n", $spec);
/** @var Style $s */
foreach ($arr as $s) {
print " [\n";
$s->debug_print();
print " ]\n";
}
}
}
// Merge the new styles with the inherited styles
$acceptedmedia = self::$ACCEPTED_GENERIC_MEDIA_TYPES;
$acceptedmedia[] = $this->_dompdf->getOptions()->getDefaultMediaType();
foreach ($applied_styles as $arr) {
/** @var Style $s */
foreach ($arr as $s) {
$media_queries = $s->get_media_queries();
foreach ($media_queries as $media_query) {
list($media_query_feature, $media_query_value) = $media_query;
// if any of the Style's media queries fail then do not apply the style
//TODO: When the media query logic is fully developed we should not apply the Style when any of the media queries fail or are bad, per https://www.w3.org/TR/css3-mediaqueries/#error-handling
if (in_array($media_query_feature, self::$VALID_MEDIA_TYPES)) {
if ((strlen($media_query_feature) === 0 && !in_array($media_query, $acceptedmedia)) || (in_array($media_query, $acceptedmedia) && $media_query_value == "not")) {
continue (3);
}
} else {
switch ($media_query_feature) {
case "height":
if ($paper_height !== (float)$style->length_in_pt($media_query_value)) {
continue (3);
}
break;
case "min-height":
if ($paper_height < (float)$style->length_in_pt($media_query_value)) {
continue (3);
}
break;
case "max-height":
if ($paper_height > (float)$style->length_in_pt($media_query_value)) {
continue (3);
}
break;
case "width":
if ($paper_width !== (float)$style->length_in_pt($media_query_value)) {
continue (3);
}
break;
case "min-width":
//if (min($paper_width, $media_query_width) === $paper_width) {
if ($paper_width < (float)$style->length_in_pt($media_query_value)) {
continue (3);
}
break;
case "max-width":
//if (max($paper_width, $media_query_width) === $paper_width) {
if ($paper_width > (float)$style->length_in_pt($media_query_value)) {
continue (3);
}
break;
case "orientation":
if ($paper_orientation !== $media_query_value) {
continue (3);
}
break;
default:
Helpers::record_warnings(E_USER_WARNING, "Unknown media query: $media_query_feature", __FILE__, __LINE__);
break;
}
}
}
$style->merge($s);
}
}
}
// Handle inheritance
if ($p && $DEBUGCSS) {
print " inherit [\n";
$p->get_style()->debug_print();
print " ]\n";
}
$style->inherit($p ? $p->get_style() : null);
if ($DEBUGCSS) {
print " DomElementStyle [\n";
$style->debug_print();
print " ]\n";
print "]\n";
}
$style->clear_important();
$frame->set_style($style);
if (!$root_flg && $this->_page_styles["base"]) {
$root_flg = true;
// set the page width, height, and orientation based on the parsed page style
if ($style->size !== "auto") {
list($paper_width, $paper_height) = $style->size;
}
$paper_width = $paper_width - (float)$style->length_in_pt($style->margin_left) - (float)$style->length_in_pt($style->margin_right);
$paper_height = $paper_height - (float)$style->length_in_pt($style->margin_top) - (float)$style->length_in_pt($style->margin_bottom);
$paper_orientation = ($paper_width > $paper_height ? "landscape" : "portrait");
}
}
// We're done! Clean out the registry of all styles since we
// won't be needing this later.
foreach (array_keys($this->_styles) as $key) {
$this->_styles[$key] = null;
unset($this->_styles[$key]);
}
}
/**
* parse a CSS string using a regex parser
* Called by {@link Stylesheet::parse_css()}
*
* @param string $str
*
* @throws Exception
*/
private function _parse_css($str)
{
$str = trim($str);
// Destroy comments and remove HTML comments
$css = preg_replace([
"'/\*.*?\*/'si",
"/^$/"
], "", $str);
// FIXME: handle '{' within strings, e.g. [attr="string {}"]
// Something more legible:
$re =
"/\s* # Skip leading whitespace \n" .
"( @([^\s{]+)\s*([^{;]*) (?:;|({)) )? # Match @rules followed by ';' or '{' \n" .
"(?(1) # Only parse sub-sections if we're in an @rule... \n" .
" (?(4) # ...and if there was a leading '{' \n" .
" \s*( (?:(?>[^{}]+) ({)? # Parse rulesets and individual @page rules \n" .
" (?(6) (?>[^}]*) }) \s*)+? \n" .
" ) \n" .
" }) # Balancing '}' \n" .
"| # Branch to match regular rules (not preceded by '@') \n" .
"([^{]*{[^}]*})) # Parse normal rulesets \n" .
"/xs";
if (preg_match_all($re, $css, $matches, PREG_SET_ORDER) === false) {
// An error occurred
throw new Exception("Error parsing css file: preg_match_all() failed.");
}
// After matching, the array indices are set as follows:
//
// [0] => complete text of match
// [1] => contains '@import ...;' or '@media {' if applicable
// [2] => text following @ for cases where [1] is set
// [3] => media types or full text following '@import ...;'
// [4] => '{', if present
// [5] => rulesets within media rules
// [6] => '{', within media rules
// [7] => individual rules, outside of media rules
//
$media_query_regex = "/(?:((only|not)?\s*(" . implode("|", self::$VALID_MEDIA_TYPES) . "))|(\s*\(\s*((?:(min|max)-)?([\w\-]+))\s*(?:\:\s*(.*?)\s*)?\)))/isx";
//Helpers::pre_r($matches);
foreach ($matches as $match) {
$match[2] = trim($match[2]);
if ($match[2] !== "") {
// Handle @rules
switch ($match[2]) {
case "import":
$this->_parse_import($match[3]);
break;
case "media":
$acceptedmedia = self::$ACCEPTED_GENERIC_MEDIA_TYPES;
$acceptedmedia[] = $this->_dompdf->getOptions()->getDefaultMediaType();
$media_queries = preg_split("/\s*,\s*/", mb_strtolower(trim($match[3])));
foreach ($media_queries as $media_query) {
if (in_array($media_query, $acceptedmedia)) {
//if we have a media type match go ahead and parse the stylesheet
$this->_parse_sections($match[5]);
break;
} elseif (!in_array($media_query, self::$VALID_MEDIA_TYPES)) {
// otherwise conditionally parse the stylesheet assuming there are parseable media queries
if (preg_match_all($media_query_regex, $media_query, $media_query_matches, PREG_SET_ORDER) !== false) {
$mq = [];
foreach ($media_query_matches as $media_query_match) {
if (empty($media_query_match[1]) === false) {
$media_query_feature = strtolower($media_query_match[3]);
$media_query_value = strtolower($media_query_match[2]);
$mq[] = [$media_query_feature, $media_query_value];
} elseif (empty($media_query_match[4]) === false) {
$media_query_feature = strtolower($media_query_match[5]);
$media_query_value = (array_key_exists(8, $media_query_match) ? strtolower($media_query_match[8]) : null);
$mq[] = [$media_query_feature, $media_query_value];
}
}
$this->_parse_sections($match[5], $mq);
break;
}
}
}
break;
case "page":
//This handles @page to be applied to page oriented media
//Note: This has a reduced syntax:
//@page { margin:1cm; color:blue; }
//Not a sequence of styles like a full.css, but only the properties
//of a single style, which is applied to the very first "root" frame before
//processing other styles of the frame.
//Working properties:
// margin (for margin around edge of paper)
// font-family (default font of pages)
// color (default text color of pages)
//Non working properties:
// border
// padding
// background-color
//Todo:Reason is unknown
//Other properties (like further font or border attributes) not tested.
//If a border or background color around each paper sheet is desired,
//assign it to the tag, possibly only for the css of the correct media type.
// If the page has a name, skip the style.
$page_selector = trim($match[3]);
$key = null;
switch ($page_selector) {
case "":
$key = "base";
break;
case ":left":
case ":right":
case ":odd":
case ":even":
/** @noinspection PhpMissingBreakStatementInspection */
case ":first":
$key = $page_selector;
break;
default:
break 2;
}
// Store the style for later...
if (empty($this->_page_styles[$key])) {
$this->_page_styles[$key] = $this->_parse_properties($match[5]);
} else {
$this->_page_styles[$key]->merge($this->_parse_properties($match[5]));
}
break;
case "font-face":
$this->_parse_font_face($match[5]);
break;
default:
// ignore everything else
break;
}
continue;
}
if ($match[7] !== "") {
$this->_parse_sections($match[7]);
}
}
}
/**
* Resolve the given `url()` declaration to an absolute URL.
*
* @param string|null $val The declaration to resolve in the context of the stylesheet.
* @return string The resolved URL, or `none`, if the value is `none`,
* invalid, or points to a non-existent local file.
*/
public function resolve_url($val): string
{
$DEBUGCSS = $this->_dompdf->getOptions()->getDebugCss();
$parsed_url = "none";
if (empty($val) || $val === "none") {
$path = "none";
} elseif (mb_strpos($val, "url") === false) {
$path = "none"; //Don't resolve no image -> otherwise would prefix path and no longer recognize as none
} else {
$val = preg_replace("/url\(\s*['\"]?([^'\")]+)['\"]?\s*\)/", "\\1", trim($val));
// Resolve the url now in the context of the current stylesheet
$path = Helpers::build_url($this->_protocol,
$this->_base_host,
$this->_base_path,
$val);
if ($path === null) {
$path = "none";
}
}
if ($DEBUGCSS) {
$parsed_url = Helpers::explode_url($path);
print "[_image\n";
print_r($parsed_url);
print $this->_protocol . "\n" . $this->_base_path . "\n" . $path . "\n";
print "_image]";
}
return $path;
}
/**
* parse @import{} sections
*
* @param string $url the url of the imported CSS file
*/
private function _parse_import($url)
{
$arr = preg_split("/[\s\n,]/", $url, -1, PREG_SPLIT_NO_EMPTY);
$url = array_shift($arr);
$accept = false;
if (count($arr) > 0) {
$acceptedmedia = self::$ACCEPTED_GENERIC_MEDIA_TYPES;
$acceptedmedia[] = $this->_dompdf->getOptions()->getDefaultMediaType();
// @import url media_type [media_type...]
foreach ($arr as $type) {
if (in_array(mb_strtolower(trim($type)), $acceptedmedia)) {
$accept = true;
break;
}
}
} else {
// unconditional import
$accept = true;
}
if ($accept) {
// Store our current base url properties in case the new url is elsewhere
$protocol = $this->_protocol;
$host = $this->_base_host;
$path = $this->_base_path;
// $url = str_replace(array('"',"url", "(", ")"), "", $url);
// If the protocol is php, assume that we will import using file://
// $url = Helpers::build_url($protocol === "php://" ? "file://" : $protocol, $host, $path, $url);
// Above does not work for subfolders and absolute urls.
// Todo: As above, do we need to replace php or file to an empty protocol for local files?
if (($url = $this->resolve_url($url)) !== "none") {
$this->load_css_file($url);
}
// Restore the current base url
$this->_protocol = $protocol;
$this->_base_host = $host;
$this->_base_path = $path;
}
}
/**
* parse @font-face{} sections
* http://www.w3.org/TR/css3-fonts/#the-font-face-rule
*
* @param string $str CSS @font-face rules
*/
private function _parse_font_face($str)
{
$descriptors = $this->_parse_properties($str);
preg_match_all("/(url|local)\s*\(\s*[\"\']?([^\"\'\)]+)[\"\']?\s*\)\s*(format\s*\(\s*[\"\']?([^\"\'\)]+)[\"\']?\s*\))?/i", $descriptors->src, $src);
$valid_sources = [];
foreach ($src[0] as $i => $value) {
$source = [
"local" => strtolower($src[1][$i]) === "local",
"uri" => $src[2][$i],
"format" => strtolower($src[4][$i]),
"path" => Helpers::build_url($this->_protocol, $this->_base_host, $this->_base_path, $src[2][$i]),
];
if (!$source["local"] && in_array($source["format"], ["", "truetype"]) && $source["path"] !== null) {
$valid_sources[] = $source;
}
}
// No valid sources
if (empty($valid_sources)) {
return;
}
$style = [
"family" => $descriptors->get_font_family_raw(),
"weight" => $descriptors->font_weight,
"style" => $descriptors->font_style,
];
$this->getFontMetrics()->registerFont($style, $valid_sources[0]["path"], $this->_dompdf->getHttpContext());
}
/**
* parse regular CSS blocks
*
* _parse_properties() creates a new Style object based on the provided
* CSS rules.
*
* @param string $str CSS rules
* @return Style
*/
private function _parse_properties($str)
{
$properties = preg_split("/;(?=(?:[^\(]*\([^\)]*\))*(?![^\)]*\)))/", $str);
$DEBUGCSS = $this->_dompdf->getOptions()->getDebugCss();
if ($DEBUGCSS) {
print '[_parse_properties';
}
// Create the style
$style = new Style($this, Stylesheet::ORIG_AUTHOR);
foreach ($properties as $prop) {
// If the $prop contains an url, the regex may be wrong
// @todo: fix the regex so that it works every time
/*if (strpos($prop, "url(") === false) {
if (preg_match("/([a-z-]+)\s*:\s*[^:]+$/i", $prop, $m))
$prop = $m[0];
}*/
//A css property can have " ! important" appended (whitespace optional)
//strip this off to decode core of the property correctly.
/* Instead of short code, prefer the typical case with fast code
$important = preg_match("/(.*?)!\s*important/",$prop,$match);
if ( $important ) {
$prop = $match[1];
}
$prop = trim($prop);
*/
if ($DEBUGCSS) print '(';
$important = false;
$prop = trim($prop);
if (substr($prop, -9) === 'important') {
$prop_tmp = rtrim(substr($prop, 0, -9));
if (substr($prop_tmp, -1) === '!') {
$prop = rtrim(substr($prop_tmp, 0, -1));
$important = true;
}
}
if ($prop === "") {
if ($DEBUGCSS) print 'empty)';
continue;
}
$i = mb_strpos($prop, ":");
if ($i === false) {
if ($DEBUGCSS) print 'novalue' . $prop . ')';
continue;
}
$prop_name = rtrim(mb_strtolower(mb_substr($prop, 0, $i)));
$value = ltrim(mb_substr($prop, $i + 1));
if ($DEBUGCSS) print $prop_name . ':=' . $value . ($important ? '!IMPORTANT' : '') . ')';
$style->set_prop($prop_name, $value, $important, false);
}
if ($DEBUGCSS) print '_parse_properties]';
return $style;
}
/**
* parse selector + rulesets
*
* @param string $str CSS selectors and rulesets
* @param array $media_queries
*/
private function _parse_sections($str, $media_queries = [])
{
// Pre-process selectors: collapse all whitespace and strip whitespace
// around '>', '.', ':', '+', '~', '#'
$patterns = ["/\s+/", "/\s+([>.:+~#])\s+/"];
$replacements = [" ", "\\1"];
$DEBUGCSS = $this->_dompdf->getOptions()->getDebugCss();
$sections = explode("}", $str);
if ($DEBUGCSS) print '[_parse_sections';
foreach ($sections as $sect) {
$i = mb_strpos($sect, "{");
if ($i === false) { continue; }
if ($DEBUGCSS) print '[section';
$selector_str = preg_replace($patterns, $replacements, mb_substr($sect, 0, $i));
$selectors = preg_split("/,(?![^\(]*\))/", $selector_str, 0, PREG_SPLIT_NO_EMPTY);
$style = $this->_parse_properties(trim(mb_substr($sect, $i + 1)));
// Assign it to the selected elements
foreach ($selectors as $selector) {
$selector = trim($selector);
if ($selector === "") {
if ($DEBUGCSS) print '#empty#';
continue;
}
if ($DEBUGCSS) print '#' . $selector . '#';
//if ($DEBUGCSS) { if (strpos($selector,'p') !== false) print '!!!p!!!#'; }
//FIXME: tag the selector with a hash of the media query to separate it from non-conditional styles (?), xpath comments are probably not what we want to do here
if (count($media_queries) > 0) {
$style->set_media_queries($media_queries);
}
$this->add_style($selector, $style);
}
if ($DEBUGCSS) {
print 'section]';
}
}
if ($DEBUGCSS) {
print "_parse_sections]\n";
}
}
/**
* @return string
*/
public function getDefaultStylesheet()
{
$options = $this->_dompdf->getOptions();
$rootDir = realpath($options->getRootDir());
return Helpers::build_url("file://", "", $rootDir, $rootDir . self::DEFAULT_STYLESHEET);
}
/**
* @param FontMetrics $fontMetrics
* @return $this
*/
public function setFontMetrics(FontMetrics $fontMetrics)
{
$this->fontMetrics = $fontMetrics;
return $this;
}
/**
* @return FontMetrics
*/
public function getFontMetrics()
{
return $this->fontMetrics;
}
/**
* dumps the entire stylesheet as a string
*
* Generates a string of each selector and associated style in the
* Stylesheet. Useful for debugging.
*
* @return string
*/
function __toString()
{
$str = "";
foreach ($this->_styles as $selector => $selector_styles) {
foreach ($selector_styles as $style) {
$str .= "$selector => " . $style->__toString() . "\n";
}
}
return $str;
}
}