18300675247

Committed 07 Oct 2025 02:59AM UTC coverage: 96.552% (-0.2%) from 96.757%

Build # 18300675247

Build Type

Pull #2839

github

Committed by

web-flow

Commit Message

Merge d0fa28234 into 0ab0b4940

Pull Request Pull Request #2839: SimpleType: Color - Create a simple color type for easily specifying preset color values.

Run Details

59 of 73 new or added lines in 1 file covered. (80.82%)

15 existing lines in 1 file now uncovered.

12545 of 12993 relevant lines covered (96.55%)

35.41 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

80.14

/src/PhpWord/Shared/Converter.php

<?php

/**
 * This file is part of PHPWord - A pure PHP library for reading and writing
 * word processing documents.
 *
 * PHPWord is free software distributed under the terms of the GNU Lesser
 * General Public License version 3 as published by the Free Software Foundation.
 *
 * For the full copyright and license information, please read the LICENSE
 * file that was distributed with this source code. For the full list of
 * contributors, visit https://github.com/PHPOffice/PHPWord/contributors.
 *
 * @see         https://github.com/PHPOffice/PHPWord
 *
 * @license     http://www.gnu.org/licenses/lgpl.txt LGPL version 3
 */

namespace PhpOffice\PhpWord\Shared;

use PhpOffice\PhpWord\SimpleType\Color;
use PhpOffice\PhpWord\Style\Font as FontColor;

/**
 * Common converter functions.
 */
class Converter
{
    const INCH_TO_CM = 2.54;
    const INCH_TO_TWIP = 1440;
    const INCH_TO_PIXEL = 96;
    const INCH_TO_POINT = 72;
    const INCH_TO_PICA = 6;
    const PIXEL_TO_EMU = 9525;
    const DEGREE_TO_ANGLE = 60000;

    /**
     * Convert centimeter to twip.
     *
     * @param float $centimeter
     *
     * @return float
     */
    public static function cmToTwip($centimeter = 1)
    {
        return $centimeter / self::INCH_TO_CM * self::INCH_TO_TWIP;
    }

    /**
     * Convert centimeter to inch.
     *
     * @param float $centimeter
     *
     * @return float
     */
    public static function cmToInch($centimeter = 1)
    {
        return $centimeter / self::INCH_TO_CM;
    }

    /**
     * Convert centimeter to pixel.
     *
     * @param float $centimeter
     *
     * @return float
     */
    public static function cmToPixel($centimeter = 1)
    {
        return $centimeter / self::INCH_TO_CM * self::INCH_TO_PIXEL;
    }

    /**
     * Convert centimeter to point.
     *
     * @param float $centimeter
     *
     * @return float
     */
    public static function cmToPoint($centimeter = 1)
    {
        return $centimeter / self::INCH_TO_CM * self::INCH_TO_POINT;
    }

    /**
     * Convert centimeter to EMU.
     *
     * @param float $centimeter
     *
     * @return float
     */
    public static function cmToEmu($centimeter = 1)
    {
        return round($centimeter / self::INCH_TO_CM * self::INCH_TO_PIXEL * self::PIXEL_TO_EMU);
    }

    /**
     * Convert inch to twip.
     *
     * @param float $inch
     *
     * @return float
     */
    public static function inchToTwip($inch = 1)
    {
        return $inch * self::INCH_TO_TWIP;
    }

    /**
     * Convert inch to centimeter.
     *
     * @param float $inch
     *
     * @return float
     */
    public static function inchToCm($inch = 1)
    {
        return $inch * self::INCH_TO_CM;
    }

    /**
     * Convert inch to pixel.
     *
     * @param float $inch
     *
     * @return float
     */
    public static function inchToPixel($inch = 1)
    {
        return $inch * self::INCH_TO_PIXEL;
    }

    /**
     * Convert inch to point.
     *
     * @param float $inch
     *
     * @return float
     */
    public static function inchToPoint($inch = 1)
    {
        return $inch * self::INCH_TO_POINT;
    }

    /**
     * Convert inch to EMU.
     *
     * @param float $inch
     *
     * @return int
     */
    public static function inchToEmu($inch = 1)
    {
        return round($inch * self::INCH_TO_PIXEL * self::PIXEL_TO_EMU);
    }

