vendor/dompdf/dompdf/src/Css/Style.php line 2834

Open in your IDE?
  1. <?php
  2. /**
  3.  * @package dompdf
  4.  * @link    http://dompdf.github.com/
  5.  * @author  Benj Carson <benjcarson@digitaljunkies.ca>
  6.  * @author  Helmut Tischer <htischer@weihenstephan.org>
  7.  * @author  Fabien Ménager <fabien.menager@gmail.com>
  8.  * @license http://www.gnu.org/copyleft/lesser.html GNU Lesser General Public License
  9.  */
  11. namespace Dompdf\Css;
  13. use Dompdf\Adapter\CPDF;
  14. use Dompdf\Exception;
  15. use Dompdf\FontMetrics;
  16. use Dompdf\Frame;
  18. /**
  19.  * Represents CSS properties.
  20.  *
  21.  * The Style class is responsible for handling and storing CSS properties.
  22.  * It includes methods to resolve colors and lengths, as well as getters &
  23.  * setters for many CSS properties.
  24.  *
  25.  * Actual CSS parsing is performed in the {@link Stylesheet} class.
  26.  *
  27.  * @package dompdf
  28.  */
  29. class Style
  30. {
  31.     const CSS_IDENTIFIER = "-?[_a-zA-Z]+[_a-zA-Z0-9-]*";
  32.     const CSS_INTEGER = "[+-]?\d+";
  33.     const CSS_NUMBER = "[+-]?\d*\.?\d+";
  35.     /**
  36.      * Default font size, in points.
  37.      *
  38.      * @var float
  39.      */
  40.     static $default_font_size = 12;
  42.     /**
  43.      * Default line height, as a fraction of the font size.
  44.      *
  45.      * @var float
  46.      */
  47.     static $default_line_height = 1.2;
  49.     /**
  50.      * Default "absolute" font sizes relative to the default font-size
  51.      * http://www.w3.org/TR/css3-fonts/#font-size-the-font-size-property
  52.      * @var array<float>
  53.      */
  54.     static $font_size_keywords = [
  55.         "xx-small" => 0.6, // 3/5
  56.         "x-small" => 0.75, // 3/4
  57.         "small" => 0.889, // 8/9
  58.         "medium" => 1, // 1
  59.         "large" => 1.2, // 6/5
  60.         "x-large" => 1.5, // 3/2
  61.         "xx-large" => 2.0, // 2/1
  62.     ];
  64.     /**
  65.      * List of valid text-align keywords.  Should also really be a constant.
  66.      *
  67.      * @var array
  68.      */
  69.     static $text_align_keywords = ["left", "right", "center", "justify"];
  71.     /**
  72.      * List of valid vertical-align keywords.  Should also really be a constant.
  73.      *
  74.      * @var array
  75.      */
  76.     static $vertical_align_keywords = ["baseline", "bottom", "middle", "sub",
  77.         "super", "text-bottom", "text-top", "top"];
  79.     /**
  80.      * List of all block-level (outer) display types.
  81.      * * https://www.w3.org/TR/css-display-3/#display-type
  82.      * * https://www.w3.org/TR/css-display-3/#block-level
  83.      */
  84.     public const BLOCK_LEVEL_TYPES = [
  85.         "block",
  86.         // "flow-root",
  87.         "list-item",
  88.         // "flex",
  89.         // "grid",
  90.         "table"
  91.     ];
  93.     /**
  94.      * List of all inline-level (outer) display types.
  95.      * * https://www.w3.org/TR/css-display-3/#display-type
  96.      * * https://www.w3.org/TR/css-display-3/#inline-level
  97.      */
  98.     public const INLINE_LEVEL_TYPES = [
  99.         "inline",
  100.         "inline-block",
  101.         // "inline-flex",
  102.         // "inline-grid",
  103.         "inline-table"
  104.     ];
  106.     /**
  107.      * List of all table-internal (outer) display types.
  108.      * * https://www.w3.org/TR/css-display-3/#layout-specific-display
  109.      */
  110.     public const TABLE_INTERNAL_TYPES = [
  111.         "table-row-group",
  112.         "table-header-group",
  113.         "table-footer-group",
  114.         "table-row",
  115.         "table-cell",
  116.         "table-column-group",
  117.         "table-column",
  118.         "table-caption"
  119.     ];
  121.     /**
  122.      * List of all inline (inner) display types.  Should really be a constant.
  123.      *
  124.      * @var array
  125.      */
  126.     static $INLINE_TYPES = ["inline"];
  128.     /**
  129.      * List of all block (inner) display types.  Should really be a constant.
  130.      *
  131.      * @var array
  132.      */
  133.     static $BLOCK_TYPES = ["block", "inline-block", "table-cell", "list-item"];
  135.     /**
  136.      * List of all table (inner) display types.  Should really be a constant.
  137.      *
  138.      * @var array
  139.      */
  140.     static $TABLE_TYPES = ["table", "inline-table"];
  142.     /**
  143.      * Lookup table for valid display types. Initially computed from the
  144.      * different constants.
  145.      *
  146.      * @var array
  147.      */
  148.     protected static $valid_display_types = [];
  150.     /**
  151.      * List of all positioned types.  Should really be a constant.
  152.      *
  153.      * @var array
  154.      */
  155.     static $POSITIONNED_TYPES = ["relative", "absolute", "fixed"];
  157.     /**
  158.      * List of valid border styles.  Should also really be a constant.
  159.      *
  160.      * @var array
  161.      */
  162.     static $BORDER_STYLES = ["none", "hidden", "dotted", "dashed", "solid",
  163.         "double", "groove", "ridge", "inset", "outset"];
  165.     /**
  166.      * Map of CSS shorthand properties and their corresponding sub-properties.
  167.      * The order of the sub-properties is relevant for the fallback getter,
  168.      * which is used in case no specific getter method is defined.
  169.      *
  170.      * @var array
  171.      */
  172.     protected static $_props_shorthand = [
  173.         "background" => [
  174.             "background_image",
  175.             "background_position",
  176.             "background_size",
  177.             "background_repeat",
  178.             // "background_origin",
  179.             // "background_clip",
  180.             "background_attachment",
  181.             "background_color"
  182.         ],
  183.         "border" => [
  184.             "border_width",
  185.             "border_style",
  186.             "border_color"
  187.         ],
  188.         "border_top" => [
  189.             "border_top_width",
  190.             "border_top_style",
  191.             "border_top_color"
  192.         ],
  193.         "border_right" => [
  194.             "border_right_width",
  195.             "border_right_style",
  196.             "border_right_color"
  197.         ],
  198.         "border_bottom" => [
  199.             "border_bottom_width",
  200.             "border_bottom_style",
  201.             "border_bottom_color"
  202.         ],
  203.         "border_left" => [
  204.             "border_left_width",
  205.             "border_left_style",
  206.             "border_left_color"
  207.         ],
  208.         "border_width" => [
  209.             "border_top_width",
  210.             "border_right_width",
  211.             "border_bottom_width",
  212.             "border_left_width"
  213.         ],
  214.         "border_style" => [
  215.             "border_top_style",
  216.             "border_right_style",
  217.             "border_bottom_style",
  218.             "border_left_style"
  219.         ],
  220.         "border_color" => [
  221.             "border_top_color",
  222.             "border_right_color",
  223.             "border_bottom_color",
  224.             "border_left_color"
  225.         ],
  226.         "border_radius" => [
  227.             "border_top_left_radius",
  228.             "border_top_right_radius",
  229.             "border_bottom_right_radius",
  230.             "border_bottom_left_radius"
  231.         ],
  232.         "font" => [
  233.             "font_family",
  234.             "font_size",
  235.             // "font_stretch",
  236.             "font_style",
  237.             "font_variant",
  238.             "font_weight",
  239.             "line_height"
  240.         ],
  241.         "list_style" => [
  242.             "list_style_image",
  243.             "list_style_position",
  244.             "list_style_type"
  245.         ],
  246.         "margin" => [
  247.             "margin_top",
  248.             "margin_right",
  249.             "margin_bottom",
  250.             "margin_left"
  251.         ],
  252.         "padding" => [
  253.             "padding_top",
  254.             "padding_right",
  255.             "padding_bottom",
  256.             "padding_left"
  257.         ],
  258.         "outline" => [
  259.             "outline_width",
  260.             "outline_style",
  261.             "outline_color"
  262.         ]
  263.     ];
  265.     /**
  266.      * Maps legacy property names to actual property names.
  267.      *
  268.      * @var array
  269.      */
  270.     protected static $_props_alias = [
  271.         "word_wrap"                           => "overflow_wrap",
  272.         "_dompdf_background_image_resolution" => "background_image_resolution",
  273.         "_dompdf_image_resolution"            => "image_resolution",
  274.         "_webkit_transform"                   => "transform",
  275.         "_webkit_transform_origin"            => "transform_origin"
  276.     ];
  278.     /**
  279.      * Default style values.
  280.      *
  281.      * @link http://www.w3.org/TR/CSS21/propidx.html
  282.      *
  283.      * @var array
  284.      */
  285.     protected static $_defaults = null;
  287.     /**
  288.      * List of inherited properties
  289.      *
  290.      * @link http://www.w3.org/TR/CSS21/propidx.html
  291.      *
  292.      * @var array
  293.      */
  294.     protected static $_inherited = null;
  296.     /**
  297.      * Caches method_exists result
  298.      *
  299.      * @var array<bool>
  300.      */
  301.     protected static $_methods_cache = [];
  303.     /**
  304.      * The stylesheet this style belongs to
  305.      *
  306.      * @var Stylesheet
  307.      */
  308.     protected $_stylesheet;
  310.     /**
  311.      * Media queries attached to the style
  312.      *
  313.      * @var array
  314.      */
  315.     protected $_media_queries;
  317.     /**
  318.      * Specified (or declared) values of the CSS properties.
  319.      * https://www.w3.org/TR/css-cascade-3/#value-stages
  320.      *
  321.      * @var array
  322.      */
  323.     protected $_props = [];
  325.     /**
  326.      * Properties set by an `!important` declaration.
  327.      *
  328.      * @var array
  329.      */
  330.     protected $_important_props = [];
  332.     /**
  333.      * Computed values of the CSS properties.
  334.      *
  335.      * @var array
  336.      */
  337.     protected $_props_computed = [];
  339.     /**
  340.      * Used values of the CSS properties.
  341.      *
  342.      * @var array
  343.      */
  344.     protected $_prop_cache = [];
  346.     protected static $_dependency_map = [
  347.         "border_top_style" => [
  348.             "border_top_width"
  349.         ],
  350.         "border_bottom_style" => [
  351.             "border_bottom_width"
  352.         ],
  353.         "border_left_style" => [
  354.             "border_left_width"
  355.         ],
  356.         "border_right_style" => [
  357.             "border_right_width"
  358.         ],
  359.         "direction" => [
  360.             "text_align"
  361.         ],
  362.         "font_size" => [
  363.             "background_position",
  364.             "background_size",
  365.             "border_top_width",
  366.             "border_right_width",
  367.             "border_bottom_width",
  368.             "border_left_width",
  369.             "line_height",
  370.             "margin_top",
  371.             "margin_right",
  372.             "margin_bottom",
  373.             "margin_left",
  374.             "outline_width",
  375.             "outline_offset",
  376.             "padding_top",
  377.             "padding_right",
  378.             "padding_bottom",
  379.             "padding_left"
  380.         ],
  381.         "float" => [
  382.             "display"
  383.         ],
  384.         "position" => [
  385.             "display"
  386.         ],
  387.         "outline_style" => [
  388.             "outline_width"
  389.         ]
  390.     ];
  392.     /**
  393.      * Lookup table for dependent properties. Initially computed from the
  394.      * dependency map.
  395.      *
  396.      * @var array
  397.      */
  398.     protected static $_dependent_props = [];
  400.     /**
  401.      * Style of the parent element in document tree.
  402.      *
  403.      * @var Style
  404.      */
  405.     protected $parent_style;
  407.     /**
  408.      * @var Frame
  409.      */
  410.     protected $_frame;
  412.     /**
  413.      * The origin of the style
  414.      *
  415.      * @var int
  416.      */
  417.     protected $_origin = Stylesheet::ORIG_AUTHOR;
  419.     // private members
  420.     /**
  421.      * The computed bottom spacing
  422.      */
  423.     private $_computed_bottom_spacing = null;
  425.     /**
  426.      * @var bool
  427.      */
  428.     private $has_border_radius_cache = null;
  430.     /**
  431.      * @var array
  432.      */
  433.     private $resolved_border_radius = null;
  435.     /**
  436.      * @var FontMetrics
  437.      */
  438.     private $fontMetrics;
  440.     /**
  441.      * Class constructor
  442.      *
  443.      * @param Stylesheet $stylesheet the stylesheet this Style is associated with.
  444.      * @param int $origin
  445.      */
  446.     public function __construct(Stylesheet $stylesheet, $origin = Stylesheet::ORIG_AUTHOR)
  447.     {
  448.         $this->setFontMetrics($stylesheet->getFontMetrics());
  450.         $this->_stylesheet = $stylesheet;
  451.         $this->_media_queries = [];
  452.         $this->_origin = $origin;
  453.         $this->parent_style = null;
  455.         if (!isset(self::$_defaults)) {
  457.             // Shorthand
  458.             $d =& self::$_defaults;
  460.             // All CSS 2.1 properties, and their default values
  461.             $d["azimuth"] = "center";
  462.             $d["background_attachment"] = "scroll";
  463.             $d["background_color"] = "transparent";
  464.             $d["background_image"] = "none";
  465.             $d["background_image_resolution"] = "normal";
  466.             $d["background_position"] = "0% 0%";
  467.             $d["background_repeat"] = "repeat";
  468.             $d["background"] = "";
  469.             $d["border_collapse"] = "separate";
  470.             $d["border_color"] = "";
  471.             $d["border_spacing"] = "0";
  472.             $d["border_style"] = "";
  473.             $d["border_top"] = "";
  474.             $d["border_right"] = "";
  475.             $d["border_bottom"] = "";
  476.             $d["border_left"] = "";
  477.             $d["border_top_color"] = "currentcolor";
  478.             $d["border_right_color"] = "currentcolor";
  479.             $d["border_bottom_color"] = "currentcolor";
  480.             $d["border_left_color"] = "currentcolor";
  481.             $d["border_top_style"] = "none";
  482.             $d["border_right_style"] = "none";
  483.             $d["border_bottom_style"] = "none";
  484.             $d["border_left_style"] = "none";
  485.             $d["border_top_width"] = "medium";
  486.             $d["border_right_width"] = "medium";
  487.             $d["border_bottom_width"] = "medium";
  488.             $d["border_left_width"] = "medium";
  489.             $d["border_width"] = "";
  490.             $d["border_bottom_left_radius"] = "0";
  491.             $d["border_bottom_right_radius"] = "0";
  492.             $d["border_top_left_radius"] = "0";
  493.             $d["border_top_right_radius"] = "0";
  494.             $d["border_radius"] = "";
  495.             $d["border"] = "";
  496.             $d["bottom"] = "auto";
  497.             $d["caption_side"] = "top";
  498.             $d["clear"] = "none";
  499.             $d["clip"] = "auto";
  500.             $d["color"] = "#000000";
  501.             $d["content"] = "normal";
  502.             $d["counter_increment"] = "none";
  503.             $d["counter_reset"] = "none";
  504.             $d["cue_after"] = "none";
  505.             $d["cue_before"] = "none";
  506.             $d["cue"] = "";
  507.             $d["cursor"] = "auto";
  508.             $d["direction"] = "ltr";
  509.             $d["display"] = "inline";
  510.             $d["elevation"] = "level";
  511.             $d["empty_cells"] = "show";
  512.             $d["float"] = "none";
  513.             $d["font_family"] = $stylesheet->get_dompdf()->getOptions()->getDefaultFont();
  514.             $d["font_size"] = "medium";
  515.             $d["font_style"] = "normal";
  516.             $d["font_variant"] = "normal";
  517.             $d["font_weight"] = "normal";
  518.             $d["font"] = "";
  519.             $d["height"] = "auto";
  520.             $d["image_resolution"] = "normal";
  521.             $d["left"] = "auto";
  522.             $d["letter_spacing"] = "normal";
  523.             $d["line_height"] = "normal";
  524.             $d["list_style_image"] = "none";
  525.             $d["list_style_position"] = "outside";
  526.             $d["list_style_type"] = "disc";
  527.             $d["list_style"] = "";
  528.             $d["margin_right"] = "0";
  529.             $d["margin_left"] = "0";
  530.             $d["margin_top"] = "0";
  531.             $d["margin_bottom"] = "0";
  532.             $d["margin"] = "";
  533.             $d["max_height"] = "none";
  534.             $d["max_width"] = "none";
  535.             $d["min_height"] = "auto";
  536.             $d["min_width"] = "auto";
  537.             $d["orphans"] = "2";
  538.             $d["outline_color"] = "currentcolor"; // "invert" special color is not supported
  539.             $d["outline_style"] = "none";
  540.             $d["outline_width"] = "medium";
  541.             $d["outline_offset"] = "0";
  542.             $d["outline"] = "";
  543.             $d["overflow"] = "visible";
  544.             $d["overflow_wrap"] = "normal";
  545.             $d["padding_top"] = "0";
  546.             $d["padding_right"] = "0";
  547.             $d["padding_bottom"] = "0";
  548.             $d["padding_left"] = "0";
  549.             $d["padding"] = "";
  550.             $d["page_break_after"] = "auto";
  551.             $d["page_break_before"] = "auto";
  552.             $d["page_break_inside"] = "auto";
  553.             $d["pause_after"] = "0";
  554.             $d["pause_before"] = "0";
  555.             $d["pause"] = "";
  556.             $d["pitch_range"] = "50";
  557.             $d["pitch"] = "medium";
  558.             $d["play_during"] = "auto";
  559.             $d["position"] = "static";
  560.             $d["quotes"] = "auto";
  561.             $d["richness"] = "50";
  562.             $d["right"] = "auto";
  563.             $d["size"] = "auto"; // @page
  564.             $d["speak_header"] = "once";
  565.             $d["speak_numeral"] = "continuous";
  566.             $d["speak_punctuation"] = "none";
  567.             $d["speak"] = "normal";
  568.             $d["speech_rate"] = "medium";
  569.             $d["stress"] = "50";
  570.             $d["table_layout"] = "auto";
  571.             $d["text_align"] = "";
  572.             $d["text_decoration"] = "none";
  573.             $d["text_indent"] = "0";
  574.             $d["text_transform"] = "none";
  575.             $d["top"] = "auto";
  576.             $d["unicode_bidi"] = "normal";
  577.             $d["vertical_align"] = "baseline";
  578.             $d["visibility"] = "visible";
  579.             $d["voice_family"] = "";
  580.             $d["volume"] = "medium";
  581.             $d["white_space"] = "normal";
  582.             $d["widows"] = "2";
  583.             $d["width"] = "auto";
  584.             $d["word_spacing"] = "normal";
  585.             $d["z_index"] = "auto";
  587.             // CSS3
  588.             $d["opacity"] = "1.0";
  589.             $d["background_size"] = "auto auto";
  590.             $d["transform"] = "none";
  591.             $d["transform_origin"] = "50% 50%";
  593.             // for @font-face
  594.             $d["src"] = "";
  595.             $d["unicode_range"] = "";
  597.             // vendor-prefixed properties
  598.             $d["_dompdf_keep"] = "";
  600.             // Properties that inherit by default
  601.             self::$_inherited = [
  602.                 "azimuth",
  603.                 "background_image_resolution",
  604.                 "border_collapse",
  605.                 "border_spacing",
  606.                 "caption_side",
  607.                 "color",
  608.                 "cursor",
  609.                 "direction",
  610.                 "elevation",
  611.                 "empty_cells",
  612.                 "font_family",
  613.                 "font_size",
  614.                 "font_style",
  615.                 "font_variant",
  616.                 "font_weight",
  617.                 "font",
  618.                 "image_resolution",
  619.                 "letter_spacing",
  620.                 "line_height",
  621.                 "list_style_image",
  622.                 "list_style_position",
  623.                 "list_style_type",
  624.                 "list_style",
  625.                 "orphans",
  626.                 "overflow_wrap",
  627.                 "pitch_range",
  628.                 "pitch",
  629.                 "quotes",
  630.                 "richness",
  631.                 "speak_header",
  632.                 "speak_numeral",
  633.                 "speak_punctuation",
  634.                 "speak",
  635.                 "speech_rate",
  636.                 "stress",
  637.                 "text_align",
  638.                 "text_indent",
  639.                 "text_transform",
  640.                 "visibility",
  641.                 "voice_family",
  642.                 "volume",
  643.                 "white_space",
  644.                 "widows",
  645.                 "word_spacing",
  646.             ];
  648.             // Compute dependent props from dependency map
  649.             foreach (self::$_dependency_map as $props) {
  650.                 foreach ($props as $prop) {
  651.                     self::$_dependent_props[$prop] = true;
  652.                 }
  653.             }
  655.             // Compute valid display-type lookup table
  656.             self::$valid_display_types = [
  657.                 "none"                => true,
  658.                 "-dompdf-br"          => true,
  659.                 "-dompdf-image"       => true,
  660.                 "-dompdf-list-bullet" => true,
  661.                 "-dompdf-page"        => true
  662.             ];
  663.             foreach (self::BLOCK_LEVEL_TYPES as $val) {
  664.                 self::$valid_display_types[$val] = true;
  665.             }
  666.             foreach (self::INLINE_LEVEL_TYPES as $val) {
  667.                 self::$valid_display_types[$val] = true;
  668.             }
  669.             foreach (self::TABLE_INTERNAL_TYPES as $val) {
  670.                 self::$valid_display_types[$val] = true;
  671.             }
  672.         }
  673.     }
  675.     /**
  676.      * "Destructor": forcibly free all references held by this object
  677.      */
  678.     function dispose()
  679.     {
  680.     }
  682.     /**
  683.      * @param $media_queries
  684.      */
  685.     function set_media_queries($media_queries)
  686.     {
  687.         $this->_media_queries = $media_queries;
  688.     }
  690.     /**
  691.      * @return array|int
  692.      */
  693.     function get_media_queries()
  694.     {
  695.         return $this->_media_queries;
  696.     }
  698.     /**
  699.      * @param Frame $frame
  700.      */
  701.     function set_frame(Frame $frame)
  702.     {
  703.         $this->_frame = $frame;
  704.     }
  706.     /**
  707.      * @return Frame
  708.      */
  709.     function get_frame()
  710.     {
  711.         return $this->_frame;
  712.     }
  714.     /**
  715.      * @param $origin
  716.      */
  717.     function set_origin($origin)
  718.     {
  719.         $this->_origin = $origin;
  720.     }
  722.     /**
  723.      * @return int
  724.      */
  725.     function get_origin()
  726.     {
  727.         return $this->_origin;
  728.     }
  730.     /**
  731.      * returns the {@link Stylesheet} this Style is associated with.
  732.      *
  733.      * @return Stylesheet
  734.      */
  735.     function get_stylesheet()
  736.     {
  737.         return $this->_stylesheet;
  738.     }
  740.     public function is_absolute(): bool
  741.     {
  742.         $position = $this->__get("position");
  743.         return $position === "absolute" || $position === "fixed";
  744.     }
  746.     public function is_in_flow(): bool
  747.     {
  748.         $float = $this->__get("float");
  749.         return $float === "none" && !$this->is_absolute();
  750.     }
  752.     /**
  753.      * Converts any CSS length value into an absolute length in points.
  754.      *
  755.      * length_in_pt() takes a single length (e.g. '1em') or an array of
  756.      * lengths and returns an absolute length.  If an array is passed, then
  757.      * the return value is the sum of all elements. If any of the lengths
  758.      * provided are "auto" or "none" then that value is returned.
  759.      *
  760.      * If a reference size is not provided, the current font size is used.
  761.      *
  762.      * @param float|string|array $length   The numeric length (or string measurement) or array of lengths to resolve.
  763.      * @param float|null         $ref_size An absolute reference size to resolve percentage lengths.
  764.      *
  765.      * @return float|string
  766.      */
  767.     function length_in_pt($length, ?float $ref_size = null)
  768.     {
  769.         $font_size = $this->__get("font_size");
  770.         $ref_size = $ref_size ?? $font_size;
  772.         if (!is_array($length)) {
  773.             $length = [$length];
  774.         }
  776.         $ret = 0.0;
  778.         foreach ($length as $l) {
  779.             if ($l === "auto" || $l === "none") {
  780.                 return $l;
  781.             }
  783.             // Assume numeric values are already in points
  784.             if (is_numeric($l)) {
  785.                 $ret += (float) $l;
  786.                 continue;
  787.             }
  789.             $val = $this->single_length_in_pt((string) $l, $ref_size, $font_size);
  791.             // FIXME: Using the ref size as fallback here currently ensures that
  792.             // invalid widths or heights are treated as the corresponding
  793.             // containing-block dimension, which can look like the declaration
  794.             // is being ignored. Implement proper compute methods instead, and
  795.             // fall back to 0 here
  796.             $ret += $val ?? $ref_size;
  797.         }
  799.         return $ret;
  800.     }
  802.     /**
  803.      * Convert a length declaration to pt.
  804.      *
  805.      * @param string     $l         The length declaration.
  806.      * @param float      $ref_size  Reference size for percentage declarations.
  807.      * @param float|null $font_size Font size for resolving font-size relative units.
  808.      *
  809.      * @return float|null The length in pt, or `null` for invalid declarations.
  810.      */
  811.     protected function single_length_in_pt(string $l, float $ref_size = 0, ?float $font_size = null): ?float
  812.     {
  813.         static $cache = [];
  815.         $font_size = $font_size ?? $this->__get("font_size");
  817.         $key = "$l/$ref_size/$font_size";
  819.         if (isset($cache[$key])) {
  820.             return $cache[$key];
  821.         }
  823.         if (is_numeric($l)) {
  824.             // Legacy support for unitless values, not covered by spec. Might
  825.             // want to restrict this to unitless `0` in the future
  826.             $value = (float) $l;
  827.         }
  829.         elseif (($i = mb_stripos($l, "%")) !== false) {
  830.             $value = (float)mb_substr($l, 0, $i) / 100 * $ref_size;
  831.         }
  833.         elseif (($i = mb_stripos($l, "px")) !== false) {
  834.             $dpi = $this->_stylesheet->get_dompdf()->getOptions()->getDpi();
  835.             $value = ((float)mb_substr($l, 0, $i) * 72) / $dpi;
  836.         }
  838.         elseif (($i = mb_stripos($l, "pt")) !== false) {
  839.             $value = (float)mb_substr($l, 0, $i);
  840.         }
  842.         elseif (($i = mb_stripos($l, "rem")) !== false) {
  843.             $root_style = $this->_stylesheet->get_dompdf()->getTree()->get_root()->get_style();
  844.             $root_font_size = $root_style === null || $root_style === $this
  845.                 ? $font_size
  846.                 : $root_style->font_size;
  847.             $value = (float)mb_substr($l, 0, $i) * $root_font_size;
  848.         }
  850.         elseif (($i = mb_stripos($l, "em")) !== false) {
  851.             $value = (float)mb_substr($l, 0, $i) * $font_size;
  852.         }
  854.         elseif (($i = mb_stripos($l, "cm")) !== false) {
  855.             $value = (float)mb_substr($l, 0, $i) * 72 / 2.54;
  856.         }
  858.         elseif (($i = mb_stripos($l, "mm")) !== false) {
  859.             $value = (float)mb_substr($l, 0, $i) * 72 / 25.4;
  860.         }
  862.         elseif (($i = mb_stripos($l, "ex")) !== false) {
  863.             // FIXME: em:ex ratio?
  864.             $value = (float)mb_substr($l, 0, $i) * $font_size / 2;
  865.         }
  867.         elseif (($i = mb_stripos($l, "in")) !== false) {
  868.             $value = (float)mb_substr($l, 0, $i) * 72;
  869.         }
  871.         elseif (($i = mb_stripos($l, "pc")) !== false) {
  872.             $value = (float)mb_substr($l, 0, $i) * 12;
  873.         }
  875.         else {
  876.             // Invalid or unsupported declaration
  877.             $value = null;
  878.         }
  880.         return $cache[$key] = $value;
  881.     }
  884.     /**
  885.      * Resolve inherited property values using the provided parent style or the
  886.      * default values, in case no parent style exists.
  887.      *
  888.      * https://www.w3.org/TR/css-cascade-3/#inheriting
  889.      *
  890.      * @param Style|null $parent
  891.      *
  892.      * @return Style
  893.      */
  894.     function inherit(?Style $parent = null)
  895.     {
  896.         $this->parent_style = $parent;
  898.         // Clear the computed font size, as it might depend on the parent
  899.         // font size
  900.         unset($this->_props_computed["font_size"]);
  901.         unset($this->_prop_cache["font_size"]);
  903.         if ($parent) {
  904.             foreach (self::$_inherited as $prop) {
  905.                 // For properties that inherit by default: When the cascade did
  906.                 // not result in a value, inherit the parent value. Inheritance
  907.                 // is handled via the specific sub-properties for shorthands
  908.                 if (isset($this->_props[$prop]) || isset(self::$_props_shorthand[$prop])) {
  909.                     continue;
  910.                 }
  911.     
  912.                 if (isset($parent->_props[$prop])) {
  913.                     $parent_val = \array_key_exists($prop, $parent->_props_computed)
  914.                         ? $parent->_props_computed[$prop]
  915.                         : $parent->compute_prop($prop, $parent->_props[$prop]);
  916.     
  917.                     $this->_props[$prop] = $parent_val;
  918.                     $this->_props_computed[$prop] = $parent_val;
  919.                     $this->_prop_cache[$prop] = null;
  920.                 }
  921.             }
  922.         }
  924.         foreach ($this->_props as $prop => $val) {
  925.             if ($val === "inherit") {
  926.                 if ($parent && isset($parent->_props[$prop])) {
  927.                     $parent_val = \array_key_exists($prop, $parent->_props_computed)
  928.                         ? $parent->_props_computed[$prop]
  929.                         : $parent->compute_prop($prop, $parent->_props[$prop]);
  931.                     $this->_props[$prop] = $parent_val;
  932.                     $this->_props_computed[$prop] = $parent_val;
  933.                     $this->_prop_cache[$prop] = null;
  934.                 } else {
  935.                     // Parent prop not set, use default
  936.                     $this->_props[$prop] = self::$_defaults[$prop];
  937.                     unset($this->_props_computed[$prop]);
  938.                     unset($this->_prop_cache[$prop]);
  939.                 }
  940.             }
  941.         }
  943.         return $this;
  944.     }
  946.     /**
  947.      * Override properties in this style with those in $style
  948.      *
  949.      * @param Style $style
  950.      */
  951.     function merge(Style $style)
  952.     {
  953.         foreach ($style->_props as $prop => $val) {
  954.             $important = isset($style->_important_props[$prop]);
  956.             // `!important` declarations take precedence over normal ones
  957.             if (!$important && isset($this->_important_props[$prop])) {
  958.                 continue;
  959.             }
  961.             $computed = \array_key_exists($prop, $style->_props_computed)
  962.                 ? $style->_props_computed[$prop]
  963.                 : $style->compute_prop($prop, $val);
  965.             // Skip invalid declarations. Because styles are merged into an
  966.             // initially empty style object during stylesheet loading, this
  967.             // handles all invalid declarations
  968.             if ($computed === null) {
  969.                 continue;
  970.             }
  972.             if ($important) {
  973.                 $this->_important_props[$prop] = true;
  974.             }
  976.             $this->_props[$prop] = $val;
  978.             // Don't use the computed value for dependent properties; they will
  979.             // be computed on-demand during inheritance or property access
  980.             // instead
  981.             if (isset(self::$_dependent_props[$prop])) {
  982.                 unset($this->_props_computed[$prop]);
  983.                 unset($this->_prop_cache[$prop]);
  984.             } else {
  985.                 $this->_props_computed[$prop] = $computed;
  986.                 $this->_prop_cache[$prop] = null;
  987.             }
  988.         }
  989.     }
  991.     /**
  992.      * Returns an array(r, g, b, "r"=> r, "g"=>g, "b"=>b, "alpha"=>alpha, "hex"=>"#rrggbb")
  993.      * based on the provided CSS color value.
  994.      *
  995.      * @param string $color
  996.      * @return array|string|null
  997.      */
  998.     function munge_color($color)
  999.     {
  1000.         return Color::parse($color);
  1001.     }
  1003.     /**
  1004.      * @deprecated
  1005.      * @param string $prop
  1006.      */
  1007.     function important_set($prop)
  1008.     {
  1009.         $prop = str_replace("-", "_", $prop);
  1010.         $this->_important_props[$prop] = true;
  1011.     }
  1013.     /**
  1014.      * @deprecated
  1015.      * @param string $prop
  1016.      * @return bool
  1017.      */
  1018.     function important_get($prop)
  1019.     {
  1020.         return isset($this->_important_props[$prop]);
  1021.     }
  1023.     /**
  1024.      * Clear information about important declarations after the style has been
  1025.      * finalized during stylesheet loading.
  1026.      */
  1027.     public function clear_important(): void
  1028.     {
  1029.         $this->_important_props = [];
  1030.     }
  1032.     /**
  1033.      * Set the specified value of a property.
  1034.      *
  1035.      * Setting `$clear_dependencies` to `false` is useful for saving a bit of
  1036.      * unnecessary work while loading stylesheets.
  1037.      *
  1038.      * @param string $prop               The property to set.
  1039.      * @param mixed  $val                The value declaration.
  1040.      * @param bool   $important          Whether the declaration is important.
  1041.      * @param bool   $clear_dependencies Whether to clear computed values of dependent properties.
  1042.      */
  1043.     function set_prop(string $prop, $val, bool $important = false, bool $clear_dependencies = true): void
  1044.     {
  1045.         $prop = str_replace("-", "_", $prop);
  1047.         // Legacy property aliases
  1048.         if (isset(self::$_props_alias[$prop])) {
  1049.             $prop = self::$_props_alias[$prop];
  1050.         }
  1052.         if (!isset(self::$_defaults[$prop])) {
  1053.             global $_dompdf_warnings;
  1054.             $_dompdf_warnings[] = "'$prop' is not a recognized CSS property.";
  1055.             return;
  1056.         }
  1058.         if ($prop !== "content" && is_string($val) && mb_strpos($val, "url") === false && strlen($val) > 1) {
  1059.             $val = mb_strtolower(trim(str_replace(["\n", "\t"], [" "], $val)));
  1060.             $val = preg_replace("/([0-9]+) (pt|px|pc|rem|em|ex|in|cm|mm|%)/S", "\\1\\2", $val);
  1061.         }
  1063.         if (isset(self::$_props_shorthand[$prop])) {
  1064.             // Shorthand properties directly set their respective sub-properties
  1065.             // https://www.w3.org/TR/css-cascade-3/#shorthand
  1066.             if ($val === "initial" || $val === "inherit" || $val === "unset") {
  1067.                 foreach (self::$_props_shorthand[$prop] as $sub_prop) {
  1068.                     $this->set_prop($sub_prop, $val, $important, $clear_dependencies);
  1069.                 }
  1070.             } else {
  1071.                 $method = "set_$prop";
  1072.     
  1073.                 if (!isset(self::$_methods_cache[$method])) {
  1074.                     self::$_methods_cache[$method] = method_exists($this, $method);
  1075.                 }
  1076.     
  1077.                 if (self::$_methods_cache[$method]) {
  1078.                     $this->$method($val, $important);
  1079.                 }
  1080.             }
  1081.         } else {
  1082.             // `!important` declarations take precedence over normal ones
  1083.             if (!$important && isset($this->_important_props[$prop])) {
  1084.                 return;
  1085.             }
  1087.             if ($important) {
  1088.                 $this->_important_props[$prop] = true;
  1089.             }
  1091.             // https://www.w3.org/TR/css-cascade-3/#inherit-initial
  1092.             if ($val === "unset") {
  1093.                 $val = in_array($prop, self::$_inherited, true)
  1094.                     ? "inherit"
  1095.                     : "initial";
  1096.             }
  1098.             // https://www.w3.org/TR/css-cascade-3/#valdef-all-initial
  1099.             if ($val === "initial") {
  1100.                 $val = self::$_defaults[$prop];
  1101.             }
  1103.             $this->_props[$prop] = $val;
  1104.             unset($this->_props_computed[$prop]);
  1105.             unset($this->_prop_cache[$prop]);
  1107.             if ($clear_dependencies) {
  1108.                 // Clear the computed values of any dependent properties, so
  1109.                 // they can be re-computed
  1110.                 if (isset(self::$_dependency_map[$prop])) {
  1111.                     foreach (self::$_dependency_map[$prop] as $dependent) {
  1112.                         unset($this->_props_computed[$dependent]);
  1113.                         unset($this->_prop_cache[$dependent]);
  1114.                     }
  1115.                 }
  1117.                 // Clear border-radius cache on setting any border-radius
  1118.                 // property
  1119.                 if ($prop === "border_top_left_radius"
  1120.                     || $prop === "border_top_right_radius"
  1121.                     || $prop === "border_bottom_left_radius"
  1122.                     || $prop === "border_bottom_right_radius"
  1123.                 ) {
  1124.                     $this->has_border_radius_cache = null;
  1125.                 }
  1126.             }
  1128.             // FIXME: temporary hack around lack of persistence of base href for
  1129.             // URLs. Compute value immediately, before the original base href is
  1130.             // no longer available
  1131.             if ($prop === "background_image" || $prop === "list_style_image") {
  1132.                 $this->compute_prop($prop, $val);
  1133.             }
  1134.         }
  1135.     }
  1137.     /**
  1138.      * Similar to __get() without storing the result. Useful for accessing
  1139.      * properties while loading stylesheets.
  1140.      *
  1141.      * @param string $prop
  1142.      *
  1143.      * @return mixed
  1144.      * @throws Exception
  1145.      */
  1146.     function get_prop(string $prop)
  1147.     {
  1148.         // Legacy property aliases
  1149.         if (isset(self::$_props_alias[$prop])) {
  1150.             $prop = self::$_props_alias[$prop];
  1151.         }
  1153.         if (!isset(self::$_defaults[$prop])) {
  1154.             throw new Exception("'$prop' is not a recognized CSS property.");
  1155.         }
  1157.         $method = "get_$prop";
  1159.         if (isset($this->_props_computed[$prop])) {
  1160.             if (method_exists($this, $method)) {
  1161.                 return $this->$method();
  1162.             }
  1164.             return $this->_props_computed[$prop];
  1165.         }
  1167.         // Fall back on defaults if property is not set
  1168.         return $this->_props[$prop] ?? self::$_defaults[$prop];
  1169.     }
  1171.     /**
  1172.      * PHP5 overloaded setter
  1173.      *
  1174.      * This function along with {@link Style::__get()} permit a user of the
  1175.      * Style class to access any (CSS) property using the following syntax:
  1176.      * <code>
  1177.      *  Style->margin_top = "1em";
  1178.      *  echo (Style->margin_top);
  1179.      * </code>
  1180.      *
  1181.      * __set() automatically calls the provided set function, if one exists,
  1182.      * otherwise it sets the property directly.  Typically, __set() is not
  1183.      * called directly from outside of this class.
  1184.      *
  1185.      * On each modification clear cache to return accurate setting.
  1186.      * Also affects direct settings not using __set
  1187.      * For easier finding all assignments, attempted to allowing only explicite assignment:
  1188.      * Very many uses, e.g. AbstractFrameReflower.php -> for now leave as it is
  1189.      * function __set($prop, $val) {
  1190.      *   throw new Exception("Implicit replacement of assignment by __set.  Not good.");
  1191.      * }
  1192.      * function props_set($prop, $val) { ... }
  1193.      *
  1194.      * @param string $prop the property to set
  1195.      * @param mixed $val the value of the property
  1196.      *
  1197.      */
  1198.     function __set($prop, $val)
  1199.     {
  1200.         $this->set_prop($prop, $val);
  1201.     }
  1203.     /**
  1204.      * PHP5 overloaded getter
  1205.      * Along with {@link Style::__set()} __get() provides access to all CSS
  1206.      * properties directly.  Typically __get() is not called directly outside
  1207.      * of this class.
  1208.      * On each modification clear cache to return accurate setting.
  1209.      * Also affects direct settings not using __set
  1210.      *
  1211.      * @param string $prop
  1212.      *
  1213.      * @return mixed
  1214.      * @throws Exception
  1215.      */
  1216.     function __get($prop)
  1217.     {
  1218.         // Legacy property aliases
  1219.         if (isset(self::$_props_alias[$prop])) {
  1220.             $prop = self::$_props_alias[$prop];
  1221.         }
  1223.         if (!isset(self::$_defaults[$prop])) {
  1224.             throw new Exception("'$prop' is not a recognized CSS property.");
  1225.         }
  1227.         if (isset($this->_prop_cache[$prop])) {
  1228.             return $this->_prop_cache[$prop];
  1229.         }
  1231.         $method = "get_$prop";
  1232.     
  1233.         if (!isset(self::$_methods_cache[$method])) {
  1234.             self::$_methods_cache[$method] = method_exists($this, $method);
  1235.         }
  1237.         if (isset(self::$_props_shorthand[$prop])) {
  1238.             // Don't cache shorthand values, always use getter. If no dedicated
  1239.             // getter exists, use a simple fallback getter concatenating all
  1240.             // sub-property values
  1241.             if (self::$_methods_cache[$method]) {
  1242.                 return $this->$method();
  1243.             } else {
  1244.                 return implode(" ", array_map(function ($sub_prop) {
  1245.                     $val = $this->__get($sub_prop);
  1246.                     return is_array($val) ? implode(" ", $val) : $val;
  1247.                 }, self::$_props_shorthand[$prop]));
  1248.             }
  1249.         } else {
  1250.             // Compute the value if needed
  1251.             if (!\array_key_exists($prop, $this->_props_computed)) {
  1252.                 $val = $this->_props[$prop] ?? self::$_defaults[$prop];
  1253.                 $this->compute_prop($prop, $val);
  1254.             }
  1256.             // Invalid declarations are skipped on style merge, but during
  1257.             // style parsing, styles might contain invalid declarations. Fall
  1258.             // back to the default value in that case
  1259.             $computed = $this->_props_computed[$prop]
  1260.                 ?? $this->compute_prop($prop, self::$_defaults[$prop]);
  1261.             $used = self::$_methods_cache[$method]
  1262.                 ? $this->$method()
  1263.                 : $computed;
  1265.             $this->_prop_cache[$prop] = $used;
  1266.             return $used;
  1267.         }
  1268.     }
  1270.     /**
  1271.      * Experimental fast setter for used values.
  1272.      *
  1273.      * If a shorthand property is specified, all of its sub-properties are set
  1274.      * to the same value.
  1275.      *
  1276.      * @param string $prop
  1277.      * @param mixed  $val
  1278.      */
  1279.     function set_used(string $prop, $val): void
  1280.     {
  1281.         // Legacy property aliases
  1282.         if (isset(self::$_props_alias[$prop])) {
  1283.             $prop = self::$_props_alias[$prop];
  1284.         }
  1286.         if (!isset(self::$_defaults[$prop])) {
  1287.             throw new Exception("'$prop' is not a recognized CSS property.");
  1288.         }
  1290.         if (isset(self::$_props_shorthand[$prop])) {
  1291.             foreach (self::$_props_shorthand[$prop] as $sub_prop) {
  1292.                 $this->set_used($sub_prop, $val);
  1293.             }
  1294.         } else {
  1295.             $this->_prop_cache[$prop] = $val;
  1296.         }
  1297.     }
  1299.     /**
  1300.      * @param string $prop The property to compute.
  1301.      * @param mixed  $val  The value to compute.
  1302.      *
  1303.      * @return mixed The computed value.
  1304.      */
  1305.     protected function compute_prop(string $prop, $val)
  1306.     {
  1307.         $this->_props_computed[$prop] = null;
  1308.         $this->_prop_cache[$prop] = null;
  1310.         $method = "set_$prop";
  1312.         if (!isset(self::$_methods_cache[$method])) {
  1313.             self::$_methods_cache[$method] = method_exists($this, $method);
  1314.         }
  1316.         // During style merge, the parent style is not available yet, so
  1317.         // temporarily use the initial value for `inherit` properties. The
  1318.         // keyword is properly resolved during inheritance
  1319.         if ($val === "inherit") {
  1320.             $val = self::$_defaults[$prop];
  1321.         }
  1323.         if (self::$_methods_cache[$method]) {
  1324.             $this->$method($val);
  1325.         } elseif ($val !== "") {
  1326.             $this->_props_computed[$prop] = $val;
  1327.         }
  1329.         return $this->_props_computed[$prop];
  1330.     }
  1332.     /**
  1333.      * @param float $cbw The width of the containing block.
  1334.      * @return float|null|string
  1335.      */
  1336.     function computed_bottom_spacing(float $cbw)
  1337.     {
  1338.         // Caching the bottom spacing independently of the given width is a bit
  1339.         // iffy, but should be okay, as the containing block should only
  1340.         // potentially change after a page break, and the style is reset in that
  1341.         // case
  1342.         if ($this->_computed_bottom_spacing !== null) {
  1343.             return $this->_computed_bottom_spacing;
  1344.         }
  1345.         return $this->_computed_bottom_spacing = $this->length_in_pt(
  1346.             [
  1347.                 $this->margin_bottom,
  1348.                 $this->padding_bottom,
  1349.                 $this->border_bottom_width
  1350.             ],
  1351.             $cbw
  1352.         );
  1353.     }
  1355.     /**
  1356.      * @return string
  1357.      */
  1358.     function get_font_family_raw()
  1359.     {
  1360.         return trim($this->_props["font_family"], " \t\n\r\x0B\"'");
  1361.     }
  1363.     /**
  1364.      * Getter for the 'font-family' CSS property.
  1365.      * Uses the {@link FontMetrics} class to resolve the font family into an
  1366.      * actual font file.
  1367.      *
  1368.      * @link http://www.w3.org/TR/CSS21/fonts.html#propdef-font-family
  1369.      * @throws Exception
  1370.      *
  1371.      * @return string
  1372.      */
  1373.     function get_font_family()
  1374.     {
  1375.         //TODO: we should be using the calculated prop rather than perform the entire family parsing operation again
  1377.         $DEBUGCSS = $this->_stylesheet->get_dompdf()->getOptions()->getDebugCss();
  1379.         // Select the appropriate font.  First determine the subtype, then check
  1380.         // the specified font-families for a candidate.
  1382.         // Resolve font-weight
  1383.         $weight = $this->__get("font_weight");
  1384.         if ($weight === 'bold') {
  1385.             $weight = 700;
  1386.         } elseif (preg_match('/^[0-9]+$/', $weight, $match)) {
  1387.             $weight = (int)$match[0];
  1388.         } else {
  1389.             $weight = 400;
  1390.         }
  1392.         // Resolve font-style
  1393.         $font_style = $this->__get("font_style");
  1394.         $subtype = $this->getFontMetrics()->getType($weight . ' ' . $font_style);
  1396.         $families = preg_split("/\s*,\s*/", $this->_props_computed["font_family"]);
  1398.         $font = null;
  1399.         foreach ($families as $family) {
  1400.             //remove leading and trailing string delimiters, e.g. on font names with spaces;
  1401.             //remove leading and trailing whitespace
  1402.             $family = trim($family, " \t\n\r\x0B\"'");
  1403.             if ($DEBUGCSS) {
  1404.                 print '(' . $family . ')';
  1405.             }
  1406.             $font = $this->getFontMetrics()->getFont($family, $subtype);
  1408.             if ($font) {
  1409.                 if ($DEBUGCSS) {
  1410.                     print "<pre>[get_font_family:";
  1411.                     print '(' . $this->_props_computed["font_family"] . '.' . $font_style . '.' . $weight . '.' . $subtype . ')';
  1412.                     print '(' . $font . ")get_font_family]\n</pre>";
  1413.                 }
  1414.                 return $font;
  1415.             }
  1416.         }
  1418.         $family = null;
  1419.         if ($DEBUGCSS) {
  1420.             print '(default)';
  1421.         }
  1422.         $font = $this->getFontMetrics()->getFont($family, $subtype);
  1424.         if ($font) {
  1425.             if ($DEBUGCSS) {
  1426.                 print '(' . $font . ")get_font_family]\n</pre>";
  1427.             }
  1428.             return $font;
  1429.         }
  1431.         throw new Exception("Unable to find a suitable font replacement for: '" . $this->_props_computed["font_family"] . "'");
  1432.     }
  1434.     /**
  1435.      * @link http://www.w3.org/TR/CSS21/text.html#propdef-word-spacing
  1436.      * @return float
  1437.      */
  1438.     function get_word_spacing()
  1439.     {
  1440.         $word_spacing = $this->_props_computed["word_spacing"];
  1442.         if ($word_spacing === "normal") {
  1443.             return 0;
  1444.         }
  1446.         if (strpos($word_spacing, "%") !== false) {
  1447.             return $word_spacing;
  1448.         }
  1450.         return (float)$this->length_in_pt($word_spacing, $this->__get("font_size"));
  1451.     }
  1453.     /**
  1454.      * @link http://www.w3.org/TR/CSS21/text.html#propdef-letter-spacing
  1455.      * @return float
  1456.      */
  1457.     function get_letter_spacing()
  1458.     {
  1459.         $letter_spacing = $this->_props_computed["letter_spacing"];
  1461.         if ($letter_spacing === "normal") {
  1462.             return 0;
  1463.         }
  1465.         return (float)$this->length_in_pt($letter_spacing, $this->__get("font_size"));
  1466.     }
  1468.     /**
  1469.      * @link http://www.w3.org/TR/CSS21/visudet.html#propdef-line-height
  1470.      * @return float
  1471.      */
  1472.     function get_line_height()
  1473.     {
  1474.         $line_height = $this->_props_computed["line_height"];
  1476.         if ($line_height === "normal") {
  1477.             return self::$default_line_height * $this->__get("font_size");
  1478.         }
  1480.         if (is_numeric($line_height)) {
  1481.             return $line_height * $this->__get("font_size");
  1482.         }
  1484.         return (float)$this->length_in_pt($line_height, $this->__get("font_size"));
  1485.     }
  1487.     /**
  1488.      * @param string $prop
  1489.      * @param bool $current_is_parent
  1490.      * @return array|string
  1491.      */
  1492.     protected function get_prop_color(string $prop, bool $current_is_parent = false)
  1493.     {
  1494.         $val = $this->_props_computed[$prop];
  1496.         if ($val === "currentcolor") {
  1497.             // https://www.w3.org/TR/css-color-4/#resolving-other-colors
  1498.             if ($current_is_parent) {
  1499.                 // Use the `color` value from the parent for the `color`
  1500.                 // property itself
  1501.                 return isset($this->parent_style)
  1502.                     ? $this->parent_style->__get("color")
  1503.                     : $this->munge_color(self::$_defaults[$prop]);
  1504.             }
  1506.             return $this->__get("color");
  1507.         }
  1509.         return $this->munge_color($val) ?? "transparent";
  1510.     }
  1512.     /**
  1513.      * Returns the color as an array
  1514.      *
  1515.      * The array has the following format:
  1516.      * <code>array(r,g,b, "r" => r, "g" => g, "b" => b, "hex" => "#rrggbb")</code>
  1517.      *
  1518.      * @link http://www.w3.org/TR/CSS21/colors.html#propdef-color
  1519.      * @return array
  1520.      */
  1521.     function get_color()
  1522.     {
  1523.         return $this->get_prop_color("color", true);
  1524.     }
  1526.     /**
  1527.      * Returns the background color as an array
  1528.      *
  1529.      * The returned array has the same format as {@link Style::get_color()}
  1530.      *
  1531.      * @link http://www.w3.org/TR/CSS21/colors.html#propdef-background-color
  1532.      * @return array
  1533.      */
  1534.     function get_background_color()
  1535.     {
  1536.         return $this->get_prop_color("background_color");
  1537.     }
  1539.     /**
  1540.      * Returns the background image URI, or "none"
  1541.      *
  1542.      * @link https://www.w3.org/TR/CSS21/colors.html#propdef-background-image
  1543.      * @return string
  1544.      */
  1545.     function get_background_image()
  1546.     {
  1547.         return $this->_stylesheet->resolve_url($this->_props_computed["background_image"]);
  1548.     }
  1550.     /**
  1551.      * Returns the background position as an array
  1552.      *
  1553.      * The returned array has the following format:
  1554.      * <code>array(x,y, "x" => x, "y" => y)</code>
  1555.      *
  1556.      * @link http://www.w3.org/TR/CSS21/colors.html#propdef-background-position
  1557.      * @return array
  1558.      */
  1559.     function get_background_position()
  1560.     {
  1561.         $tmp = explode(" ", $this->_props_computed["background_position"]);
  1563.         return [
  1564.             0 => $tmp[0], "x" => $tmp[0],
  1565.             1 => $tmp[1], "y" => $tmp[1],
  1566.         ];
  1567.     }
  1570.     /**
  1571.      * Returns the background size as an array
  1572.      *
  1573.      * The return value has one of the following formats:
  1574.      * <code>"cover"</code>
  1575.      * <code>"contain"</code>
  1576.      * <code>array(width,height)</code>
  1577.      *
  1578.      * @link https://www.w3.org/TR/css3-background/#background-size
  1579.      * @return string|array
  1580.      */
  1581.     function get_background_size()
  1582.     {
  1583.         switch ($this->_props_computed["background_size"]) {
  1584.             case "cover":
  1585.                 return "cover";
  1586.             case "contain":
  1587.                 return "contain";
  1588.             default:
  1589.                 break;
  1590.         }
  1592.         $result = explode(" ", $this->_props_computed["background_size"]);
  1593.         return [$result[0], $result[1]];
  1594.     }
  1596.     /**#@+
  1597.      * Returns the border color as an array
  1598.      *
  1599.      * See {@link Style::get_color()}
  1600.      *
  1601.      * @link http://www.w3.org/TR/CSS21/box.html#border-color-properties
  1602.      * @return array
  1603.      */
  1604.     function get_border_top_color()
  1605.     {
  1606.         return $this->get_prop_color("border_top_color");
  1607.     }
  1609.     /**
  1610.      * @return array
  1611.      */
  1612.     function get_border_right_color()
  1613.     {
  1614.         return $this->get_prop_color("border_right_color");
  1615.     }
  1617.     /**
  1618.      * @return array
  1619.      */
  1620.     function get_border_bottom_color()
  1621.     {
  1622.         return $this->get_prop_color("border_bottom_color");
  1623.     }
  1625.     /**
  1626.      * @return array
  1627.      */
  1628.     function get_border_left_color()
  1629.     {
  1630.         return $this->get_prop_color("border_left_color");
  1631.     }
  1633.     /**#@-*/
  1635.     /**
  1636.      * Return an array of all border properties.
  1637.      *
  1638.      * The returned array has the following structure:
  1639.      * <code>
  1640.      * array("top" => array("width" => [border-width],
  1641.      *                      "style" => [border-style],
  1642.      *                      "color" => [border-color (array)]),
  1643.      *       "bottom" ... )
  1644.      * </code>
  1645.      *
  1646.      * @return array
  1647.      */
  1648.     function get_border_properties()
  1649.     {
  1650.         return [
  1651.             "top" => [
  1652.                 "width" => $this->__get("border_top_width"),
  1653.                 "style" => $this->__get("border_top_style"),
  1654.                 "color" => $this->__get("border_top_color"),
  1655.             ],
  1656.             "bottom" => [
  1657.                 "width" => $this->__get("border_bottom_width"),
  1658.                 "style" => $this->__get("border_bottom_style"),
  1659.                 "color" => $this->__get("border_bottom_color"),
  1660.             ],
  1661.             "right" => [
  1662.                 "width" => $this->__get("border_right_width"),
  1663.                 "style" => $this->__get("border_right_style"),
  1664.                 "color" => $this->__get("border_right_color"),
  1665.             ],
  1666.             "left" => [
  1667.                 "width" => $this->__get("border_left_width"),
  1668.                 "style" => $this->__get("border_left_style"),
  1669.                 "color" => $this->__get("border_left_color"),
  1670.             ],
  1671.         ];
  1672.     }
  1674.     /**
  1675.      * Return a single border property
  1676.      *
  1677.      * @param string $side
  1678.      *
  1679.      * @return mixed
  1680.      */
  1681.     protected function _get_border($side)
  1682.     {
  1683.         $color = $this->__get("border_" . $side . "_color");
  1685.         return $this->__get("border_" . $side . "_width") . " " .
  1686.             $this->__get("border_" . $side . "_style") . " " .
  1687.             (is_array($color) ? $color["hex"] : $color);
  1688.     }
  1690.     /**#@+
  1691.      * Return full border properties as a string
  1692.      *
  1693.      * Border properties are returned just as specified in CSS:
  1694.      * <pre>[width] [style] [color]</pre>
  1695.      * e.g. "1px solid blue"
  1696.      *
  1697.      * @link http://www.w3.org/TR/CSS21/box.html#border-shorthand-properties
  1698.      * @return string
  1699.      */
  1700.     function get_border_top()
  1701.     {
  1702.         return $this->_get_border("top");
  1703.     }
  1705.     /**
  1706.      * @return mixed
  1707.      */
  1708.     function get_border_right()
  1709.     {
  1710.         return $this->_get_border("right");
  1711.     }
  1713.     /**
  1714.      * @return mixed
  1715.      */
  1716.     function get_border_bottom()
  1717.     {
  1718.         return $this->_get_border("bottom");
  1719.     }
  1721.     /**
  1722.      * @return mixed
  1723.      */
  1724.     function get_border_left()
  1725.     {
  1726.         return $this->_get_border("left");
  1727.     }
  1729.     /**
  1730.      * @deprecated
  1731.      * @param float $w
  1732.      * @param float $h
  1733.      * @return float[]
  1734.      */
  1735.     function get_computed_border_radius($w, $h)
  1736.     {
  1737.         return $this->resolve_border_radius([0, 0, $w, $h]);
  1738.     }
  1740.     public function has_border_radius(): bool
  1741.     {
  1742.         if (isset($this->has_border_radius_cache)) {
  1743.             return $this->has_border_radius_cache;
  1744.         }
  1746.         // Use a fixed ref size here. We don't know the border-box width here
  1747.         // and font size might be 0. Since we are only interested in whether
  1748.         // there is any border radius at all, this should do
  1749.         $tl = (float) $this->length_in_pt($this->border_top_left_radius, 10);
  1750.         $tr = (float) $this->length_in_pt($this->border_top_right_radius, 10);
  1751.         $br = (float) $this->length_in_pt($this->border_bottom_right_radius, 10);
  1752.         $bl = (float) $this->length_in_pt($this->border_bottom_left_radius, 10);
  1754.         $this->has_border_radius_cache = $tl + $tr + $br + $bl > 0;
  1755.         return $this->has_border_radius_cache;
  1756.     }
  1758.     /**
  1759.      * Get the final border-radius values to use.
  1760.      *
  1761.      * Percentage values are resolved relative to the width of the border box.
  1762.      * The border radius is additionally scaled for the given render box, and
  1763.      * constrained by its width and height.
  1764.      *
  1765.      * @param float[]      $border_box The border box of the frame.
  1766.      * @param float[]|null $render_box The box to resolve the border radius for.
  1767.      *
  1768.      * @return float[] A 4-tuple of top-left, top-right, bottom-right, and bottom-left radius.
  1769.      */
  1770.     public function resolve_border_radius(
  1771.         array $border_box,
  1772.         ?array $render_box = null
  1773.     ): array {
  1774.         $render_box = $render_box ?? $border_box;
  1775.         $use_cache = $render_box === $border_box;
  1777.         if ($use_cache && isset($this->resolved_border_radius)) {
  1778.             return $this->resolved_border_radius;
  1779.         }
  1781.         [$x, $y, $w, $h] = $border_box;
  1783.         // Resolve percentages relative to width, as long as we have no support
  1784.         // for per-axis radii
  1785.         $tl = (float) $this->length_in_pt($this->border_top_left_radius, $w);
  1786.         $tr = (float) $this->length_in_pt($this->border_top_right_radius, $w);
  1787.         $br = (float) $this->length_in_pt($this->border_bottom_right_radius, $w);
  1788.         $bl = (float) $this->length_in_pt($this->border_bottom_left_radius, $w);
  1790.         if ($tl + $tr + $br + $bl > 0) {
  1791.             [$rx, $ry, $rw, $rh] = $render_box;
  1793.             $t_offset = $y - $ry;
  1794.             $r_offset = $rx + $rw - $x - $w;
  1795.             $b_offset = $ry + $rh - $y - $h;
  1796.             $l_offset = $x - $rx;
  1798.             if ($tl > 0) {
  1799.                 $tl = max($tl + ($t_offset + $l_offset) / 2, 0);
  1800.             }
  1801.             if ($tr > 0) {
  1802.                 $tr = max($tr + ($t_offset + $r_offset) / 2, 0);
  1803.             }
  1804.             if ($br > 0) {
  1805.                 $br = max($br + ($b_offset + $r_offset) / 2, 0);
  1806.             }
  1807.             if ($bl > 0) {
  1808.                 $bl = max($bl + ($b_offset + $l_offset) / 2, 0);
  1809.             }
  1811.             if ($tl + $bl > $rh) {
  1812.                 $f = $rh / ($tl + $bl);
  1813.                 $tl = $f * $tl;
  1814.                 $bl = $f * $bl;
  1815.             }
  1816.             if ($tr + $br > $rh) {
  1817.                 $f = $rh / ($tr + $br);
  1818.                 $tr = $f * $tr;
  1819.                 $br = $f * $br;
  1820.             }
  1821.             if ($tl + $tr > $rw) {
  1822.                 $f = $rw / ($tl + $tr);
  1823.                 $tl = $f * $tl;
  1824.                 $tr = $f * $tr;
  1825.             }
  1826.             if ($bl + $br > $rw) {
  1827.                 $f = $rw / ($bl + $br);
  1828.                 $bl = $f * $bl;
  1829.                 $br = $f * $br;
  1830.             }
  1831.         }
  1833.         $values = [$tl, $tr, $br, $bl];
  1835.         if ($use_cache) {
  1836.             $this->resolved_border_radius = $values;
  1837.         }
  1839.         return $values;
  1840.     }
  1842.     /**
  1843.      * Returns the outline color as an array
  1844.      *
  1845.      * See {@link Style::get_color()}
  1846.      *
  1847.      * @link http://www.w3.org/TR/CSS21/box.html#border-color-properties
  1848.      * @return array
  1849.      */
  1850.     function get_outline_color()
  1851.     {
  1852.         return $this->get_prop_color("outline_color");
  1853.     }
  1855.     /**
  1856.      * Return full outline properties as a string
  1857.      *
  1858.      * Outline properties are returned just as specified in CSS:
  1859.      * <pre>[width] [style] [color]</pre>
  1860.      * e.g. "1px solid blue"
  1861.      *
  1862.      * @link http://www.w3.org/TR/CSS21/box.html#border-shorthand-properties
  1863.      * @return string
  1864.      */
  1865.     function get_outline()
  1866.     {
  1867.         $color = $this->__get("outline_color");
  1869.         return $this->__get("outline_width") . " " .
  1870.             $this->__get("outline_style") . " " .
  1871.             (is_array($color) ? $color["hex"] : $color);
  1872.     }
  1874.     /**
  1875.      * Returns border spacing as an array
  1876.      *
  1877.      * The array has the format (h_space,v_space)
  1878.      *
  1879.      * @link http://www.w3.org/TR/CSS21/tables.html#propdef-border-spacing
  1880.      * @return array
  1881.      */
  1882.     function get_border_spacing()
  1883.     {
  1884.         $arr = explode(" ", $this->_props_computed["border_spacing"]);
  1885.         if (count($arr) == 1) {
  1886.             $arr[1] = $arr[0];
  1887.         }
  1888.         return $arr;
  1889.     }
  1891.     /**
  1892.      * Returns the list style image URI, or "none"
  1893.      *
  1894.      * @link http://www.w3.org/TR/CSS21/generate.html#propdef-list-style-image
  1895.      * @return string
  1896.      */
  1897.     function get_list_style_image()
  1898.     {
  1899.         return $this->_stylesheet->resolve_url($this->_props_computed["list_style_image"]);
  1900.     }
  1902.     /**
  1903.      * @param string $value
  1904.      * @param int    $default
  1905.      *
  1906.      * @return array|string
  1907.      */
  1908.     protected function parse_counter_prop(string $value, int $default)
  1909.     {
  1910.         $ident = self::CSS_IDENTIFIER;
  1911.         $integer = self::CSS_INTEGER;
  1912.         $pattern = "/($ident)(?:\s+($integer))?/";
  1914.         if (!preg_match_all($pattern, $value, $matches, PREG_SET_ORDER)) {
  1915.             return "none";
  1916.         }
  1918.         $counters = [];
  1920.         foreach ($matches as $match) {
  1921.             $counter = $match[1];
  1922.             $value = isset($match[2]) ? (int) $match[2] : $default;
  1923.             $counters[$counter] = $value;
  1924.         }
  1926.         return $counters;
  1927.     }
  1929.     /**
  1930.      * @return array|string
  1931.      */
  1932.     function get_counter_increment()
  1933.     {
  1934.         $val = $this->_props_computed["counter_increment"];
  1936.         if ($val === "none" || $val === "inherit") {
  1937.             return "none";
  1938.         }
  1940.         return $this->parse_counter_prop($val, 1);
  1941.     }
  1943.     /**
  1944.      * @return array|string
  1945.      */
  1946.     protected function get_counter_reset()
  1947.     {
  1948.         $val = $this->_props_computed["counter_reset"];
  1950.         if ($val === "none") {
  1951.             return "none";
  1952.         }
  1954.         return $this->parse_counter_prop($val, 0);
  1955.     }
  1957.     /**
  1958.      * @return string[]|string
  1959.      */
  1960.     protected function get_content()
  1961.     {
  1962.         $val = $this->_props_computed["content"];
  1964.         if ($val === "normal" || $val === "none") {
  1965.             return $val;
  1966.         }
  1968.         return $this->parse_property_value($val);
  1969.     }
  1971.     /*==============================*/
  1973.     /**
  1974.      * Parse a property value into its components.
  1975.      *
  1976.      * @param string $value
  1977.      *
  1978.      * @return string[]
  1979.      */
  1980.     protected function parse_property_value(string $value): array
  1981.     {
  1982.         $ident = self::CSS_IDENTIFIER;
  1983.         $number = self::CSS_NUMBER;
  1985.         $pattern = "/\n" .
  1986.             "\s* \" ( (?:[^\"]|\\\\[\"])* ) (?<!\\\\)\" |\n" . // String ""
  1987.             "\s* '  ( (?:[^']|\\\\['])* )   (?<!\\\\)'  |\n" . // String ''
  1988.             "\s* ($ident \\([^)]*\\) )                  |\n" . // Functional
  1989.             "\s* ($ident)                               |\n" . // Keyword
  1990.             "\s* (\#[0-9a-fA-F]*)                       |\n" . // Hex value
  1991.             "\s* ($number [a-zA-Z%]*)                   |\n" . // Number (+ unit/percentage)
  1992.             "\s* ([\/,;])                                \n" . // Delimiter
  1993.             "/Sx";
  1995.         if (!preg_match_all($pattern, $value, $matches)) {
  1996.             return [];
  1997.         }
  1999.         return array_map("trim", $matches[0]);
  2000.     }
  2002.     protected function is_color_value(string $val): bool
  2003.     {
  2004.         return $val === "currentcolor"
  2005.             || $val === "transparent"
  2006.             || isset(Color::$cssColorNames[$val])
  2007.             || preg_match("/^#|rgb\(|rgba\(|cmyk\(/", $val);
  2008.     }
  2010.     protected function prop_name(string $style, string $side, string $type): string
  2011.     {
  2012.         $prop = $style;
  2013.         if ($side !== "") {
  2014.             $prop .= "_" . $side;
  2015.         };
  2016.         if ($type !== "") {
  2017.             $prop .= "_" . $type;
  2018.         };
  2019.         return $prop;
  2020.     }
  2022.     /**
  2023.      * Generalized set function for individual attribute of combined style.
  2024.      *
  2025.      * Applicable for margin, border, padding, outline.
  2026.      *
  2027.      * @param string $style
  2028.      * @param string $side
  2029.      * @param string $type
  2030.      * @param mixed $val
  2031.      */
  2032.     protected function _set_style_side_type($style, $side, $type, $val)
  2033.     {
  2034.         $prop = $this->prop_name($style, $side, $type);
  2036.         $this->_prop_cache[$prop] = null;
  2038.         if ($val === "inherit") {
  2039.             $this->_props_computed[$prop] = null;
  2040.             return;
  2041.         }
  2043.         if ($side === "bottom") {
  2044.             $this->_computed_bottom_spacing = null; //reset computed cache, border style can disable/enable border calculations
  2045.         }
  2047.         if ($type === "color") {
  2048.             $this->set_prop_color($prop, $val);
  2049.         } elseif (($style === "border" || $style === "outline") && $type === "width") {
  2050.             // Border-width keywords
  2051.             if ($val === "thin") {
  2052.                 $val_computed = 0.5;
  2053.             } elseif ($val === "medium") {
  2054.                 $val_computed = 1.5;
  2055.             } elseif ($val === "thick") {
  2056.                 $val_computed = 2.5;
  2057.             } elseif (mb_strpos($val, "%") !== false) {
  2058.                 $val_computed = null;
  2059.             } else {
  2060.                 $val_computed = $this->single_length_in_pt($val);
  2062.                 if ($val_computed < 0) {
  2063.                     $val_computed = null;
  2064.                 }
  2065.             }
  2067.             if ($val_computed === null) {
  2068.                 $this->_props_computed[$prop] = null;
  2069.             } else {
  2070.                 $line_style_prop = $this->prop_name($style, $side, "style");
  2071.                 $line_style = $this->__get($line_style_prop);
  2072.                 $has_line_style = $line_style !== "none" && $line_style !== "hidden";
  2074.                 $this->_props_computed[$prop] = $has_line_style ? $val_computed : 0;
  2075.             }
  2076.         } elseif (($style === "border" || $style === "outline") && $type === "style") {
  2077.             if (in_array($val, Style::$BORDER_STYLES, true)) {
  2078.                 $this->_props_computed[$prop] = $val;
  2079.             } else {
  2080.                 $this->_props_computed[$prop] = null;
  2081.             }
  2082.         } elseif ($style === "margin" || $style === "padding") {
  2083.             if ($val === "none") {
  2084.                 // Legacy support for `none` keyword, not covered by spec
  2085.                 $val_computed = 0;
  2086.             } elseif ($style === "margin" && $val === "auto") {
  2087.                 $val_computed = $val;
  2088.             } elseif (mb_strpos($val, "%") !== false) {
  2089.                 $val_computed = $val;
  2090.             } else {
  2091.                 $val_computed = $this->single_length_in_pt($val);
  2093.                 if ($style === "padding" && $val_computed < 0) {
  2094.                     $val_computed = null;
  2095.                 }
  2096.             }
  2098.             $this->_props_computed[$prop] = $val_computed;
  2099.         } elseif ($val !== "") {
  2100.             $this->_props_computed[$prop] = $val;
  2101.         } else {
  2102.             $this->_props_computed[$prop] = null;
  2103.         }
  2104.     }
  2106.     /**
  2107.      * @param string $style
  2108.      * @param string $type
  2109.      * @param mixed $val
  2110.      * @param bool $important
  2111.      */
  2112.     protected function _set_style_type($style, $type, $val, $important)
  2113.     {
  2114.         $v = $this->parse_property_value($val);
  2116.         switch (count($v)) {
  2117.             case 1:
  2118.                 [$top, $right, $bottom, $left] = [$v[0], $v[0], $v[0], $v[0]];
  2119.                 break;
  2120.             case 2:
  2121.                 [$top, $right, $bottom, $left] = [$v[0], $v[1], $v[0], $v[1]];
  2122.                 break;
  2123.             case 3:
  2124.                 [$top, $right, $bottom, $left] = [$v[0], $v[1], $v[2], $v[1]];
  2125.                 break;
  2126.             case 4:
  2127.                 [$top, $right, $bottom, $left] = [$v[0], $v[1], $v[2], $v[3]];
  2128.                 break;
  2129.             default:
  2130.                 return;
  2131.         }
  2133.         $this->set_prop($this->prop_name($style, "top", $type), $top, $important);
  2134.         $this->set_prop($this->prop_name($style, "right", $type), $right, $important);
  2135.         $this->set_prop($this->prop_name($style, "bottom", $type), $bottom, $important);
  2136.         $this->set_prop($this->prop_name($style, "left", $type), $left, $important);
  2137.     }
  2139.     /*======================*/
  2141.     /**
  2142.      * https://www.w3.org/TR/CSS21/visuren.html#display-prop
  2143.      *
  2144.      * @param string $val
  2145.      */
  2146.     protected function set_display(string $val): void
  2147.     {
  2148.         // Make sure that common valid, but unsupported display types have an
  2149.         // appropriate fallback display type
  2150.         switch ($val) {
  2151.             case "flow-root":
  2152.             case "flex":
  2153.             case "grid":
  2154.             case "table-caption":
  2155.                 $val = "block";
  2156.                 break;
  2157.             case "inline-flex":
  2158.             case "inline-grid":
  2159.                 $val = "inline-block";
  2160.                 break;
  2161.         }
  2163.         if (!isset(self::$valid_display_types[$val])) {
  2164.             return;
  2165.         }
  2167.         // https://www.w3.org/TR/CSS21/visuren.html#dis-pos-flo
  2168.         if ($this->is_in_flow()) {
  2169.             $computed = $val;
  2170.         } else {
  2171.             switch ($val) {
  2172.                 case "inline":
  2173.                 case "inline-block":
  2174.                 // case "table-row-group":
  2175.                 // case "table-header-group":
  2176.                 // case "table-footer-group":
  2177.                 // case "table-row":
  2178.                 // case "table-cell":
  2179.                 // case "table-column-group":
  2180.                 // case "table-column":
  2181.                 // case "table-caption":
  2182.                     $computed = "block";
  2183.                     break;
  2184.                 case "inline-table":
  2185.                     $computed = "table";
  2186.                     break;
  2187.                 default:
  2188.                     $computed = $val;
  2189.                     break;
  2190.             }
  2191.         }
  2193.         $this->_props_computed["display"] = $computed;
  2194.     }
  2196.     protected function set_prop_color($prop, $val)
  2197.     {
  2198.         $this->_prop_cache[$prop] = null;
  2200.         // https://www.w3.org/TR/css-color-4/#resolving-other-colors
  2201.         $munged_color = $val !== "currentcolor"
  2202.             ? $this->munge_color($val)
  2203.             : $val;
  2205.         if (is_null($munged_color)) {
  2206.             $this->_props_computed[$prop] = null;
  2207.             return;
  2208.         }
  2210.         $this->_props_computed[$prop] = is_array($munged_color) ? $munged_color["hex"] : $munged_color;
  2211.     }
  2213.     /**
  2214.      * Sets color
  2215.      *
  2216.      * The color parameter can be any valid CSS color value
  2217.      *
  2218.      * @link http://www.w3.org/TR/CSS21/colors.html#propdef-color
  2219.      * @param string $color
  2220.      */
  2221.     function set_color($color)
  2222.     {
  2223.         $this->set_prop_color("color", $color);
  2224.     }
  2226.     /**
  2227.      * Sets the background color
  2228.      *
  2229.      * @link http://www.w3.org/TR/CSS21/colors.html#propdef-background-color
  2230.      * @param string $color
  2231.      */
  2232.     function set_background_color($color)
  2233.     {
  2234.         $this->set_prop_color("background_color", $color);
  2235.     }
  2237.     /**
  2238.      * Set the background image url
  2239.      * @link https://www.w3.org/TR/CSS21/colors.html#propdef-background-image
  2240.      *
  2241.      * @param string $val
  2242.      */
  2243.     function set_background_image($val)
  2244.     {
  2245.         $this->_prop_cache["background_image"] = null;
  2247.         $parsed_val = $this->_stylesheet->resolve_url($val);
  2249.         if ($parsed_val === "none") {
  2250.             $this->_props_computed["background_image"] = "none";
  2251.         } else {
  2252.             $this->_props_computed["background_image"] = "url(" . $parsed_val . ")";
  2253.         }
  2254.     }
  2256.     /**
  2257.      * Sets the background repeat
  2258.      *
  2259.      * @link http://www.w3.org/TR/CSS21/colors.html#propdef-background-repeat
  2260.      * @param string $val
  2261.      */
  2262.     function set_background_repeat($val)
  2263.     {
  2264.         $this->_prop_cache["background_repeat"] = null;
  2266.         if ($val === "inherit") {
  2267.             $this->_props_computed["background_repeat"] = null;
  2268.             return;
  2269.         }
  2271.         $this->_props_computed["background_repeat"] = $val;
  2272.     }
  2274.     /**
  2275.      * Sets the background attachment
  2276.      *
  2277.      * @link http://www.w3.org/TR/CSS21/colors.html#propdef-background-attachment
  2278.      * @param string $val
  2279.      */
  2280.     function set_background_attachment($val)
  2281.     {
  2282.         $this->_prop_cache["background_attachment"] = null;
  2284.         if ($val === "inherit") {
  2285.             $this->_props_computed["background_attachment"] = null;
  2286.             return;
  2287.         }
  2289.         $this->_props_computed["background_attachment"] = $val;
  2290.     }
  2292.     /**
  2293.      * Sets the background position
  2294.      *
  2295.      * @link http://www.w3.org/TR/CSS21/colors.html#propdef-background-position
  2296.      * @param string $val
  2297.      */
  2298.     function set_background_position($val)
  2299.     {
  2300.         $this->_prop_cache["background_position"] = null;
  2302.         $tmp = explode(" ", $val);
  2304.         switch ($tmp[0]) {
  2305.             case "left":
  2306.                 $x = "0%";
  2307.                 break;
  2309.             case "right":
  2310.                 $x = "100%";
  2311.                 break;
  2313.             case "top":
  2314.                 $y = "0%";
  2315.                 break;
  2317.             case "bottom":
  2318.                 $y = "100%";
  2319.                 break;
  2321.             case "center":
  2322.                 $x = "50%";
  2323.                 $y = "50%";
  2324.                 break;
  2326.             default:
  2327.                 $x = $tmp[0];
  2328.                 break;
  2329.         }
  2331.         if (isset($tmp[1])) {
  2332.             switch ($tmp[1]) {
  2333.                 case "left":
  2334.                     $x = "0%";
  2335.                     break;
  2337.                 case "right":
  2338.                     $x = "100%";
  2339.                     break;
  2341.                 case "top":
  2342.                     $y = "0%";
  2343.                     break;
  2345.                 case "bottom":
  2346.                     $y = "100%";
  2347.                     break;
  2349.                 case "center":
  2350.                     if ($tmp[0] === "left" || $tmp[0] === "right" || $tmp[0] === "center") {
  2351.                         $y = "50%";
  2352.                     } else {
  2353.                         $x = "50%";
  2354.                     }
  2355.                     break;
  2357.                 default:
  2358.                     $y = $tmp[1];
  2359.                     break;
  2360.             }
  2361.         } else {
  2362.             $y = "50%";
  2363.         }
  2365.         if (!isset($x)) {
  2366.             $x = "0%";
  2367.         }
  2369.         if (!isset($y)) {
  2370.             $y = "0%";
  2371.         }
  2372.         
  2373.         $this->_props_computed["background_position"] = "$x $y";
  2374.     }
  2376.     /**
  2377.      * Sets the background size
  2378.      *
  2379.      * @link https://www.w3.org/TR/css3-background/#background-size
  2380.      * @param string $val
  2381.      */
  2382.     function set_background_size($val)
  2383.     {
  2384.         $this->_prop_cache["background_size"] = null;
  2386.         $result = explode(" ", $val);
  2387.         $width = $result[0];
  2389.         switch ($width) {
  2390.             case "cover":
  2391.             case "contain":
  2392.                 $this->_props_computed["background_size"] = $width;
  2393.                 return;
  2394.             case "inherit":
  2395.                 $this->_props_computed["background_size"] = null;
  2396.                 return;
  2397.         }
  2399.         if ($width !== "auto" && strpos($width, "%") === false) {
  2400.             $width = (float)$this->length_in_pt($width);
  2401.         }
  2403.         $height = $result[1] ?? "auto";
  2404.         if ($height !== "auto" && strpos($height, "%") === false) {
  2405.             $height = (float)$this->length_in_pt($height);
  2406.         }
  2408.         $this->_props_computed["background_size"] = "$width $height";
  2409.     }
  2411.     /**
  2412.      * Sets the background - combined options
  2413.      *
  2414.      * @link http://www.w3.org/TR/CSS21/colors.html#propdef-background
  2415.      * @param string $value
  2416.      * @param bool $important
  2417.      */
  2418.     function set_background($value, bool $important = false)
  2419.     {
  2420.         if ($value === "none") {
  2421.             $this->set_prop("background_image", "none", $important);
  2422.             $this->set_prop("background_color", "transparent", $important);
  2423.         } else {
  2424.             $components = $this->parse_property_value($value);
  2425.             $pos_size = [];
  2427.             foreach ($components as $val) {
  2428.                 if ($val === "none" || mb_substr($val, 0, 4) === "url(") {
  2429.                     $this->set_prop("background_image", $val, $important);
  2430.                 } elseif ($val === "fixed" || $val === "scroll") {
  2431.                     $this->set_prop("background_attachment", $val, $important);
  2432.                 } elseif ($val === "repeat" || $val === "repeat-x" || $val === "repeat-y" || $val === "no-repeat") {
  2433.                     $this->set_prop("background_repeat", $val, $important);
  2434.                 } elseif ($this->is_color_value($val)) {
  2435.                     $this->set_prop("background_color", $val, $important);
  2436.                 } else {
  2437.                     $pos_size[] = $val;
  2438.                 }
  2439.             }
  2441.             if (count($pos_size)) {
  2442.                 // Split value list at "/"
  2443.                 $index = array_search("/", $pos_size, true);
  2445.                 if ($index !== false) {
  2446.                     $pos = array_slice($pos_size, 0, $index);
  2447.                     $size = array_slice($pos_size, $index + 1);
  2448.                 } else {
  2449.                     $pos = $pos_size;
  2450.                     $size = [];
  2451.                 }
  2453.                 $this->set_prop("background_position", implode(" ", $pos), $important);
  2455.                 if (count($size)) {
  2456.                     $this->set_prop("background_size", implode(" ", $size), $important);
  2457.                 }
  2458.             }
  2459.         }
  2460.     }
  2462.     /**
  2463.      * Sets the font size
  2464.      *
  2465.      * $size can be any acceptable CSS size
  2466.      *
  2467.      * @link http://www.w3.org/TR/CSS21/fonts.html#propdef-font-size
  2468.      * @param string|float $size
  2469.      */
  2470.     function set_font_size($size)
  2471.     {
  2472.         $this->_prop_cache["font_size"] = null;
  2474.         if ($size === "inherit") {
  2475.             $this->_props_computed["font_size"] = null;
  2476.             return;
  2477.         }
  2479.         $parent_font_size = isset($this->parent_style)
  2480.             ? $this->parent_style->__get("font_size")
  2481.             : self::$default_font_size;
  2483.         switch ((string)$size) {
  2484.             case "xx-small":
  2485.             case "x-small":
  2486.             case "small":
  2487.             case "medium":
  2488.             case "large":
  2489.             case "x-large":
  2490.             case "xx-large":
  2491.                 $fs = self::$default_font_size * self::$font_size_keywords[$size];
  2492.                 break;
  2494.             case "smaller":
  2495.                 $fs = 8 / 9 * $parent_font_size;
  2496.                 break;
  2498.             case "larger":
  2499.                 $fs = 6 / 5 * $parent_font_size;
  2500.                 break;
  2502.             default:
  2503.                 $fs = $this->single_length_in_pt($size, $parent_font_size, $parent_font_size);
  2504.                 break;
  2505.         }
  2507.         $this->_props_computed["font_size"] = $fs;
  2508.     }
  2510.     /**
  2511.      * Sets the font weight
  2512.      *
  2513.      * @param string|int $weight
  2514.      */
  2515.     function set_font_weight($weight)
  2516.     {
  2517.         $this->_prop_cache["font_weight"] = null;
  2519.         if ($weight === "inherit") {
  2520.             $this->_props_computed["font_weight"] = null;
  2521.             return;
  2522.         }
  2524.         $computed_weight = $weight;
  2526.         if ($weight === "bolder") {
  2527.             //TODO: One font weight heavier than the parent element (among the available weights of the font).
  2528.             $computed_weight = "bold";
  2529.         } elseif ($weight === "lighter") {
  2530.             //TODO: One font weight lighter than the parent element (among the available weights of the font).
  2531.             $computed_weight = "normal";
  2532.         }
  2534.         $this->_props_computed["font_weight"] = $computed_weight;
  2535.     }
  2537.     /**
  2538.      * Sets the font style
  2539.      *
  2540.      * combined attributes
  2541.      * set individual attributes also, respecting !important mark
  2542.      * exactly this order, separate by space. Multiple fonts separated by comma:
  2543.      * font-style, font-variant, font-weight, font-size, line-height, font-family
  2544.      *
  2545.      * Other than with border and list, existing partial attributes should
  2546.      * reset when starting here, even when not mentioned.
  2547.      * If individual attribute is !important and explicit or implicit replacement is not,
  2548.      * keep individual attribute
  2549.      *
  2550.      * require whitespace as delimiters for single value attributes
  2551.      * On delimiter "/" treat first as font height, second as line height
  2552.      * treat all remaining at the end of line as font
  2553.      * font-style, font-variant, font-weight, font-size, line-height, font-family
  2554.      *
  2555.      * missing font-size and font-family might be not allowed, but accept it here and
  2556.      * use default (medium size, empty font name)
  2557.      *
  2558.      * @link https://www.w3.org/TR/CSS21/fonts.html#font-shorthand
  2559.      * @param string $val
  2560.      * @param bool $important
  2561.      */
  2562.     function set_font($val, bool $important = false)
  2563.     {
  2564.         if (preg_match("/^(italic|oblique|normal)\s*(.*)$/i", $val, $match)) {
  2565.             $this->set_prop("font_style", $match[1], $important);
  2566.             $val = $match[2];
  2567.         }
  2569.         if (preg_match("/^(small-caps|normal)\s*(.*)$/i", $val, $match)) {
  2570.             $this->set_prop("font_variant", $match[1], $important);
  2571.             $val = $match[2];
  2572.         }
  2574.         //matching numeric value followed by unit -> this is indeed a subsequent font size. Skip!
  2575.         if (preg_match("/^(bold|bolder|lighter|100|200|300|400|500|600|700|800|900|normal)\s*(.*)$/i", $val, $match) &&
  2576.             !preg_match("/^(?:pt|px|pc|rem|em|ex|in|cm|mm|%)/", $match[2])
  2577.         ) {
  2578.             $this->set_prop("font_weight", $match[1], $important);
  2579.             $val = $match[2];
  2580.         }
  2582.         if (preg_match("/^(xx-small|x-small|small|medium|large|x-large|xx-large|smaller|larger|\d+\s*(?:pt|px|pc|rem|em|ex|in|cm|mm|%))(?:\/|\s*)(.*)$/i", $val, $match)) {
  2583.             $this->set_prop("font_size", $match[1], $important);
  2584.             $val = $match[2];
  2585.             if (preg_match("/^(?:\/|\s*)(\d+\s*(?:pt|px|pc|rem|em|ex|in|cm|mm|%)?)\s*(.*)$/i", $val, $match)) {
  2586.                 $this->set_prop("line_height", $match[1], $important);
  2587.                 $val = $match[2];
  2588.             }
  2589.         }
  2591.         if (strlen($val) != 0) {
  2592.             $this->set_prop("font_family", $val, $important);
  2593.         }
  2594.     }
  2596.     /**
  2597.      * Sets the text alignment
  2598.      *
  2599.      * If no alignment is set on the element and the direction is rtl then
  2600.      * the property is set to "right", otherwise it is set to "left".
  2601.      *
  2602.      * @link https://www.w3.org/TR/CSS21/text.html#propdef-text-align
  2603.      */
  2604.     public function set_text_align($val)
  2605.     {
  2606.         $this->_prop_cache["text_align"] = null;
  2608.         $alignment = $val;
  2609.         if ($alignment === "") {
  2610.             $alignment = "left";
  2611.             if ($this->__get("direction") === "rtl") {
  2612.                 $alignment = "right";
  2613.             }
  2614.         }
  2616.         if (!in_array($alignment, self::$text_align_keywords, true)) {
  2617.             $this->_props_computed["text_align"] = null;
  2618.             return;
  2619.         }
  2621.         $this->_props_computed["text_align"] = $alignment;
  2622.     }
  2624.     /**
  2625.      * Sets word spacing property
  2626.      *
  2627.      * @link http://www.w3.org/TR/CSS21/text.html#propdef-word-spacing
  2628.      * @param $val
  2629.      */
  2630.     function set_word_spacing($val)
  2631.     {
  2632.         $this->_prop_cache["word_spacing"] = null;
  2634.         if ($val === "inherit") {
  2635.             $this->_props_computed["word_spacing"] = null;
  2636.             return;
  2637.         }
  2639.         if ($val === "normal" || strpos($val, "%") !== false) {
  2640.             $this->_props_computed["word_spacing"] = $val;
  2641.         } else {
  2642.             $this->_props_computed["word_spacing"] = ((float)$this->length_in_pt($val, $this->__get("font_size"))) . "pt";
  2643.         }
  2644.     }
  2646.     /**
  2647.      * Sets letter spacing property
  2648.      *
  2649.      * @link http://www.w3.org/TR/CSS21/text.html#propdef-letter-spacing
  2650.      * @param $val
  2651.      */
  2652.     function set_letter_spacing($val)
  2653.     {
  2654.         $this->_prop_cache["letter_spacing"] = null;
  2656.         if ($val === "inherit") {
  2657.             $this->_props_computed["letter_spacing"] = null;
  2658.             return;
  2659.         }
  2661.         if ($val === "normal") {
  2662.             $this->_props_computed["letter_spacing"] = $val;
  2663.         } else {
  2664.             $this->_props_computed["letter_spacing"] = ((float)$this->length_in_pt($val, $this->__get("font_size"))) . "pt";
  2665.         }
  2666.     }
  2668.     /**
  2669.      * Sets line height property
  2670.      *
  2671.      * @link http://www.w3.org/TR/CSS21/visudet.html#propdef-line-height
  2672.      * @param $val
  2673.      */
  2674.     function set_line_height($val)
  2675.     {
  2676.         $this->_prop_cache["line_height"] = null;
  2678.         if ($val === "inherit") {
  2679.             $this->_props_computed["line_height"] = null;
  2680.             return;
  2681.         }
  2683.         if ($val === "normal" || is_numeric($val)) {
  2684.             $this->_props_computed["line_height"] = $val;
  2685.         } else {
  2686.             $this->_props_computed["line_height"] = ((float)$this->length_in_pt($val, $this->__get("font_size"))) . "pt";
  2687.         }
  2688.     }
  2690.     /**
  2691.      * Sets page break properties
  2692.      *
  2693.      * @link http://www.w3.org/TR/CSS21/page.html#page-breaks
  2694.      * @param string $break
  2695.      */
  2696.     function set_page_break_before($break)
  2697.     {
  2698.         $this->_prop_cache["page_break_before"] = null;
  2700.         if ($break === "inherit") {
  2701.             $this->_props_computed["page_break_before"] = null;
  2702.             return;
  2703.         }
  2705.         if ($break === "left" || $break === "right") {
  2706.             $break = "always";
  2707.         }
  2709.         $this->_props_computed["page_break_before"] = $break;
  2710.     }
  2712.     /**
  2713.      * @param $break
  2714.      */
  2715.     function set_page_break_after($break)
  2716.     {
  2717.         $this->_prop_cache["page_break_after"] = null;
  2719.         if ($break === "inherit") {
  2720.             $this->_props_computed["page_break_after"] = null;
  2721.             return;
  2722.         }
  2724.         if ($break === "left" || $break === "right") {
  2725.             $break = "always";
  2726.         }
  2728.         $this->_props_computed["page_break_after"] = $break;
  2729.     }
  2731.     /**
  2732.      * Sets the margin size
  2733.      *
  2734.      * @link http://www.w3.org/TR/CSS21/box.html#margin-properties
  2735.      * @param $val
  2736.      */
  2737.     function set_margin_top($val)
  2738.     {
  2739.         $this->_set_style_side_type("margin", "top", "", $val);
  2740.     }
  2742.     /**
  2743.      * @param $val
  2744.      */
  2745.     function set_margin_right($val)
  2746.     {
  2747.         $this->_set_style_side_type("margin", "right", "", $val);
  2748.     }
  2750.     /**
  2751.      * @param $val
  2752.      */
  2753.     function set_margin_bottom($val)
  2754.     {
  2755.         $this->_set_style_side_type("margin", "bottom", "", $val);
  2756.     }
  2758.     /**
  2759.      * @param $val
  2760.      */
  2761.     function set_margin_left($val)
  2762.     {
  2763.         $this->_set_style_side_type("margin", "left", "", $val);
  2764.     }
  2766.     /**
  2767.      * @param string $val
  2768.      * @param bool $important
  2769.      */
  2770.     function set_margin($val, bool $important = false)
  2771.     {
  2772.         $this->_set_style_type("margin", "", $val, $important);
  2773.     }
  2775.     /**
  2776.      * Sets the padding size
  2777.      *
  2778.      * @link http://www.w3.org/TR/CSS21/box.html#padding-properties
  2779.      * @param $val
  2780.      */
  2781.     function set_padding_top($val)
  2782.     {
  2783.         $this->_set_style_side_type("padding", "top", "", $val);
  2784.     }
  2786.     /**
  2787.      * @param $val
  2788.      */
  2789.     function set_padding_right($val)
  2790.     {
  2791.         $this->_set_style_side_type("padding", "right", "", $val);
  2792.     }
  2794.     /**
  2795.      * @param $val
  2796.      */
  2797.     function set_padding_bottom($val)
  2798.     {
  2799.         $this->_set_style_side_type("padding", "bottom", "", $val);
  2800.     }
  2802.     /**
  2803.      * @param $val
  2804.      */
  2805.     function set_padding_left($val)
  2806.     {
  2807.         $this->_set_style_side_type("padding", "left", "", $val);
  2808.     }
  2810.     /**
  2811.      * @param string $val
  2812.      * @param bool $important
  2813.      */
  2814.     function set_padding($val, bool $important = false)
  2815.     {
  2816.         $this->_set_style_type("padding", "", $val, $important);
  2817.     }
  2819.     /**
  2820.      * Sets a single border
  2821.      *
  2822.      * @param string $side
  2823.      * @param string $border_spec ([width] [style] [color])
  2824.      * @param bool $important
  2825.      */
  2826.     protected function _set_border($side, $border_spec, bool $important)
  2827.     {
  2828.         $components = $this->parse_property_value($border_spec);
  2830.         foreach ($components as $val) {
  2831.             if (in_array($val, self::$BORDER_STYLES, true)) {
  2832.                 $this->set_prop("border_${side}_style", $val, $important);
  2833.             } elseif ($this->is_color_value($val)) {
  2834.                 $this->set_prop("border_${side}_color", $val, $important);
  2835.             } else {
  2836.                 // Assume width
  2837.                 $this->set_prop("border_${side}_width", $val, $important);
  2838.             }
  2839.         }
  2840.     }
  2842.     /**
  2843.      * @link http://www.w3.org/TR/CSS21/box.html#border-properties
  2844.      * @param string $val
  2845.      * @param bool $important
  2846.      */
  2847.     function set_border_top($val, bool $important = false)
  2848.     {
  2849.         $this->_set_border("top", $val, $important);
  2850.     }
  2852.     function set_border_top_color($val)
  2853.     {
  2854.         $this->_set_style_side_type("border", "top", "color", $val);
  2855.     }
  2857.     function set_border_top_style($val)
  2858.     {
  2859.         $this->_set_style_side_type("border", "top", "style", $val);
  2860.     }
  2862.     function set_border_top_width($val)
  2863.     {
  2864.         $this->_set_style_side_type("border", "top", "width", $val);
  2865.     }
  2867.     /**
  2868.      * @param string $val
  2869.      * @param bool $important
  2870.      */
  2871.     function set_border_right($val, bool $important = false)
  2872.     {
  2873.         $this->_set_border("right", $val, $important);
  2874.     }
  2876.     function set_border_right_color($val)
  2877.     {
  2878.         $this->_set_style_side_type("border", "right", "color", $val);
  2879.     }
  2881.     function set_border_right_style($val)
  2882.     {
  2883.         $this->_set_style_side_type("border", "right", "style", $val);
  2884.     }
  2886.     function set_border_right_width($val)
  2887.     {
  2888.         $this->_set_style_side_type("border", "right", "width", $val);
  2889.     }
  2891.     /**
  2892.      * @param string $val
  2893.      * @param bool $important
  2894.      */
  2895.     function set_border_bottom($val, bool $important = false)
  2896.     {
  2897.         $this->_set_border("bottom", $val, $important);
  2898.     }
  2900.     function set_border_bottom_color($val)
  2901.     {
  2902.         $this->_set_style_side_type("border", "bottom", "color", $val);
  2903.     }
  2905.     function set_border_bottom_style($val)
  2906.     {
  2907.         $this->_set_style_side_type("border", "bottom", "style", $val);
  2908.     }
  2910.     function set_border_bottom_width($val)
  2911.     {
  2912.         $this->_set_style_side_type("border", "bottom", "width", $val);
  2913.     }
  2915.     /**
  2916.      * @param string $val
  2917.      * @param bool $important
  2918.      */
  2919.     function set_border_left($val, bool $important = false)
  2920.     {
  2921.         $this->_set_border("left", $val, $important);
  2922.     }
  2924.     function set_border_left_color($val)
  2925.     {
  2926.         $this->_set_style_side_type("border", "left", "color", $val);
  2927.     }
  2929.     function set_border_left_style($val)
  2930.     {
  2931.         $this->_set_style_side_type("border", "left", "style", $val);
  2932.     }
  2934.     function set_border_left_width($val)
  2935.     {
  2936.         $this->_set_style_side_type("border", "left", "width", $val);
  2937.     }
  2939.     /**
  2940.      * @param string $val
  2941.      * @param bool $important
  2942.      */
  2943.     function set_border($val, bool $important = false)
  2944.     {
  2945.         $this->_set_border("top", $val, $important);
  2946.         $this->_set_border("right", $val, $important);
  2947.         $this->_set_border("bottom", $val, $important);
  2948.         $this->_set_border("left", $val, $important);
  2949.     }
  2951.     /**
  2952.      * @param string $val
  2953.      * @param bool $important
  2954.      */
  2955.     function set_border_width($val, bool $important = false)
  2956.     {
  2957.         $this->_set_style_type("border", "width", $val, $important);
  2958.     }
  2960.     /**
  2961.      * @param string $val
  2962.      * @param bool $important
  2963.      */
  2964.     function set_border_color($val, bool $important = false)
  2965.     {
  2966.         $this->_set_style_type("border", "color", $val, $important);
  2967.     }
  2969.     /**
  2970.      * @param string $val
  2971.      * @param bool $important
  2972.      */
  2973.     function set_border_style($val, bool $important = false)
  2974.     {
  2975.         $this->_set_style_type("border", "style", $val, $important);
  2976.     }
  2978.     /**
  2979.      * Sets the border radius size
  2980.      *
  2981.      * http://www.w3.org/TR/css3-background/#corners
  2982.      *
  2983.      * @param string $val
  2984.      */
  2985.     function set_border_top_left_radius($val)
  2986.     {
  2987.         $this->_set_border_radius_corner($val, "top_left");
  2988.     }
  2990.     /**
  2991.      * @param string $val
  2992.      */
  2993.     function set_border_top_right_radius($val)
  2994.     {
  2995.         $this->_set_border_radius_corner($val, "top_right");
  2996.     }
  2998.     /**
  2999.      * @param string $val
  3000.      */
  3001.     function set_border_bottom_left_radius($val)
  3002.     {
  3003.         $this->_set_border_radius_corner($val, "bottom_left");
  3004.     }
  3006.     /**
  3007.      * @param string $val
  3008.      */
  3009.     function set_border_bottom_right_radius($val)
  3010.     {
  3011.         $this->_set_border_radius_corner($val, "bottom_right");
  3012.     }
  3014.     /**
  3015.      * @param string $val
  3016.      * @param bool $important
  3017.      */
  3018.     function set_border_radius($val, bool $important = false)
  3019.     {
  3020.         $r = $this->parse_property_value($val);
  3022.         switch (count($r)) {
  3023.             case 1:
  3024.                 [$tl, $tr, $br, $bl] = [$r[0], $r[0], $r[0], $r[0]];
  3025.                 break;
  3026.             case 2:
  3027.                 [$tl, $tr, $br, $bl] = [$r[0], $r[1], $r[0], $r[1]];
  3028.                 break;
  3029.             case 3:
  3030.                 [$tl, $tr, $br, $bl] = [$r[0], $r[1], $r[2], $r[1]];
  3031.                 break;
  3032.             case 4:
  3033.                 [$tl, $tr, $br, $bl] = [$r[0], $r[1], $r[2], $r[3]];
  3034.                 break;
  3035.             default:
  3036.                 return;
  3037.         }
  3039.         $this->set_prop("border_top_left_radius", $tl, $important);
  3040.         $this->set_prop("border_top_right_radius", $tr, $important);
  3041.         $this->set_prop("border_bottom_right_radius", $br, $important);
  3042.         $this->set_prop("border_bottom_left_radius", $bl, $important);
  3043.     }
  3045.     /**
  3046.      * @param string $val
  3047.      * @param string $corner
  3048.      */
  3049.     protected function _set_border_radius_corner($val, $corner)
  3050.     {
  3051.         $prop = "border_" . $corner . "_radius";
  3053.         $this->_prop_cache[$prop] = null;
  3055.         if ($val === "inherit") {
  3056.             $this->_props_computed[$prop] = null;
  3057.             return;
  3058.         }
  3060.         $computed = mb_strpos($val, "%") === false
  3061.             ? $this->single_length_in_pt($val)
  3062.             : $val;
  3064.         $this->_props_computed[$prop] = $computed;
  3065.     }
  3067.     /**
  3068.      * @return float|int|string
  3069.      */
  3070.     function get_border_top_left_radius()
  3071.     {
  3072.         return $this->_get_border_radius_corner("top_left");
  3073.     }
  3075.     /**
  3076.      * @return float|int|string
  3077.      */
  3078.     function get_border_top_right_radius()
  3079.     {
  3080.         return $this->_get_border_radius_corner("top_right");
  3081.     }
  3083.     /**
  3084.      * @return float|int|string
  3085.      */
  3086.     function get_border_bottom_left_radius()
  3087.     {
  3088.         return $this->_get_border_radius_corner("bottom_left");
  3089.     }
  3091.     /**
  3092.      * @return float|int|string
  3093.      */
  3094.     function get_border_bottom_right_radius()
  3095.     {
  3096.         return $this->_get_border_radius_corner("bottom_right");
  3097.     }
  3099.     /**
  3100.      * @param $corner
  3101.      * @return float|int|string
  3102.      */
  3103.     protected function _get_border_radius_corner($corner)
  3104.     {
  3105.         $prop = "border_" . $corner . "_radius";
  3107.         if (!isset($this->_props_computed[$prop])) {
  3108.             return 0;
  3109.         }
  3111.         return $this->_props_computed[$prop];
  3112.     }
  3114.     /**
  3115.      * Sets the outline styles
  3116.      *
  3117.      * @link http://www.w3.org/TR/CSS21/ui.html#dynamic-outlines
  3118.      * @param string $value
  3119.      * @param bool $important
  3120.      */
  3121.     function set_outline($value, bool $important = false)
  3122.     {
  3123.         $components = $this->parse_property_value($value);
  3125.         foreach ($components as $val) {
  3126.             if (in_array($val, self::$BORDER_STYLES, true)) {
  3127.                 $this->set_prop("outline_style", $val, $important);
  3128.             } elseif ($this->is_color_value($val)) {
  3129.                 $this->set_prop("outline_color", $val, $important);
  3130.             } else {
  3131.                 // Assume width
  3132.                 $this->set_prop("outline_width", $val, $important);
  3133.             }
  3134.         }
  3135.     }
  3137.     /**
  3138.      * @param $val
  3139.      */
  3140.     function set_outline_width($val)
  3141.     {
  3142.         $this->_set_style_side_type("outline", "", "width", $val);
  3143.     }
  3145.     /**
  3146.      * @param $val
  3147.      */
  3148.     function set_outline_color($val)
  3149.     {
  3150.         $this->_set_style_side_type("outline", "", "color", $val);
  3151.     }
  3153.     /**
  3154.      * @param $val
  3155.      */
  3156.     function set_outline_style($val)
  3157.     {
  3158.         $this->_set_style_side_type("outline", "", "style", $val);
  3159.     }
  3161.     /**
  3162.      * Sets the border spacing
  3163.      *
  3164.      * @link http://www.w3.org/TR/CSS21/box.html#border-properties
  3165.      * @param float $val
  3166.      */
  3167.     function set_border_spacing($val)
  3168.     {
  3169.         $this->_prop_cache["border_spacing"] = null;
  3171.         if ($val === "inherit") {
  3172.             $this->_props_computed["border_spacing"] = null;
  3173.             return;
  3174.         }
  3176.         $arr = explode(" ", $val);
  3178.         if (count($arr) === 1) {
  3179.             $arr[1] = $arr[0];
  3180.         }
  3182.         $this->_props_computed["border_spacing"] = "$arr[0] $arr[1]";
  3183.     }
  3185.     /**
  3186.      * Sets the list style image
  3187.      *
  3188.      * @link http://www.w3.org/TR/CSS21/generate.html#propdef-list-style-image
  3189.      * @param $val
  3190.      */
  3191.     function set_list_style_image($val)
  3192.     {
  3193.         $this->_prop_cache["list_style_image"] = null;
  3195.         if ($val === "inherit") {
  3196.             $this->_props_computed["list_style_image"] = null;
  3197.             return;
  3198.         }
  3200.         $parsed_val = $this->_stylesheet->resolve_url($val);
  3202.         if ($parsed_val === "none") {
  3203.             $this->_props_computed["list_style_image"] = "none";
  3204.         } else {
  3205.             $this->_props_computed["list_style_image"] = "url(" . $parsed_val . ")";
  3206.         }
  3207.     }
  3209.     /**
  3210.      * Sets the list style
  3211.      *
  3212.      * @link http://www.w3.org/TR/CSS21/generate.html#propdef-list-style
  3213.      * @param string $value
  3214.      * @param bool $important
  3215.      */
  3216.     function set_list_style($value, bool $important = false)
  3217.     {
  3218.         static $positions = ["inside", "outside"];
  3219.         static $types = [
  3220.             "disc", "circle", "square",
  3221.             "decimal-leading-zero", "decimal", "1",
  3222.             "lower-roman", "upper-roman", "a", "A",
  3223.             "lower-greek",
  3224.             "lower-latin", "upper-latin",
  3225.             "lower-alpha", "upper-alpha",
  3226.             "armenian", "georgian", "hebrew",
  3227.             "cjk-ideographic", "hiragana", "katakana",
  3228.             "hiragana-iroha", "katakana-iroha", "none"
  3229.         ];
  3231.         $components = $this->parse_property_value($value);
  3233.         foreach ($components as $val) {
  3234.             /* http://www.w3.org/TR/CSS21/generate.html#list-style
  3235.              * A value of 'none' for the 'list-style' property sets both 'list-style-type' and 'list-style-image' to 'none'
  3236.              */
  3237.             if ($val === "none") {
  3238.                 $this->set_prop("list_style_type", $val, $important);
  3239.                 $this->set_prop("list_style_image", $val, $important);
  3240.                 continue;
  3241.             }
  3243.             //On setting or merging or inheriting list_style_image as well as list_style_type,
  3244.             //and url exists, then url has precedence, otherwise fall back to list_style_type
  3245.             //Firefox is wrong here (list_style_image gets overwritten on explicit list_style_type)
  3246.             //Internet Explorer 7/8 and dompdf is right.
  3248.             if (mb_substr($val, 0, 4) === "url(") {
  3249.                 $this->set_prop("list_style_image", $val, $important);
  3250.                 continue;
  3251.             }
  3253.             if (in_array($val, $types, true)) {
  3254.                 $this->set_prop("list_style_type", $val, $important);
  3255.             } elseif (in_array($val, $positions, true)) {
  3256.                 $this->set_prop("list_style_position", $val, $important);
  3257.             }
  3258.         }
  3259.     }
  3261.     /**
  3262.      * @param $val
  3263.      */
  3264.     function set_size($val)
  3265.     {
  3266.         $this->_prop_cache["size"] = null;
  3268.         $length_re = "/(\d+\s*(?:pt|px|pc|rem|em|ex|in|cm|mm|%))/";
  3270.         $val = mb_strtolower($val);
  3272.         if ($val === "auto") {
  3273.             $this->_props_computed["size"] = $val;
  3274.             return;
  3275.         }
  3277.         $parts = preg_split("/\s+/", $val);
  3279.         $computed = [];
  3280.         if (preg_match($length_re, $parts[0])) {
  3281.             $computed[] = $this->length_in_pt($parts[0]);
  3283.             if (isset($parts[1]) && preg_match($length_re, $parts[1])) {
  3284.                 $computed[] = $this->length_in_pt($parts[1]);
  3285.             } else {
  3286.                 $computed[] = $computed[0];
  3287.             }
  3289.             if (isset($parts[2]) && $parts[2] === "landscape") {
  3290.                 $computed = array_reverse($computed);
  3291.             }
  3292.         } elseif (isset(CPDF::$PAPER_SIZES[$parts[0]])) {
  3293.             $computed = array_slice(CPDF::$PAPER_SIZES[$parts[0]], 2, 2);
  3295.             if (isset($parts[1]) && $parts[1] === "landscape") {
  3296.                 $computed = array_reverse($computed);
  3297.             }
  3298.         } else {
  3299.             $this->_props_computed["size"] = null;
  3300.             return;
  3301.         }
  3303.         $this->_props_computed["size"] = $computed;
  3304.     }
  3306.     /**
  3307.      * Gets the CSS3 transform property
  3308.      *
  3309.      * @link http://www.w3.org/TR/css3-2d-transforms/#transform-property
  3310.      * @return array|null
  3311.      */
  3312.     function get_transform()
  3313.     {
  3314.         //TODO: should be handled in setter (lengths set to absolute)
  3316.         $number = "\s*([^,\s]+)\s*";
  3317.         $tr_value = "\s*([^,\s]+)\s*";
  3318.         $angle = "\s*([^,\s]+(?:deg|rad)?)\s*";
  3320.         if (!preg_match_all("/[a-z]+\([^\)]+\)/i", $this->_props_computed["transform"], $parts, PREG_SET_ORDER)) {
  3321.             return null;
  3322.         }
  3324.         $functions = [
  3325.             //"matrix"     => "\($number,$number,$number,$number,$number,$number\)",
  3327.             "translate" => "\($tr_value(?:,$tr_value)?\)",
  3328.             "translateX" => "\($tr_value\)",
  3329.             "translateY" => "\($tr_value\)",
  3331.             "scale" => "\($number(?:,$number)?\)",
  3332.             "scaleX" => "\($number\)",
  3333.             "scaleY" => "\($number\)",
  3335.             "rotate" => "\($angle\)",
  3337.             "skew" => "\($angle(?:,$angle)?\)",
  3338.             "skewX" => "\($angle\)",
  3339.             "skewY" => "\($angle\)",
  3340.         ];
  3342.         $transforms = [];
  3344.         foreach ($parts as $part) {
  3345.             $t = $part[0];
  3347.             foreach ($functions as $name => $pattern) {
  3348.                 if (preg_match("/$name\s*$pattern/i", $t, $matches)) {
  3349.                     $values = array_slice($matches, 1);
  3351.                     switch ($name) {
  3352.                         // <angle> units
  3353.                         case "rotate":
  3354.                         case "skew":
  3355.                         case "skewX":
  3356.                         case "skewY":
  3358.                             foreach ($values as $i => $value) {
  3359.                                 if (strpos($value, "rad")) {
  3360.                                     $values[$i] = rad2deg(floatval($value));
  3361.                                 } else {
  3362.                                     $values[$i] = floatval($value);
  3363.                                 }
  3364.                             }
  3366.                             switch ($name) {
  3367.                                 case "skew":
  3368.                                     if (!isset($values[1])) {
  3369.                                         $values[1] = 0;
  3370.                                     }
  3371.                                     break;
  3372.                                 case "skewX":
  3373.                                     $name = "skew";
  3374.                                     $values = [$values[0], 0];
  3375.                                     break;
  3376.                                 case "skewY":
  3377.                                     $name = "skew";
  3378.                                     $values = [0, $values[0]];
  3379.                                     break;
  3380.                             }
  3381.                             break;
  3383.                         // <translation-value> units
  3384.                         case "translate":
  3385.                             $values[0] = $this->length_in_pt($values[0], (float)$this->length_in_pt($this->width));
  3387.                             if (isset($values[1])) {
  3388.                                 $values[1] = $this->length_in_pt($values[1], (float)$this->length_in_pt($this->height));
  3389.                             } else {
  3390.                                 $values[1] = 0;
  3391.                             }
  3392.                             break;
  3394.                         case "translateX":
  3395.                             $name = "translate";
  3396.                             $values = [$this->length_in_pt($values[0], (float)$this->length_in_pt($this->width)), 0];
  3397.                             break;
  3399.                         case "translateY":
  3400.                             $name = "translate";
  3401.                             $values = [0, $this->length_in_pt($values[0], (float)$this->length_in_pt($this->height))];
  3402.                             break;
  3404.                         // <number> units
  3405.                         case "scale":
  3406.                             if (!isset($values[1])) {
  3407.                                 $values[1] = $values[0];
  3408.                             }
  3409.                             break;
  3411.                         case "scaleX":
  3412.                             $name = "scale";
  3413.                             $values = [$values[0], 1.0];
  3414.                             break;
  3416.                         case "scaleY":
  3417.                             $name = "scale";
  3418.                             $values = [1.0, $values[0]];
  3419.                             break;
  3420.                     }
  3422.                     $transforms[] = [
  3423.                         $name,
  3424.                         $values,
  3425.                     ];
  3426.                 }
  3427.             }
  3428.         }
  3430.         return $transforms;
  3431.     }
  3433.     /**
  3434.      * @param $val
  3435.      */
  3436.     function set_transform($val)
  3437.     {
  3438.         $this->_prop_cache["transform"] = null;
  3440.         if ($val === "inherit") {
  3441.             $this->_props_computed["transform"] = null;
  3442.             return;
  3443.         }
  3444.         
  3445.         $this->_props_computed["transform"] = $val;
  3446.     }
  3448.     /**
  3449.      * Sets the CSS3 transform-origin property
  3450.      *
  3451.      * @link http://www.w3.org/TR/css3-2d-transforms/#transform-origin
  3452.      * @param string $val
  3453.      */
  3454.     function set_transform_origin($val)
  3455.     {
  3456.         $this->_prop_cache["transform_origin"] = null;
  3458.         if ($val === "inherit") {
  3459.             $this->_props_computed["transform_origin"] = null;
  3460.             return;
  3461.         }
  3463.         $this->_props_computed["transform_origin"] = $val;
  3464.     }
  3466.     /**
  3467.      * Gets the CSS3 transform-origin property
  3468.      *
  3469.      * @link http://www.w3.org/TR/css3-2d-transforms/#transform-origin
  3470.      * @return mixed[]
  3471.      */
  3472.     function get_transform_origin()
  3473.     {
  3474.         //TODO: should be handled in setter
  3475.         
  3476.         $values = preg_split("/\s+/", $this->_props_computed["transform_origin"]);
  3478.         $values = array_map(function ($value) {
  3479.             if (in_array($value, ["top", "left"])) {
  3480.                 return 0;
  3481.             } else if (in_array($value, ["bottom", "right"])) {
  3482.                 return "100%";
  3483.             } else {
  3484.                 return $value;
  3485.             }
  3486.         }, $values);
  3488.         if (!isset($values[1])) {
  3489.             $values[1] = $values[0];
  3490.         }
  3492.         return $values;
  3493.     }
  3495.     /**
  3496.      * @param $val
  3497.      * @return null
  3498.      */
  3499.     protected function parse_image_resolution($val)
  3500.     {
  3501.         // If exif data could be get:
  3502.         // $re = '/^\s*(\d+|normal|auto)(?:\s*,\s*(\d+|normal))?\s*$/';
  3504.         $re = '/^\s*(\d+|normal|auto)\s*$/';
  3506.         if (!preg_match($re, $val, $matches)) {
  3507.             return null;
  3508.         }
  3510.         return $matches[1];
  3511.     }
  3513.     /**
  3514.      * auto | normal | dpi
  3515.      *
  3516.      * @param $val
  3517.      */
  3518.     function set_background_image_resolution($val)
  3519.     {
  3520.         $this->_prop_cache["background_image_resolution"] = null;
  3522.         if ($val === "inherit") {
  3523.             $this->_props_computed["background_image_resolution"] = null;
  3524.             return;
  3525.         }
  3527.         $parsed = $this->parse_image_resolution($val);
  3529.         $this->_props_computed["background_image_resolution"] = $parsed;
  3530.     }
  3532.     /**
  3533.      * auto | normal | dpi
  3534.      *
  3535.      * @param $val
  3536.      */
  3537.     function set_image_resolution($val)
  3538.     {
  3539.         $this->_prop_cache["image_resolution"] = null;
  3541.         if ($val === "inherit") {
  3542.             $this->_props_computed["image_resolution"] = null;
  3543.             return;
  3544.         }
  3546.         $parsed = $this->parse_image_resolution($val);
  3548.         $this->_props_computed["image_resolution"] = $parsed;
  3549.     }
  3551.     /**
  3552.      * @param $val
  3553.      */
  3554.     function set_z_index($val)
  3555.     {
  3556.         $this->_prop_cache["z_index"] = null;
  3558.         if ($val === "inherit") {
  3559.             $this->_props_computed["z_index"] = null;
  3560.             return;
  3561.         }
  3563.         if ($val !== "auto" && round((float) $val) != $val) {
  3564.             $this->_props_computed["z_index"] = null;
  3565.             return;
  3566.         }
  3568.         $this->_props_computed["z_index"] = $val;
  3569.     }
  3571.     /**
  3572.      * @param FontMetrics $fontMetrics
  3573.      * @return $this
  3574.      */
  3575.     public function setFontMetrics(FontMetrics $fontMetrics)
  3576.     {
  3577.         $this->fontMetrics = $fontMetrics;
  3578.         return $this;
  3579.     }
  3581.     /**
  3582.      * @return FontMetrics
  3583.      */
  3584.     public function getFontMetrics()
  3585.     {
  3586.         return $this->fontMetrics;
  3587.     }
  3589.     /**
  3590.      * Generate a string representation of the Style
  3591.      *
  3592.      * This dumps the entire property array into a string via print_r.  Useful
  3593.      * for debugging.
  3594.      *
  3595.      * @return string
  3596.      */
  3597.     /*DEBUGCSS print: see below additional debugging util*/
  3598.     function __toString()
  3599.     {
  3600.         $parent_font_size = $this->parent_style
  3601.             ? $this->parent_style->font_size
  3602.             : self::$default_font_size;
  3604.         return print_r(array_merge(["parent_font_size" => $parent_font_size ],
  3605.             $this->_props), true);
  3606.     }
  3608.     /*DEBUGCSS*/
  3609.     function debug_print()
  3610.     {
  3611.         $parent_font_size = $this->parent_style
  3612.             ? $this->parent_style->font_size
  3613.             : self::$default_font_size;
  3615.         print "    parent_font_size:" . $parent_font_size . ";\n";
  3616.         print "    Props [\n";
  3617.         print "      specified [\n";
  3618.         foreach ($this->_props as $prop => $val) {
  3619.             print '        ' . $prop . ': ' . preg_replace("/\r\n/", ' ', print_r($val, true));
  3620.             if (isset($this->_important_props[$prop])) {
  3621.                 print ' !important';
  3622.             }
  3623.             print ";\n";
  3624.         }
  3625.         print "      ]\n";
  3626.         print "      computed [\n";
  3627.         foreach ($this->_props_computed as $prop => $val) {
  3628.             print '        ' . $prop . ': ' . preg_replace("/\r\n/", ' ', print_r($val, true));
  3629.             print ";\n";
  3630.         }
  3631.         print "      ]\n";
  3632.         print "      cached [\n";
  3633.         foreach ($this->_prop_cache as $prop => $val) {
  3634.             print '        ' . $prop . ': ' . preg_replace("/\r\n/", ' ', print_r($val, true));
  3635.             print ";\n";
  3636.         }
  3637.         print "      ]\n";
  3638.         print "    ]\n";
  3639.     }
  3640. }