mirror of
https://github.com/Icinga/icingaweb2.git
synced 2025-10-31 11:24:51 +01:00
1419 lines
40 KiB
PHP
1419 lines
40 KiB
PHP
<?php
|
|
/**
|
|
* @package dompdf
|
|
* @link http://dompdf.github.com/
|
|
* @author Benj Carson <benjcarson@digitaljunkies.ca>
|
|
* @author Helmut Tischer <htischer@weihenstephan.org>
|
|
* @author Fabien Ménager <fabien.menager@gmail.com>
|
|
* @license http://www.gnu.org/copyleft/lesser.html GNU Lesser General Public License
|
|
*/
|
|
|
|
/**
|
|
* The location of the default built-in CSS file.
|
|
* {@link Stylesheet::DEFAULT_STYLESHEET}
|
|
*/
|
|
define('__DEFAULT_STYLESHEET', DOMPDF_LIB_DIR . DIRECTORY_SEPARATOR . "res" . DIRECTORY_SEPARATOR . "html.css");
|
|
|
|
/**
|
|
* The master stylesheet class
|
|
*
|
|
* The Stylesheet class is responsible for parsing stylesheets and style
|
|
* tags/attributes. It also acts as a registry of the individual Style
|
|
* objects generated by the current set of loaded CSS files and style
|
|
* elements.
|
|
*
|
|
* @see Style
|
|
* @package dompdf
|
|
*/
|
|
class Stylesheet {
|
|
|
|
/**
|
|
* The location of the default built-in CSS file.
|
|
*/
|
|
const DEFAULT_STYLESHEET = __DEFAULT_STYLESHEET;
|
|
|
|
/**
|
|
* User agent stylesheet origin
|
|
*
|
|
* @var int
|
|
*/
|
|
const ORIG_UA = 1;
|
|
|
|
/**
|
|
* User normal stylesheet origin
|
|
*
|
|
* @var int
|
|
*/
|
|
const ORIG_USER = 2;
|
|
|
|
/**
|
|
* Author normal stylesheet origin
|
|
*
|
|
* @var int
|
|
*/
|
|
const ORIG_AUTHOR = 3;
|
|
|
|
private static $_stylesheet_origins = array(
|
|
self::ORIG_UA => -0x0FFFFFFF, // user agent style sheets
|
|
self::ORIG_USER => -0x0000FFFF, // user normal style sheets
|
|
self::ORIG_AUTHOR => 0x00000000, // author normal style sheets
|
|
);
|
|
|
|
/**
|
|
* Current dompdf instance
|
|
*
|
|
* @var DOMPDF
|
|
*/
|
|
private $_dompdf;
|
|
|
|
/**
|
|
* Array of currently defined styles
|
|
*
|
|
* @var Style[]
|
|
*/
|
|
private $_styles;
|
|
|
|
/**
|
|
* Base protocol of the document being parsed
|
|
* Used to handle relative urls.
|
|
*
|
|
* @var string
|
|
*/
|
|
private $_protocol;
|
|
|
|
/**
|
|
* Base hostname of the document being parsed
|
|
* Used to handle relative urls.
|
|
*
|
|
* @var string
|
|
*/
|
|
private $_base_host;
|
|
|
|
/**
|
|
* Base path of the document being parsed
|
|
* Used to handle relative urls.
|
|
*
|
|
* @var string
|
|
*/
|
|
private $_base_path;
|
|
|
|
/**
|
|
* The styles defined by @page rules
|
|
*
|
|
* @var array<Style>
|
|
*/
|
|
private $_page_styles;
|
|
|
|
/**
|
|
* List of loaded files, used to prevent recursion
|
|
*
|
|
* @var array
|
|
*/
|
|
private $_loaded_files;
|
|
|
|
/**
|
|
* Current stylesheet origin
|
|
*
|
|
* @var int
|
|
*/
|
|
private $_current_origin = self::ORIG_UA;
|
|
|
|
/**
|
|
* Accepted CSS media types
|
|
* List of types and parsing rules for future extensions:
|
|
* http://www.w3.org/TR/REC-html40/types.html
|
|
* screen, tty, tv, projection, handheld, print, braille, aural, all
|
|
* The following are non standard extensions for undocumented specific environments.
|
|
* static, visual, bitmap, paged, dompdf
|
|
* Note, even though the generated pdf file is intended for print output,
|
|
* the desired content might be different (e.g. screen or projection view of html file).
|
|
* Therefore allow specification of content by dompdf setting DOMPDF_DEFAULT_MEDIA_TYPE.
|
|
* If given, replace media "print" by DOMPDF_DEFAULT_MEDIA_TYPE.
|
|
* (Previous version $ACCEPTED_MEDIA_TYPES = $ACCEPTED_GENERIC_MEDIA_TYPES + $ACCEPTED_DEFAULT_MEDIA_TYPE)
|
|
*/
|
|
static $ACCEPTED_DEFAULT_MEDIA_TYPE = "print";
|
|
static $ACCEPTED_GENERIC_MEDIA_TYPES = array("all", "static", "visual", "bitmap", "paged", "dompdf");
|
|
|
|
/**
|
|
* The class constructor.
|
|
*
|
|
* The base protocol, host & path are initialized to those of
|
|
* the current script.
|
|
*/
|
|
function __construct(DOMPDF $dompdf) {
|
|
$this->_dompdf = $dompdf;
|
|
$this->_styles = array();
|
|
$this->_loaded_files = array();
|
|
list($this->_protocol, $this->_base_host, $this->_base_path) = explode_url($_SERVER["SCRIPT_FILENAME"]);
|
|
$this->_page_styles = array("base" => null);
|
|
}
|
|
|
|
/**
|
|
* Class destructor
|
|
*/
|
|
function __destruct() {
|
|
clear_object($this);
|
|
}
|
|
|
|
/**
|
|
* Set the base protocol
|
|
*
|
|
* @param string $protocol
|
|
*/
|
|
function set_protocol($protocol) { $this->_protocol = $protocol; }
|
|
|
|
/**
|
|
* Set the base host
|
|
*
|
|
* @param string $host
|
|
*/
|
|
function set_host($host) { $this->_base_host = $host; }
|
|
|
|
/**
|
|
* Set the base path
|
|
*
|
|
* @param string $path
|
|
*/
|
|
function set_base_path($path) { $this->_base_path = $path; }
|
|
|
|
/**
|
|
* Return the DOMPDF object
|
|
*
|
|
* @return DOMPDF
|
|
*/
|
|
function get_dompdf() { return $this->_dompdf; }
|
|
|
|
/**
|
|
* Return the base protocol for this stylesheet
|
|
*
|
|
* @return string
|
|
*/
|
|
function get_protocol() { return $this->_protocol; }
|
|
|
|
/**
|
|
* Return the base host for this stylesheet
|
|
*
|
|
* @return string
|
|
*/
|
|
function get_host() { return $this->_base_host; }
|
|
|
|
/**
|
|
* Return the base path for this stylesheet
|
|
*
|
|
* @return string
|
|
*/
|
|
function get_base_path() { return $this->_base_path; }
|
|
|
|
/**
|
|
* Return the array of page styles
|
|
*
|
|
* @return Style[]
|
|
*/
|
|
function get_page_styles() { return $this->_page_styles; }
|
|
|
|
/**
|
|
* Add a new Style object to the stylesheet
|
|
* add_style() adds a new Style object to the current stylesheet, or
|
|
* merges a new Style with an existing one.
|
|
*
|
|
* @param string $key the Style's selector
|
|
* @param Style $style the Style to be added
|
|
*
|
|
* @throws DOMPDF_Exception
|
|
*/
|
|
function add_style($key, Style $style) {
|
|
if ( !is_string($key) ) {
|
|
throw new DOMPDF_Exception("CSS rule must be keyed by a string.");
|
|
}
|
|
|
|
if ( isset($this->_styles[$key]) ) {
|
|
$this->_styles[$key]->merge($style);
|
|
}
|
|
else {
|
|
$this->_styles[$key] = clone $style;
|
|
}
|
|
|
|
$this->_styles[$key]->set_origin( $this->_current_origin );
|
|
}
|
|
|
|
/**
|
|
* lookup a specifc Style object
|
|
*
|
|
* lookup() returns the Style specified by $key, or null if the Style is
|
|
* not found.
|
|
*
|
|
* @param string $key the selector of the requested Style
|
|
* @return Style
|
|
*/
|
|
function lookup($key) {
|
|
if ( !isset($this->_styles[$key]) ) {
|
|
return null;
|
|
}
|
|
|
|
return $this->_styles[$key];
|
|
}
|
|
|
|
/**
|
|
* create a new Style object associated with this stylesheet
|
|
*
|
|
* @param Style $parent The style of this style's parent in the DOM tree
|
|
* @return Style
|
|
*/
|
|
function create_style(Style $parent = null) {
|
|
return new Style($this, $this->_current_origin);
|
|
}
|
|
|
|
/**
|
|
* load and parse a CSS string
|
|
*
|
|
* @param string $css
|
|
*/
|
|
function load_css(&$css) { $this->_parse_css($css); }
|
|
|
|
|
|
/**
|
|
* load and parse a CSS file
|
|
*
|
|
* @param string $file
|
|
* @param int $origin
|
|
*/
|
|
function load_css_file($file, $origin = self::ORIG_AUTHOR) {
|
|
if ( $origin ) {
|
|
$this->_current_origin = $origin;
|
|
}
|
|
|
|
// Prevent circular references
|
|
if ( isset($this->_loaded_files[$file]) ) {
|
|
return;
|
|
}
|
|
|
|
$this->_loaded_files[$file] = true;
|
|
|
|
if ( strpos($file, "data:") === 0) {
|
|
$parsed = parse_data_uri($file);
|
|
$css = $parsed["data"];
|
|
}
|
|
else {
|
|
$parsed_url = explode_url($file);
|
|
|
|
list($this->_protocol, $this->_base_host, $this->_base_path, $filename) = $parsed_url;
|
|
|
|
// Fix submitted by Nick Oostveen for aliased directory support:
|
|
if ( $this->_protocol == "" ) {
|
|
$file = $this->_base_path . $filename;
|
|
}
|
|
else {
|
|
$file = build_url($this->_protocol, $this->_base_host, $this->_base_path, $filename);
|
|
}
|
|
|
|
set_error_handler("record_warnings");
|
|
$css = file_get_contents($file, null, $this->_dompdf->get_http_context());
|
|
restore_error_handler();
|
|
|
|
$good_mime_type = true;
|
|
|
|
// See http://the-stickman.com/web-development/php/getting-http-response-headers-when-using-file_get_contents/
|
|
if ( isset($http_response_header) && !$this->_dompdf->get_quirksmode() ) {
|
|
foreach($http_response_header as $_header) {
|
|
if ( preg_match("@Content-Type:\s*([\w/]+)@i", $_header, $matches) &&
|
|
($matches[1] !== "text/css") ) {
|
|
$good_mime_type = false;
|
|
}
|
|
}
|
|
}
|
|
|
|
if ( !$good_mime_type || $css == "" ) {
|
|
record_warnings(E_USER_WARNING, "Unable to load css file $file", __FILE__, __LINE__);
|
|
return;
|
|
}
|
|
}
|
|
|
|
$this->_parse_css($css);
|
|
}
|
|
|
|
/**
|
|
* @link http://www.w3.org/TR/CSS21/cascade.html#specificity
|
|
*
|
|
* @param string $selector
|
|
* @param int $origin :
|
|
* - ua: user agent style sheets
|
|
* - un: user normal style sheets
|
|
* - an: author normal style sheets
|
|
* - ai: author important style sheets
|
|
* - ui: user important style sheets
|
|
*
|
|
* @return int
|
|
*/
|
|
private function _specificity($selector, $origin = self::ORIG_AUTHOR) {
|
|
// http://www.w3.org/TR/CSS21/cascade.html#specificity
|
|
// ignoring the ":" pseudoclass modifyers
|
|
// also ignored in _css_selector_to_xpath
|
|
|
|
$a = ($selector === "!attr") ? 1 : 0;
|
|
|
|
$b = min(mb_substr_count($selector, "#"), 255);
|
|
|
|
$c = min(mb_substr_count($selector, ".") +
|
|
mb_substr_count($selector, "["), 255);
|
|
|
|
$d = min(mb_substr_count($selector, " ") +
|
|
mb_substr_count($selector, ">") +
|
|
mb_substr_count($selector, "+"), 255);
|
|
|
|
//If a normal element name is at the begining of the string,
|
|
//a leading whitespace might have been removed on whitespace collapsing and removal
|
|
//therefore there might be one whitespace less as selected element names
|
|
//this can lead to a too small specificity
|
|
//see _css_selector_to_xpath
|
|
|
|
if ( !in_array($selector[0], array(" ", ">", ".", "#", "+", ":", "["))/* && $selector !== "*"*/) {
|
|
$d++;
|
|
}
|
|
|
|
if (DEBUGCSS) {
|
|
/*DEBUGCSS*/ print "<pre>\n";
|
|
/*DEBUGCSS*/ printf("_specificity(): 0x%08x \"%s\"\n", ($a << 24) | ($b << 16) | ($c << 8) | ($d), $selector);
|
|
/*DEBUGCSS*/ print "</pre>";
|
|
}
|
|
|
|
return self::$_stylesheet_origins[$origin] + ($a << 24) | ($b << 16) | ($c << 8) | ($d);
|
|
}
|
|
|
|
/**
|
|
* Converts a CSS selector to an XPath query.
|
|
*
|
|
* @param string $selector
|
|
* @param bool $first_pass
|
|
*
|
|
* @throws DOMPDF_Exception
|
|
* @return string
|
|
*/
|
|
private function _css_selector_to_xpath($selector, $first_pass = false) {
|
|
|
|
// Collapse white space and strip whitespace around delimiters
|
|
// $search = array("/\\s+/", "/\\s+([.>#+:])\\s+/");
|
|
// $replace = array(" ", "\\1");
|
|
// $selector = preg_replace($search, $replace, trim($selector));
|
|
|
|
// Initial query (non-absolute)
|
|
$query = "//";
|
|
|
|
// Will contain :before and :after if they must be created
|
|
$pseudo_elements = array();
|
|
|
|
// Parse the selector
|
|
//$s = preg_split("/([ :>.#+])/", $selector, -1, PREG_SPLIT_DELIM_CAPTURE);
|
|
|
|
$delimiters = array(" ", ">", ".", "#", "+", ":", "[", "(");
|
|
|
|
// Add an implicit * at the beginning of the selector
|
|
// if it begins with an attribute selector
|
|
if ( $selector[0] === "[" ) {
|
|
$selector = "*$selector";
|
|
}
|
|
|
|
// Add an implicit space at the beginning of the selector if there is no
|
|
// delimiter there already.
|
|
if ( !in_array($selector[0], $delimiters) ) {
|
|
$selector = " $selector";
|
|
}
|
|
|
|
$tok = "";
|
|
$len = mb_strlen($selector);
|
|
$i = 0;
|
|
|
|
while ( $i < $len ) {
|
|
|
|
$s = $selector[$i];
|
|
$i++;
|
|
|
|
// Eat characters up to the next delimiter
|
|
$tok = "";
|
|
$in_attr = false;
|
|
|
|
while ($i < $len) {
|
|
$c = $selector[$i];
|
|
$c_prev = $selector[$i-1];
|
|
|
|
if ( !$in_attr && in_array($c, $delimiters) ) {
|
|
break;
|
|
}
|
|
|
|
if ( $c_prev === "[" ) {
|
|
$in_attr = true;
|
|
}
|
|
|
|
$tok .= $selector[$i++];
|
|
|
|
if ( $in_attr && $c === "]" ) {
|
|
$in_attr = false;
|
|
break;
|
|
}
|
|
}
|
|
|
|
switch ($s) {
|
|
|
|
case " ":
|
|
case ">":
|
|
// All elements matching the next token that are direct children of
|
|
// the current token
|
|
$expr = $s === " " ? "descendant" : "child";
|
|
|
|
if ( mb_substr($query, -1, 1) !== "/" ) {
|
|
$query .= "/";
|
|
}
|
|
|
|
// Tag names are case-insensitive
|
|
$tok = strtolower($tok);
|
|
|
|
if ( !$tok ) {
|
|
$tok = "*";
|
|
}
|
|
|
|
$query .= "$expr::$tok";
|
|
$tok = "";
|
|
break;
|
|
|
|
case ".":
|
|
case "#":
|
|
// All elements matching the current token with a class/id equal to
|
|
// the _next_ token.
|
|
|
|
$attr = $s === "." ? "class" : "id";
|
|
|
|
// empty class/id == *
|
|
if ( mb_substr($query, -1, 1) === "/" ) {
|
|
$query .= "*";
|
|
}
|
|
|
|
// Match multiple classes: $tok contains the current selected
|
|
// class. Search for class attributes with class="$tok",
|
|
// class=".* $tok .*" and class=".* $tok"
|
|
|
|
// This doesn't work because libxml only supports XPath 1.0...
|
|
//$query .= "[matches(@$attr,\"^${tok}\$|^${tok}[ ]+|[ ]+${tok}\$|[ ]+${tok}[ ]+\")]";
|
|
|
|
// Query improvement by Michael Sheakoski <michael@mjsdigital.com>:
|
|
$query .= "[contains(concat(' ', @$attr, ' '), concat(' ', '$tok', ' '))]";
|
|
$tok = "";
|
|
break;
|
|
|
|
case "+":
|
|
// All sibling elements that folow the current token
|
|
if ( mb_substr($query, -1, 1) !== "/" ) {
|
|
$query .= "/";
|
|
}
|
|
|
|
$query .= "following-sibling::$tok";
|
|
$tok = "";
|
|
break;
|
|
|
|
case ":":
|
|
$i2 = $i-strlen($tok)-2; // the char before ":"
|
|
if ( !isset($selector[$i2]) || in_array($selector[$i2], $delimiters) ) {
|
|
$query .= "*";
|
|
}
|
|
|
|
$last = false;
|
|
|
|
// Pseudo-classes
|
|
switch ($tok) {
|
|
|
|
case "first-child":
|
|
$query .= "[1]";
|
|
$tok = "";
|
|
break;
|
|
|
|
case "last-child":
|
|
$query .= "[not(following-sibling::*)]";
|
|
$tok = "";
|
|
break;
|
|
|
|
case "first-of-type":
|
|
$query .= "[position() = 1]";
|
|
$tok = "";
|
|
break;
|
|
|
|
case "last-of-type":
|
|
$query .= "[position() = last()]";
|
|
$tok = "";
|
|
break;
|
|
|
|
// an+b, n, odd, and even
|
|
case "nth-last-of-type":
|
|
case "nth-last-child":
|
|
$last = true;
|
|
|
|
case "nth-of-type":
|
|
case "nth-child":
|
|
$p = $i+1;
|
|
$nth = trim(mb_substr($selector, $p, strpos($selector, ")", $i)-$p));
|
|
|
|
// 1
|
|
if ( preg_match("/^\d+$/", $nth) ) {
|
|
$condition = "position() = $nth";
|
|
}
|
|
|
|
// odd
|
|
elseif ( $nth === "odd" ) {
|
|
$condition = "(position() mod 2) = 1";
|
|
}
|
|
|
|
// even
|
|
elseif ( $nth === "even" ) {
|
|
$condition = "(position() mod 2) = 0";
|
|
}
|
|
|
|
// an+b
|
|
else {
|
|
$condition = $this->_selector_an_plus_b($nth, $last);
|
|
}
|
|
|
|
$query .= "[$condition]";
|
|
$tok = "";
|
|
break;
|
|
|
|
case "link":
|
|
$query .= "[@href]";
|
|
$tok = "";
|
|
break;
|
|
|
|
case "first-line": // TODO
|
|
case "first-letter": // TODO
|
|
|
|
// N/A
|
|
case "active":
|
|
case "hover":
|
|
case "visited":
|
|
$query .= "[false()]";
|
|
$tok = "";
|
|
break;
|
|
|
|
/* Pseudo-elements */
|
|
case "before":
|
|
case "after":
|
|
if ( $first_pass ) {
|
|
$pseudo_elements[$tok] = $tok;
|
|
}
|
|
else {
|
|
$query .= "/*[@$tok]";
|
|
}
|
|
|
|
$tok = "";
|
|
break;
|
|
|
|
case "empty":
|
|
$query .= "[not(*) and not(normalize-space())]";
|
|
$tok = "";
|
|
break;
|
|
|
|
case "disabled":
|
|
case "checked":
|
|
$query .= "[@$tok]";
|
|
$tok = "";
|
|
break;
|
|
|
|
case "enabled":
|
|
$query .= "[not(@disabled)]";
|
|
$tok = "";
|
|
break;
|
|
}
|
|
|
|
break;
|
|
|
|
case "[":
|
|
// Attribute selectors. All with an attribute matching the following token(s)
|
|
$attr_delimiters = array("=", "]", "~", "|", "$", "^", "*");
|
|
$tok_len = mb_strlen($tok);
|
|
$j = 0;
|
|
|
|
$attr = "";
|
|
$op = "";
|
|
$value = "";
|
|
|
|
while ( $j < $tok_len ) {
|
|
if ( in_array($tok[$j], $attr_delimiters) ) {
|
|
break;
|
|
}
|
|
$attr .= $tok[$j++];
|
|
}
|
|
|
|
switch ( $tok[$j] ) {
|
|
|
|
case "~":
|
|
case "|":
|
|
case "$":
|
|
case "^":
|
|
case "*":
|
|
$op .= $tok[$j++];
|
|
|
|
if ( $tok[$j] !== "=" ) {
|
|
throw new DOMPDF_Exception("Invalid CSS selector syntax: invalid attribute selector: $selector");
|
|
}
|
|
|
|
$op .= $tok[$j];
|
|
break;
|
|
|
|
case "=":
|
|
$op = "=";
|
|
break;
|
|
|
|
}
|
|
|
|
// Read the attribute value, if required
|
|
if ( $op != "" ) {
|
|
$j++;
|
|
while ( $j < $tok_len ) {
|
|
if ( $tok[$j] === "]" ) {
|
|
break;
|
|
}
|
|
$value .= $tok[$j++];
|
|
}
|
|
}
|
|
|
|
if ( $attr == "" ) {
|
|
throw new DOMPDF_Exception("Invalid CSS selector syntax: missing attribute name");
|
|
}
|
|
|
|
$value = trim($value, "\"'");
|
|
|
|
switch ( $op ) {
|
|
|
|
case "":
|
|
$query .= "[@$attr]";
|
|
break;
|
|
|
|
case "=":
|
|
$query .= "[@$attr=\"$value\"]";
|
|
break;
|
|
|
|
case "~=":
|
|
// FIXME: this will break if $value contains quoted strings
|
|
// (e.g. [type~="a b c" "d e f"])
|
|
$values = explode(" ", $value);
|
|
$query .= "[";
|
|
|
|
foreach ( $values as $val ) {
|
|
$query .= "@$attr=\"$val\" or ";
|
|
}
|
|
|
|
$query = rtrim($query, " or ") . "]";
|
|
break;
|
|
|
|
case "|=":
|
|
$values = explode("-", $value);
|
|
$query .= "[";
|
|
|
|
foreach ( $values as $val ) {
|
|
$query .= "starts-with(@$attr, \"$val\") or ";
|
|
}
|
|
|
|
$query = rtrim($query, " or ") . "]";
|
|
break;
|
|
|
|
case "$=":
|
|
$query .= "[substring(@$attr, string-length(@$attr)-".(strlen($value) - 1).")=\"$value\"]";
|
|
break;
|
|
|
|
case "^=":
|
|
$query .= "[starts-with(@$attr,\"$value\")]";
|
|
break;
|
|
|
|
case "*=":
|
|
$query .= "[contains(@$attr,\"$value\")]";
|
|
break;
|
|
}
|
|
|
|
break;
|
|
}
|
|
}
|
|
$i++;
|
|
|
|
// case ":":
|
|
// // Pseudo selectors: ignore for now. Partially handled directly
|
|
// // below.
|
|
|
|
// // Skip until the next special character, leaving the token as-is
|
|
// while ( $i < $len ) {
|
|
// if ( in_array($selector[$i], $delimiters) )
|
|
// break;
|
|
// $i++;
|
|
// }
|
|
// break;
|
|
|
|
// default:
|
|
// // Add the character to the token
|
|
// $tok .= $selector[$i++];
|
|
// break;
|
|
// }
|
|
|
|
// }
|
|
|
|
|
|
// Trim the trailing '/' from the query
|
|
if ( mb_strlen($query) > 2 ) {
|
|
$query = rtrim($query, "/");
|
|
}
|
|
|
|
return array("query" => $query, "pseudo_elements" => $pseudo_elements);
|
|
}
|
|
|
|
// https://github.com/tenderlove/nokogiri/blob/master/lib/nokogiri/css/xpath_visitor.rb
|
|
protected function _selector_an_plus_b($expr, $last = false) {
|
|
$expr = preg_replace("/\s/", "", $expr);
|
|
if ( !preg_match("/^(?P<a>-?[0-9]*)?n(?P<b>[-+]?[0-9]+)?$/", $expr, $matches)) {
|
|
return "false()";
|
|
}
|
|
|
|
$a = ((isset($matches["a"]) && $matches["a"] !== "") ? intval($matches["a"]) : 1);
|
|
$b = ((isset($matches["b"]) && $matches["b"] !== "") ? intval($matches["b"]) : 0);
|
|
|
|
$position = ($last ? "(last()-position()+1)" : "position()");
|
|
|
|
if ( $b == 0 ) {
|
|
return "($position mod $a) = 0";
|
|
}
|
|
else {
|
|
$compare = (($a < 0) ? "<=" : ">=");
|
|
$b2 = -$b;
|
|
if ( $b2 >= 0 ) {
|
|
$b2 = "+$b2";
|
|
}
|
|
return "($position $compare $b) and ((($position $b2) mod ".abs($a).") = 0)";
|
|
}
|
|
}
|
|
|
|
/**
|
|
* applies all current styles to a particular document tree
|
|
*
|
|
* apply_styles() applies all currently loaded styles to the provided
|
|
* {@link Frame_Tree}. Aside from parsing CSS, this is the main purpose
|
|
* of this class.
|
|
*
|
|
* @param Frame_Tree $tree
|
|
*/
|
|
function apply_styles(Frame_Tree $tree) {
|
|
// Use XPath to select nodes. This would be easier if we could attach
|
|
// Frame objects directly to DOMNodes using the setUserData() method, but
|
|
// we can't do that just yet. Instead, we set a _node attribute_ in
|
|
// Frame->set_id() and use that as a handle on the Frame object via
|
|
// Frame_Tree::$_registry.
|
|
|
|
// We create a scratch array of styles indexed by frame id. Once all
|
|
// styles have been assigned, we order the cached styles by specificity
|
|
// and create a final style object to assign to the frame.
|
|
|
|
// FIXME: this is not particularly robust...
|
|
|
|
$styles = array();
|
|
$xp = new DOMXPath($tree->get_dom());
|
|
|
|
// Add generated content
|
|
foreach ($this->_styles as $selector => $style) {
|
|
if ( strpos($selector, ":before") === false && strpos($selector, ":after") === false ) {
|
|
continue;
|
|
}
|
|
|
|
$query = $this->_css_selector_to_xpath($selector, true);
|
|
|
|
// Retrieve the nodes, limit to body for generated content
|
|
$nodes = @$xp->query( '.'.$query["query"] );
|
|
if ( $nodes == null ) {
|
|
record_warnings(E_USER_WARNING, "The CSS selector '$selector' is not valid", __FILE__, __LINE__);
|
|
continue;
|
|
}
|
|
|
|
foreach ($nodes as $node) {
|
|
foreach ($query["pseudo_elements"] as $pos) {
|
|
// Do not add a new pseudo element if another one already matched
|
|
if ( $node->hasAttribute("dompdf_{$pos}_frame_id") ) {
|
|
continue;
|
|
}
|
|
|
|
if (($src = $this->_image($style->content)) !== "none") {
|
|
$new_node = $node->ownerDocument->createElement("img_generated");
|
|
$new_node->setAttribute("src", $src);
|
|
}
|
|
else {
|
|
$new_node = $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 => $style) {
|
|
$query = $this->_css_selector_to_xpath($selector);
|
|
|
|
// Retrieve the nodes
|
|
$nodes = @$xp->query($query["query"]);
|
|
if ( $nodes == null ) {
|
|
record_warnings(E_USER_WARNING, "The CSS selector '$selector' is not valid", __FILE__, __LINE__);
|
|
continue;
|
|
}
|
|
|
|
foreach ($nodes as $node) {
|
|
// Retrieve the node id
|
|
// Only DOMElements get styles
|
|
if ( $node->nodeType != XML_ELEMENT_NODE ) {
|
|
continue;
|
|
}
|
|
|
|
$id = $node->getAttribute("frame_id");
|
|
|
|
// Assign the current style to the scratch array
|
|
$spec = $this->_specificity($selector);
|
|
$styles[$id][$spec][] = $style;
|
|
}
|
|
}
|
|
|
|
// Now create the styles and assign them to the appropriate frames. (We
|
|
// iterate over the tree using an implicit Frame_Tree iterator.)
|
|
$root_flg = false;
|
|
foreach ($tree->get_frames() as $frame) {
|
|
// pre_r($frame->get_node()->nodeName . ":");
|
|
if ( !$root_flg && $this->_page_styles["base"] ) {
|
|
$style = $this->_page_styles["base"];
|
|
$root_flg = true;
|
|
}
|
|
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 ) {
|
|
if ( $p ) {
|
|
$style->inherit($p->get_style());
|
|
}
|
|
|
|
$frame->set_style($style);
|
|
continue;
|
|
}
|
|
|
|
$id = $frame->get_id();
|
|
|
|
// Handle HTML 4.0 attributes
|
|
Attribute_Translator::translate_attributes($frame);
|
|
if ( ($str = $frame->get_node()->getAttribute(Attribute_Translator::$_style_attr)) !== "" ) {
|
|
// Lowest specificity
|
|
$styles[$id][1][] = $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");
|
|
$styles[$id][$spec][] = $this->_parse_properties($str);
|
|
}
|
|
|
|
// Grab the applicable styles
|
|
if ( isset($styles[$id]) ) {
|
|
|
|
$applied_styles = $styles[ $frame->get_id() ];
|
|
|
|
// Sort by specificity
|
|
ksort($applied_styles);
|
|
|
|
if (DEBUGCSS) {
|
|
$debug_nodename = $frame->get_node()->nodeName;
|
|
print "<pre>\n[$debug_nodename\n";
|
|
foreach ($applied_styles as $spec => $arr) {
|
|
printf("specificity: 0x%08x\n",$spec);
|
|
foreach ($arr as $s) {
|
|
print "[\n";
|
|
$s->debug_print();
|
|
print "]\n";
|
|
}
|
|
}
|
|
}
|
|
|
|
// Merge the new styles with the inherited styles
|
|
foreach ($applied_styles as $arr) {
|
|
foreach ($arr as $s) {
|
|
$style->merge($s);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Inherit parent's styles if required
|
|
if ( $p ) {
|
|
|
|
if (DEBUGCSS) {
|
|
print "inherit:\n";
|
|
print "[\n";
|
|
$p->get_style()->debug_print();
|
|
print "]\n";
|
|
}
|
|
|
|
$style->inherit( $p->get_style() );
|
|
}
|
|
|
|
if (DEBUGCSS) {
|
|
print "DomElementStyle:\n";
|
|
print "[\n";
|
|
$style->debug_print();
|
|
print "]\n";
|
|
print "/$debug_nodename]\n</pre>";
|
|
}
|
|
|
|
/*DEBUGCSS print: see below different print debugging method
|
|
pre_r($frame->get_node()->nodeName . ":");
|
|
echo "<pre>";
|
|
echo $style;
|
|
echo "</pre>";*/
|
|
$frame->set_style($style);
|
|
|
|
}
|
|
|
|
// 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 DOMPDF_Exception
|
|
*/
|
|
private function _parse_css($str) {
|
|
|
|
$str = trim($str);
|
|
|
|
// Destroy comments and remove HTML comments
|
|
$css = preg_replace(array(
|
|
"'/\*.*?\*/'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 preceeded by '@')\n".
|
|
"([^{]*{[^}]*})) # Parse normal rulesets\n".
|
|
"/xs";
|
|
|
|
if ( preg_match_all($re, $css, $matches, PREG_SET_ORDER) === false ) {
|
|
// An error occured
|
|
throw new DOMPDF_Exception("Error parsing css file: preg_match_all() failed.");
|
|
}
|
|
|
|
// After matching, the array indicies 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
|
|
//
|
|
//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->get_option("default_media_type");
|
|
|
|
$media = preg_split("/\s*,\s*/", mb_strtolower(trim($match[3])));
|
|
|
|
if ( count(array_intersect($acceptedmedia, $media)) ) {
|
|
$this->_parse_sections($match[5]);
|
|
}
|
|
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 <body> 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":
|
|
case ":first":
|
|
$key = $page_selector;
|
|
|
|
default: continue;
|
|
}
|
|
|
|
// 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]);
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
/* See also style.cls Style::_image(), refactoring?, works also for imported css files */
|
|
protected function _image($val) {
|
|
$DEBUGCSS=DEBUGCSS;
|
|
$parsed_url = "none";
|
|
|
|
if ( 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\(['\"]?([^'\")]+)['\"]?\)/","\\1", trim($val));
|
|
|
|
// Resolve the url now in the context of the current stylesheet
|
|
$parsed_url = explode_url($val);
|
|
if ( $parsed_url["protocol"] == "" && $this->get_protocol() == "" ) {
|
|
if ($parsed_url["path"][0] === '/' || $parsed_url["path"][0] === '\\' ) {
|
|
$path = $_SERVER["DOCUMENT_ROOT"].'/';
|
|
}
|
|
else {
|
|
$path = $this->get_base_path();
|
|
}
|
|
|
|
$path .= $parsed_url["path"] . $parsed_url["file"];
|
|
$path = realpath($path);
|
|
// If realpath returns FALSE then specifically state that there is no background image
|
|
// FIXME: Is this causing problems for imported CSS files? There are some './none' references when running the test cases.
|
|
if (!$path) { $path = 'none'; }
|
|
}
|
|
else {
|
|
$path = build_url($this->get_protocol(),
|
|
$this->get_host(),
|
|
$this->get_base_path(),
|
|
$val);
|
|
}
|
|
}
|
|
|
|
if ($DEBUGCSS) {
|
|
print "<pre>[_image\n";
|
|
print_r($parsed_url);
|
|
print $this->get_protocol()."\n".$this->get_base_path()."\n".$path."\n";
|
|
print "_image]</pre>";;
|
|
}
|
|
|
|
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->get_option("default_media_type");
|
|
|
|
// @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 = 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?
|
|
|
|
$url = $this->_image($url);
|
|
|
|
$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
|
|
* @return Style
|
|
*/
|
|
private function _parse_font_face($str) {
|
|
$descriptors = $this->_parse_properties($str);
|
|
|
|
preg_match_all("/(url|local)\s*\([\"\']?([^\"\'\)]+)[\"\']?\)\s*(format\s*\([\"\']?([^\"\'\)]+)[\"\']?\))?/i", $descriptors->src, $src);
|
|
|
|
$sources = array();
|
|
$valid_sources = array();
|
|
|
|
foreach($src[0] as $i => $value) {
|
|
$source = array(
|
|
"local" => strtolower($src[1][$i]) === "local",
|
|
"uri" => $src[2][$i],
|
|
"format" => $src[4][$i],
|
|
"path" => build_url($this->_protocol, $this->_base_host, $this->_base_path, $src[2][$i]),
|
|
);
|
|
|
|
if ( !$source["local"] && in_array($source["format"], array("", "woff", "opentype", "truetype")) ) {
|
|
$valid_sources[] = $source;
|
|
}
|
|
|
|
$sources[] = $source;
|
|
}
|
|
|
|
// No valid sources
|
|
if ( empty($valid_sources) ) {
|
|
return;
|
|
}
|
|
|
|
$style = array(
|
|
"family" => $descriptors->get_font_family_raw(),
|
|
"weight" => $descriptors->font_weight,
|
|
"style" => $descriptors->font_style,
|
|
);
|
|
|
|
Font_Metrics::register_font($style, $valid_sources[0]["path"]);
|
|
}
|
|
|
|
/**
|
|
* 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);
|
|
|
|
if (DEBUGCSS) print '[_parse_properties';
|
|
|
|
// Create the style
|
|
$style = new Style($this);
|
|
|
|
foreach ($properties as $prop) {
|
|
// If the $prop contains an url, the regex may be wrong
|
|
// @todo: fix the regex so that it works everytime
|
|
/*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.
|
|
//Pass on in the style to allow proper handling:
|
|
//!important properties can only be overridden by other !important ones.
|
|
//$style->$prop_name = is a shortcut of $style->__set($prop_name,$value);.
|
|
//If no specific set function available, set _props["prop_name"]
|
|
//style is always copied completely, or $_props handled separately
|
|
//Therefore set a _important_props["prop_name"]=true to indicate the modifier
|
|
|
|
/* 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':'').')';
|
|
//New style, anyway empty
|
|
//if ($important || !$style->important_get($prop_name) ) {
|
|
//$style->$prop_name = array($value,$important);
|
|
//assignment might be replaced by overloading through __set,
|
|
//and overloaded functions might check _important_props,
|
|
//therefore set _important_props first.
|
|
if ($important) {
|
|
$style->important_set($prop_name);
|
|
}
|
|
//For easier debugging, don't use overloading of assignments with __set
|
|
$style->$prop_name = $value;
|
|
//$style->props_set($prop_name, $value);
|
|
}
|
|
if (DEBUGCSS) print '_parse_properties]';
|
|
|
|
return $style;
|
|
}
|
|
|
|
/**
|
|
* parse selector + rulesets
|
|
*
|
|
* @param string $str CSS selectors and rulesets
|
|
*/
|
|
private function _parse_sections($str) {
|
|
// Pre-process: collapse all whitespace and strip whitespace around '>',
|
|
// '.', ':', '+', '#'
|
|
|
|
$patterns = array("/[\\s\n]+/", "/\\s+([>.:+#])\\s+/");
|
|
$replacements = array(" ", "\\1");
|
|
$str = preg_replace($patterns, $replacements, $str);
|
|
|
|
$sections = explode("}", $str);
|
|
if (DEBUGCSS) print '[_parse_sections';
|
|
foreach ($sections as $sect) {
|
|
$i = mb_strpos($sect, "{");
|
|
|
|
$selectors = explode(",", mb_substr($sect, 0, $i));
|
|
if (DEBUGCSS) print '[section';
|
|
$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!!!#'; }
|
|
|
|
$this->add_style($selector, $style);
|
|
}
|
|
|
|
if (DEBUGCSS) print 'section]';
|
|
}
|
|
|
|
if (DEBUGCSS) print '_parse_sections]';
|
|
}
|
|
|
|
/**
|
|
* 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 => $style) {
|
|
$str .= "$selector => " . $style->__toString() . "\n";
|
|
}
|
|
|
|
return $str;
|
|
}
|
|
}
|