    /**
     * Convert pixel to twip.
     *
     * @param float $pixel
     *
     * @return float
     */
    public static function pixelToTwip($pixel = 1)
    {
        return $pixel / self::INCH_TO_PIXEL * self::INCH_TO_TWIP;
    }

    /**
     * Convert pixel to centimeter.
     *
     * @param float $pixel
     *
     * @return float
     */
    public static function pixelToCm($pixel = 1)
    {
        return $pixel / self::INCH_TO_PIXEL * self::INCH_TO_CM;
    }

    /**
     * Convert pixel to point.
     *
     * @param float $pixel
     *
     * @return float
     */
    public static function pixelToPoint($pixel = 1)
    {
        return $pixel / self::INCH_TO_PIXEL * self::INCH_TO_POINT;
    }

    /**
     * Convert pixel to EMU.
     *
     * @param float $pixel
     *
     * @return int
     */
    public static function pixelToEmu($pixel = 1)
    {
        return round($pixel * self::PIXEL_TO_EMU);
    }

    /**
     * Convert point to twip unit.
     *
     * @param float $point
     *
     * @return float
     */
    public static function pointToTwip($point = 1)
    {
        return $point / self::INCH_TO_POINT * self::INCH_TO_TWIP;
    }

    /**
     * Convert point to pixel.
     *
     * @param float $point
     *
     * @return float
     */
    public static function pointToPixel($point = 1)
    {
        return $point / self::INCH_TO_POINT * self::INCH_TO_PIXEL;
    }

    /**
     * Convert point to EMU.
     *
     * @param float $point
     *
     * @return float
     */
    public static function pointToEmu($point = 1)
    {
        return round($point / self::INCH_TO_POINT * self::INCH_TO_PIXEL * self::PIXEL_TO_EMU);
    }

    /**
     * Convert point to cm.
     *
     * @param float $point
     *
     * @return float
     */
    public static function pointToCm($point = 1)
    {
        return $point / self::INCH_TO_POINT * self::INCH_TO_CM;
    }

    /**
     * Convert EMU to pixel.
     *
     * @param float $emu
     *
     * @return float
     */
    public static function emuToPixel($emu = 1)
    {
        return round($emu / self::PIXEL_TO_EMU);
    }

    /**
     * Convert pica to point.
     *
     * @param float $pica
     *
     * @return float
     */
    public static function picaToPoint($pica = 1)
    {
        return $pica / self::INCH_TO_PICA * self::INCH_TO_POINT;
    }

    /**
     * Convert degree to angle.
     *
     * @param float $degree
     *
     * @return int
     */
    public static function degreeToAngle($degree = 1)
    {
        return (int) round($degree * self::DEGREE_TO_ANGLE);
    }

    /**
     * Convert angle to degrees.
     *
     * @param float $angle
     *
     * @return int
     */
    public static function angleToDegree($angle = 1)
    {
        return round($angle / self::DEGREE_TO_ANGLE);
    }

