source: spip-zone/_core_/branches/spip-3.2/plugins/compresseur/lib/csstidy/class.csstidy_optimise.php @ 111766

Last change on this file since 111766 was 111766, checked in by cedric@…, 11 months ago

Maj de CSSTidy en v1.6.3

File size: 39.1 KB
Line 
1<?php
2
3/**
4 * CSSTidy - CSS Parser and Optimiser
5 *
6 * CSS Optimising Class
7 * This class optimises CSS data generated by csstidy.
8 *
9 * Copyright 2005, 2006, 2007 Florian Schmitz
10 *
11 * This file is part of CSSTidy.
12 *
13 *   CSSTidy is free software; you can redistribute it and/or modify
14 *   it under the terms of the GNU Lesser General Public License as published by
15 *   the Free Software Foundation; either version 2.1 of the License, or
16 *   (at your option) any later version.
17 *
18 *   CSSTidy is distributed in the hope that it will be useful,
19 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
20 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
21 *   GNU Lesser General Public License for more details.
22 *
23 *   You should have received a copy of the GNU Lesser General Public License
24 *   along with this program.  If not, see <http://www.gnu.org/licenses/>.
25 *
26 * @license http://opensource.org/licenses/lgpl-license.php GNU Lesser General Public License
27 * @package csstidy
28 * @author Florian Schmitz (floele at gmail dot com) 2005-2007
29 * @author Brett Zamir (brettz9 at yahoo dot com) 2007
30 * @author Nikolay Matsievsky (speed at webo dot name) 2009-2010
31 * @author Cedric Morin (cedric at yterium dot com) 2010-2012
32 */
33
34/**
35 * CSS Optimising Class
36 *
37 * This class optimises CSS data generated by csstidy.
38 *
39 * @package csstidy
40 * @author Florian Schmitz (floele at gmail dot com) 2005-2006
41 * @version 1.0
42 */
43class csstidy_optimise {
44
45        /**
46         * csstidy object
47         * @var object
48         */
49        public $parser;
50
51        /**
52         * Constructor
53         * @param array $css contains the class csstidy
54         * @access private
55         * @version 1.0
56         */
57        public function __construct($css) {
58                $this->parser = $css;
59                $this->css = & $css->css;
60                $this->sub_value = & $css->sub_value;
61                $this->at = & $css->at;
62                $this->selector = & $css->selector;
63                $this->property = & $css->property;
64                $this->value = & $css->value;
65        }
66
67        /**
68         * Optimises $css after parsing
69         * @access public
70         * @version 1.0
71         */
72        public function postparse() {
73
74                if ($this->parser->get_cfg('reverse_left_and_right') > 0) {
75
76                        foreach ($this->css as $medium => $selectors) {
77                                foreach ($selectors as $selector => $properties) {
78                                        $this->css[$medium][$selector] = $this->reverse_left_and_right($this->css[$medium][$selector]);
79                                }
80                        }
81
82                }
83
84                if ($this->parser->get_cfg('preserve_css')) {
85                        return;
86                }
87
88                if ((int)$this->parser->get_cfg('merge_selectors') === 2) {
89                        foreach ($this->css as $medium => $value) {
90                                $this->merge_selectors($this->css[$medium]);
91                        }
92                }
93
94                if ($this->parser->get_cfg('discard_invalid_selectors')) {
95                        foreach ($this->css as $medium => $value) {
96                                $this->discard_invalid_selectors($this->css[$medium]);
97                        }
98                }
99
100                if ($this->parser->get_cfg('optimise_shorthands') > 0) {
101                        foreach ($this->css as $medium => $value) {
102                                foreach ($value as $selector => $value1) {
103                                        $this->css[$medium][$selector] = $this->merge_4value_shorthands($this->css[$medium][$selector]);
104                                        $this->css[$medium][$selector] = $this->merge_4value_radius_shorthands($this->css[$medium][$selector]);
105
106                                        if ($this->parser->get_cfg('optimise_shorthands') < 2) {
107                                                continue;
108                                        }
109
110                                        $this->css[$medium][$selector] = $this->merge_font($this->css[$medium][$selector]);
111
112                                        if ($this->parser->get_cfg('optimise_shorthands') < 3) {
113                                                continue;
114                                        }
115
116                                        $this->css[$medium][$selector] = $this->merge_bg($this->css[$medium][$selector]);
117                                        if (empty($this->css[$medium][$selector])) {
118                                                unset($this->css[$medium][$selector]);
119                                        }
120                                }
121                        }
122                }
123        }
124
125        /**
126         * Optimises values
127         * @access public
128         * @version 1.0
129         */
130        public function value() {
131                $shorthands = & $this->parser->data['csstidy']['shorthands'];
132
133                // optimise shorthand properties
134                if (isset($shorthands[$this->property])) {
135                        $temp = $this->shorthand($this->value); // FIXME - move
136                        if ($temp != $this->value) {
137                                $this->parser->log('Optimised shorthand notation (' . $this->property . '): Changed "' . $this->value . '" to "' . $temp . '"', 'Information');
138                        }
139                        $this->value = $temp;
140                }
141
142                // Remove whitespace at ! important
143                if ($this->value != $this->compress_important($this->value)) {
144                        $this->parser->log('Optimised !important', 'Information');
145                }
146        }
147
148        /**
149         * Optimises shorthands
150         * @access public
151         * @version 1.0
152         */
153        public function shorthands() {
154                $shorthands = & $this->parser->data['csstidy']['shorthands'];
155
156                if (!$this->parser->get_cfg('optimise_shorthands') || $this->parser->get_cfg('preserve_css')) {
157                        return;
158                }
159
160                if ($this->property === 'font' && $this->parser->get_cfg('optimise_shorthands') > 1) {
161                        $this->css[$this->at][$this->selector]['font']='';
162                        $this->parser->merge_css_blocks($this->at, $this->selector, $this->dissolve_short_font($this->value));
163                }
164                if ($this->property === 'background' && $this->parser->get_cfg('optimise_shorthands') > 2) {
165                        $this->css[$this->at][$this->selector]['background']='';
166                        $this->parser->merge_css_blocks($this->at, $this->selector, $this->dissolve_short_bg($this->value));
167                }
168                if (isset($shorthands[$this->property])) {
169                        $this->parser->merge_css_blocks($this->at, $this->selector, $this->dissolve_4value_shorthands($this->property, $this->value));
170                        if (is_array($shorthands[$this->property])) {
171                                $this->css[$this->at][$this->selector][$this->property] = '';
172                        }
173                }
174        }
175
176        /**
177         * Optimises a sub-value
178         * @access public
179         * @version 1.0
180         */
181        public function subvalue() {
182                $replace_colors = & $this->parser->data['csstidy']['replace_colors'];
183
184                $this->sub_value = trim($this->sub_value);
185                if ($this->sub_value == '') { // caution : '0'
186                        return;
187                }
188
189                $important = '';
190                if ($this->parser->is_important($this->sub_value)) {
191                        $important = '!important';
192                }
193                $this->sub_value = $this->parser->gvw_important($this->sub_value);
194
195                // Compress font-weight
196                if ($this->property === 'font-weight' && $this->parser->get_cfg('compress_font-weight')) {
197                        if ($this->sub_value === 'bold') {
198                                $this->sub_value = '700';
199                                $this->parser->log('Optimised font-weight: Changed "bold" to "700"', 'Information');
200                        } elseif ($this->sub_value === 'normal') {
201                                $this->sub_value = '400';
202                                $this->parser->log('Optimised font-weight: Changed "normal" to "400"', 'Information');
203                        }
204                }
205
206                $temp = $this->compress_numbers($this->sub_value);
207                if (strcasecmp($temp, $this->sub_value) !== 0) {
208                        if (strlen($temp) > strlen($this->sub_value)) {
209                                $this->parser->log('Fixed invalid number: Changed "' . $this->sub_value . '" to "' . $temp . '"', 'Warning');
210                        } else {
211                                $this->parser->log('Optimised number: Changed "' . $this->sub_value . '" to "' . $temp . '"', 'Information');
212                        }
213                        $this->sub_value = $temp;
214                }
215                if ($this->parser->get_cfg('compress_colors')) {
216                        $temp = $this->cut_color($this->sub_value);
217                        if ($temp !== $this->sub_value) {
218                                if (isset($replace_colors[$this->sub_value])) {
219                                        $this->parser->log('Fixed invalid color name: Changed "' . $this->sub_value . '" to "' . $temp . '"', 'Warning');
220                                } else {
221                                        $this->parser->log('Optimised color: Changed "' . $this->sub_value . '" to "' . $temp . '"', 'Information');
222                                }
223                                $this->sub_value = $temp;
224                        }
225                }
226                $this->sub_value .= $important;
227        }
228
229        /**
230         * Compresses shorthand values. Example: margin:1px 1px 1px 1px -> margin:1px
231         * @param string $value
232         * @access public
233         * @return string
234         * @version 1.0
235         */
236        public function shorthand($value) {
237                $important = '';
238                if ($this->parser->is_important($value)) {
239                        $values = $this->parser->gvw_important($value);
240                        $important = '!important';
241                }
242                else
243                        $values = $value;
244
245                $values = explode(' ', $values);
246                switch (count($values)) {
247                        case 4:
248                                if ($values[0] == $values[1] && $values[0] == $values[2] && $values[0] == $values[3]) {
249                                        return $values[0] . $important;
250                                } elseif ($values[1] == $values[3] && $values[0] == $values[2]) {
251                                        return $values[0] . ' ' . $values[1] . $important;
252                                } elseif ($values[1] == $values[3]) {
253                                        return $values[0] . ' ' . $values[1] . ' ' . $values[2] . $important;
254                                }
255                                break;
256
257                        case 3:
258                                if ($values[0] == $values[1] && $values[0] == $values[2]) {
259                                        return $values[0] . $important;
260                                } elseif ($values[0] == $values[2]) {
261                                        return $values[0] . ' ' . $values[1] . $important;
262                                }
263                                break;
264
265                        case 2:
266                                if ($values[0] == $values[1]) {
267                                        return $values[0] . $important;
268                                }
269                                break;
270                }
271
272                return $value;
273        }
274
275        /**
276         * Removes unnecessary whitespace in ! important
277         * @param string $string
278         * @return string
279         * @access public
280         * @version 1.1
281         */
282        public function compress_important(&$string) {
283                if ($this->parser->is_important($string)) {
284                        $important = $this->parser->get_cfg('space_before_important') ? ' !important' : '!important';
285                        $string = $this->parser->gvw_important($string) . $important;
286                }
287                return $string;
288        }
289
290        /**
291         * Color compression function. Converts all rgb() values to #-values and uses the short-form if possible. Also replaces 4 color names by #-values.
292         * @param string $color
293         * @return string
294         * @version 1.1
295         */
296        public function cut_color($color) {
297                $replace_colors = & $this->parser->data['csstidy']['replace_colors'];
298
299                // if it's a string, don't touch !
300                if (strncmp($color, "'", 1) == 0 || strncmp($color, '"', 1) == 0)
301                        return $color;
302
303                /* expressions complexes de type gradient */
304                if (strpos($color, '(') !== false && strncmp($color, 'rgb(' ,4) != 0) {
305                        // on ne touche pas aux couleurs dans les expression ms, c'est trop sensible
306                        if (stripos($color, 'progid:') !== false)
307                                return $color;
308                        preg_match_all(",rgb\([^)]+\),i", $color, $matches, PREG_SET_ORDER);
309                        if (count($matches)) {
310                                foreach ($matches as $m) {
311                                        $color = str_replace($m[0], $this->cut_color($m[0]), $color);
312                                }
313                        }
314                        preg_match_all(",#[0-9a-f]{6}(?=[^0-9a-f]),i", $color, $matches, PREG_SET_ORDER);
315                        if (count($matches)) {
316                                foreach ($matches as $m) {
317                                        $color = str_replace($m[0],$this->cut_color($m[0]), $color);
318                                }
319                        }
320                        return $color;
321                }
322
323                // rgb(0,0,0) -> #000000 (or #000 in this case later)
324                if (strncasecmp($color, 'rgb(', 4)==0) {
325                        $color_tmp = substr($color, 4, strlen($color) - 5);
326                        $color_tmp = explode(',', $color_tmp);
327                        for ($i = 0; $i < count($color_tmp); $i++) {
328                                $color_tmp[$i] = trim($color_tmp[$i]);
329                                if (substr($color_tmp[$i], -1) === '%') {
330                                        $color_tmp[$i] = round((255 * $color_tmp[$i]) / 100);
331                                }
332                                if ($color_tmp[$i] > 255)
333                                        $color_tmp[$i] = 255;
334                        }
335                        $color = '#';
336                        for ($i = 0; $i < 3; $i++) {
337                                if ($color_tmp[$i] < 16) {
338                                        $color .= '0' . dechex($color_tmp[$i]);
339                                } else {
340                                        $color .= dechex($color_tmp[$i]);
341                                }
342                        }
343                }
344
345                // Fix bad color names
346                if (isset($replace_colors[strtolower($color)])) {
347                        $color = $replace_colors[strtolower($color)];
348                }
349
350                // #aabbcc -> #abc
351                if (strlen($color) == 7) {
352                        $color_temp = strtolower($color);
353                        if ($color_temp{0} === '#' && $color_temp{1} == $color_temp{2} && $color_temp{3} == $color_temp{4} && $color_temp{5} == $color_temp{6}) {
354                                $color = '#' . $color{1} . $color{3} . $color{5};
355                        }
356                }
357
358                switch (strtolower($color)) {
359                        /* color name -> hex code */
360                        case 'black': return '#000';
361                        case 'fuchsia': return '#f0f';
362                        case 'white': return '#fff';
363                        case 'yellow': return '#ff0';
364
365                        /* hex code -> color name */
366                        case '#800000': return 'maroon';
367                        case '#ffa500': return 'orange';
368                        case '#808000': return 'olive';
369                        case '#800080': return 'purple';
370                        case '#008000': return 'green';
371                        case '#000080': return 'navy';
372                        case '#008080': return 'teal';
373                        case '#c0c0c0': return 'silver';
374                        case '#808080': return 'gray';
375                        case '#f00': return 'red';
376                }
377
378                return $color;
379        }
380
381        /**
382         * Compresses numbers (ie. 1.0 becomes 1 or 1.100 becomes 1.1 )
383         * @param string $subvalue
384         * @return string
385         * @version 1.2
386         */
387        public function compress_numbers($subvalue) {
388                $unit_values = & $this->parser->data['csstidy']['unit_values'];
389                $color_values = & $this->parser->data['csstidy']['color_values'];
390
391                // for font:1em/1em sans-serif...;
392                if ($this->property === 'font') {
393                        $temp = explode('/', $subvalue);
394                } else {
395                        $temp = array($subvalue);
396                }
397
398                for ($l = 0; $l < count($temp); $l++) {
399                        // if we are not dealing with a number at this point, do not optimise anything
400                        $number = $this->AnalyseCssNumber($temp[$l]);
401                        if ($number === false) {
402                                return $subvalue;
403                        }
404
405                        // Fix bad colors
406                        if (in_array($this->property, $color_values)) {
407                                $temp[$l] = '#' . $temp[$l];
408                                continue;
409                        }
410
411                        if (abs($number[0]) > 0) {
412                                if ($number[1] == '' && in_array($this->property, $unit_values, true)) {
413                                        $number[1] = 'px';
414                                }
415                        } elseif ($number[1] != 's' && $number[1] != 'ms') {
416                                $number[1] = '';
417                        }
418
419                        $temp[$l] = $number[0] . $number[1];
420                }
421
422                return ((count($temp) > 1) ? $temp[0] . '/' . $temp[1] : $temp[0]);
423        }
424
425        /**
426         * Checks if a given string is a CSS valid number. If it is,
427         * an array containing the value and unit is returned
428         * @param string $string
429         * @return array ('unit' if unit is found or '' if no unit exists, number value) or false if no number
430         */
431        public function AnalyseCssNumber($string) {
432                // most simple checks first
433                if (strlen($string) == 0 || ctype_alpha($string{0})) {
434                        return false;
435                }
436
437                $units = & $this->parser->data['csstidy']['units'];
438                $return = array(0, '');
439
440                $return[0] = floatval($string);
441                if (abs($return[0]) > 0 && abs($return[0]) < 1) {
442                        if ($return[0] < 0) {
443                                $return[0] = '-' . ltrim(substr($return[0], 1), '0');
444                        } else {
445                                $return[0] = ltrim($return[0], '0');
446                        }
447                }
448
449                // Look for unit and split from value if exists
450                foreach ($units as $unit) {
451                        $expectUnitAt = strlen($string) - strlen($unit);
452                        if (!($unitInString = stristr($string, $unit))) { // mb_strpos() fails with "false"
453                                continue;
454                        }
455                        $actualPosition = strpos($string, $unitInString);
456                        if ($expectUnitAt === $actualPosition) {
457                                $return[1] = $unit;
458                                $string = substr($string, 0, - strlen($unit));
459                                break;
460                        }
461                }
462                if (!is_numeric($string)) {
463                        return false;
464                }
465                return $return;
466        }
467
468        /**
469         * Merges selectors with same properties. Example: a{color:red} b{color:red} -> a,b{color:red}
470         * Very basic and has at least one bug. Hopefully there is a replacement soon.
471         * @param array $array
472         * @return array
473         * @access public
474         * @version 1.2
475         */
476        public function merge_selectors(&$array) {
477                $css = $array;
478                foreach ($css as $key => $value) {
479                        if (!isset($css[$key])) {
480                                continue;
481                        }
482                        $newsel = '';
483
484                        // Check if properties also exist in another selector
485                        $keys = array();
486                        // PHP bug (?) without $css = $array; here
487                        foreach ($css as $selector => $vali) {
488                                if ($selector == $key) {
489                                        continue;
490                                }
491
492                                if ($css[$key] === $vali) {
493                                        $keys[] = $selector;
494                                }
495                        }
496
497                        if (!empty($keys)) {
498                                $newsel = $key;
499                                unset($css[$key]);
500                                foreach ($keys as $selector) {
501                                        unset($css[$selector]);
502                                        $newsel .= ',' . $selector;
503                                }
504                                $css[$newsel] = $value;
505                        }
506                }
507                $array = $css;
508        }
509
510        /**
511         * Removes invalid selectors and their corresponding rule-sets as
512         * defined by 4.1.7 in REC-CSS2. This is a very rudimentary check
513         * and should be replaced by a full-blown parsing algorithm or
514         * regular expression
515         * @version 1.4
516         */
517        public function discard_invalid_selectors(&$array) {
518                $invalid = array('+' => true, '~' => true, ',' => true, '>' => true);
519                foreach ($array as $selector => $decls) {
520                        $ok = true;
521                        $selectors = array_map('trim', explode(',', $selector));
522                        foreach ($selectors as $s) {
523                                $simple_selectors = preg_split('/\s*[+>~\s]\s*/', $s);
524                                foreach ($simple_selectors as $ss) {
525                                        if ($ss === '')
526                                                $ok = false;
527                                        // could also check $ss for internal structure,
528                                        // but that probably would be too slow
529                                }
530                        }
531                        if (!$ok)
532                                unset($array[$selector]);
533                }
534        }
535
536        /**
537         * Dissolves properties like padding:10px 10px 10px to padding-top:10px;padding-bottom:10px;...
538         * @param string $property
539         * @param string $value
540         * @param array|null $shorthands
541         * @return array
542         * @version 1.0
543         * @see merge_4value_shorthands()
544         */
545        public function dissolve_4value_shorthands($property, $value, $shorthands = null) {
546                if (is_null($shorthands)) {
547                        $shorthands = & $this->parser->data['csstidy']['shorthands'];
548                }
549                if (!is_array($shorthands[$property])) {
550                        $return[$property] = $value;
551                        return $return;
552                }
553
554                $important = '';
555                if ($this->parser->is_important($value)) {
556                        $value = $this->parser->gvw_important($value);
557                        $important = '!important';
558                }
559                $values = explode(' ', $value);
560
561
562                $return = array();
563                if (count($values) == 4) {
564                        for ($i = 0; $i < 4; $i++) {
565                                $return[$shorthands[$property][$i]] = $values[$i] . $important;
566                        }
567                } elseif (count($values) == 3) {
568                        $return[$shorthands[$property][0]] = $values[0] . $important;
569                        $return[$shorthands[$property][1]] = $values[1] . $important;
570                        $return[$shorthands[$property][3]] = $values[1] . $important;
571                        $return[$shorthands[$property][2]] = $values[2] . $important;
572                } elseif (count($values) == 2) {
573                        for ($i = 0; $i < 4; $i++) {
574                                $return[$shorthands[$property][$i]] = (($i % 2 != 0)) ? $values[1] . $important : $values[0] . $important;
575                        }
576                } else {
577                        for ($i = 0; $i < 4; $i++) {
578                                $return[$shorthands[$property][$i]] = $values[0] . $important;
579                        }
580                }
581
582                return $return;
583        }
584
585        /**
586         * Dissolves radius properties like
587         * border-radius:10px 10px 10px / 1px 2px
588         * to border-top-left:10px 1px;border-top-right:10px 2x;...
589         * @param string $property
590         * @param string $value
591         * @return array
592         * @version 1.0
593         * @use dissolve_4value_shorthands()
594         * @see merge_4value_radius_shorthands()
595         */
596        public function dissolve_4value_radius_shorthands($property, $value) {
597                $shorthands = & $this->parser->data['csstidy']['radius_shorthands'];
598                if (!is_array($shorthands[$property])) {
599                        $return[$property] = $value;
600                        return $return;
601                }
602
603                if (strpos($value, '/') !== false) {
604                        $values = $this->explode_ws('/', $value);
605                        if (count($values) == 2) {
606                                $r[0] = $this->dissolve_4value_shorthands($property, trim($values[0]), $shorthands);
607                                $r[1] = $this->dissolve_4value_shorthands($property, trim($values[1]), $shorthands);
608                                $return = array();
609                                foreach ($r[0] as $p=>$v) {
610                                        $return[$p] = $v;
611                                        if ($r[1][$p] !== $v) {
612                                                $return[$p] .= ' ' . $r[1][$p];
613                                        }
614                                }
615                                return $return;
616                        }
617                }
618
619                $return = $this->dissolve_4value_shorthands($property, $value, $shorthands);
620                return $return;
621        }
622
623        /**
624         * Explodes a string as explode() does, however, not if $sep is escaped or within a string.
625         * @param string $sep seperator
626         * @param string $string
627         * @param bool $explode_in_parenthesis
628         * @return array
629         * @version 1.0
630         */
631        public function explode_ws($sep, $string, $explode_in_parenthesis = false) {
632                $status = 'st';
633                $to = '';
634
635                $output = array(
636                        0 => '',
637                );
638                $num = 0;
639                for ($i = 0, $len = strlen($string); $i < $len; $i++) {
640                        switch ($status) {
641                                case 'st':
642                                        if ($string{$i} == $sep && !$this->parser->escaped($string, $i)) {
643                                                ++$num;
644                                        } elseif ($string{$i} === '"' || $string{$i} === '\'' || (!$explode_in_parenthesis && $string{$i} === '(') && !$this->parser->escaped($string, $i)) {
645                                                $status = 'str';
646                                                $to = ($string{$i} === '(') ? ')' : $string{$i};
647                                                (isset($output[$num])) ? $output[$num] .= $string{$i} : $output[$num] = $string{$i};
648                                        } else {
649                                                (isset($output[$num])) ? $output[$num] .= $string{$i} : $output[$num] = $string{$i};
650                                        }
651                                        break;
652
653                                case 'str':
654                                        if ($string{$i} == $to && !$this->parser->escaped($string, $i)) {
655                                                $status = 'st';
656                                        }
657                                        (isset($output[$num])) ? $output[$num] .= $string{$i} : $output[$num] = $string{$i};
658                                        break;
659                        }
660                }
661
662                return $output;
663        }
664
665        /**
666         * Merges Shorthand properties again, the opposite of dissolve_4value_shorthands()
667         * @param array $array
668         * @param array|null $shorthands
669         * @return array
670         * @version 1.2
671         * @see dissolve_4value_shorthands()
672         */
673        public function merge_4value_shorthands($array, $shorthands = null) {
674                $return = $array;
675                if (is_null($shorthands)) {
676                        $shorthands = & $this->parser->data['csstidy']['shorthands'];
677                }
678
679                foreach ($shorthands as $key => $value) {
680                        if ($value !== 0 && isset($array[$value[0]]) && isset($array[$value[1]])
681                                                        && isset($array[$value[2]]) && isset($array[$value[3]])) {
682                                $return[$key] = '';
683
684                                $important = '';
685                                for ($i = 0; $i < 4; $i++) {
686                                        $val = $array[$value[$i]];
687                                        if ($this->parser->is_important($val)) {
688                                                $important = '!important';
689                                                $return[$key] .= $this->parser->gvw_important($val) . ' ';
690                                        } else {
691                                                $return[$key] .= $val . ' ';
692                                        }
693                                        unset($return[$value[$i]]);
694                                }
695                                $return[$key] = $this->shorthand(trim($return[$key] . $important));
696                        }
697                }
698                return $return;
699        }
700
701        /**
702         * Merges Shorthand properties again, the opposite of dissolve_4value_shorthands()
703         * @param array $array
704         * @return array
705         * @version 1.2
706         * @use merge_4value_shorthands()
707         * @see dissolve_4value_radius_shorthands()
708         */
709        public function merge_4value_radius_shorthands($array) {
710                $return = $array;
711                $shorthands = & $this->parser->data['csstidy']['radius_shorthands'];
712
713                foreach ($shorthands as $key => $value) {
714                        if (isset($array[$value[0]]) && isset($array[$value[1]])
715                                                        && isset($array[$value[2]]) && isset($array[$value[3]]) && $value !== 0) {
716                                $return[$key] = '';
717                                $a = array();
718                                for ($i = 0; $i < 4; $i++) {
719                                        $v = $this->explode_ws(' ', trim($array[$value[$i]]));
720                                        $a[0][$value[$i]] = reset($v);
721                                        $a[1][$value[$i]] = end($v);
722                                }
723                                $r = array();
724                                $r[0] = $this->merge_4value_shorthands($a[0], $shorthands);
725                                $r[1] = $this->merge_4value_shorthands($a[1], $shorthands);
726
727                                if (isset($r[0][$key]) and isset($r[1][$key])) {
728                                        $return[$key] = $r[0][$key];
729                                        if ($r[1][$key] !== $r[0][$key]) {
730                                                $return[$key] .= ' / ' . $r[1][$key];
731                                        }
732                                        for ($i = 0; $i < 4; $i++) {
733                                                unset($return[$value[$i]]);
734                                        }
735                                }
736                        }
737                }
738                return $return;
739        }
740        /**
741         * Dissolve background property
742         * @param string $str_value
743         * @return array
744         * @version 1.0
745         * @see merge_bg()
746         * @todo full CSS 3 compliance
747         */
748        public function dissolve_short_bg($str_value) {
749                // don't try to explose background gradient !
750                if (stripos($str_value, 'gradient(')!== false)
751                        return array('background'=>$str_value);
752
753                $background_prop_default = & $this->parser->data['csstidy']['background_prop_default'];
754                $repeat = array('repeat', 'repeat-x', 'repeat-y', 'no-repeat', 'space');
755                $attachment = array('scroll', 'fixed', 'local');
756                $clip = array('border', 'padding');
757                $origin = array('border', 'padding', 'content');
758                $pos = array('top', 'center', 'bottom', 'left', 'right');
759                $important = '';
760                $return = array('background-image' => null, 'background-size' => null, 'background-repeat' => null, 'background-position' => null, 'background-attachment' => null, 'background-clip' => null, 'background-origin' => null, 'background-color' => null);
761
762                if ($this->parser->is_important($str_value)) {
763                        $important = ' !important';
764                        $str_value = $this->parser->gvw_important($str_value);
765                }
766
767                $str_value = $this->explode_ws(',', $str_value);
768                for ($i = 0; $i < count($str_value); $i++) {
769                        $have['clip'] = false;
770                        $have['pos'] = false;
771                        $have['color'] = false;
772                        $have['bg'] = false;
773
774                        if (is_array($str_value[$i])) {
775                                $str_value[$i] = $str_value[$i][0];
776                        }
777                        $str_value[$i] = $this->explode_ws(' ', trim($str_value[$i]));
778
779                        for ($j = 0; $j < count($str_value[$i]); $j++) {
780                                if ($have['bg'] === false && (substr($str_value[$i][$j], 0, 4) === 'url(' || $str_value[$i][$j] === 'none')) {
781                                        $return['background-image'] .= $str_value[$i][$j] . ',';
782                                        $have['bg'] = true;
783                                } elseif (in_array($str_value[$i][$j], $repeat, true)) {
784                                        $return['background-repeat'] .= $str_value[$i][$j] . ',';
785                                } elseif (in_array($str_value[$i][$j], $attachment, true)) {
786                                        $return['background-attachment'] .= $str_value[$i][$j] . ',';
787                                } elseif (in_array($str_value[$i][$j], $clip, true) && !$have['clip']) {
788                                        $return['background-clip'] .= $str_value[$i][$j] . ',';
789                                        $have['clip'] = true;
790                                } elseif (in_array($str_value[$i][$j], $origin, true)) {
791                                        $return['background-origin'] .= $str_value[$i][$j] . ',';
792                                } elseif ($str_value[$i][$j]{0} === '(') {
793                                        $return['background-size'] .= substr($str_value[$i][$j], 1, -1) . ',';
794                                } elseif (in_array($str_value[$i][$j], $pos, true) || is_numeric($str_value[$i][$j]{0}) || $str_value[$i][$j]{0} === null || $str_value[$i][$j]{0} === '-' || $str_value[$i][$j]{0} === '.') {
795                                        $return['background-position'] .= $str_value[$i][$j];
796                                        if (!$have['pos'])
797                                                $return['background-position'] .= ' '; else
798                                                $return['background-position'].= ',';
799                                        $have['pos'] = true;
800                                } elseif (!$have['color']) {
801                                        $return['background-color'] .= $str_value[$i][$j] . ',';
802                                        $have['color'] = true;
803                                }
804                        }
805                }
806
807                foreach ($background_prop_default as $bg_prop => $default_value) {
808                        if ($return[$bg_prop] !== null) {
809                                $return[$bg_prop] = substr($return[$bg_prop], 0, -1) . $important;
810                        }
811                        else
812                                $return[$bg_prop] = $default_value . $important;
813                }
814                return $return;
815        }
816
817        /**
818         * Merges all background properties
819         * @param array $input_css
820         * @return array
821         * @version 1.0
822         * @see dissolve_short_bg()
823         * @todo full CSS 3 compliance
824         */
825        public function merge_bg($input_css) {
826                $background_prop_default = & $this->parser->data['csstidy']['background_prop_default'];
827                // Max number of background images. CSS3 not yet fully implemented
828                $number_of_values = @max(count($this->explode_ws(',', $input_css['background-image'])), count($this->explode_ws(',', $input_css['background-color'])), 1);
829                // Array with background images to check if BG image exists
830                $bg_img_array = @$this->explode_ws(',', $this->parser->gvw_important($input_css['background-image']));
831                $new_bg_value = '';
832                $important = '';
833
834                // if background properties is here and not empty, don't try anything
835                if (isset($input_css['background']) && $input_css['background'])
836                        return $input_css;
837
838                for ($i = 0; $i < $number_of_values; $i++) {
839                        foreach ($background_prop_default as $bg_property => $default_value) {
840                                // Skip if property does not exist
841                                if (!isset($input_css[$bg_property])) {
842                                        continue;
843                                }
844
845                                $cur_value = $input_css[$bg_property];
846                                // skip all optimisation if gradient() somewhere
847                                if (stripos($cur_value, 'gradient(') !== false)
848                                        return $input_css;
849
850                                // Skip some properties if there is no background image
851                                if ((!isset($bg_img_array[$i]) || $bg_img_array[$i] === 'none')
852                                                                && ($bg_property === 'background-size' || $bg_property === 'background-position'
853                                                                || $bg_property === 'background-attachment' || $bg_property === 'background-repeat')) {
854                                        continue;
855                                }
856
857                                // Remove !important
858                                if ($this->parser->is_important($cur_value)) {
859                                        $important = ' !important';
860                                        $cur_value = $this->parser->gvw_important($cur_value);
861                                }
862
863                                // Do not add default values
864                                if ($cur_value === $default_value) {
865                                        continue;
866                                }
867
868                                $temp = $this->explode_ws(',', $cur_value);
869
870                                if (isset($temp[$i])) {
871                                        if ($bg_property === 'background-size') {
872                                                $new_bg_value .= '(' . $temp[$i] . ') ';
873                                        } else {
874                                                $new_bg_value .= $temp[$i] . ' ';
875                                        }
876                                }
877                        }
878
879                        $new_bg_value = trim($new_bg_value);
880                        if ($i != $number_of_values - 1)
881                                $new_bg_value .= ',';
882                }
883
884                // Delete all background-properties
885                foreach ($background_prop_default as $bg_property => $default_value) {
886                        unset($input_css[$bg_property]);
887                }
888
889                // Add new background property
890                if ($new_bg_value !== '')
891                        $input_css['background'] = $new_bg_value . $important;
892                elseif(isset ($input_css['background']))
893                        $input_css['background'] = 'none';
894
895                return $input_css;
896        }
897
898        /**
899         * Dissolve font property
900         * @param string $str_value
901         * @return array
902         * @version 1.3
903         * @see merge_font()
904         */
905        public function dissolve_short_font($str_value) {
906                $font_prop_default = & $this->parser->data['csstidy']['font_prop_default'];
907                $font_weight = array('normal', 'bold', 'bolder', 'lighter', 100, 200, 300, 400, 500, 600, 700, 800, 900);
908                $font_variant = array('normal', 'small-caps');
909                $font_style = array('normal', 'italic', 'oblique');
910                $important = '';
911                $return = array('font-style' => null, 'font-variant' => null, 'font-weight' => null, 'font-size' => null, 'line-height' => null, 'font-family' => null);
912
913                if ($this->parser->is_important($str_value)) {
914                        $important = '!important';
915                        $str_value = $this->parser->gvw_important($str_value);
916                }
917
918                $have['style'] = false;
919                $have['variant'] = false;
920                $have['weight'] = false;
921                $have['size'] = false;
922                // Detects if font-family consists of several words w/o quotes
923                $multiwords = false;
924
925                // Workaround with multiple font-family
926                $str_value = $this->explode_ws(',', trim($str_value));
927
928                $str_value[0] = $this->explode_ws(' ', trim($str_value[0]));
929
930                for ($j = 0; $j < count($str_value[0]); $j++) {
931                        if ($have['weight'] === false && in_array($str_value[0][$j], $font_weight)) {
932                                $return['font-weight'] = $str_value[0][$j];
933                                $have['weight'] = true;
934                        } elseif ($have['variant'] === false && in_array($str_value[0][$j], $font_variant)) {
935                                $return['font-variant'] = $str_value[0][$j];
936                                $have['variant'] = true;
937                        } elseif ($have['style'] === false && in_array($str_value[0][$j], $font_style)) {
938                                $return['font-style'] = $str_value[0][$j];
939                                $have['style'] = true;
940                        } elseif ($have['size'] === false && (is_numeric($str_value[0][$j]{0}) || $str_value[0][$j]{0} === null || $str_value[0][$j]{0} === '.')) {
941                                $size = $this->explode_ws('/', trim($str_value[0][$j]));
942                                $return['font-size'] = $size[0];
943                                if (isset($size[1])) {
944                                        $return['line-height'] = $size[1];
945                                } else {
946                                        $return['line-height'] = ''; // don't add 'normal' !
947                                }
948                                $have['size'] = true;
949                        } else {
950                                if (isset($return['font-family'])) {
951                                        $return['font-family'] .= ' ' . $str_value[0][$j];
952                                        $multiwords = true;
953                                } else {
954                                        $return['font-family'] = $str_value[0][$j];
955                                }
956                        }
957                }
958                // add quotes if we have several qords in font-family
959                if ($multiwords !== false) {
960                        $return['font-family'] = '"' . $return['font-family'] . '"';
961                }
962                $i = 1;
963                while (isset($str_value[$i])) {
964                        $return['font-family'] .= ',' . trim($str_value[$i]);
965                        $i++;
966                }
967
968                // Fix for 100 and more font-size
969                if ($have['size'] === false && isset($return['font-weight']) &&
970                                                is_numeric($return['font-weight']{0})) {
971                        $return['font-size'] = $return['font-weight'];
972                        unset($return['font-weight']);
973                }
974
975                foreach ($font_prop_default as $font_prop => $default_value) {
976                        if ($return[$font_prop] !== null) {
977                                $return[$font_prop] = $return[$font_prop] . $important;
978                        }
979                        else
980                                $return[$font_prop] = $default_value . $important;
981                }
982                return $return;
983        }
984
985        /**
986         * Merges all fonts properties
987         * @param array $input_css
988         * @return array
989         * @version 1.3
990         * @see dissolve_short_font()
991         */
992        public function merge_font($input_css) {
993                $font_prop_default = & $this->parser->data['csstidy']['font_prop_default'];
994                $new_font_value = '';
995                $important = '';
996                // Skip if not font-family and font-size set
997                if (isset($input_css['font-family']) && isset($input_css['font-size']) && $input_css['font-family'] != 'inherit') {
998                        // fix several words in font-family - add quotes
999                        if (isset($input_css['font-family'])) {
1000                                $families = explode(',', $input_css['font-family']);
1001                                $result_families = array();
1002                                foreach ($families as $family) {
1003                                        $family = trim($family);
1004                                        $len = strlen($family);
1005                                        if (strpos($family, ' ') &&
1006                                                                        !(($family{0} === '"' && $family{$len - 1} === '"') ||
1007                                                                        ($family{0} === "'" && $family{$len - 1} === "'"))) {
1008                                                $family = '"' . $family . '"';
1009                                        }
1010                                        $result_families[] = $family;
1011                                }
1012                                $input_css['font-family'] = implode(',', $result_families);
1013                        }
1014                        foreach ($font_prop_default as $font_property => $default_value) {
1015
1016                                // Skip if property does not exist
1017                                if (!isset($input_css[$font_property])) {
1018                                        continue;
1019                                }
1020
1021                                $cur_value = $input_css[$font_property];
1022
1023                                // Skip if default value is used
1024                                if ($cur_value === $default_value) {
1025                                        continue;
1026                                }
1027
1028                                // Remove !important
1029                                if ($this->parser->is_important($cur_value)) {
1030                                        $important = '!important';
1031                                        $cur_value = $this->parser->gvw_important($cur_value);
1032                                }
1033
1034                                $new_font_value .= $cur_value;
1035                                // Add delimiter
1036                                $new_font_value .= ( $font_property === 'font-size' &&
1037                                                                isset($input_css['line-height'])) ? '/' : ' ';
1038                        }
1039
1040                        $new_font_value = trim($new_font_value);
1041
1042                        // Delete all font-properties
1043                        foreach ($font_prop_default as $font_property => $default_value) {
1044                                if ($font_property !== 'font' || !$new_font_value)
1045                                        unset($input_css[$font_property]);
1046                        }
1047
1048                        // Add new font property
1049                        if ($new_font_value !== '') {
1050                                $input_css['font'] = $new_font_value . $important;
1051                        }
1052                }
1053
1054                return $input_css;
1055        }
1056
1057        /**
1058         * Reverse left vs right in a list of properties/values
1059         * @param array $array
1060         * @return array
1061         */
1062        public function reverse_left_and_right($array) {
1063                $return = array();
1064
1065                // change left <-> right in properties name and values
1066                foreach ($array as $propertie => $value) {
1067
1068                        if (method_exists($this, $m = 'reverse_left_and_right_' . str_replace('-','_',trim($propertie)))) {
1069                                $value = $this->$m($value);
1070                        }
1071
1072                        // simple replacement for properties
1073                        $propertie = str_ireplace(array('left', 'right' ,"\x1"), array("\x1", 'left', 'right') , $propertie);
1074                        // be careful for values, not modifying protected or quoted valued
1075                        foreach (array('left' => "\x1", 'right' => 'left', "\x1" => 'right') as $v => $r) {
1076                                if (strpos($value, $v) !== false) {
1077                                        // attraper les left et right separes du reste (pas au milieu d'un mot)
1078                                        if (in_array($v, array('left', 'right') )) {
1079                                                $value = preg_replace(",\\b$v\\b,", "\x0" , $value);
1080                                        }
1081                                        else {
1082                                                $value = str_replace($v, "\x0" , $value);
1083                                        }
1084                                        $value = $this->explode_ws("\x0", $value . ' ', true);
1085                                        $value = rtrim(implode($r, $value));
1086                                        $value = str_replace("\x0" , $v, $value);
1087                                }
1088                        }
1089                        $return[$propertie] = $value;
1090                }
1091
1092                return $return;
1093        }
1094
1095        /**
1096         * Reversing 4 values shorthands properties
1097         * @param string $value
1098         * @return string
1099         */
1100        public function reverse_left_and_right_4value_shorthands($property, $value) {
1101                $shorthands = & $this->parser->data['csstidy']['shorthands'];
1102                if (isset($shorthands[$property])) {
1103                        $property_right = $shorthands[$property][1];
1104                        $property_left = $shorthands[$property][3];
1105                        $v = $this->dissolve_4value_shorthands($property, $value);
1106                        if ($v[$property_left] !== $v[$property_right]) {
1107                                $r = $v[$property_right];
1108                                $v[$property_right] = $v[$property_left];
1109                                $v[$property_left] = $r;
1110                                $v = $this->merge_4value_shorthands($v);
1111                                if (isset($v[$property])) {
1112                                        return $v[$property];
1113                                }
1114                        }
1115                }
1116                return $value;
1117        }
1118
1119        /**
1120         * Reversing 4 values radius shorthands properties
1121         * @param string $value
1122         * @return string
1123         */
1124        public function reverse_left_and_right_4value_radius_shorthands($property, $value) {
1125                $shorthands = & $this->parser->data['csstidy']['radius_shorthands'];
1126                if (isset($shorthands[$property])) {
1127                        $v = $this->dissolve_4value_radius_shorthands($property, $value);
1128                        if ($v[$shorthands[$property][0]] !== $v[$shorthands[$property][1]]
1129                          or $v[$shorthands[$property][2]] !== $v[$shorthands[$property][3]]) {
1130                                $r = array(
1131                                        $shorthands[$property][0] => $v[$shorthands[$property][1]],
1132                                        $shorthands[$property][1] => $v[$shorthands[$property][0]],
1133                                        $shorthands[$property][2] => $v[$shorthands[$property][3]],
1134                                        $shorthands[$property][3] => $v[$shorthands[$property][2]],
1135                                );
1136                                $v = $this->merge_4value_radius_shorthands($r);
1137                                if (isset($v[$property])) {
1138                                        return $v[$property];
1139                                }
1140                        }
1141                }
1142                return $value;
1143        }
1144
1145        /**
1146         * Reversing margin shorthands
1147         * @param string $value
1148         * @return string
1149         */
1150        public function reverse_left_and_right_margin($value) {
1151                return $this->reverse_left_and_right_4value_shorthands('margin', $value);
1152        }
1153
1154        /**
1155         * Reversing padding shorthands
1156         * @param string $value
1157         * @return string
1158         */
1159        public function reverse_left_and_right_padding($value) {
1160                return $this->reverse_left_and_right_4value_shorthands('padding', $value);
1161        }
1162
1163        /**
1164         * Reversing border-color shorthands
1165         * @param string $value
1166         * @return string
1167         */
1168        public function reverse_left_and_right_border_color($value) {
1169                return $this->reverse_left_and_right_4value_shorthands('border-color', $value);
1170        }
1171
1172        /**
1173         * Reversing border-style shorthands
1174         * @param string $value
1175         * @return string
1176         */
1177        public function reverse_left_and_right_border_style($value) {
1178                return $this->reverse_left_and_right_4value_shorthands('border-style', $value);
1179        }
1180
1181        /**
1182         * Reversing border-width shorthands
1183         * @param string $value
1184         * @return string
1185         */
1186        public function reverse_left_and_right_border_width($value) {
1187                return $this->reverse_left_and_right_4value_shorthands('border-width', $value);
1188        }
1189
1190        /**
1191         * Reversing border-radius shorthands
1192         * @param string $value
1193         * @return string
1194         */
1195        public function reverse_left_and_right_border_radius($value) {
1196                return $this->reverse_left_and_right_4value_radius_shorthands('border-radius', $value);
1197        }
1198
1199        /**
1200         * Reversing border-radius shorthands
1201         * @param string $value
1202         * @return string
1203         */
1204        public function reverse_left_and_right__moz_border_radius($value) {
1205                return $this->reverse_left_and_right_4value_radius_shorthands('border-radius', $value);
1206        }
1207
1208        /**
1209         * Reversing border-radius shorthands
1210         * @param string $value
1211         * @return string
1212         */
1213        public function reverse_left_and_right__webkit_border_radius($value) {
1214                return $this->reverse_left_and_right_4value_radius_shorthands('border-radius', $value);
1215        }
1216
1217
1218        /**
1219         * Reversing background shorthands
1220         * @param string $value
1221         * @return string
1222         */
1223        public function reverse_left_and_right_background($value) {
1224                $values = $this->dissolve_short_bg($value);
1225                if (isset($values['background-position']) and $values['background-position']) {
1226                        $v = $this->reverse_left_and_right_background_position($values['background-position']);
1227                        if ($v !== $values['background-position']) {
1228                                if ($value == $values['background-position']) {
1229                                        return $v;
1230                                }
1231                                else {
1232                                        $values['background-position'] = $v;
1233                                        $x = $this->merge_bg($values);
1234                                        if (isset($x['background'])) {
1235                                                return $x['background'];
1236                                        }
1237                                }
1238                        }
1239                }
1240                return $value;
1241        }
1242
1243        /**
1244         * Reversing background position shorthands
1245         * @param string $value
1246         * @return string
1247         */
1248        public function reverse_left_and_right_background_position_x($value) {
1249                return $this->reverse_left_and_right_background_position($value);
1250        }
1251
1252        /**
1253         * Reversing background position shorthands
1254         * @param string $value
1255         * @return string
1256         */
1257        public function reverse_left_and_right_background_position($value) {
1258                // multiple background case
1259                if (strpos($value, ',') !== false) {
1260                        $values = $this->explode_ws(',', $value);
1261                        if (count($values) > 1) {
1262                                foreach ($values as $k=>$v) {
1263                                        $values[$k] = $this->reverse_left_and_right_background_position($v);
1264                                }
1265                                return implode(',', $values);
1266                        }
1267                }
1268
1269                // if no explicit left or right value
1270                if (stripos($value, 'left') === false and stripos($value, 'right') === false) {
1271                        $values = $this->explode_ws(' ', trim($value));
1272                        $values = array_map('trim', $values);
1273                        $values = array_filter($values);
1274                        $values = array_values($values);
1275                        if (count($values) == 1) {
1276                                return "left $value";
1277                        }
1278                        if ($values[1] == 'top' or $values[1] == 'bottom') {
1279                                return 'left ' . implode(' ', $values);
1280                        }
1281                        else {
1282                                $last = array_pop($values);
1283                                return implode(' ', $values) . ' left ' . $last;
1284                        }
1285                }
1286
1287                return $value;
1288        }
1289
1290}
Note: See TracBrowser for help on using the repository browser.