    /**
     * Convert colorname as string to RGB.
     *
     * @param string $value color name
     *
     * @return string color as hex RGB string, or original value if unknown
     */
    public static function stringToRgb($value)
    {
        switch ($value) {
            case Color::BLACK:
                return '000000';
            case Color::BLUE:
                return '0000FF';
            case Color::BROWN:
                return 'A52A2A';
            case Color::CYAN:
                return '00FFFF';
            case Color::DARKBLUE:
                return '00008B';
            case Color::DARKCYAN:
                return '008B8B';
            case Color::DARKGRAY:
                return 'A9A9A9';
            case Color::DARKGREEN:
                return '006400';
            case Color::DARKMAGENTA:
                return '8B008B';
            case Color::DARKORANGE:
                return 'FF8C00';
            case Color::DARKRED:
                return '8B0000';
            case Color::DARKVIOLET:
                return '9400D3';
            case Color::DARKYELLOW:
                return '8B8B00';
            case Color::GRAY:
                return '808080';
            case Color::GREEN:
                return '008000';
            case Color::LIGHTBLUE:
                return 'ADD8E6';
            case Color::LIGHTCYAN:
                return 'E0FFFF';
            case Color::LIGHTGRAY:
                return 'D3D3D3';
            case Color::LIGHTGREEN:
                return '90EE90';
            case Color::LIGHTPINK:
                return 'FFB6C1';
            case Color::LIGHTYELLOW:
                return 'FFFFE0';
            case Color::MAGENTA:
                return 'FF00FF';
            case Color::ORANGE:
                return 'FFA500';
            case Color::PINK:
                return 'FFC0CB';
            case Color::PURPLE:
                return '800080';
            case Color::RED:
                return 'FF0000';
            case Color::VIOLET:
                return 'EE82EE';
            case Color::WHITE:
                return 'FFFFFF';
            case Color::YELLOW:
                return 'FFFF00';

                // deprecated constants
            case FontColor::FGCOLOR_YELLOW:
                return 'FFFF00';
            case FontColor::FGCOLOR_LIGHTGREEN:
                return '90EE90';
            case FontColor::FGCOLOR_CYAN:
                return '00FFFF';
            case FontColor::FGCOLOR_MAGENTA:
                return 'FF00FF';
            case FontColor::FGCOLOR_BLUE:
                return '0000FF';
            case FontColor::FGCOLOR_RED:
                return 'FF0000';
            case FontColor::FGCOLOR_DARKBLUE:
                return '00008B';
            case FontColor::FGCOLOR_DARKCYAN:
                return '008B8B';
            case FontColor::FGCOLOR_DARKGREEN:
                return '006400';
            case FontColor::FGCOLOR_DARKMAGENTA:
                return '8B008B';
            case FontColor::FGCOLOR_DARKRED:
                return '8B0000';
            case FontColor::FGCOLOR_DARKYELLOW:
                return '8B8B00';
            case FontColor::FGCOLOR_DARKGRAY:
                return 'A9A9A9';
            case FontColor::FGCOLOR_LIGHTGRAY:
                return 'D3D3D3';
            case FontColor::FGCOLOR_BLACK:
                return '000000';
        }

        return $value;
    }

    /**
     * Convert HTML hexadecimal to RGB.
     *
     * @param string $value HTML Color in hexadecimal
     *
     * @return array Value in RGB
     */
    public static function htmlToRgb($value)
    {
        if ($value[0] == '#') {
            $value = substr($value, 1);
        } else {
            $value = self::stringToRgb($value);
        }

        if (strlen($value) == 6) {
            [$red, $green, $blue] = [$value[0] . $value[1], $value[2] . $value[3], $value[4] . $value[5]];
        } elseif (strlen($value) == 3) {
            [$red, $green, $blue] = [$value[0] . $value[0], $value[1] . $value[1], $value[2] . $value[2]];
        } else {
            return false;
        }

        $red = ctype_xdigit($red) ? hexdec($red) : 0;
        $green = ctype_xdigit($green) ? hexdec($green) : 0;
        $blue = ctype_xdigit($blue) ? hexdec($blue) : 0;

        return [$red, $green, $blue];
    }

    /**
     * Transforms a size in CSS format (eg. 10px, 10px, ...) to points.
     *
     * @param string $value
     *
     * @return ?float
     */
    public static function cssToPoint($value)
    {
        if ($value == '0') {
            return 0;
        }
        $matches = [];
        if (preg_match('/^[+-]?([0-9]+\.?[0-9]*)?(px|em|ex|%|in|cm|mm|pt|pc)$/i', $value, $matches)) {
            $size = $matches[1];
            $unit = $matches[2];

            switch ($unit) {
                case 'pt':
                    return $size;
                case 'px':
                    return self::pixelToPoint($size);
                case 'cm':
                    return self::cmToPoint($size);
                case 'mm':
                    return self::cmToPoint($size / 10);
                case 'in':
                    return self::inchToPoint($size);
                case 'pc':
                    return self::picaToPoint($size);
            }
        }

        return null;
    }

    /**
     * Transforms a size in CSS format (eg. 10px, 10px, ...) to twips.
     *
     * @param string $value
     *
     * @return float
     */
    public static function cssToTwip($value)
    {
        return self::pointToTwip(self::cssToPoint($value));
    }

    /**
     * Transforms a size in CSS format (eg. 10px, 10px, ...) to pixel.
     *
     * @param string $value
     *
     * @return float
     */
    public static function cssToPixel($value)
    {
        return self::pointToPixel(self::cssToPoint($value));
    }

    /**
     * Transforms a size in CSS format (eg. 10px, 10px, ...) to cm.
     *
     * @param string $value
     *
     * @return float
     */
    public static function cssToCm($value)
    {
        return self::pointToCm(self::cssToPoint($value));
    }

    /**
     * Transforms a size in CSS format (eg. 10px, 10px, ...) to emu.
     *
     * @param string $value
     *
     * @return float
     */
    public static function cssToEmu($value)
    {
        return self::pointToEmu(self::cssToPoint($value));
    }
}

1	<?php
2
3	/**
4	* This file is part of PHPWord - A pure PHP library for reading and writing
5	* word processing documents.
6	*
7	* PHPWord is free software distributed under the terms of the GNU Lesser
8	* General Public License version 3 as published by the Free Software Foundation.
9	*
10	* For the full copyright and license information, please read the LICENSE
11	* file that was distributed with this source code. For the full list of
12	* contributors, visit https://github.com/PHPOffice/PHPWord/contributors.
13	*
14	* @see https://github.com/PHPOffice/PHPWord
15	*
16	* @license http://www.gnu.org/licenses/lgpl.txt LGPL version 3
17	*/
18
19	namespace PhpOffice\PhpWord\Shared;
20
21	use PhpOffice\PhpWord\SimpleType\Color;
22	use PhpOffice\PhpWord\Style\Font as FontColor;
23
24	/**
25	* Common converter functions.
26	*/
27	class Converter
28	{
29	const INCH_TO_CM = 2.54;
30	const INCH_TO_TWIP = 1440;
31	const INCH_TO_PIXEL = 96;
32	const INCH_TO_POINT = 72;
33	const INCH_TO_PICA = 6;
34	const PIXEL_TO_EMU = 9525;
35	const DEGREE_TO_ANGLE = 60000;
36
37	/**
38	* Convert centimeter to twip.
39	*
40	* @param float $centimeter
41	*
42	* @return float
43	*/
44	public static function cmToTwip($centimeter = 1)
45	{
46	return $centimeter / self::INCH_TO_CM * self::INCH_TO_TWIP;	334✔
47	}
48
49	/**
50	* Convert centimeter to inch.
51	*
52	* @param float $centimeter
53	*
54	* @return float
55	*/
56	public static function cmToInch($centimeter = 1)
57	{
58	return $centimeter / self::INCH_TO_CM;	1✔
59	}
60
61	/**
62	* Convert centimeter to pixel.
63	*
64	* @param float $centimeter
65	*
66	* @return float
67	*/
68	public static function cmToPixel($centimeter = 1)
69	{
70	return $centimeter / self::INCH_TO_CM * self::INCH_TO_PIXEL;	3✔
71	}
72
73	/**
74	* Convert centimeter to point.
75	*
76	* @param float $centimeter
77	*
78	* @return float
79	*/
80	public static function cmToPoint($centimeter = 1)
81	{
82	return $centimeter / self::INCH_TO_CM * self::INCH_TO_POINT;	2✔
83	}
84
85	/**
86	* Convert centimeter to EMU.
87	*
88	* @param float $centimeter
89	*
90	* @return float
91	*/
92	public static function cmToEmu($centimeter = 1)
93	{
94	return round($centimeter / self::INCH_TO_CM * self::INCH_TO_PIXEL * self::PIXEL_TO_EMU);	1✔
95	}
96
97	/**
98	* Convert inch to twip.
99	*
100	* @param float $inch
101	*
102	* @return float
103	*/
104	public static function inchToTwip($inch = 1)
105	{
106	return $inch * self::INCH_TO_TWIP;	6✔
107	}
108
109	/**
110	* Convert inch to centimeter.
111	*
112	* @param float $inch
113	*
114	* @return float
115	*/
116	public static function inchToCm($inch = 1)
117	{
118	return $inch * self::INCH_TO_CM;	1✔
119	}
120
121	/**
122	* Convert inch to pixel.
123	*
124	* @param float $inch
125	*
126	* @return float
127	*/
128	public static function inchToPixel($inch = 1)
129	{
130	return $inch * self::INCH_TO_PIXEL;	1✔
131	}
132
133	/**
134	* Convert inch to point.
135	*
136	* @param float $inch
137	*
138	* @return float
139	*/
140	public static function inchToPoint($inch = 1)
141	{
142	return $inch * self::INCH_TO_POINT;	3✔
143	}
144
145	/**
146	* Convert inch to EMU.
147	*
148	* @param float $inch
149	*
150	* @return int
151	*/
152	public static function inchToEmu($inch = 1)
153	{
154	return round($inch * self::INCH_TO_PIXEL * self::PIXEL_TO_EMU);	1✔
155	}
156
157	/**
158	* Convert pixel to twip.
159	*
160	* @param float $pixel
161	*
162	* @return float
163	*/
164	public static function pixelToTwip($pixel = 1)
165	{
166	return $pixel / self::INCH_TO_PIXEL * self::INCH_TO_TWIP;	10✔
167	}
168
169	/**
170	* Convert pixel to centimeter.
171	*
172	* @param float $pixel
173	*
174	* @return float
175	*/
176	public static function pixelToCm($pixel = 1)
177	{
178	return $pixel / self::INCH_TO_PIXEL * self::INCH_TO_CM;	6✔
179	}
180
181	/**
182	* Convert pixel to point.
183	*
184	* @param float $pixel
185	*
186	* @return float
187	*/
188	public static function pixelToPoint($pixel = 1)
189	{
190	return $pixel / self::INCH_TO_PIXEL * self::INCH_TO_POINT;	16✔
191	}
192
193	/**
194	* Convert pixel to EMU.
195	*
196	* @param float $pixel
197	*
198	* @return int
199	*/
200	public static function pixelToEmu($pixel = 1)
201	{
202	return round($pixel * self::PIXEL_TO_EMU);	1✔
203	}
204
205	/**
206	* Convert point to twip unit.
207	*
208	* @param float $point
209	*
210	* @return float
211	*/
212	public static function pointToTwip($point = 1)
213	{
214	return $point / self::INCH_TO_POINT * self::INCH_TO_TWIP;	12✔
215	}
216
217	/**
218	* Convert point to pixel.
219	*
220	* @param float $point
221	*
222	* @return float
223	*/
224	public static function pointToPixel($point = 1)
225	{
226	return $point / self::INCH_TO_POINT * self::INCH_TO_PIXEL;	4✔
227	}
228
229	/**
230	* Convert point to EMU.
231	*
232	* @param float $point
233	*
234	* @return float
235	*/
236	public static function pointToEmu($point = 1)
237	{
238	return round($point / self::INCH_TO_POINT * self::INCH_TO_PIXEL * self::PIXEL_TO_EMU);	2✔
239	}
240
241	/**
242	* Convert point to cm.
243	*
244	* @param float $point
245	*
246	* @return float
247	*/
248	public static function pointToCm($point = 1)
249	{
250	return $point / self::INCH_TO_POINT * self::INCH_TO_CM;	2✔
251	}
252
253	/**
254	* Convert EMU to pixel.
255	*
256	* @param float $emu
257	*
258	* @return float
259	*/
260	public static function emuToPixel($emu = 1)
261	{
262	return round($emu / self::PIXEL_TO_EMU);	1✔
263	}
264
265	/**
266	* Convert pica to point.
267	*
268	* @param float $pica
269	*
270	* @return float
271	*/
272	public static function picaToPoint($pica = 1)
273	{
274	return $pica / self::INCH_TO_PICA * self::INCH_TO_POINT;	2✔
275	}
276
277	/**
278	* Convert degree to angle.
279	*
280	* @param float $degree
281	*
282	* @return int
283	*/
284	public static function degreeToAngle($degree = 1)
285	{
286	return (int) round($degree * self::DEGREE_TO_ANGLE);	1✔
287	}
288
289	/**
290	* Convert angle to degrees.
291	*
292	* @param float $angle
293	*
294	* @return int
295	*/
296	public static function angleToDegree($angle = 1)
297	{
298	return round($angle / self::DEGREE_TO_ANGLE);	1✔
299	}
300
301	/**
302	* Convert colorname as string to RGB.
303	*
304	* @param string $value color name
305	*
306	* @return string color as hex RGB string, or original value if unknown
307	*/
308	public static function stringToRgb($value)
309	{
310	switch ($value) {
311	case Color::BLACK:	53✔
312	return '000000';	2✔
313	case Color::BLUE:	52✔
314	return '0000FF';	1✔
315	case Color::BROWN:	52✔
NEW 316	return 'A52A2A';	×
317	case Color::CYAN:	52✔
318	return '00FFFF';	1✔
319	case Color::DARKBLUE:	52✔
320	return '00008B';	1✔
321	case Color::DARKCYAN:	52✔
322	return '008B8B';	1✔
323	case Color::DARKGRAY:	52✔
324	return 'A9A9A9';	1✔
325	case Color::DARKGREEN:	52✔
326	return '006400';	2✔
327	case Color::DARKMAGENTA:	52✔
328	return '8B008B';	2✔
329	case Color::DARKORANGE:	52✔
NEW 330	return 'FF8C00';	×
331	case Color::DARKRED:	52✔
332	return '8B0000';	1✔
333	case Color::DARKVIOLET:	52✔
NEW 334	return '9400D3';	×
335	case Color::DARKYELLOW:	52✔
336	return '8B8B00';	1✔
337	case Color::GRAY:	52✔
NEW 338	return '808080';	×
339	case Color::GREEN:	52✔
NEW 340	return '008000';	×
341	case Color::LIGHTBLUE:	52✔
NEW 342	return 'ADD8E6';	×
343	case Color::LIGHTCYAN:	52✔
NEW 344	return 'E0FFFF';	×
345	case Color::LIGHTGRAY:	52✔
346	return 'D3D3D3';	1✔
347	case Color::LIGHTGREEN:	52✔
348	return '90EE90';	1✔
349	case Color::LIGHTPINK:	52✔
NEW 350	return 'FFB6C1';	×
351	case Color::LIGHTYELLOW:	52✔
NEW 352	return 'FFFFE0';	×
353	case Color::MAGENTA:	52✔
354	return 'FF00FF';	1✔
355	case Color::ORANGE:	52✔
NEW 356	return 'FFA500';	×
357	case Color::PINK:	52✔
NEW 358	return 'FFC0CB';	×
359	case Color::PURPLE:	52✔
NEW 360	return '800080';	×
361	case Color::RED:	52✔
362	return 'FF0000';	1✔
363	case Color::VIOLET:	52✔
NEW 364	return 'EE82EE';	×
365	case Color::WHITE:	52✔
NEW 366	return 'FFFFFF';	×
367	case Color::YELLOW:	52✔
368	return 'FFFF00';	1✔
369
370	// deprecated constants
371	case FontColor::FGCOLOR_YELLOW:	52✔
UNCOV 372	return 'FFFF00';	×
373	case FontColor::FGCOLOR_LIGHTGREEN:	52✔
UNCOV 374	return '90EE90';	×
375	case FontColor::FGCOLOR_CYAN:	52✔
UNCOV 376	return '00FFFF';	×
377	case FontColor::FGCOLOR_MAGENTA:	52✔
UNCOV 378	return 'FF00FF';	×
379	case FontColor::FGCOLOR_BLUE:	52✔
UNCOV 380	return '0000FF';	×
381	case FontColor::FGCOLOR_RED:	52✔
UNCOV 382	return 'FF0000';	×
383	case FontColor::FGCOLOR_DARKBLUE:	52✔
UNCOV 384	return '00008B';	×
385	case FontColor::FGCOLOR_DARKCYAN:	52✔
UNCOV 386	return '008B8B';	×
387	case FontColor::FGCOLOR_DARKGREEN:	52✔
UNCOV 388	return '006400';	×
389	case FontColor::FGCOLOR_DARKMAGENTA:	52✔
UNCOV 390	return '8B008B';	×
391	case FontColor::FGCOLOR_DARKRED:	52✔
UNCOV 392	return '8B0000';	×
393	case FontColor::FGCOLOR_DARKYELLOW:	52✔
UNCOV 394	return '8B8B00';	×
395	case FontColor::FGCOLOR_DARKGRAY:	52✔
UNCOV 396	return 'A9A9A9';	×
397	case FontColor::FGCOLOR_LIGHTGRAY:	52✔
UNCOV 398	return 'D3D3D3';	×
399	case FontColor::FGCOLOR_BLACK:	52✔
UNCOV 400	return '000000';	×
401	}
402
403	return $value;	52✔
404	}
405
406	/**
407	* Convert HTML hexadecimal to RGB.
408	*
409	* @param string $value HTML Color in hexadecimal
410	*
411	* @return array Value in RGB
412	*/
413	public static function htmlToRgb($value)
414	{
415	if ($value[0] == '#') {	2✔
416	$value = substr($value, 1);	1✔
417	} else {
418	$value = self::stringToRgb($value);	2✔
419	}
420
421	if (strlen($value) == 6) {	2✔
422	[$red, $green, $blue] = [$value[0] . $value[1], $value[2] . $value[3], $value[4] . $value[5]];	2✔
423	} elseif (strlen($value) == 3) {	1✔
424	[$red, $green, $blue] = [$value[0] . $value[0], $value[1] . $value[1], $value[2] . $value[2]];	1✔
425	} else {
426	return false;	1✔
427	}
428
429	$red = ctype_xdigit($red) ? hexdec($red) : 0;	2✔
430	$green = ctype_xdigit($green) ? hexdec($green) : 0;	2✔
431	$blue = ctype_xdigit($blue) ? hexdec($blue) : 0;	2✔
432
433	return [$red, $green, $blue];	2✔
434	}
435
436	/**
437	* Transforms a size in CSS format (eg. 10px, 10px, ...) to points.
438	*
439	* @param string $value
440	*
441	* @return ?float
442	*/
443	public static function cssToPoint($value)
444	{
445	if ($value == '0') {	17✔
446	return 0;	2✔
447	}
448	$matches = [];	17✔
449	if (preg_match('/^[+-]?([0-9]+\.?[0-9]*)?(px\|em\|ex\|%\|in\|cm\|mm\|pt\|pc)$/i', $value, $matches)) {	17✔
450	$size = $matches[1];	17✔
451	$unit = $matches[2];	17✔
452
453	switch ($unit) {
454	case 'pt':	17✔
455	return $size;	7✔
456	case 'px':	16✔
457	return self::pixelToPoint($size);	15✔
458	case 'cm':	2✔
459	return self::cmToPoint($size);	1✔
460	case 'mm':	2✔
461	return self::cmToPoint($size / 10);	1✔
462	case 'in':	2✔
463	return self::inchToPoint($size);	2✔
464	case 'pc':	1✔
465	return self::picaToPoint($size);	1✔
466	}
467	}
468
469	return null;	1✔
470	}
471
472	/**
473	* Transforms a size in CSS format (eg. 10px, 10px, ...) to twips.
474	*
475	* @param string $value
476	*
477	* @return float
478	*/
479	public static function cssToTwip($value)
480	{
481	return self::pointToTwip(self::cssToPoint($value));	11✔
482	}
483
484	/**
485	* Transforms a size in CSS format (eg. 10px, 10px, ...) to pixel.
486	*
487	* @param string $value
488	*
489	* @return float
490	*/
491	public static function cssToPixel($value)
492	{
493	return self::pointToPixel(self::cssToPoint($value));	1✔
494	}
495
496	/**
497	* Transforms a size in CSS format (eg. 10px, 10px, ...) to cm.
498	*
499	* @param string $value
500	*
501	* @return float
502	*/
503	public static function cssToCm($value)
504	{
505	return self::pointToCm(self::cssToPoint($value));	1✔
506	}
507
508	/**
509	* Transforms a size in CSS format (eg. 10px, 10px, ...) to emu.
510	*
511	* @param string $value
512	*
513	* @return float
514	*/
515	public static function cssToEmu($value)
516	{
517	return self::pointToEmu(self::cssToPoint($value));	1✔
518	}
519	}

PHPOffice / PHPWord / 18300675247

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous